@livekit/rtc-node 0.13.32 → 0.13.34

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-4M8XlO4-.d.cts → audio_stream-BNVaONuH.d.cts}

@@ -6,7 +6,7 @@ import { FfiHandle, TrackPublicationInfo, OwnedTrackPublication, TrackKind, Trac
 import { AudioSource } from './audio_source.cjs';
 import './ffi_client.cjs';
 import { TypedEventEmitter } from '@livekit/typed-emitter';
-import { B as BaseStreamInfo, c as ByteStreamOptions, T as TextStreamHandler, a as ByteStreamHandler } from './types-_PdPVish.cjs';
+import { B as BaseStreamInfo, c as ByteStreamOptions, T as TextStreamHandler, a as ByteStreamHandler } from './types-f7wTlFjs.cjs';
 import { E2EEManager, E2EEOptions } from './e2ee.cjs';
 import { Mutex } from '@livekit/mutex';
 import { PathLike } from 'node:fs';
@@ -92,6 +92,7 @@ declare class LocalParticipant extends Participant {
     private rpcHandlers;
     private ffiEventLock;
     private disconnectSignal;
+    private openStreamWriters;
     trackPublications: Map<string, LocalTrackPublication>;
     constructor(info: OwnedParticipant, ffiEventLock: Mutex, disconnectSignal: AbortSignal);
     publishData(data: Uint8Array, options: DataPublishOptions): Promise<void>;
@@ -114,6 +115,12 @@ declare class LocalParticipant extends Participant {
         attributes?: Record<string, string>;
         destinationIdentities?: Array<string>;
         streamId?: string;
+        /**
+         * Whether the payload may be compressed on the wire. Defaults to true;
+         * compression is only applied when it actually reduces the payload size
+         * and every recipient supports it.
+         */
+        compress?: boolean;
     }): Promise<BaseStreamInfo>;
     streamBytes(options?: {
         name?: string;
@@ -126,9 +133,20 @@ declare class LocalParticipant extends Participant {
     }): Promise<ByteStreamWriter>;
     /** Sends a file provided as PathLike to specified recipients */
     sendFile(path: PathLike, options?: ByteStreamOptions): Promise<void>;
-    private sendStreamHeader;
-    private sendStreamChunk;
-    private sendStreamTrailer;
+    private textStreamWriterWrite;
+    private textStreamWriterClose;
+    private byteStreamWriterWrite;
+    private byteStreamWriterClose;
+    /**
+     * Drops the native writers of any data streams that were opened but never
+     * closed — a writer the caller abandoned, or one whose write failed. Their
+     * handles would otherwise be held by the FFI server for the lifetime of the
+     * process. The room is already gone at this point, so the handles are dropped
+     * directly rather than closed: there is no end-of-stream left to deliver.
+     *
+     * @internal
+     */
+    disposeOpenStreamWriters(): void;
     /**
      * Sends a chat message to participants in the room
      *
@@ -202,6 +220,14 @@ interface RtcConfiguration {
     iceServers: IceServer[];
 }
 declare const defaultRtcConfiguration: RtcConfiguration;
+interface RoomDataStreamOptions {
+    /**
+     * Maximum decompressed payload size in bytes accepted for a single incoming
+     * data stream. Incoming streams exceeding this limit terminate with an error
+     * on the receiving side. Unset falls back to the SDK default of 5gb.
+     */
+    maxPayloadByteLength?: number;
+}
 interface RoomOptions {
     autoSubscribe: boolean;
     dynacast: boolean;
@@ -211,6 +237,8 @@ interface RoomOptions {
     e2ee?: E2EEOptions;
     encryption?: E2EEOptions;
     rtcConfig?: RtcConfiguration;
+    /** Options controlling data stream behavior for this room. */
+    dataStream?: RoomDataStreamOptions;
 }
 declare const defaultRoomOptions: RoomOptions$1;
 declare const Room_base: new () => TypedEventEmitter<RoomCallbacks>;
@@ -223,8 +251,7 @@ declare class Room extends Room_base {
      * before processing the next events
      */
     private ffiEventLock;
-    private byteStreamControllers;
-    private textStreamControllers;
+    private streamReaders;
     private byteStreamHandlers;
     private textStreamHandlers;
     private preConnectEvents;
@@ -316,9 +343,8 @@ declare class Room extends Room_base {
     private requirePublicationOfParticipant;
     private requirePublicationOfRemoteParticipant;
     private createRemoteParticipant;
-    private handleStreamHeader;
-    private handleStreamChunk;
-    private handleStreamTrailer;
+    private handleByteStreamOpened;
+    private handleTextStreamOpened;
 }
 declare class ConnectError extends Error {
     constructor(message: string);
@@ -520,4 +546,4 @@ declare class AudioStream extends ReadableStream<AudioFrame> {
     constructor(track: Track, options: AudioStreamOptions);
 }
 
-export { AudioStream as A, ConnectError as C, type DataPublishOptions as D, LocalAudioTrack as L, type NoiseCancellationOptions as N, Participant as P, RemoteAudioTrack as R, Track as T, type VideoTrack as V, type AudioTrack as a, LocalParticipant as b, type LocalTrack as c, LocalTrackPublication as d, LocalVideoTrack as e, RemoteParticipant as f, type RemoteTrack as g, RemoteTrackPublication as h, RemoteVideoTrack as i, Room as j, RoomEvent as k, type RoomOptions as l, type RtcConfiguration as m, TrackPublication as n, type RoomCallbacks as o, defaultRoomOptions as p, defaultRtcConfiguration as q, type AudioStreamOptions as r, AudioStreamSource as s };
+export { AudioStream as A, ConnectError as C, type DataPublishOptions as D, LocalAudioTrack as L, type NoiseCancellationOptions as N, Participant as P, RemoteAudioTrack as R, Track as T, type VideoTrack as V, type AudioTrack as a, LocalParticipant as b, type LocalTrack as c, LocalTrackPublication as d, LocalVideoTrack as e, RemoteParticipant as f, type RemoteTrack as g, RemoteTrackPublication as h, RemoteVideoTrack as i, Room as j, type RoomDataStreamOptions as k, RoomEvent as l, type RoomOptions as m, type RtcConfiguration as n, TrackPublication as o, type RoomCallbacks as p, defaultRoomOptions as q, defaultRtcConfiguration as r, type AudioStreamOptions as s, AudioStreamSource as t };

package/dist/audio_stream.d.cts

@@ -1,13 +1,13 @@
 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-4M8XlO4-.cjs';
+export { A as AudioStream, s as AudioStreamOptions, t as AudioStreamSource, N as NoiseCancellationOptions } from './audio_stream-BNVaONuH.cjs';
 import '@livekit/rtc-ffi-bindings';
 import './video_frame.cjs';
 import './audio_source.cjs';
 import './ffi_client.cjs';
 import '@livekit/typed-emitter';
-import './types-_PdPVish.cjs';
+import './types-f7wTlFjs.cjs';
 import './e2ee.cjs';
 import '@livekit/mutex';
 import 'node:fs';

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-CTyN1Ldy.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/data_streams/index.d.cts

@@ -1,3 +1,3 @@
-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.cjs';
+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-f7wTlFjs.cjs';
 export { ByteStreamWriter, TextStreamWriter } from './stream_writer.cjs';
 import '@livekit/rtc-ffi-bindings';

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.cjs

@@ -23,46 +23,105 @@ __export(stream_reader_exports, {
 });
 module.exports = __toCommonJS(stream_reader_exports);
 var import_log = require("../log.cjs");
-var import_utils = require("../utils.cjs");
 class BaseStreamReader {
-  get info() {
-    return this._info;
-  }
   constructor(info, stream, totalByteSize) {
+    this.closed = false;
+    // The reader held by an in-progress iteration. Cancelling has to go through
+    // it, since it holds the stream's lock.
+    this.activeReader = null;
     this.reader = stream;
     this.totalByteSize = totalByteSize;
     this._info = info;
     this.bytesReceived = 0;
   }
-}
-class ByteStreamReader extends BaseStreamReader {
+  get info() {
+    return this._info;
+  }
   handleChunkReceived(chunk) {
     var _a;
     this.bytesReceived += chunk.content.byteLength;
     const currentProgress = this.totalByteSize ? this.bytesReceived / this.totalByteSize : void 0;
     (_a = this.onProgress) == null ? void 0 : _a.call(this, currentProgress);
   }
-  [Symbol.asyncIterator]() {
+  /** Takes the stream's reader for an iteration, remembering it so that
+   * close() can cancel a read that is still in flight. */
+  acquireReader() {
     const reader = this.reader.getReader();
+    this.activeReader = reader;
+    return reader;
+  }
+  /** Releases the stream lock after an iteration ended on its own — because a
+   * read reported end-of-stream, or because the stream itself errored. Either
+   * way the stream is in a terminal state and the FFI subscription behind it
+   * was already dropped by that terminal event, so there is nothing to cancel.
+   *
+   * An error raised *around* a read rather than by it — a chunk that failed to
+   * process — leaves the stream live, so it has to go through close() instead. */
+  finishIteration(reader) {
+    this.closed = true;
+    if (this.activeReader === reader) {
+      this.activeReader = null;
+    }
+    reader.releaseLock();
+  }
+  /**
+   * Stops receiving this stream and releases the resources behind it.
+   *
+   * A reader is subscribed to FFI events from the moment it is handed to a
+   * stream handler, and only unsubscribes once a read consumes the stream's
+   * end-of-stream event. So a reader that is abandoned part-way through, or
+   * that a handler never reads at all, has to be closed here or its
+   * subscription lives for the rest of the process. Reading to completion — or
+   * breaking out of a `for await` — closes the reader for you, and closing an
+   * already-closed reader is a no-op.
+   */
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const active = this.activeReader;
+    this.activeReader = null;
+    try {
+      if (active) {
+        await active.cancel();
+        active.releaseLock();
+      } else {
+        await this.reader.cancel();
+      }
+    } catch (error) {
+      import_log.log.debug("error closing stream reader: %s", error);
+    }
+  }
+}
+class ByteStreamReader extends BaseStreamReader {
+  [Symbol.asyncIterator]() {
+    const reader = this.acquireReader();
     return {
       next: async () => {
+        let read;
         try {
-          const { done, value } = await reader.read();
-          if (done) {
-            reader.releaseLock();
-            return { done: true, value: void 0 };
-          } else {
-            this.handleChunkReceived(value);
-            return { done: false, value: value.content };
-          }
+          read = await reader.read();
         } catch (error) {
-          reader.releaseLock();
-          import_log.log.error("error processing stream update: %s", error);
+          this.finishIteration(reader);
+          import_log.log.error("error reading stream: %s", error);
+          throw error;
+        }
+        if (read.done) {
+          this.finishIteration(reader);
           return { done: true, value: void 0 };
         }
+        try {
+          this.handleChunkReceived(read.value);
+          return { done: false, value: read.value.content };
+        } catch (error) {
+          await this.close();
+          import_log.log.error("error processing stream update: %s", error);
+          throw error;
+        }
       },
-      return() {
-        reader.releaseLock();
+      return: async () => {
+        await this.close();
         return { done: true, value: void 0 };
       }
     };
@@ -76,59 +135,39 @@ class ByteStreamReader extends BaseStreamReader {
   }
 }
 class TextStreamReader extends BaseStreamReader {
-  /**
-   * 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, stream, totalChunkCount) {
-    super(info, stream, totalChunkCount);
-    this.receivedChunks = /* @__PURE__ */ new Map();
-  }
-  handleChunkReceived(chunk) {
-    var _a;
-    const index = (0, import_utils.bigIntToNumber)(chunk.chunkIndex);
-    const previousChunkAtIndex = this.receivedChunks.get(index);
-    if (previousChunkAtIndex && previousChunkAtIndex.version > chunk.version) {
-      return;
-    }
-    this.receivedChunks.set(index, chunk);
-    const currentProgress = this.totalByteSize ? this.receivedChunks.size / this.totalByteSize : void 0;
-    (_a = this.onProgress) == null ? void 0 : _a.call(this, currentProgress);
-  }
   /**
    * Async iterator implementation to allow usage of `for await...of` syntax.
    * Yields structured chunks from the stream.
    *
    */
   [Symbol.asyncIterator]() {
-    const reader = this.reader.getReader();
+    const reader = this.acquireReader();
     const decoder = new TextDecoder();
-    const receivedChunks = this.receivedChunks;
     return {
       next: async () => {
+        let read;
         try {
-          const { done, value } = await reader.read();
-          if (done) {
-            reader.releaseLock();
-            receivedChunks.clear();
-            return { done: true, value: void 0 };
-          } else {
-            this.handleChunkReceived(value);
-            return {
-              done: false,
-              value: decoder.decode(value.content)
-            };
-          }
+          read = await reader.read();
         } catch (error) {
-          reader.releaseLock();
-          receivedChunks.clear();
-          import_log.log.error("error processing stream update: %s", error);
+          this.finishIteration(reader);
+          import_log.log.error("error reading stream: %s", error);
+          throw error;
+        }
+        if (read.done) {
+          this.finishIteration(reader);
           return { done: true, value: void 0 };
         }
+        try {
+          this.handleChunkReceived(read.value);
+          return { done: false, value: decoder.decode(read.value.content) };
+        } catch (error) {
+          await this.close();
+          import_log.log.error("error processing stream update: %s", error);
+          throw error;
+        }
       },
-      return() {
-        reader.releaseLock();
-        receivedChunks.clear();
+      return: async () => {
+        await this.close();
         return { done: true, value: void 0 };
       }
     };

package/dist/data_streams/stream_reader.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/data_streams/stream_reader.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { DataStream_Chunk } from '@livekit/rtc-ffi-bindings';\nimport { log } from '../log.js';\nimport { bigIntToNumber } from '../utils.js';\nimport type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';\n\nabstract class BaseStreamReader<T extends BaseStreamInfo> {\n  protected reader: ReadableStream<DataStream_Chunk>;\n\n  protected totalByteSize?: number;\n\n  protected _info: T;\n\n  protected bytesReceived: number;\n\n  get info() {\n    return this._info;\n  }\n\n  constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number) {\n    this.reader = stream;\n    this.totalByteSize = totalByteSize;\n    this._info = info;\n    this.bytesReceived = 0;\n  }\n\n  protected abstract handleChunkReceived(chunk: DataStream_Chunk): void;\n\n  onProgress?: (progress: number | undefined) => void;\n\n  abstract readAll(): Promise<string | Array<Uint8Array>>;\n}\n\n/**\n * A class to read chunks from a ReadableStream and provide them in a structured format.\n */\nexport class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {\n  protected handleChunkReceived(chunk: DataStream_Chunk) {\n    this.bytesReceived += chunk.content!.byteLength;\n    const currentProgress = this.totalByteSize\n      ? this.bytesReceived / this.totalByteSize\n      : undefined;\n    this.onProgress?.(currentProgress);\n  }\n\n  [Symbol.asyncIterator]() {\n    const reader = this.reader.getReader();\n\n    return {\n      next: async (): Promise<IteratorResult<Uint8Array>> => {\n        try {\n          const { done, value } = await reader.read();\n          if (done) {\n            // Release the lock when the stream is exhausted so the\n            // underlying ReadableStream can be garbage-collected.\n            reader.releaseLock();\n            return { done: true, value: undefined as unknown };\n          } else {\n            this.handleChunkReceived(value);\n            return { done: false, value: value.content! };\n          }\n        } catch (error: unknown) {\n          // Release the lock on error so it doesn't stay held when the\n          // consumer never calls return() (e.g. breaking out of for-await).\n          reader.releaseLock();\n          log.error('error processing stream update: %s', error);\n          return { done: true, value: undefined as unknown };\n        }\n      },\n\n      return(): IteratorResult<Uint8Array> {\n        reader.releaseLock();\n        return { done: true, value: undefined };\n      },\n    };\n  }\n\n  async readAll(): Promise<Array<Uint8Array>> {\n    const chunks: Set<Uint8Array> = new Set();\n    for await (const chunk of this) {\n      chunks.add(chunk);\n    }\n    return Array.from(chunks);\n  }\n}\n\n/**\n * A class to read chunks from a ReadableStream and provide them in a structured format.\n */\nexport class TextStreamReader extends BaseStreamReader<TextStreamInfo> {\n  private receivedChunks: Map<number, DataStream_Chunk>;\n\n  /**\n   * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string\n   * that has been received up to the current point in time.\n   */\n  constructor(\n    info: TextStreamInfo,\n    stream: ReadableStream<DataStream_Chunk>,\n    totalChunkCount?: number,\n  ) {\n    super(info, stream, totalChunkCount);\n    this.receivedChunks = new Map();\n  }\n\n  protected handleChunkReceived(chunk: DataStream_Chunk) {\n    const index = bigIntToNumber(chunk.chunkIndex!);\n    const previousChunkAtIndex = this.receivedChunks.get(index!);\n    if (previousChunkAtIndex && previousChunkAtIndex.version! > chunk.version!) {\n      // we have a newer version already, dropping the old one\n      return;\n    }\n    this.receivedChunks.set(index, chunk);\n    const currentProgress = this.totalByteSize\n      ? this.receivedChunks.size / this.totalByteSize\n      : undefined;\n    this.onProgress?.(currentProgress);\n  }\n\n  /**\n   * Async iterator implementation to allow usage of `for await...of` syntax.\n   * Yields structured chunks from the stream.\n   *\n   */\n  [Symbol.asyncIterator]() {\n    const reader = this.reader.getReader();\n    const decoder = new TextDecoder();\n    const receivedChunks = this.receivedChunks;\n\n    return {\n      next: async (): Promise<IteratorResult<string>> => {\n        try {\n          const { done, value } = await reader.read();\n          if (done) {\n            // Release the lock when the stream is exhausted so the\n            // underlying ReadableStream can be garbage-collected.\n            reader.releaseLock();\n            // Clear received chunks so the buffered data can be GC'd.\n            receivedChunks.clear();\n            return { done: true, value: undefined };\n          } else {\n            this.handleChunkReceived(value);\n            return {\n              done: false,\n              value: decoder.decode(value.content!),\n            };\n          }\n        } catch (error: unknown) {\n          // Release the lock on error so it doesn't stay held when the\n          // consumer never calls return() (e.g. breaking out of for-await).\n          reader.releaseLock();\n          receivedChunks.clear();\n          log.error('error processing stream update: %s', error);\n          return { done: true, value: undefined };\n        }\n      },\n\n      return(): IteratorResult<string> {\n        reader.releaseLock();\n        // Clear received chunks so the buffered data can be GC'd.\n        receivedChunks.clear();\n        return { done: true, value: undefined };\n      },\n    };\n  }\n\n  async readAll(): Promise<string> {\n    let finalString: string = '';\n    for await (const chunk of this) {\n      finalString += chunk;\n    }\n    return finalString;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,iBAAoB;AACpB,mBAA+B;AAG/B,MAAe,iBAA2C;AAAA,EASxD,IAAI,OAAO;AACT,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,YAAY,MAAS,QAA0C,eAAwB;AACrF,SAAK,SAAS;AACd,SAAK,gBAAgB;AACrB,SAAK,QAAQ;AACb,SAAK,gBAAgB;AAAA,EACvB;AAOF;AAKO,MAAM,yBAAyB,iBAAiC;AAAA,EAC3D,oBAAoB,OAAyB;AAvCzD;AAwCI,SAAK,iBAAiB,MAAM,QAAS;AACrC,UAAM,kBAAkB,KAAK,gBACzB,KAAK,gBAAgB,KAAK,gBAC1B;AACJ,eAAK,eAAL,8BAAkB;AAAA,EACpB;AAAA,EAEA,CAAC,OAAO,aAAa,IAAI;AACvB,UAAM,SAAS,KAAK,OAAO,UAAU;AAErC,WAAO;AAAA,MACL,MAAM,YAAiD;AACrD,YAAI;AACF,gBAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,cAAI,MAAM;AAGR,mBAAO,YAAY;AACnB,mBAAO,EAAE,MAAM,MAAM,OAAO,OAAqB;AAAA,UACnD,OAAO;AACL,iBAAK,oBAAoB,KAAK;AAC9B,mBAAO,EAAE,MAAM,OAAO,OAAO,MAAM,QAAS;AAAA,UAC9C;AAAA,QACF,SAAS,OAAgB;AAGvB,iBAAO,YAAY;AACnB,yBAAI,MAAM,sCAAsC,KAAK;AACrD,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAqB;AAAA,QACnD;AAAA,MACF;AAAA,MAEA,SAAqC;AACnC,eAAO,YAAY;AACnB,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,UAAsC;AAC1C,UAAM,SAA0B,oBAAI,IAAI;AACxC,qBAAiB,SAAS,MAAM;AAC9B,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO,MAAM,KAAK,MAAM;AAAA,EAC1B;AACF;AAKO,MAAM,yBAAyB,iBAAiC;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrE,YACE,MACA,QACA,iBACA;AACA,UAAM,MAAM,QAAQ,eAAe;AACnC,SAAK,iBAAiB,oBAAI,IAAI;AAAA,EAChC;AAAA,EAEU,oBAAoB,OAAyB;AA3GzD;AA4GI,UAAM,YAAQ,6BAAe,MAAM,UAAW;AAC9C,UAAM,uBAAuB,KAAK,eAAe,IAAI,KAAM;AAC3D,QAAI,wBAAwB,qBAAqB,UAAW,MAAM,SAAU;AAE1E;AAAA,IACF;AACA,SAAK,eAAe,IAAI,OAAO,KAAK;AACpC,UAAM,kBAAkB,KAAK,gBACzB,KAAK,eAAe,OAAO,KAAK,gBAChC;AACJ,eAAK,eAAL,8BAAkB;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,CAAC,OAAO,aAAa,IAAI;AACvB,UAAM,SAAS,KAAK,OAAO,UAAU;AACrC,UAAM,UAAU,IAAI,YAAY;AAChC,UAAM,iBAAiB,KAAK;AAE5B,WAAO;AAAA,MACL,MAAM,YAA6C;AACjD,YAAI;AACF,gBAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,cAAI,MAAM;AAGR,mBAAO,YAAY;AAEnB,2BAAe,MAAM;AACrB,mBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,UACxC,OAAO;AACL,iBAAK,oBAAoB,KAAK;AAC9B,mBAAO;AAAA,cACL,MAAM;AAAA,cACN,OAAO,QAAQ,OAAO,MAAM,OAAQ;AAAA,YACtC;AAAA,UACF;AAAA,QACF,SAAS,OAAgB;AAGvB,iBAAO,YAAY;AACnB,yBAAe,MAAM;AACrB,yBAAI,MAAM,sCAAsC,KAAK;AACrD,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,QACxC;AAAA,MACF;AAAA,MAEA,SAAiC;AAC/B,eAAO,YAAY;AAEnB,uBAAe,MAAM;AACrB,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,UAA2B;AAC/B,QAAI,cAAsB;AAC1B,qBAAiB,SAAS,MAAM;AAC9B,qBAAe;AAAA,IACjB;AACA,WAAO;AAAA,EACT;AACF;","names":[]}
+{"version":3,"sources":["../../src/data_streams/stream_reader.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { DataStream_Chunk } from '@livekit/rtc-ffi-bindings';\nimport { log } from '../log.js';\nimport type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types.js';\n\nabstract class BaseStreamReader<T extends BaseStreamInfo> {\n  protected reader: ReadableStream<DataStream_Chunk>;\n\n  protected totalByteSize?: number;\n\n  protected _info: T;\n\n  protected bytesReceived: number;\n\n  private closed = false;\n\n  // The reader held by an in-progress iteration. Cancelling has to go through\n  // it, since it holds the stream's lock.\n  private activeReader: ReadableStreamDefaultReader<DataStream_Chunk> | null = null;\n\n  get info() {\n    return this._info;\n  }\n\n  constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number) {\n    this.reader = stream;\n    this.totalByteSize = totalByteSize;\n    this._info = info;\n    this.bytesReceived = 0;\n  }\n\n  protected handleChunkReceived(chunk: DataStream_Chunk) {\n    this.bytesReceived += chunk.content!.byteLength;\n    const currentProgress = this.totalByteSize\n      ? this.bytesReceived / this.totalByteSize\n      : undefined;\n    this.onProgress?.(currentProgress);\n  }\n\n  /** Takes the stream's reader for an iteration, remembering it so that\n   * close() can cancel a read that is still in flight. */\n  protected acquireReader(): ReadableStreamDefaultReader<DataStream_Chunk> {\n    const reader = this.reader.getReader();\n    this.activeReader = reader;\n    return reader;\n  }\n\n  /** Releases the stream lock after an iteration ended on its own — because a\n   * read reported end-of-stream, or because the stream itself errored. Either\n   * way the stream is in a terminal state and the FFI subscription behind it\n   * was already dropped by that terminal event, so there is nothing to cancel.\n   *\n   * An error raised *around* a read rather than by it — a chunk that failed to\n   * process — leaves the stream live, so it has to go through close() instead. */\n  protected finishIteration(reader: ReadableStreamDefaultReader<DataStream_Chunk>) {\n    this.closed = true;\n    if (this.activeReader === reader) {\n      this.activeReader = null;\n    }\n    reader.releaseLock();\n  }\n\n  /**\n   * Stops receiving this stream and releases the resources behind it.\n   *\n   * A reader is subscribed to FFI events from the moment it is handed to a\n   * stream handler, and only unsubscribes once a read consumes the stream's\n   * end-of-stream event. So a reader that is abandoned part-way through, or\n   * that a handler never reads at all, has to be closed here or its\n   * subscription lives for the rest of the process. Reading to completion — or\n   * breaking out of a `for await` — closes the reader for you, and closing an\n   * already-closed reader is a no-op.\n   */\n  async close(): Promise<void> {\n    if (this.closed) {\n      return;\n    }\n    this.closed = true;\n    const active = this.activeReader;\n    this.activeReader = null;\n    try {\n      if (active) {\n        await active.cancel();\n        active.releaseLock();\n      } else {\n        await this.reader.cancel();\n      }\n    } catch (error: unknown) {\n      // The stream was already closed or errored (e.g. the room disconnected\n      // mid-stream), in which case its subscription is already gone.\n      log.debug('error closing stream reader: %s', error);\n    }\n  }\n\n  onProgress?: (progress: number | undefined) => void;\n\n  abstract readAll(): Promise<string | Array<Uint8Array>>;\n}\n\n/**\n * A class to read chunks from a ReadableStream and provide them in a structured format.\n */\nexport class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {\n  [Symbol.asyncIterator]() {\n    const reader = this.acquireReader();\n\n    return {\n      next: async (): Promise<IteratorResult<Uint8Array>> => {\n        let read: Awaited<ReturnType<typeof reader.read>>;\n        try {\n          read = await reader.read();\n        } catch (error: unknown) {\n          // The stream errored, which is terminal: release the lock so it\n          // doesn't stay held when the consumer never calls return() (a\n          // rejecting next() doesn't trigger it).\n          this.finishIteration(reader);\n          log.error('error reading stream: %s', error);\n          // Propagate abnormal termination (e.g. remote abort, payload over\n          // the receiver's size limit) instead of presenting the truncated\n          // payload as a clean EOF.\n          throw error;\n        }\n\n        if (read.done) {\n          // Release the lock when the stream is exhausted so the\n          // underlying ReadableStream can be garbage-collected.\n          this.finishIteration(reader);\n          return { done: true, value: undefined as unknown };\n        }\n\n        try {\n          this.handleChunkReceived(read.value);\n          return { done: false, value: read.value.content! };\n        } catch (error: unknown) {\n          // The chunk arrived fine but handling it threw (e.g. a consumer's\n          // onProgress callback). The stream is still live, so it has to be\n          // cancelled to release its FFI subscription.\n          await this.close();\n          log.error('error processing stream update: %s', error);\n          throw error;\n        }\n      },\n\n      return: async (): Promise<IteratorResult<Uint8Array>> => {\n        await this.close();\n        return { done: true, value: undefined };\n      },\n    };\n  }\n\n  async readAll(): Promise<Array<Uint8Array>> {\n    const chunks: Set<Uint8Array> = new Set();\n    for await (const chunk of this) {\n      chunks.add(chunk);\n    }\n    return Array.from(chunks);\n  }\n}\n\n/**\n * A class to read chunks from a ReadableStream and provide them in a structured format.\n */\nexport class TextStreamReader extends BaseStreamReader<TextStreamInfo> {\n  /**\n   * Async iterator implementation to allow usage of `for await...of` syntax.\n   * Yields structured chunks from the stream.\n   *\n   */\n  [Symbol.asyncIterator]() {\n    const reader = this.acquireReader();\n    const decoder = new TextDecoder();\n\n    return {\n      next: async (): Promise<IteratorResult<string>> => {\n        let read: Awaited<ReturnType<typeof reader.read>>;\n        try {\n          read = await reader.read();\n        } catch (error: unknown) {\n          // The stream errored, which is terminal: release the lock so it\n          // doesn't stay held when the consumer never calls return() (a\n          // rejecting next() doesn't trigger it).\n          this.finishIteration(reader);\n          log.error('error reading stream: %s', error);\n          // Propagate abnormal termination (e.g. remote abort, payload over\n          // the receiver's size limit) instead of presenting the truncated\n          // payload as a clean EOF.\n          throw error;\n        }\n\n        if (read.done) {\n          // Release the lock when the stream is exhausted so the\n          // underlying ReadableStream can be garbage-collected.\n          this.finishIteration(reader);\n          return { done: true, value: undefined };\n        }\n\n        try {\n          this.handleChunkReceived(read.value);\n          return { done: false, value: decoder.decode(read.value.content!) };\n        } catch (error: unknown) {\n          // The chunk arrived fine but handling it threw (e.g. a consumer's\n          // onProgress callback). The stream is still live, so it has to be\n          // cancelled to release its FFI subscription.\n          await this.close();\n          log.error('error processing stream update: %s', error);\n          throw error;\n        }\n      },\n\n      return: async (): Promise<IteratorResult<string>> => {\n        await this.close();\n        return { done: true, value: undefined };\n      },\n    };\n  }\n\n  async readAll(): Promise<string> {\n    let finalString: string = '';\n    for await (const chunk of this) {\n      finalString += chunk;\n    }\n    return finalString;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,iBAAoB;AAGpB,MAAe,iBAA2C;AAAA,EAmBxD,YAAY,MAAS,QAA0C,eAAwB;AAVvF,SAAQ,SAAS;AAIjB;AAAA;AAAA,SAAQ,eAAqE;AAO3E,SAAK,SAAS;AACd,SAAK,gBAAgB;AACrB,SAAK,QAAQ;AACb,SAAK,gBAAgB;AAAA,EACvB;AAAA,EATA,IAAI,OAAO;AACT,WAAO,KAAK;AAAA,EACd;AAAA,EASU,oBAAoB,OAAyB;AAjCzD;AAkCI,SAAK,iBAAiB,MAAM,QAAS;AACrC,UAAM,kBAAkB,KAAK,gBACzB,KAAK,gBAAgB,KAAK,gBAC1B;AACJ,eAAK,eAAL,8BAAkB;AAAA,EACpB;AAAA;AAAA;AAAA,EAIU,gBAA+D;AACvE,UAAM,SAAS,KAAK,OAAO,UAAU;AACrC,SAAK,eAAe;AACpB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,gBAAgB,QAAuD;AAC/E,SAAK,SAAS;AACd,QAAI,KAAK,iBAAiB,QAAQ;AAChC,WAAK,eAAe;AAAA,IACtB;AACA,WAAO,YAAY;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,QAAuB;AAC3B,QAAI,KAAK,QAAQ;AACf;AAAA,IACF;AACA,SAAK,SAAS;AACd,UAAM,SAAS,KAAK;AACpB,SAAK,eAAe;AACpB,QAAI;AACF,UAAI,QAAQ;AACV,cAAM,OAAO,OAAO;AACpB,eAAO,YAAY;AAAA,MACrB,OAAO;AACL,cAAM,KAAK,OAAO,OAAO;AAAA,MAC3B;AAAA,IACF,SAAS,OAAgB;AAGvB,qBAAI,MAAM,mCAAmC,KAAK;AAAA,IACpD;AAAA,EACF;AAKF;AAKO,MAAM,yBAAyB,iBAAiC;AAAA,EACrE,CAAC,OAAO,aAAa,IAAI;AACvB,UAAM,SAAS,KAAK,cAAc;AAElC,WAAO;AAAA,MACL,MAAM,YAAiD;AACrD,YAAI;AACJ,YAAI;AACF,iBAAO,MAAM,OAAO,KAAK;AAAA,QAC3B,SAAS,OAAgB;AAIvB,eAAK,gBAAgB,MAAM;AAC3B,yBAAI,MAAM,4BAA4B,KAAK;AAI3C,gBAAM;AAAA,QACR;AAEA,YAAI,KAAK,MAAM;AAGb,eAAK,gBAAgB,MAAM;AAC3B,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAqB;AAAA,QACnD;AAEA,YAAI;AACF,eAAK,oBAAoB,KAAK,KAAK;AACnC,iBAAO,EAAE,MAAM,OAAO,OAAO,KAAK,MAAM,QAAS;AAAA,QACnD,SAAS,OAAgB;AAIvB,gBAAM,KAAK,MAAM;AACjB,yBAAI,MAAM,sCAAsC,KAAK;AACrD,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,MAEA,QAAQ,YAAiD;AACvD,cAAM,KAAK,MAAM;AACjB,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,UAAsC;AAC1C,UAAM,SAA0B,oBAAI,IAAI;AACxC,qBAAiB,SAAS,MAAM;AAC9B,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO,MAAM,KAAK,MAAM;AAAA,EAC1B;AACF;AAKO,MAAM,yBAAyB,iBAAiC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrE,CAAC,OAAO,aAAa,IAAI;AACvB,UAAM,SAAS,KAAK,cAAc;AAClC,UAAM,UAAU,IAAI,YAAY;AAEhC,WAAO;AAAA,MACL,MAAM,YAA6C;AACjD,YAAI;AACJ,YAAI;AACF,iBAAO,MAAM,OAAO,KAAK;AAAA,QAC3B,SAAS,OAAgB;AAIvB,eAAK,gBAAgB,MAAM;AAC3B,yBAAI,MAAM,4BAA4B,KAAK;AAI3C,gBAAM;AAAA,QACR;AAEA,YAAI,KAAK,MAAM;AAGb,eAAK,gBAAgB,MAAM;AAC3B,iBAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,QACxC;AAEA,YAAI;AACF,eAAK,oBAAoB,KAAK,KAAK;AACnC,iBAAO,EAAE,MAAM,OAAO,OAAO,QAAQ,OAAO,KAAK,MAAM,OAAQ,EAAE;AAAA,QACnE,SAAS,OAAgB;AAIvB,gBAAM,KAAK,MAAM;AACjB,yBAAI,MAAM,sCAAsC,KAAK;AACrD,gBAAM;AAAA,QACR;AAAA,MACF;AAAA,MAEA,QAAQ,YAA6C;AACnD,cAAM,KAAK,MAAM;AACjB,eAAO,EAAE,MAAM,MAAM,OAAO,OAAU;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,UAA2B;AAC/B,QAAI,cAAsB;AAC1B,qBAAiB,SAAS,MAAM;AAC9B,qBAAe;AAAA,IACjB;AACA,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/data_streams/stream_reader.d.cts

@@ -1,2 +1,2 @@
 import '@livekit/rtc-ffi-bindings';
-export { d as ByteStreamReader, g as TextStreamReader } from '../types-_PdPVish.cjs';
+export { d as ByteStreamReader, g as TextStreamReader } from '../types-f7wTlFjs.cjs';