@livekit/rtc-node 0.13.29 → 0.13.30

package/dist/audio_stream-DEG1JKge.d.ts

@@ -0,0 +1,498 @@
+import { UnderlyingSource } from 'node:stream/web';
+import { AudioFrame } from './audio_frame.js';
+import { FrameProcessor } from './frame_processor.js';
+import * as _livekit_rtc_ffi_bindings from '@livekit/rtc-ffi-bindings';
+import { FfiHandle, TrackPublicationInfo, OwnedTrackPublication, TrackKind, TrackSource, EncryptionType, ParticipantInfo, OwnedParticipant, ParticipantKind, ParticipantKindDetail, DisconnectReason, TrackPublishOptions, RoomInfo, ConnectionQuality, DataPacketKind, ConnectionState, IceTransportType, ContinualGatheringPolicy, IceServer, SimulateScenarioKind, RoomOptions as RoomOptions$1, TrackInfo, OwnedTrack, StreamState } from '@livekit/rtc-ffi-bindings';
+import { AudioSource } from './audio_source.js';
+import './ffi_client.js';
+import { TypedEventEmitter } from '@livekit/typed-emitter';
+import { B as BaseStreamInfo, c as ByteStreamOptions, T as TextStreamHandler, a as ByteStreamHandler } from './types-_PdPVish.js';
+import { E2EEManager, E2EEOptions } from './e2ee.js';
+import { Mutex } from '@livekit/mutex';
+import { PathLike } from 'node:fs';
+import { TextStreamWriter, ByteStreamWriter } from './data_streams/stream_writer.js';
+import { PerformRpcParams, RpcInvocationData } from './rpc.js';
+import { Transcription } from './transcription.js';
+import { ChatMessage } from './types.js';
+import { VideoSource } from './video_source.js';
+
+declare abstract class TrackPublication {
+    /** @internal */
+    ffiHandle: FfiHandle;
+    /** @internal */
+    info?: TrackPublicationInfo;
+    track?: Track;
+    constructor(ownedInfo: OwnedTrackPublication);
+    get sid(): string | undefined;
+    get name(): string | undefined;
+    get kind(): TrackKind | undefined;
+    get source(): TrackSource | undefined;
+    get simulcasted(): boolean | undefined;
+    get width(): number | undefined;
+    get height(): number | undefined;
+    get mimeType(): string | undefined;
+    get muted(): boolean | undefined;
+    get encryptionType(): EncryptionType | undefined;
+    /**
+     * Update the publication's info in place. Used by the SDK when the
+     * server re-issues IDs / metadata for an existing publication (e.g.
+     * after a full reconnect). Application code holding a cached
+     * publication reference continues to read fresh values via the
+     * unchanged object identity.
+     * @internal
+     */
+    updateInfo(info: TrackPublicationInfo): void;
+}
+declare class LocalTrackPublication extends TrackPublication {
+    private firstSubscription;
+    private firstSubscriptionResolver;
+    constructor(ownedInfo: OwnedTrackPublication);
+    waitForSubscription(): Promise<void>;
+    /** @internal */
+    resolveFirstSubscription(): void;
+}
+declare class RemoteTrackPublication extends TrackPublication {
+    subscribed: boolean;
+    constructor(ownedInfo: OwnedTrackPublication);
+    setSubscribed(subscribed: boolean): void;
+}
+
+declare abstract class Participant {
+    /** @internal */
+    info: ParticipantInfo;
+    /** @internal */
+    ffi_handle: FfiHandle;
+    trackPublications: Map<string, TrackPublication>;
+    constructor(owned_info: OwnedParticipant);
+    get sid(): string | undefined;
+    get name(): string | undefined;
+    get identity(): string;
+    get metadata(): string;
+    get attributes(): Record<string, string>;
+    get kind(): ParticipantKind;
+    get kindDetails(): ParticipantKindDetail[];
+    get disconnectReason(): DisconnectReason | undefined;
+}
+type DataPublishOptions = {
+    /**
+     * whether to send this as reliable or lossy.
+     * For data that you need delivery guarantee (such as chat messages), use Reliable.
+     * For data that should arrive as quickly as possible, but you are ok with dropped
+     * packets, use Lossy.
+     */
+    reliable?: boolean;
+    /**
+     * the identities of participants who will receive the message, will be sent to every one if empty
+     */
+    destination_identities?: string[];
+    /** the topic under which the message gets published */
+    topic?: string;
+};
+declare class LocalParticipant extends Participant {
+    private rpcHandlers;
+    private ffiEventLock;
+    private disconnectSignal;
+    trackPublications: Map<string, LocalTrackPublication>;
+    constructor(info: OwnedParticipant, ffiEventLock: Mutex, disconnectSignal: AbortSignal);
+    publishData(data: Uint8Array, options: DataPublishOptions): Promise<void>;
+    publishDtmf(code: number, digit: string): Promise<void>;
+    publishTranscription(transcription: Transcription): Promise<void>;
+    updateMetadata(metadata: string): Promise<void>;
+    /**
+     * Returns a `StreamWriter` instance that allows to write individual chunks of text to a stream.
+     * Well suited for TTS and/or streaming LLM output. If you want to simply send a text then use sendText() instead
+     */
+    streamText(options?: {
+        topic?: string;
+        attributes?: Record<string, string>;
+        destinationIdentities?: Array<string>;
+        streamId?: string;
+        senderIdentity?: string;
+    }): Promise<TextStreamWriter>;
+    sendText(text: string, options?: {
+        topic?: string;
+        attributes?: Record<string, string>;
+        destinationIdentities?: Array<string>;
+        streamId?: string;
+    }): Promise<BaseStreamInfo>;
+    streamBytes(options?: {
+        name?: string;
+        topic?: string;
+        attributes?: Record<string, string>;
+        destinationIdentities?: Array<string>;
+        streamId?: string;
+        mimeType?: string;
+        totalSize?: number;
+    }): Promise<ByteStreamWriter>;
+    /** Sends a file provided as PathLike to specified recipients */
+    sendFile(path: PathLike, options?: ByteStreamOptions): Promise<void>;
+    private sendStreamHeader;
+    private sendStreamChunk;
+    private sendStreamTrailer;
+    /**
+     * Sends a chat message to participants in the room
+     *
+     * @param text - The text content of the chat message.
+     * @param destinationIdentities - An optional array of recipient identities to whom the message will be sent. If omitted, the message is broadcast to all participants.
+     * @param senderIdentity - An optional identity of the sender. If omitted, the default sender identity is used.
+     *
+     */
+    sendChatMessage(text: string, destinationIdentities?: Array<string>, senderIdentity?: string): Promise<ChatMessage>;
+    /**
+     * @experimental
+     */
+    editChatMessage(editText: string, originalMessage: ChatMessage, destinationIdentities?: Array<string>, senderIdentity?: string): Promise<ChatMessage>;
+    updateName(name: string): Promise<void>;
+    setAttributes(attributes: Record<string, string>): Promise<void>;
+    publishTrack(track: LocalTrack, options: TrackPublishOptions): Promise<LocalTrackPublication>;
+    unpublishTrack(trackSid: string, stopOnUnpublish?: boolean): Promise<void>;
+    /**
+     * Initiate an RPC call to a remote participant.
+     * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}
+     * @returns A promise that resolves with the response payload or rejects with an error.
+     * @throws Error on failure. Details in `message`.
+     */
+    performRpc({ destinationIdentity, method, payload, responseTimeout, }: PerformRpcParams): Promise<string>;
+    /**
+     * Establishes the participant as a receiver for calls of the specified RPC method.
+     * Will overwrite any existing callback for the same method.
+     *
+     * @param method - The name of the indicated RPC method
+     * @param handler - Will be invoked when an RPC request for this method is received
+     * @returns A promise that resolves when the method is successfully registered
+     *
+     * @example
+     * ```typescript
+     * room.localParticipant?.registerRpcMethod(
+     *   'greet',
+     *   async (data: RpcInvocationData) => {
+     *     console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
+     *     return `Hello, ${data.callerIdentity}!`;
+     *   }
+     * );
+     * ```
+     *
+     * See {@link RpcInvocationData} for more details on invocation params.
+     *
+     * The handler should return a Promise that resolves to a string.
+     * If unable to respond within `responseTimeout`, the request will result in an error on the caller's side.
+     *
+     * You may throw errors of type `RpcError` with a string `message` in the handler,
+     * and they will be received on the caller's side with the message intact.
+     * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+     */
+    registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
+    /**
+     * Unregisters a previously registered RPC method.
+     *
+     * @param method - The name of the RPC method to unregister
+     */
+    unregisterRpcMethod(method: string): void;
+    /** @internal */
+    handleRpcMethodInvocation(invocationId: bigint, method: string, requestId: string, callerIdentity: string, payload: string, responseTimeout: number): Promise<void>;
+}
+declare class RemoteParticipant extends Participant {
+    trackPublications: Map<string, RemoteTrackPublication>;
+    constructor(owned_info: OwnedParticipant);
+}
+
+interface RtcConfiguration {
+    iceTransportType: IceTransportType;
+    continualGatheringPolicy: ContinualGatheringPolicy;
+    iceServers: IceServer[];
+}
+declare const defaultRtcConfiguration: RtcConfiguration;
+interface RoomOptions {
+    autoSubscribe: boolean;
+    dynacast: boolean;
+    /**
+     * @deprecated Use `encryption` instead. See x for details
+     */
+    e2ee?: E2EEOptions;
+    encryption?: E2EEOptions;
+    rtcConfig?: RtcConfiguration;
+}
+declare const defaultRoomOptions: RoomOptions$1;
+declare const Room_base: new () => TypedEventEmitter<RoomCallbacks>;
+declare class Room extends Room_base {
+    private info?;
+    private ffiHandle?;
+    /**
+     * used to ensure events are processed sequentially and allow for
+     * the local participant to acquire the lock while doing state updates related to FFI events
+     * before processing the next events
+     */
+    private ffiEventLock;
+    private byteStreamControllers;
+    private textStreamControllers;
+    private byteStreamHandlers;
+    private textStreamHandlers;
+    private preConnectEvents;
+    private disconnectController;
+    private hasCleanedUp;
+    private _token?;
+    private _serverUrl?;
+    private _connectionState;
+    e2eeManager?: E2EEManager;
+    remoteParticipants: Map<string, RemoteParticipant>;
+    localParticipant?: LocalParticipant;
+    constructor();
+    get connectionState(): ConnectionState;
+    get name(): string | undefined;
+    get metadata(): string | undefined;
+    get isConnected(): boolean;
+    /** @internal */
+    get token(): string | undefined;
+    /** @internal */
+    get serverUrl(): string | undefined;
+    private sidPromise?;
+    /**
+     * Gets the room's server ID. This ID is assigned by the LiveKit server
+     * and is unique for each room session.
+     * SID is assigned asynchronously after connection.
+     * @returns Promise that resolves to the room's server ID, or empty string if not connected
+     */
+    getSid(): Promise<string>;
+    getRtcStats(): Promise<_livekit_rtc_ffi_bindings.GetSessionStatsCallback_Result>;
+    get numParticipants(): number;
+    get numPublishers(): number;
+    get creationTime(): Date;
+    get isRecording(): boolean;
+    /**
+     * The time in seconds after which a room will be closed after the last
+     * participant has disconnected.
+     */
+    get departureTimeout(): number;
+    /**
+     * The time in seconds after which an empty room will be automatically closed.
+     */
+    get emptyTimeout(): number;
+    /**
+     * Connects to a LiveKit room using the provided URL and access token.
+     * @param url - The WebSocket URL of the LiveKit server
+     * @param token - A valid LiveKit access token for authentication
+     * @param opts - Optional room configuration options
+     * @throws ConnectError - if connection fails
+     */
+    connect(url: string, token: string, opts?: RoomOptions): Promise<void>;
+    /**
+     * Disconnects from the room and cleans up all resources.
+     * This will stop all tracks and close the connection.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Trigger a reconnection / chaos scenario for testing. Most useful in
+     * tests to deterministically force a Resume (signal-only reconnect that
+     * preserves the PeerConnection and existing publications) or a full
+     * reconnect (the SDK rebuilds the RtcSession and re-publishes existing
+     * local tracks; `RoomEvent.Reconnected` fires).
+     */
+    simulateScenario(scenario: SimulateScenarioKind): Promise<void>;
+    private updateConnectionState;
+    private cleanupOnDisconnect;
+    /**
+     * Registers a handler for incoming text data streams on a specific topic.
+     * Text streams are used for receiving structured text data from other participants.
+     * @param topic - The topic to listen for text streams on
+     * @param callback - Function to handle incoming text stream data
+     * @throws Error - if a handler for this topic is already registered
+     */
+    registerTextStreamHandler(topic: string, callback: TextStreamHandler): void;
+    unregisterTextStreamHandler(topic: string): void;
+    /**
+     * Registers a handler for incoming byte data streams on a specific topic.
+     * Byte streams are used for receiving binary data like files from other participants.
+     * @param topic - The topic to listen for byte streams on
+     * @param callback - Function to handle incoming byte stream data
+     * @throws Error - if a handler for this topic is already registered
+     */
+    registerByteStreamHandler(topic: string, callback: ByteStreamHandler): void;
+    unregisterByteStreamHandler(topic: string): void;
+    private onFfiEvent;
+    private processFfiEvent;
+    private retrieveParticipantByIdentity;
+    private requireParticipantByIdentity;
+    private requireRemoteParticipant;
+    private requirePublicationOfParticipant;
+    private requirePublicationOfRemoteParticipant;
+    private createRemoteParticipant;
+    private handleStreamHeader;
+    private handleStreamChunk;
+    private handleStreamTrailer;
+}
+declare class ConnectError extends Error {
+    constructor(message: string);
+}
+type RoomCallbacks = {
+    participantConnected: (participant: RemoteParticipant) => void;
+    participantDisconnected: (participant: RemoteParticipant) => void;
+    localTrackPublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
+    localTrackUnpublished: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
+    /**
+     * Fired when the SDK auto-republished a local track during a full
+     * reconnect. The publication object's identity is preserved (the same
+     * instance is updated in place with the new server-assigned SIDs);
+     * `previousSid` is provided for callers that key external state on the
+     * old SID and need to reconcile.
+     */
+    localTrackRepublished: (publication: LocalTrackPublication, previousSid: string, participant: LocalParticipant) => void;
+    localTrackSubscribed: (track: LocalTrack) => void;
+    trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackUnpublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackSubscribed: (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackUnsubscribed: (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
+    trackSubscriptionFailed: (trackSid: string, participant: RemoteParticipant, reason?: string) => void;
+    trackMuted: (publication: TrackPublication, participant: Participant) => void;
+    trackUnmuted: (publication: TrackPublication, participant: Participant) => void;
+    activeSpeakersChanged: (speakers: Participant[]) => void;
+    roomMetadataChanged: (metadata: string) => void;
+    roomInfoUpdated: (info: RoomInfo) => void;
+    participantMetadataChanged: (metadata: string | undefined, participant: Participant) => void;
+    participantNameChanged: (name: string, participant: Participant) => void;
+    participantAttributesChanged: (changedAttributes: Record<string, string>, participant: Participant) => void;
+    participantEncryptionStatusChanged: (isEncrypted: boolean, participant: Participant) => void;
+    connectionQualityChanged: (quality: ConnectionQuality, participant: Participant) => void;
+    dataReceived: (payload: Uint8Array, participant?: RemoteParticipant, kind?: DataPacketKind, topic?: string, encryptionType?: EncryptionType) => void;
+    chatMessage: (message: ChatMessage, participant?: Participant) => void;
+    dtmfReceived: (code: number, digit: string, participant: RemoteParticipant) => void;
+    encryptionError: (error: Error) => void;
+    connectionStateChanged: (state: ConnectionState) => void;
+    connected: () => void;
+    disconnected: (reason: DisconnectReason) => void;
+    reconnecting: () => void;
+    reconnected: () => void;
+    roomSidChanged: (sid: string) => void;
+    roomUpdated: () => void;
+    moved: () => void;
+    tokenRefreshed: () => void;
+};
+declare enum RoomEvent {
+    ParticipantConnected = "participantConnected",
+    ParticipantDisconnected = "participantDisconnected",
+    LocalTrackPublished = "localTrackPublished",
+    LocalTrackUnpublished = "localTrackUnpublished",
+    LocalTrackRepublished = "localTrackRepublished",
+    LocalTrackSubscribed = "localTrackSubscribed",
+    TrackPublished = "trackPublished",
+    TrackUnpublished = "trackUnpublished",
+    TrackSubscribed = "trackSubscribed",
+    TrackUnsubscribed = "trackUnsubscribed",
+    TrackSubscriptionFailed = "trackSubscriptionFailed",
+    TrackMuted = "trackMuted",
+    TrackUnmuted = "trackUnmuted",
+    ActiveSpeakersChanged = "activeSpeakersChanged",
+    RoomMetadataChanged = "roomMetadataChanged",
+    RoomSidChanged = "roomSidChanged",
+    ParticipantMetadataChanged = "participantMetadataChanged",
+    ParticipantNameChanged = "participantNameChanged",
+    ParticipantAttributesChanged = "participantAttributesChanged",
+    ParticipantEncryptionStatusChanged = "participantEncryptionStatusChanged",
+    ConnectionQualityChanged = "connectionQualityChanged",
+    DataReceived = "dataReceived",
+    ChatMessage = "chatMessage",
+    DtmfReceived = "dtmfReceived",
+    EncryptionError = "encryptionError",
+    ConnectionStateChanged = "connectionStateChanged",
+    Connected = "connected",
+    Disconnected = "disconnected",
+    Reconnecting = "reconnecting",
+    Reconnected = "reconnected",
+    RoomUpdated = "roomUpdated",
+    Moved = "moved",
+    TokenRefreshed = "tokenRefreshed"
+}
+
+declare abstract class Track {
+    /** @internal */
+    info?: TrackInfo;
+    /** @internal */
+    ffi_handle: FfiHandle;
+    private roomRef;
+    private audioStreams;
+    private streamFinalizationRegistry;
+    private onRoomTokenRefreshed;
+    constructor(owned: OwnedTrack);
+    /** @internal */
+    resolveRoom(): Room | null;
+    /** @internal */
+    setRoom(room: Room | null): void;
+    /** @internal */
+    registerAudioStream(stream: AudioStreamSource): void;
+    /** @internal */
+    unregisterAudioStream(stream: AudioStreamSource): void;
+    private iterateStreams;
+    private pushProcessorMetadataToStream;
+    get sid(): string | undefined;
+    get name(): string | undefined;
+    get kind(): TrackKind | undefined;
+    get stream_state(): StreamState | undefined;
+    get muted(): boolean | undefined;
+    close(): Promise<void>;
+}
+declare class LocalAudioTrack extends Track {
+    private source?;
+    constructor(owned: OwnedTrack, source?: AudioSource);
+    static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack;
+    close(closeSource?: boolean): Promise<void>;
+}
+declare class LocalVideoTrack extends Track {
+    private source?;
+    constructor(owned: OwnedTrack, source?: VideoSource);
+    static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack;
+    close(closeSource?: boolean): Promise<void>;
+}
+declare class RemoteVideoTrack extends Track {
+    constructor(owned: OwnedTrack);
+}
+declare class RemoteAudioTrack extends Track {
+    constructor(owned: OwnedTrack);
+}
+type LocalTrack = LocalVideoTrack | LocalAudioTrack;
+type RemoteTrack = RemoteVideoTrack | RemoteAudioTrack;
+type AudioTrack = LocalAudioTrack | RemoteAudioTrack;
+type VideoTrack = LocalVideoTrack | RemoteVideoTrack;
+
+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;
+}
+interface NoiseCancellationOptions {
+    moduleId: string;
+    options: Record<string, any>;
+}
+/** @internal */
+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;
+    cancel(): void;
+}
+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);
+}
+
+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 };

package/dist/audio_stream.cjs

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var audio_stream_exports = {};
 __export(audio_stream_exports, {
-  AudioStream: () => AudioStream
+  AudioStream: () => AudioStream,
+  AudioStreamSource: () => AudioStreamSource
 });
 module.exports = __toCommonJS(audio_stream_exports);
 var import_rtc_ffi_bindings = require("@livekit/rtc-ffi-bindings");
@@ -29,8 +30,9 @@ var import_log = require("./log.cjs");
 class AudioStreamSource {
   constructor(track, sampleRateOrOptions, numChannels) {
     this.disposed = false;
+    this.frameProcessor = null;
+    this.autoCloseProcessor = true;
     this.onEvent = (ev) => {
-      var _a;
       if (!this.controller) {
         throw new Error("Stream controller not initialized");
       }
@@ -55,17 +57,22 @@ class AudioStreamSource {
           this.controller.close();
           if (!this.disposed) {
             this.disposed = true;
+            this.track.unregisterAudioStream(this);
             this.ffiHandle.dispose();
-            (_a = this.frameProcessor) == null ? void 0 : _a.close();
+            if (this.frameProcessor && this.autoCloseProcessor) {
+              this.frameProcessor.close();
+            }
           }
           break;
       }
     };
+    this.track = track;
     if (sampleRateOrOptions !== void 0 && typeof sampleRateOrOptions !== "number") {
       this.sampleRate = sampleRateOrOptions.sampleRate ?? 48e3;
       this.numChannels = sampleRateOrOptions.numChannels ?? 1;
       if ((0, import_frame_processor.isFrameProcessor)(sampleRateOrOptions.noiseCancellation)) {
         this.frameProcessor = sampleRateOrOptions.noiseCancellation;
+        this.autoCloseProcessor = sampleRateOrOptions.autoCloseNoiseCancellation ?? true;
       } else {
         this.legacyNcOptions = sampleRateOrOptions.noiseCancellation;
       }
@@ -93,17 +100,24 @@ class AudioStreamSource {
     });
     this.ffiHandle = new import_ffi_client.FfiHandle(res.stream.handle.id);
     import_ffi_client.FfiClient.instance.on(import_ffi_client.FfiClientEvent.FfiEvent, this.onEvent);
+    track.registerAudioStream(this);
+  }
+  /** @internal */
+  get processor() {
+    return this.frameProcessor;
   }
   start(controller) {
     this.controller = controller;
   }
   cancel() {
-    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();
-      (_a = this.frameProcessor) == null ? void 0 : _a.close();
+      if (this.frameProcessor && this.autoCloseProcessor) {
+        this.frameProcessor.close();
+      }
     }
   }
 }
@@ -114,6 +128,7 @@ class AudioStream extends ReadableStream {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AudioStream
+  AudioStream,
+  AudioStreamSource
 });
 //# sourceMappingURL=audio_stream.cjs.map

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  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\nclass 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>;\n  private frameSizeMs?: number;\n\n  constructor(\n    track: Track,\n    sampleRateOrOptions?: number | AudioStreamOptions,\n    numChannels?: number,\n  ) {\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      } 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  }\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.ffiHandle.dispose();\n          this.frameProcessor?.close();\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.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      this.frameProcessor?.close();\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;AAIA,8BAAuD;AAEvD,yBAA2B;AAE3B,wBAAqD;AACrD,6BAAsD;AACtD,iBAAoB;AAgBpB,MAAM,kBAA0D;AAAA,EAU9D,YACE,OACA,qBACA,aACA;AAXF,SAAQ,WAAW;AAoDnB,SAAQ,UAAU,CAAC,OAAiB;AAjFtC;AAkFI,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,UAAU,QAAQ;AACvB,uBAAK,mBAAL,mBAAqB;AAAA,UACvB;AACA;AAAA,MACJ;AAAA,IACF;AA/EE,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;AAAA,MAC5C,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;AAAA,EAC7D;AAAA,EA2CA,MAAM,YAAyD;AAC7D,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,SAAS;AA9HX;AA+HI,gCAAU,SAAS,IAAI,iCAAe,UAAU,KAAK,OAAO;AAC5D,QAAI,CAAC,KAAK,UAAU;AAClB,WAAK,WAAW;AAChB,WAAK,UAAU,QAAQ;AAGvB,iBAAK,mBAAL,mBAAqB;AAAA,IACvB;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        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":"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","names":[]}

package/dist/audio_stream.d.cts

@@ -1,28 +1,18 @@
-import { AudioFrame } from './audio_frame.cjs';
-import { FrameProcessor } from './frame_processor.cjs';
-import { Track } from './track.cjs';
+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';
 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 './e2ee.cjs';
+import '@livekit/mutex';
+import 'node:fs';
+import './data_streams/stream_writer.cjs';
+import './rpc.cjs';
+import './transcription.cjs';
+import './types.cjs';
 import './video_source.cjs';
-
-interface AudioStreamOptions {
-    noiseCancellation?: NoiseCancellationOptions | FrameProcessor<AudioFrame>;
-    sampleRate?: number;
-    numChannels?: number;
-    frameSizeMs?: number;
-}
-interface NoiseCancellationOptions {
-    moduleId: string;
-    options: Record<string, any>;
-}
-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);
-}
-
-export { AudioStream, type AudioStreamOptions, type NoiseCancellationOptions };