@livekit/rtc-node 0.13.27 → 0.13.28

package/package.json

@@ -3,7 +3,7 @@
   "description": "LiveKit RTC Node",
   "license": "Apache-2.0",
   "author": "LiveKit",
-  "version": "0.13.27",
+  "version": "0.13.28",
   "main": "dist/index.js",
   "require": "dist/index.cjs",
   "types": "dist/index.d.ts",
@@ -33,7 +33,7 @@
     "@datastructures-js/deque": "1.0.8",
     "@livekit/mutex": "^1.0.0",
     "@livekit/typed-emitter": "^3.0.0",
-    "@livekit/rtc-ffi-bindings": "0.12.52-patch.0",
+    "@livekit/rtc-ffi-bindings": "0.12.56",
     "pino": "^9.0.0",
     "pino-pretty": "^13.0.0"
   },
@@ -44,7 +44,7 @@
     "prettier": "^3.0.3",
     "tsup": "^8.3.5",
     "typescript": "5.8.2",
-    "livekit-server-sdk": "2.15.2"
+    "livekit-server-sdk": "2.15.3"
   },
   "engines": {
     "node": ">= 18"
@@ -53,6 +53,7 @@
     "prebuild": "node -p \"'export const SDK_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
     "build": "pnpm prebuild && tsup --onSuccess \"tsc --declaration --emitDeclarationOnly\"",
     "lint": "eslint -f unix \"src/**/*.ts\" --ignore-pattern \"src/proto/*\"",
-    "test": "vitest run src"
+    "test": "vitest run src",
+    "test:e2e": "node scripts/run-e2e.mjs"
   }
 }

package/src/index.ts

@@ -15,7 +15,11 @@ export type { E2EEOptions, KeyProviderOptions } from './e2ee.js';
 export { dispose } from './ffi_client.js';
 export { LocalParticipant, Participant, RemoteParticipant } from './participant.js';
 export { EncryptionState, EncryptionType } from '@livekit/rtc-ffi-bindings';
-export { DisconnectReason, ParticipantKind } from '@livekit/rtc-ffi-bindings';
+export {
+  DisconnectReason,
+  ParticipantKind,
+  ParticipantKindDetail,
+} from '@livekit/rtc-ffi-bindings';
 export {
   ConnectionQuality,
   ConnectionState,
@@ -25,7 +29,12 @@ export {
   IceTransportType,
   TrackPublishOptions,
 } from '@livekit/rtc-ffi-bindings';
-export { StreamState, TrackKind, TrackSource } from '@livekit/rtc-ffi-bindings';
+export {
+  SimulateScenarioKind,
+  StreamState,
+  TrackKind,
+  TrackSource,
+} from '@livekit/rtc-ffi-bindings';
 export { VideoBufferType, VideoCodec, VideoRotation } from '@livekit/rtc-ffi-bindings';
 export { ConnectError, Room, RoomEvent, type RoomOptions, type RtcConfiguration } from './room.js';
 export { RpcError, type PerformRpcParams, type RpcInvocationData } from './rpc.js';

package/src/participant.ts

@@ -7,6 +7,7 @@ import {
   type OwnedParticipant,
   type ParticipantInfo,
   ParticipantKind,
+  type ParticipantKindDetail,
 } from '@livekit/rtc-ffi-bindings';
 import {
   ChatMessage as ChatMessageModel,
@@ -128,6 +129,10 @@ export abstract class Participant {
     return this.info.kind ?? ParticipantKind.STANDARD;
   }
 
+  get kindDetails(): ParticipantKindDetail[] {
+    return this.info.kindDetails ?? [];
+  }
+
   get disconnectReason(): DisconnectReason | undefined {
     if (this.info.disconnectReason === DisconnectReason.UNKNOWN_REASON) {
       return undefined;

package/src/room.ts

@@ -5,7 +5,11 @@ import { Mutex } from '@livekit/mutex';
 import { EncryptionState, type EncryptionType } from '@livekit/rtc-ffi-bindings';
 import type { FfiEvent } from '@livekit/rtc-ffi-bindings';
 import { DisconnectReason, type OwnedParticipant } from '@livekit/rtc-ffi-bindings';
-import type { DataStream_Trailer, DisconnectCallback } from '@livekit/rtc-ffi-bindings';
+import type {
+  DataStream_Trailer,
+  DisconnectCallback,
+  TrackPublicationInfo,
+} from '@livekit/rtc-ffi-bindings';
 import {
   type ConnectCallback,
   ConnectRequest,
@@ -21,6 +25,9 @@ import {
   type IceServer,
   IceTransportType,
   type RoomInfo,
+  type SimulateScenarioCallback,
+  type SimulateScenarioKind,
+  type SimulateScenarioResponse,
 } from '@livekit/rtc-ffi-bindings';
 import { TrackKind } from '@livekit/rtc-ffi-bindings';
 import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
@@ -325,6 +332,36 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     this.removeAllListeners();
   }
 
+  /**
+   * 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).
+   */
+  async simulateScenario(scenario: SimulateScenarioKind): Promise<void> {
+    if (!this.isConnected || !this.ffiHandle) {
+      throw new Error('simulateScenario requires a connected room');
+    }
+    const res = FfiClient.instance.request<SimulateScenarioResponse>({
+      message: {
+        case: 'simulateScenario',
+        value: {
+          roomHandle: this.ffiHandle.handle,
+          scenario,
+        },
+      },
+    });
+    const cb = await FfiClient.instance.waitFor<SimulateScenarioCallback>(
+      (ev: FfiEvent) =>
+        ev.message.case === 'simulateScenario' && ev.message.value.asyncId === res.asyncId,
+      { signal: this.disconnectController.signal },
+    );
+    if (cb.error) {
+      throw new Error(`simulateScenario failed: ${cb.error}`);
+    }
+  }
+
   private updateConnectionState(newState: ConnectionState) {
     if (this._connectionState === newState) {
       return;
@@ -481,6 +518,19 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       const publication = this.localParticipant.trackPublications.get(ev.value.publicationSid!);
       this.localParticipant.trackPublications.delete(ev.value.publicationSid!);
       this.emit(RoomEvent.LocalTrackUnpublished, publication!, this.localParticipant!);
+    } else if ((ev.case as string) == 'localTrackRepublished') {
+      const value = (ev as any).value;
+      const previousSid: string = value.previousSid!;
+      const newInfo: TrackPublicationInfo = value.info!;
+      const publication = this.localParticipant.trackPublications.get(previousSid);
+      if (publication) {
+        publication.updateInfo(newInfo);
+        this.localParticipant.trackPublications.delete(previousSid);
+        this.localParticipant.trackPublications.set(publication.sid!, publication);
+        this.emit(RoomEvent.LocalTrackRepublished, publication, previousSid, this.localParticipant);
+      } else {
+        log.warn(`RoomEvent.LocalTrackRepublished: previous publication not found: ${previousSid}`);
+      }
     } else if (ev.case == 'localTrackSubscribed') {
       const publication = this.localParticipant.trackPublications.get(ev.value.trackSid!);
       if (publication) {
@@ -903,6 +953,18 @@ export type RoomCallbacks = {
     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;
@@ -960,6 +1022,7 @@ export enum RoomEvent {
   ParticipantDisconnected = 'participantDisconnected',
   LocalTrackPublished = 'localTrackPublished',
   LocalTrackUnpublished = 'localTrackUnpublished',
+  LocalTrackRepublished = 'localTrackRepublished',
   LocalTrackSubscribed = 'localTrackSubscribed',
   TrackPublished = 'trackPublished',
   TrackUnpublished = 'trackUnpublished',

package/src/tests/e2e.test.ts

@@ -15,6 +15,8 @@ import {
   Room,
   RoomEvent,
   RpcError,
+  SimulateScenarioKind,
+  TrackKind,
   TrackPublishOptions,
   TrackSource,
   dispose,
@@ -682,4 +684,159 @@ describeE2E('livekit-rtc e2e', () => {
     },
     testTimeoutMs,
   );
+
+  // -- Reconnect scenarios --
+  //
+  // Both tests verify the user-visible behavior: after the scenario fires,
+  // the subscriber continues to receive the publisher's tone. The full
+  // reconnect test additionally asserts there is exactly one audio
+  // publication on each side (regression: duplicate-publish bug).
+
+  const runReconnectScenario = async (scenario: SimulateScenarioKind) => {
+    const { rooms } = await connectTestRooms(2);
+    const [subRoom, pubRoom] = rooms;
+
+    const pubRateHz = 48_000;
+    const source = new AudioSource(pubRateHz, 1);
+    const track = LocalAudioTrack.createAudioTrack('reconnect_tone', source);
+    const opts = new TrackPublishOptions();
+    opts.source = TrackSource.SOURCE_MICROPHONE;
+    await pubRoom!.localParticipant!.publishTrack(track, opts);
+
+    let tonePhase = 0;
+    const samplesPer10ms = Math.floor(pubRateHz / 100);
+    const amplitude = 0.8 * 32767;
+    const sineHz = 60;
+    let toneRunning = true;
+    const toneTask = (async () => {
+      while (toneRunning) {
+        const frame = AudioFrame.create(pubRateHz, 1, samplesPer10ms);
+        for (let s = 0; s < samplesPer10ms; s++) {
+          frame.data[s] = Math.round(
+            amplitude * Math.sin((2 * Math.PI * sineHz * tonePhase) / pubRateHz),
+          );
+          tonePhase++;
+        }
+        await source.captureFrame(frame);
+      }
+    })();
+
+    // Subscriber-side: re-attach an AudioStream every time TrackSubscribed
+    // fires (a full reconnect may issue TrackUnsubscribed → TrackSubscribed
+    // with a fresh remote track).
+    const sub = {
+      lastFrameAt: 0,
+      collectFromMs: Number.POSITIVE_INFINITY,
+      collected: [] as Int16Array[],
+      readers: [] as ReturnType<AudioStream['getReader']>[],
+    };
+    const attach = (remoteTrack: unknown) => {
+      const stream = new AudioStream(remoteTrack as any, {
+        sampleRate: pubRateHz,
+        numChannels: 1,
+      });
+      const reader = stream.getReader();
+      sub.readers.push(reader);
+      (async () => {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            sub.lastFrameAt = Date.now();
+            if (sub.lastFrameAt >= sub.collectFromMs) {
+              sub.collected.push(channelSamples(value, 0));
+            }
+          }
+        } catch {
+          // reader released
+        }
+      })();
+    };
+    subRoom!.on(RoomEvent.TrackSubscribed, (t) => attach(t));
+
+    try {
+      await waitFor(() => sub.lastFrameAt > 0 && Date.now() - sub.lastFrameAt < 500, {
+        timeoutMs: 10_000,
+        debugName: 'initial audio flow',
+      });
+
+      const simulateAt = Date.now();
+      await pubRoom!.simulateScenario(scenario);
+
+      // Wait for audio to actually flow again post-simulate: a frame
+      // received well after the simulate AND a fresh latest-frame timestamp.
+      await waitFor(
+        () => sub.lastFrameAt >= simulateAt + 500 && Date.now() - sub.lastFrameAt < 300,
+        { timeoutMs: 30_000, debugName: 'audio re-established after simulate' },
+      );
+      // Drain post-recovery buffer/jitter, then collect a 2s window of
+      // steady-state samples for tone detection.
+      await delay(1_500);
+      sub.collected.length = 0;
+      sub.collectFromMs = Date.now();
+      await waitFor(() => sub.collected.reduce((a, s) => a + s.length, 0) >= pubRateHz * 2, {
+        timeoutMs: 15_000,
+        debugName: 'post-simulate audio sampling',
+      });
+
+      const totalLen = sub.collected.reduce((a, s) => a + s.length, 0);
+      const concat = new Int16Array(totalLen);
+      let off = 0;
+      for (const s of sub.collected) {
+        concat.set(s, off);
+        off += s.length;
+      }
+      const detected = estimateFreqHz(concat, pubRateHz);
+      // Wider tolerance than the clean-path sine test: post-reconnect
+      // audio has brief discontinuities, and the autocorrelation is
+      // integer-lag (next neighbors to 60Hz are exactly 80Hz/40Hz), so
+      // ±20Hz lands right on the failure boundary under CI load.
+      expect(Math.abs(detected - sineHz)).toBeLessThan(25);
+
+      return { rooms, subRoom: subRoom!, pubRoom: pubRoom! };
+    } finally {
+      toneRunning = false;
+      await toneTask;
+      for (const r of sub.readers) {
+        try {
+          r.releaseLock();
+        } catch {
+          // ignore
+        }
+      }
+      await track.close();
+    }
+  };
+
+  itRaw(
+    'resume keeps audio flowing on the subscriber side',
+    async () => {
+      const { rooms } = await runReconnectScenario(SimulateScenarioKind.SIMULATE_SIGNAL_RECONNECT);
+      await Promise.all(rooms.map((r) => r.disconnect()));
+    },
+    testTimeoutMs * 4,
+  );
+
+  itRaw(
+    'full reconnect keeps audio flowing and ends with one publication on the subscriber',
+    async () => {
+      const { rooms, subRoom, pubRoom } = await runReconnectScenario(
+        SimulateScenarioKind.SIMULATE_FULL_RECONNECT,
+      );
+
+      try {
+        // Regression: subscriber must see exactly ONE audio publication after
+        // recovery — not duplicates from the auto-republish path.
+        const subscriberAudioPubs = Array.from(
+          subRoom.remoteParticipants
+            .get(pubRoom.localParticipant!.identity)!
+            .trackPublications.values(),
+        ).filter((p) => p.kind === TrackKind.KIND_AUDIO);
+        expect(subscriberAudioPubs.length).toBe(1);
+      } finally {
+        await Promise.all(rooms.map((r) => r.disconnect()));
+      }
+    },
+    testTimeoutMs * 4,
+  );
 });

package/src/track_publication.ts

@@ -66,6 +66,18 @@ export abstract class TrackPublication {
   get encryptionType(): EncryptionType | undefined {
     return this.info?.encryptionType;
   }
+
+  /**
+   * 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 {
+    this.info = info;
+  }
 }
 
 export class LocalTrackPublication extends TrackPublication {

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.13.27";
+export const SDK_VERSION = "0.13.28";