@livekit/rtc-node 0.13.14 → 0.13.16

package/src/proto/track_pb.ts

@@ -113,6 +113,58 @@ proto2.util.setEnumType(StreamState, "livekit.proto.StreamState", [
   { no: 2, name: "STATE_PAUSED" },
 ]);
 
+/**
+ * @generated from enum livekit.proto.AudioTrackFeature
+ */
+export enum AudioTrackFeature {
+  /**
+   * @generated from enum value: TF_STEREO = 0;
+   */
+  TF_STEREO = 0,
+
+  /**
+   * @generated from enum value: TF_NO_DTX = 1;
+   */
+  TF_NO_DTX = 1,
+
+  /**
+   * @generated from enum value: TF_AUTO_GAIN_CONTROL = 2;
+   */
+  TF_AUTO_GAIN_CONTROL = 2,
+
+  /**
+   * @generated from enum value: TF_ECHO_CANCELLATION = 3;
+   */
+  TF_ECHO_CANCELLATION = 3,
+
+  /**
+   * @generated from enum value: TF_NOISE_SUPPRESSION = 4;
+   */
+  TF_NOISE_SUPPRESSION = 4,
+
+  /**
+   * @generated from enum value: TF_ENHANCED_NOISE_CANCELLATION = 5;
+   */
+  TF_ENHANCED_NOISE_CANCELLATION = 5,
+
+  /**
+   * client will buffer audio once available and send it to the server via bytes stream once connected
+   *
+   * @generated from enum value: TF_PRECONNECT_BUFFER = 6;
+   */
+  TF_PRECONNECT_BUFFER = 6,
+}
+// Retrieve enum metadata with: proto2.getEnumType(AudioTrackFeature)
+proto2.util.setEnumType(AudioTrackFeature, "livekit.proto.AudioTrackFeature", [
+  { no: 0, name: "TF_STEREO" },
+  { no: 1, name: "TF_NO_DTX" },
+  { no: 2, name: "TF_AUTO_GAIN_CONTROL" },
+  { no: 3, name: "TF_ECHO_CANCELLATION" },
+  { no: 4, name: "TF_NOISE_SUPPRESSION" },
+  { no: 5, name: "TF_ENHANCED_NOISE_CANCELLATION" },
+  { no: 6, name: "TF_PRECONNECT_BUFFER" },
+]);
+
 /**
  * Create a new VideoTrack from a VideoSource
  *
@@ -490,6 +542,11 @@ export class TrackPublicationInfo extends Message<TrackPublicationInfo> {
    */
   encryptionType?: EncryptionType;
 
+  /**
+   * @generated from field: repeated livekit.proto.AudioTrackFeature audio_features = 12;
+   */
+  audioFeatures: AudioTrackFeature[] = [];
+
   constructor(data?: PartialMessage<TrackPublicationInfo>) {
     super();
     proto2.util.initPartial(data, this);
@@ -509,6 +566,7 @@ export class TrackPublicationInfo extends Message<TrackPublicationInfo> {
     { no: 9, name: "muted", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
     { no: 10, name: "remote", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
     { no: 11, name: "encryption_type", kind: "enum", T: proto2.getEnumType(EncryptionType), req: true },
+    { no: 12, name: "audio_features", kind: "enum", T: proto2.getEnumType(AudioTrackFeature), repeated: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrackPublicationInfo {

package/src/room.ts

@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: Apache-2.0
 import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
 import EventEmitter from 'events';
-import { ReadableStream } from 'node:stream/web';
 import { ByteStreamReader, TextStreamReader } from './data_streams/stream_reader.js';
 import type {
   ByteStreamHandler,
@@ -105,6 +104,12 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     return this.ffiHandle != undefined && this.connectionState != ConnectionState.CONN_DISCONNECTED;
   }
 
+  /**
+   * 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
+   */
   async getSid(): Promise<string> {
     if (!this.isConnected) {
       return '';
@@ -127,6 +132,44 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     });
   }
 
+  get numParticipants(): number {
+    return this.info?.numParticipants ?? 0;
+  }
+
+  get numPublishers(): number {
+    return this.info?.numPublishers ?? 0;
+  }
+
+  get creationTime(): Date {
+    return new Date(Number(this.info?.creationTime ?? 0));
+  }
+
+  get isRecording(): boolean {
+    return this.info?.activeRecording ?? false;
+  }
+
+  /**
+   * The time in seconds after which a room will be closed after the last
+   * participant has disconnected.
+   */
+  get departureTimeout(): number {
+    return this.info?.departureTimeout ?? 0;
+  }
+
+  /**
+   * The time in seconds after which an empty room will be automatically closed.
+   */
+  get emptyTimeout(): number {
+    return this.info?.emptyTimeout ?? 0;
+  }
+
+  /**
+   * 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
+   */
   async connect(url: string, token: string, opts?: RoomOptions) {
     const options = { ...defaultRoomOptions, ...opts };
     const e2eeOptions = { ...defaultE2EEOptions, ...options.e2ee };
@@ -176,6 +219,10 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     }
   }
 
+  /**
+   * Disconnects from the room and cleans up all resources.
+   * This will stop all tracks and close the connection.
+   */
   async disconnect() {
     if (!this.isConnected) {
       return;
@@ -194,6 +241,13 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     this.removeAllListeners();
   }
 
+  /**
+   * 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) {
     if (this.textStreamHandlers.has(topic)) {
       throw new Error(`A text stream handler for topic "${topic}" has already been set.`);
@@ -205,6 +259,13 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     this.textStreamHandlers.delete(topic);
   }
 
+  /**
+   * 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) {
     if (this.byteStreamHandlers.has(topic)) {
       throw new Error(`A byte stream handler for topic "${topic}" has already been set.`);
@@ -421,6 +482,19 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       this.handleStreamChunk(ev.value.chunk);
     } else if (ev.case === 'streamTrailerReceived' && ev.value.trailer) {
       this.handleStreamTrailer(ev.value.trailer);
+    } else if (ev.case === 'roomUpdated') {
+      this.info = ev.value;
+      this.emit(RoomEvent.RoomUpdated);
+    } else if (ev.case === 'moved') {
+      this.info = ev.value;
+      this.emit(RoomEvent.Moved);
+    } else if (ev.case === 'participantsUpdated') {
+      for (const info of ev.value.participants) {
+        const participant = this.retrieveParticipantByIdentity(info.identity!);
+        if (participant) {
+          participant.info = info;
+        }
+      }
     }
   };
 
@@ -632,6 +706,8 @@ export type RoomCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
   roomSidChanged: (sid: string) => void;
+  roomUpdated: () => void;
+  moved: () => void;
 };
 
 export enum RoomEvent {
@@ -663,4 +739,6 @@ export enum RoomEvent {
   Disconnected = 'disconnected',
   Reconnecting = 'reconnecting',
   Reconnected = 'reconnected',
+  RoomUpdated = 'roomUpdated',
+  Moved = 'moved',
 }

package/src/track.ts

@@ -45,11 +45,18 @@ export abstract class Track {
   get muted(): boolean | undefined {
     return this.info?.muted;
   }
+
+  async close() {
+    this.ffi_handle.dispose();
+  }
 }
 
 export class LocalAudioTrack extends Track {
-  constructor(owned: OwnedTrack) {
+  private source?: AudioSource;
+
+  constructor(owned: OwnedTrack, source?: AudioSource) {
     super(owned);
+    this.source = source;
   }
 
   static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack {
@@ -62,13 +69,23 @@ export class LocalAudioTrack extends Track {
       message: { case: 'createAudioTrack', value: req },
     });
 
-    return new LocalAudioTrack(res.track!);
+    return new LocalAudioTrack(res.track!, source);
+  }
+
+  async close(closeSource = true) {
+    await super.close();
+    if (closeSource) {
+      await this.source?.close();
+    }
   }
 }
 
 export class LocalVideoTrack extends Track {
-  constructor(owned: OwnedTrack) {
+  private source?: VideoSource;
+
+  constructor(owned: OwnedTrack, source?: VideoSource) {
     super(owned);
+    this.source = source;
   }
 
   static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack {
@@ -81,7 +98,14 @@ export class LocalVideoTrack extends Track {
       message: { case: 'createVideoTrack', value: req },
     });
 
-    return new LocalVideoTrack(res.track!);
+    return new LocalVideoTrack(res.track!, source);
+  }
+
+  async close(closeSource = true) {
+    await super.close();
+    if (closeSource) {
+      await this.source?.close();
+    }
   }
 }
 

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.13.14";
+export const SDK_VERSION = "0.13.16";

package/src/video_stream.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { ReadableStream, type UnderlyingSource } from 'node:stream/web';
+import type { UnderlyingSource } from 'node:stream/web';
 import type { FfiEvent } from './ffi_client.js';
 import { FfiClient, FfiClientEvent, FfiHandle } from './ffi_client.js';
 import type { NewVideoStreamResponse, VideoRotation } from './proto/video_frame_pb.js';