@livekit/rtc-node 0.13.24 → 0.13.26

package/src/tests/e2e.test.ts

@@ -4,7 +4,7 @@
 import { AccessToken } from 'livekit-server-sdk';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
-import { afterAll, describe, expect, it } from 'vitest';
+import { afterAll, describe, expect, it as itRaw } from 'vitest';
 import {
   AudioFrame,
   AudioSource,
@@ -20,6 +20,9 @@ import {
   dispose,
 } from '../index.js';
 
+// use concurrent testing if available on the runner (currently not supported by bun's api)
+const it = typeof itRaw.concurrent === 'function' ? itRaw.concurrent : itRaw;
+
 const hasE2EEnv =
   !!process.env.LIVEKIT_URL && !!process.env.LIVEKIT_API_KEY && !!process.env.LIVEKIT_API_SECRET;
 const describeE2E = hasE2EEnv ? describe : describe.skip;
@@ -202,7 +205,7 @@ describeE2E('livekit-rtc e2e', () => {
     await dispose();
   });
 
-  it.concurrent(
+  it(
     'connects to a room',
     async () => {
       const { roomName, rooms } = await connectTestRooms(1);
@@ -225,7 +228,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
-  it.concurrent(
+  it(
     'connects multiple participants to the same room',
     async () => {
       const { roomName, rooms } = await connectTestRooms(2);
@@ -241,7 +244,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
-  it.concurrent(
+  it(
     'emits participantDisconnected when a participant leaves',
     async () => {
       const { rooms } = await connectTestRooms(2);
@@ -267,7 +270,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
-  it.concurrent(
+  it(
     'transfers audio between two participants (sine detection)',
     async () => {
       const cases = [
@@ -367,7 +370,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs * 2,
   );
 
-  it.concurrent(
+  it(
     'publishes and receives reliable data packets',
     async () => {
       const { rooms } = await connectTestRooms(2);
@@ -407,7 +410,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
-  it.concurrent(
+  it(
     'sends and receives text and byte streams',
     async () => {
       const { rooms } = await connectTestRooms(2);
@@ -469,7 +472,7 @@ describeE2E('livekit-rtc e2e', () => {
     testTimeoutMs,
   );
 
-  it.concurrent(
+  it(
     'invokes RPC methods and returns structured errors',
     async () => {
       const { rooms } = await connectTestRooms(2);
@@ -511,4 +514,172 @@ describeE2E('livekit-rtc e2e', () => {
     },
     testTimeoutMs * 2,
   );
+
+  it(
+    'cleans up stream controllers when disconnecting during an active stream',
+    async () => {
+      const { rooms } = await connectTestRooms(2);
+      const [receivingRoom, sendingRoom] = rooms;
+      const topic = 'cleanup-stream-topic';
+
+      // Register a handler on the receiving side that will intentionally
+      // NOT fully consume the stream — simulating an abandoned transfer.
+      let readerReceived = false;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      receivingRoom!.registerTextStreamHandler(topic, async (_reader, _sender) => {
+        readerReceived = true;
+        // Deliberately do not call reader.readAll() so the stream stays open
+      });
+
+      // Start sending a text stream but don't close it
+      const writer = await sendingRoom!.localParticipant!.streamText({ topic });
+      await writer.write('partial data');
+
+      // Wait for the receiving side to get the stream header
+      await waitFor(() => readerReceived, {
+        timeoutMs: 5000,
+        debugName: 'text stream header received',
+      });
+
+      // Disconnect the receiving room while the stream is still open.
+      // This should close the stream controller without throwing.
+      await receivingRoom!.disconnect();
+
+      // Also close the writer and disconnect the sender
+      await writer.close();
+      await sendingRoom!.disconnect();
+
+      // If we got here without hanging or throwing, the stream controller
+      // was properly cleaned up on disconnect.
+    },
+    testTimeoutMs,
+  );
+
+  it(
+    'cleans up track publications when a remote participant disconnects',
+    async () => {
+      const { rooms } = await connectTestRooms(2);
+      const [stayingRoom, leavingRoom] = rooms;
+
+      // Publish a track from the leaving participant so its track publication
+      // will need to be cleaned up on disconnect.
+      const source = new AudioSource(48_000, 1);
+      const track = LocalAudioTrack.createAudioTrack('cleanup-test', source);
+      const options = new TrackPublishOptions();
+      options.source = TrackSource.SOURCE_MICROPHONE;
+      await leavingRoom!.localParticipant!.publishTrack(track, options);
+
+      // Wait for the staying room to see the track subscription
+      await waitFor(
+        () => {
+          const remote = stayingRoom!.remoteParticipants.get(
+            leavingRoom!.localParticipant!.identity,
+          );
+          return remote !== undefined && remote.trackPublications.size > 0;
+        },
+        { timeoutMs: 5000, debugName: 'track publication visible' },
+      );
+
+      // Capture a reference to the remote participant before disconnect
+      const remoteParticipant = stayingRoom!.remoteParticipants.get(
+        leavingRoom!.localParticipant!.identity,
+      )!;
+      expect(remoteParticipant.trackPublications.size).toBeGreaterThan(0);
+
+      // Listen for the disconnect event
+      const disconnected = waitForRoomEvent(
+        stayingRoom!,
+        RoomEvent.ParticipantDisconnected,
+        testTimeoutMs,
+        (p: { identity: string }) => p.identity,
+      );
+
+      await leavingRoom!.disconnect();
+      await disconnected;
+
+      // trackUnpublished events fire before participantDisconnected, so
+      // by this point all publications should already be removed and disposed.
+      expect(remoteParticipant.trackPublications.size).toBe(0);
+      expect(stayingRoom!.remoteParticipants.has(remoteParticipant.identity)).toBe(false);
+
+      await source.close();
+      await stayingRoom!.disconnect();
+    },
+    testTimeoutMs,
+  );
+
+  it(
+    'cleans up resources when multiple participants disconnect simultaneously',
+    async () => {
+      // Connect 4 participants to stress-test concurrent disconnection cleanup
+      const { rooms } = await connectTestRooms(4);
+
+      // Publish a track from each participant to create track publications
+      const sources: AudioSource[] = [];
+      for (const room of rooms) {
+        const source = new AudioSource(48_000, 1);
+        sources.push(source);
+        const track = LocalAudioTrack.createAudioTrack('multi-cleanup', source);
+        const options = new TrackPublishOptions();
+        options.source = TrackSource.SOURCE_MICROPHONE;
+        await room.localParticipant!.publishTrack(track, options);
+      }
+
+      // Wait for all participants to see each other's tracks
+      await waitFor(
+        () =>
+          rooms.every(
+            (r) =>
+              r.remoteParticipants.size === 3 &&
+              [...r.remoteParticipants.values()].every((p) => p.trackPublications.size > 0),
+          ),
+        { timeoutMs: 5000, debugName: 'all tracks visible' },
+      );
+
+      // Register listeners before disconnecting so we can verify both
+      // RoomEvent.Disconnected and RoomEvent.ConnectionStateChanged fire
+      // for every room, even when disconnects race.
+      const disconnectedEvents = rooms.map((r) =>
+        waitForRoomEvent(r, RoomEvent.Disconnected, 3_000, (reason) => reason),
+      );
+      const connectionStateEvents = rooms.map((r) =>
+        waitForRoomEvent(r, RoomEvent.ConnectionStateChanged, 3_000, (state) => state),
+      );
+
+      // Disconnect all participants simultaneously
+      await Promise.all([...rooms.map((r) => r.disconnect()), ...sources.map((s) => s.close())]);
+
+      await Promise.all(disconnectedEvents);
+      const observedStates = await Promise.all(connectionStateEvents);
+
+      // Verify all rooms are disconnected and remote participant maps are empty
+      for (const room of rooms) {
+        expect(room.isConnected).toBe(false);
+      }
+      for (const state of observedStates) {
+        expect(state).toBe(ConnectionState.CONN_DISCONNECTED);
+      }
+    },
+    testTimeoutMs * 2,
+  );
+
+  it(
+    'concurrent getSid() calls share a single listener and resolve consistently',
+    async () => {
+      const { rooms } = await connectTestRooms(1);
+      const room = rooms[0]!;
+
+      // Fire multiple concurrent getSid() calls — they should all resolve
+      // to the same SID without leaking event listeners.
+      const results = await Promise.all([room.getSid(), room.getSid(), room.getSid()]);
+
+      // All calls should return the same non-empty SID
+      expect(results[0]).toBeTruthy();
+      expect(results[1]).toBe(results[0]);
+      expect(results[2]).toBe(results[0]);
+
+      await room.disconnect();
+    },
+    testTimeoutMs,
+  );
 });

package/src/track.ts

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import type { AudioSource } from './audio_source.js';
-import { FfiClient, FfiHandle } from './ffi_client.js';
 import type {
   CreateAudioTrackResponse,
   CreateVideoTrackResponse,
@@ -10,8 +8,10 @@ import type {
   StreamState,
   TrackInfo,
   TrackKind,
-} from './proto/track_pb.js';
-import { CreateAudioTrackRequest, CreateVideoTrackRequest } from './proto/track_pb.js';
+} from '@livekit/rtc-ffi-bindings';
+import { CreateAudioTrackRequest, CreateVideoTrackRequest } from '@livekit/rtc-ffi-bindings';
+import type { AudioSource } from './audio_source.js';
+import { FfiClient, FfiHandle } from './ffi_client.js';
 import type { VideoSource } from './video_source.js';
 
 export abstract class Track {

package/src/track_publication.ts

@@ -1,17 +1,17 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { FfiClient } from './ffi_client.js';
-import { FfiHandle } from './napi/native.js';
-import type { EncryptionType } from './proto/e2ee_pb.js';
-import type { SetSubscribedResponse } from './proto/room_pb.js';
-import { SetSubscribedRequest } from './proto/room_pb.js';
+import type { EncryptionType } from '@livekit/rtc-ffi-bindings';
+import type { SetSubscribedResponse } from '@livekit/rtc-ffi-bindings';
+import { SetSubscribedRequest } from '@livekit/rtc-ffi-bindings';
 import type {
   OwnedTrackPublication,
   TrackKind,
   TrackPublicationInfo,
   TrackSource,
-} from './proto/track_pb.js';
+} from '@livekit/rtc-ffi-bindings';
+import { FfiHandle } from '@livekit/rtc-ffi-bindings';
+import { FfiClient } from './ffi_client.js';
 import type { Track } from './track.js';
 
 export abstract class TrackPublication {

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.13.24";
+export const SDK_VERSION = "0.13.26";

package/src/video_frame.ts

@@ -1,13 +1,13 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { FfiClient, FfiHandle, FfiRequest } from './ffi_client.js';
-import type { OwnedVideoBuffer, VideoConvertResponse } from './proto/video_frame_pb.js';
+import type { OwnedVideoBuffer, VideoConvertResponse } from '@livekit/rtc-ffi-bindings';
 import {
   VideoBufferInfo,
   VideoBufferInfo_ComponentInfo,
   VideoBufferType,
-} from './proto/video_frame_pb.js';
+} from '@livekit/rtc-ffi-bindings';
+import { FfiClient, FfiHandle, FfiRequest } from './ffi_client.js';
 
 export class VideoFrame {
   data: Uint8Array;

package/src/video_source.ts

@@ -1,18 +1,18 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { FfiClient, FfiHandle } from './ffi_client.js';
 import type {
   CaptureVideoFrameResponse,
   NewVideoSourceResponse,
   VideoSourceInfo,
-} from './proto/video_frame_pb.js';
+} from '@livekit/rtc-ffi-bindings';
 import {
   CaptureVideoFrameRequest,
   NewVideoSourceRequest,
   VideoRotation,
   VideoSourceType,
-} from './proto/video_frame_pb.js';
+} from '@livekit/rtc-ffi-bindings';
+import { FfiClient, FfiHandle } from './ffi_client.js';
 import type { VideoFrame } from './video_frame.js';
 
 export class VideoSource {

package/src/video_stream.ts

@@ -1,11 +1,11 @@
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
+import type { NewVideoStreamResponse, VideoRotation } from '@livekit/rtc-ffi-bindings';
+import { NewVideoStreamRequest, VideoStreamType } from '@livekit/rtc-ffi-bindings';
 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';
-import { NewVideoStreamRequest, VideoStreamType } from './proto/video_frame_pb.js';
 import type { Track } from './track.js';
 import { VideoFrame } from './video_frame.js';
 
@@ -18,6 +18,7 @@ export type VideoFrameEvent = {
 class VideoStreamSource implements UnderlyingSource<VideoFrameEvent> {
   private controller?: ReadableStreamDefaultController<VideoFrameEvent>;
   private ffiHandle: FfiHandle;
+  private disposed = false;
 
   constructor(track: Track) {
     const req = new NewVideoStreamRequest({
@@ -65,6 +66,14 @@ class VideoStreamSource implements UnderlyingSource<VideoFrameEvent> {
       case 'eos':
         FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);
         this.controller.close();
+        // Dispose the native handle so the FD is released on stream end,
+        // not just when cancel() is called explicitly by the consumer.
+        // Guard against double-dispose if cancel() is called after EOS
+        // while buffered frames are still in the ReadableStream queue.
+        if (!this.disposed) {
+          this.disposed = true;
+          this.ffiHandle.dispose();
+        }
         break;
     }
   };
@@ -75,7 +84,10 @@ class VideoStreamSource implements UnderlyingSource<VideoFrameEvent> {
 
   cancel() {
     FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);
-    this.ffiHandle.dispose();
+    if (!this.disposed) {
+      this.disposed = true;
+      this.ffiHandle.dispose();
+    }
   }
 }
 

package/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-edition = "2021"
-name = "rtc-node"
-version = "0.0.1"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-napi = { version = "2.12.2", default-features = false, features = [
-    "async",
-    "napi6",
-] }
-napi-derive = "2.12.2"
-livekit-ffi = { path = "./rust-sdks/livekit-ffi" }
-prost = "0.14"
-prost-types = "0.14"
-log = "0.4.20"
-tokio = { version = "1.37.0", features = ["full"] }
-
-[build-dependencies]
-napi-build = "2.0.1"
-
-[profile.release]
-lto = true

package/build.rs

@@ -1,9 +0,0 @@
-// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
-//
-// SPDX-License-Identifier: Apache-2.0
-
-extern crate napi_build;
-
-fn main() {
-    napi_build::setup();
-}