@livekit/rtc-node 0.13.26 → 0.13.28

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';
@@ -107,9 +114,9 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
 
   private _token?: string;
   private _serverUrl?: string;
+  private _connectionState: ConnectionState = ConnectionState.CONN_DISCONNECTED;
 
   e2eeManager?: E2EEManager;
-  connectionState: ConnectionState = ConnectionState.CONN_DISCONNECTED;
 
   remoteParticipants: Map<string, RemoteParticipant> = new Map();
   localParticipant?: LocalParticipant;
@@ -118,6 +125,10 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     super();
   }
 
+  get connectionState() {
+    return this._connectionState;
+  }
+
   get name(): string | undefined {
     return this.info?.name;
   }
@@ -262,7 +273,6 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
           this._token = token;
           this._serverUrl = url;
           this.info = cb.message.value.room!.info;
-          this.connectionState = ConnectionState.CONN_CONNECTED;
           // Reset the abort controller for this connection session so that
           // a previous disconnect doesn't immediately cancel new operations.
           this.disconnectController = new AbortController();
@@ -281,6 +291,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
               rp.trackPublications.set(publication.sid!, publication);
             }
           }
+          this.updateConnectionState(ConnectionState.CONN_CONNECTED);
           break;
         case 'error':
         default:
@@ -321,6 +332,44 @@ 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;
+    }
+    this._connectionState = newState;
+    this.emit(RoomEvent.ConnectionStateChanged, this._connectionState);
+  }
+
   // Runs at most once per connection session. The FFI layer and explicit
   // disconnect() both race to get here — whichever wins emits the events,
   // the other is a no-op. A reconnect via connect() clears hasCleanedUp.
@@ -359,12 +408,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     // to reject and clean up their event listeners.
     this.disconnectController.abort();
 
-    // Only emit ConnectionStateChanged if the FFI 'connectionStateChanged'
-    // path didn't already flip us to DISCONNECTED.
-    if (this.connectionState !== ConnectionState.CONN_DISCONNECTED) {
-      this.connectionState = ConnectionState.CONN_DISCONNECTED;
-      this.emit(RoomEvent.ConnectionStateChanged, this.connectionState);
-    }
+    this.updateConnectionState(ConnectionState.CONN_DISCONNECTED);
     this.emit(RoomEvent.Disconnected, reason);
   }
 
@@ -474,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) {
@@ -678,14 +735,7 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
         this.emit(RoomEvent.EncryptionError, new Error('internal server error'));
       }
     } else if (ev.case == 'connectionStateChanged') {
-      const newState = ev.value.state!;
-      // Skip redundant transitions — cleanupOnDisconnect may have already
-      // flipped us to DISCONNECTED, and we don't want to emit the event twice.
-      if (this.connectionState === newState) {
-        return;
-      }
-      this.connectionState = newState;
-      this.emit(RoomEvent.ConnectionStateChanged, this.connectionState);
+      this.updateConnectionState(ev.value.state!);
       /*} else if (ev.case == 'connected') {
       this.emit(RoomEvent.Connected);*/
     } else if (ev.case == 'disconnected') {
@@ -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.26";
+export const SDK_VERSION = "0.13.28";