@livekit/rtc-node 0.13.25 → 0.13.26

package/src/audio_mixer.ts

@@ -311,7 +311,7 @@ export class AudioMixer {
     // Accumulate data until we have at least chunkSize samples
     while (buf.length < this.chunkSize * this.numChannels && !exhausted && !this.closed) {
       try {
-        const result = await Promise.race([iterator.next(), this.timeout(this.streamTimeoutMs)]);
+        const result = await this.timeoutRace(iterator.next(), this.streamTimeoutMs);
 
         if (result === 'timeout') {
           console.warn(`AudioMixer: stream timeout after ${this.streamTimeoutMs}ms`);
@@ -412,7 +412,13 @@ export class AudioMixer {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
-  private timeout(ms: number): Promise<'timeout'> {
-    return new Promise((resolve) => setTimeout(() => resolve('timeout'), ms));
+  /** Race a promise against a timeout. The losing setTimeout is automatically
+   *  cleared via `.finally()` so callers don't need to manage cleanup. */
+  private timeoutRace<T>(promise: Promise<T>, ms: number): Promise<T | 'timeout'> {
+    let timer: ReturnType<typeof setTimeout>;
+    const timeoutPromise = new Promise<'timeout'>((resolve) => {
+      timer = setTimeout(() => resolve('timeout'), ms);
+    });
+    return Promise.race([promise.finally(() => clearTimeout(timer)), timeoutPromise]);
   }
 }

package/src/ffi_client.ts

@@ -70,14 +70,37 @@ export class FfiClient extends (EventEmitter as new () => TypedEmitter<FfiClient
     return livekitRetrievePtr(data);
   }
 
-  async waitFor<T>(predicate: (ev: FfiEvent) => boolean): Promise<T> {
-    return new Promise<T>((resolve) => {
+  async waitFor<T>(
+    predicate: (ev: FfiEvent) => boolean,
+    options?: { signal?: AbortSignal },
+  ): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
       const listener = (ev: FfiEvent) => {
         if (predicate(ev)) {
-          this.off(FfiClientEvent.FfiEvent, listener);
+          cleanup();
           resolve(ev.message.value as T);
         }
       };
+
+      const cleanup = () => {
+        this.off(FfiClientEvent.FfiEvent, listener);
+        options?.signal?.removeEventListener('abort', onAbort);
+      };
+
+      // If an AbortSignal is provided, remove the listener when the signal
+      // fires so that pending waitFor() calls don't leak listeners after
+      // the room disconnects or the operation is cancelled.
+      const onAbort = () => {
+        cleanup();
+        reject(options?.signal?.reason ?? new Error('waitFor aborted'));
+      };
+
+      if (options?.signal?.aborted) {
+        reject(options.signal.reason ?? new Error('waitFor aborted'));
+        return;
+      }
+
+      options?.signal?.addEventListener('abort', onAbort);
       this.on(FfiClientEvent.FfiEvent, listener);
     });
   }

package/src/participant.ts

@@ -157,11 +157,16 @@ export class LocalParticipant extends Participant {
 
   private ffiEventLock: Mutex;
 
+  // Signal that fires when the owning Room disconnects, used to cancel
+  // pending FfiClient.waitFor() listeners so they don't leak.
+  private disconnectSignal: AbortSignal;
+
   trackPublications: Map<string, LocalTrackPublication> = new Map();
 
-  constructor(info: OwnedParticipant, ffiEventLock: Mutex) {
+  constructor(info: OwnedParticipant, ffiEventLock: Mutex, disconnectSignal: AbortSignal) {
     super(info);
     this.ffiEventLock = ffiEventLock;
+    this.disconnectSignal = disconnectSignal;
   }
 
   async publishData(data: Uint8Array, options: DataPublishOptions) {
@@ -178,9 +183,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'publishData', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<PublishDataCallback>((ev) => {
-      return ev.message.case == 'publishData' && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<PublishDataCallback>(
+      (ev) => ev.message.case == 'publishData' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
@@ -198,9 +204,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'publishSipDtmf', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<PublishSipDtmfCallback>((ev) => {
-      return ev.message.case == 'publishSipDtmf' && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<PublishSipDtmfCallback>(
+      (ev) => ev.message.case == 'publishSipDtmf' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
@@ -229,9 +236,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'publishTranscription', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<PublishTranscriptionCallback>((ev) => {
-      return ev.message.case == 'publishTranscription' && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<PublishTranscriptionCallback>(
+      (ev) => ev.message.case == 'publishTranscription' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
@@ -248,9 +256,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'setLocalMetadata', value: req },
     });
 
-    await FfiClient.instance.waitFor<SetLocalMetadataCallback>((ev) => {
-      return ev.message.case == 'setLocalMetadata' && ev.message.value.asyncId == res.asyncId;
-    });
+    await FfiClient.instance.waitFor<SetLocalMetadataCallback>(
+      (ev) => ev.message.case == 'setLocalMetadata' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
   }
 
   /**
@@ -335,8 +344,24 @@ export class LocalParticipant extends Participant {
         });
         await sendTrailer(trailerReq);
       },
-      abort(err) {
+      // Send a trailer with the error reason so the remote side's stream
+      // controller is closed instead of waiting for data that won't arrive.
+      async abort(err) {
         log.error(err, 'Sink Error');
+        try {
+          const trailerReq = new SendStreamTrailerRequest({
+            senderIdentity,
+            localParticipantHandle: localHandle,
+            destinationIdentities,
+            trailer: new DataStream_Trailer({
+              streamId,
+              reason: err instanceof Error ? err.message : String(err ?? ''),
+            }),
+          });
+          await sendTrailer(trailerReq);
+        } catch {
+          // Best-effort: the connection may already be gone.
+        }
       },
     });
 
@@ -450,8 +475,24 @@ export class LocalParticipant extends Participant {
         });
         await sendTrailer(trailerReq);
       },
-      abort(err) {
+      // Send a trailer with the error reason so the remote side's stream
+      // controller is closed instead of waiting for data that won't arrive.
+      async abort(err) {
         log.error(err, 'Sink error');
+        try {
+          const trailerReq = new SendStreamTrailerRequest({
+            senderIdentity,
+            localParticipantHandle: localHandle,
+            destinationIdentities,
+            trailer: new DataStream_Trailer({
+              streamId,
+              reason: err instanceof Error ? err.message : String(err ?? ''),
+            }),
+          });
+          await sendTrailer(trailerReq);
+        } catch {
+          // Best-effort: the connection may already be gone.
+        }
       },
     });
 
@@ -494,44 +535,47 @@ export class LocalParticipant extends Participant {
       message: { case: type, value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<SendStreamHeaderCallback>((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<SendStreamHeaderCallback>(
+      (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
     }
   }
 
-  private async sendStreamChunk(req: SendStreamChunkRequest) {
+  private sendStreamChunk = async (req: SendStreamChunkRequest) => {
     const type = 'sendStreamChunk';
     const res = FfiClient.instance.request<SendStreamChunkResponse>({
       message: { case: type, value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<SendStreamChunkCallback>((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<SendStreamChunkCallback>(
+      (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
     }
-  }
+  };
 
-  private async sendStreamTrailer(req: SendStreamTrailerRequest) {
+  private sendStreamTrailer = async (req: SendStreamTrailerRequest) => {
     const type = 'sendStreamTrailer';
     const res = FfiClient.instance.request<SendStreamTrailerResponse>({
       message: { case: type, value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<SendStreamTrailerCallback>((ev) => {
-      return ev.message.case == type && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<SendStreamTrailerCallback>(
+      (ev) => ev.message.case == type && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw new Error(cb.error);
     }
-  }
+  };
 
   /**
    * Sends a chat message to participants in the room
@@ -557,9 +601,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'sendChatMessage', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<SendChatMessageCallback>((ev) => {
-      return ev.message.case == 'chatMessage' && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<SendChatMessageCallback>(
+      (ev) => ev.message.case == 'chatMessage' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     switch (cb.message.case) {
       case 'chatMessage':
@@ -603,9 +648,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'editChatMessage', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<SendChatMessageCallback>((ev) => {
-      return ev.message.case == 'chatMessage' && ev.message.value.asyncId == res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<SendChatMessageCallback>(
+      (ev) => ev.message.case == 'chatMessage' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     switch (cb.message.case) {
       case 'chatMessage':
@@ -632,9 +678,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'setLocalName', value: req },
     });
 
-    await FfiClient.instance.waitFor<SetLocalNameCallback>((ev) => {
-      return ev.message.case == 'setLocalName' && ev.message.value.asyncId == res.asyncId;
-    });
+    await FfiClient.instance.waitFor<SetLocalNameCallback>(
+      (ev) => ev.message.case == 'setLocalName' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
   }
 
   async setAttributes(attributes: Record<string, string>) {
@@ -647,9 +694,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'setLocalAttributes', value: req },
     });
 
-    await FfiClient.instance.waitFor<SetLocalAttributesCallback>((ev) => {
-      return ev.message.case == 'setLocalAttributes' && ev.message.value.asyncId == res.asyncId;
-    });
+    await FfiClient.instance.waitFor<SetLocalAttributesCallback>(
+      (ev) => ev.message.case == 'setLocalAttributes' && ev.message.value.asyncId == res.asyncId,
+      { signal: this.disconnectSignal },
+    );
   }
 
   async publishTrack(
@@ -669,9 +717,10 @@ export class LocalParticipant extends Participant {
     });
 
     try {
-      const cb = await FfiClient.instance.waitFor<PublishTrackCallback>((ev) => {
-        return ev.message.case == 'publishTrack' && ev.message.value.asyncId == res.asyncId;
-      });
+      const cb = await FfiClient.instance.waitFor<PublishTrackCallback>(
+        (ev) => ev.message.case == 'publishTrack' && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal },
+      );
 
       switch (cb.message.case) {
         case 'publication':
@@ -702,9 +751,10 @@ export class LocalParticipant extends Participant {
         message: { case: 'unpublishTrack', value: req },
       });
 
-      const cb = await FfiClient.instance.waitFor<UnpublishTrackCallback>((ev) => {
-        return ev.message.case == 'unpublishTrack' && ev.message.value.asyncId == res.asyncId;
-      });
+      const cb = await FfiClient.instance.waitFor<UnpublishTrackCallback>(
+        (ev) => ev.message.case == 'unpublishTrack' && ev.message.value.asyncId == res.asyncId,
+        { signal: this.disconnectSignal },
+      );
 
       if (cb.error) {
         throw new Error(cb.error);
@@ -744,9 +794,10 @@ export class LocalParticipant extends Participant {
       message: { case: 'performRpc', value: req },
     });
 
-    const cb = await FfiClient.instance.waitFor<PerformRpcCallback>((ev) => {
-      return ev.message.case === 'performRpc' && ev.message.value.asyncId === res.asyncId;
-    });
+    const cb = await FfiClient.instance.waitFor<PerformRpcCallback>(
+      (ev) => ev.message.case === 'performRpc' && ev.message.value.asyncId === res.asyncId,
+      { signal: this.disconnectSignal },
+    );
 
     if (cb.error) {
       throw RpcError.fromProto(cb.error);

package/src/room.ts

@@ -4,7 +4,7 @@
 import { Mutex } from '@livekit/mutex';
 import { EncryptionState, type EncryptionType } from '@livekit/rtc-ffi-bindings';
 import type { FfiEvent } from '@livekit/rtc-ffi-bindings';
-import type { DisconnectReason, OwnedParticipant } 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 ConnectCallback,
@@ -96,6 +96,15 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
 
   private preConnectEvents: FfiEvent[] = [];
 
+  // Aborted on disconnect to cancel any pending FfiClient.waitFor() listeners,
+  // preventing them from leaking when the room goes away.
+  private disconnectController = new AbortController();
+
+  // Guards cleanupOnDisconnect so the ConnectionStateChanged/Disconnected
+  // events fire exactly once, no matter which path (explicit disconnect()
+  // vs. FFI 'disconnected' event) wins the race.
+  private hasCleanedUp = false;
+
   private _token?: string;
   private _serverUrl?: string;
 
@@ -131,6 +140,11 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     return this._serverUrl;
   }
 
+  // Shared promise for concurrent getSid() callers. Without this, each call
+  // registers its own RoomSidChanged + Disconnected listeners, and if many
+  // calls race only one of each pair is cleaned up — leaking the rest.
+  private sidPromise?: Promise<string>;
+
   /**
    * Gets the room's server ID. This ID is assigned by the LiveKit server
    * and is unique for each room session.
@@ -144,19 +158,26 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
     if (this.info?.sid && this.info.sid !== '') {
       return this.info.sid;
     }
-    return new Promise((resolve, reject) => {
-      const handleRoomUpdate = (sid: string) => {
-        if (sid !== '') {
+    if (!this.sidPromise) {
+      this.sidPromise = new Promise<string>((resolve, reject) => {
+        const handleDisconnect = () => {
           this.off(RoomEvent.RoomSidChanged, handleRoomUpdate);
-          resolve(sid);
-        }
-      };
-      this.on(RoomEvent.RoomSidChanged, handleRoomUpdate);
-      this.once(RoomEvent.Disconnected, () => {
-        this.off(RoomEvent.RoomSidChanged, handleRoomUpdate);
-        reject('Room disconnected before room server id was available');
+          this.sidPromise = undefined;
+          reject('Room disconnected before room server id was available');
+        };
+        const handleRoomUpdate = (sid: string) => {
+          if (sid !== '') {
+            this.off(RoomEvent.RoomSidChanged, handleRoomUpdate);
+            this.off(RoomEvent.Disconnected as any, handleDisconnect);
+            this.sidPromise = undefined;
+            resolve(sid);
+          }
+        };
+        this.on(RoomEvent.RoomSidChanged, handleRoomUpdate);
+        this.once(RoomEvent.Disconnected, handleDisconnect);
       });
-    });
+    }
+    return this.sidPromise;
   }
 
   get numParticipants(): number {
@@ -219,45 +240,56 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
 
     FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onFfiEvent);
 
-    const res = FfiClient.instance.request<ConnectResponse>({
-      message: {
-        case: 'connect',
-        value: req,
-      },
-    });
-
-    const cb = await FfiClient.instance.waitFor<ConnectCallback>((ev: FfiEvent) => {
-      return ev.message.case == 'connect' && ev.message.value.asyncId == res.asyncId;
-    });
-
-    log.debug('Connect callback received');
+    try {
+      const res = FfiClient.instance.request<ConnectResponse>({
+        message: {
+          case: 'connect',
+          value: req,
+        },
+      });
 
-    switch (cb.message.case) {
-      case 'result':
-        this.ffiHandle = new FfiHandle(cb.message.value.room!.handle!.id!);
-        this.e2eeManager = e2eeEnabled && new E2EEManager(this.ffiHandle.handle, e2eeOptions);
+      const cb = await FfiClient.instance.waitFor<ConnectCallback>((ev: FfiEvent) => {
+        return ev.message.case == 'connect' && ev.message.value.asyncId == res.asyncId;
+      });
 
-        this._token = token;
-        this._serverUrl = url;
-        this.info = cb.message.value.room!.info;
-        this.connectionState = ConnectionState.CONN_CONNECTED;
-        this.localParticipant = new LocalParticipant(
-          cb.message.value.localParticipant!,
-          this.ffiEventLock,
-        );
+      log.debug('Connect callback received');
+
+      switch (cb.message.case) {
+        case 'result':
+          this.ffiHandle = new FfiHandle(cb.message.value.room!.handle!.id!);
+          this.e2eeManager = e2eeEnabled && new E2EEManager(this.ffiHandle.handle, e2eeOptions);
+
+          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();
+          this.hasCleanedUp = false;
+          this.localParticipant = new LocalParticipant(
+            cb.message.value.localParticipant!,
+            this.ffiEventLock,
+            this.disconnectController.signal,
+          );
 
-        for (const pt of cb.message.value.participants) {
-          const rp = this.createRemoteParticipant(pt.participant!);
+          for (const pt of cb.message.value.participants) {
+            const rp = this.createRemoteParticipant(pt.participant!);
 
-          for (const pub of pt.publications) {
-            const publication = new RemoteTrackPublication(pub);
-            rp.trackPublications.set(publication.sid!, publication);
+            for (const pub of pt.publications) {
+              const publication = new RemoteTrackPublication(pub);
+              rp.trackPublications.set(publication.sid!, publication);
+            }
           }
-        }
-        break;
-      case 'error':
-      default:
-        throw new ConnectError(cb.message.value || '');
+          break;
+        case 'error':
+        default:
+          throw new ConnectError(cb.message.value || '');
+      }
+    } catch (e) {
+      FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onFfiEvent);
+      this.preConnectEvents = [];
+      throw e;
     }
   }
 
@@ -283,10 +315,59 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       return ev.message.case == 'disconnect' && ev.message.value.asyncId == res.asyncId;
     });
 
+    this.cleanupOnDisconnect(DisconnectReason.CLIENT_INITIATED);
     FfiClient.instance.removeListener(FfiClientEvent.FfiEvent, this.onFfiEvent);
+
     this.removeAllListeners();
   }
 
+  // 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.
+  private cleanupOnDisconnect(reason: DisconnectReason = DisconnectReason.CLIENT_INITIATED) {
+    if (this.hasCleanedUp) return;
+    this.hasCleanedUp = true;
+
+    // Error all in-progress stream controllers to prevent FD leaks.
+    // Streams that were receiving data but never got a trailer (e.g. the sender
+    // disconnected mid-transfer) would otherwise keep their ReadableStream open
+    // indefinitely, leaking the underlying controller and any buffered chunks.
+    // Using error() instead of close() signals an abnormal termination to consumers.
+    for (const [, streamController] of this.byteStreamControllers) {
+      try {
+        streamController.controller.error(new Error('Disconnected while receiving'));
+      } catch {
+        // controller may already be closed or errored
+      }
+    }
+    this.byteStreamControllers.clear();
+
+    for (const [, streamController] of this.textStreamControllers) {
+      try {
+        streamController.controller.error(new Error('Disconnected while receiving'));
+      } catch {
+        // controller may already be closed or errored
+      }
+    }
+    this.textStreamControllers.clear();
+
+    // Clear sidPromise before removing listeners so that a reconnect
+    // doesn't return a stale, permanently-pending promise.
+    this.sidPromise = undefined;
+    // Abort all pending FfiClient.waitFor() listeners so they don't leak.
+    // This causes any in-flight operations (publishData, publishTrack, etc.)
+    // 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.emit(RoomEvent.Disconnected, reason);
+  }
+
   /**
    * Registers a handler for incoming text data streams on a specific topic.
    * Text streams are used for receiving structured text data from other participants.
@@ -418,6 +499,9 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
       participant.trackPublications.delete(ev.value.publicationSid!);
       if (publication) {
         this.emit(RoomEvent.TrackUnpublished, publication, participant);
+        // Dispose eagerly so handles don't accumulate when a participant
+        // publishes and unpublishes many tracks during a long-lived session.
+        publication.ffiHandle.dispose();
       } else {
         log.warn(`RoomEvent.TrackUnpublished: Could not find publication`);
       }
@@ -594,12 +678,20 @@ export class Room extends (EventEmitter as new () => TypedEmitter<RoomCallbacks>
         this.emit(RoomEvent.EncryptionError, new Error('internal server error'));
       }
     } else if (ev.case == 'connectionStateChanged') {
-      this.connectionState = ev.value.state!;
+      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);
       /*} else if (ev.case == 'connected') {
       this.emit(RoomEvent.Connected);*/
     } else if (ev.case == 'disconnected') {
-      this.emit(RoomEvent.Disconnected, ev.value.reason!);
+      // cleanupOnDisconnect emits RoomEvent.Disconnected itself (guarded by
+      // hasCleanedUp so it fires exactly once across both disconnect paths).
+      this.cleanupOnDisconnect(ev.value.reason!);
     } else if (ev.case == 'reconnecting') {
       this.emit(RoomEvent.Reconnecting);
     } else if (ev.case == 'reconnected') {