livekit-client 2.21.0 → 2.22.0

package/src/room/RTCEngine.ts

@@ -18,6 +18,7 @@ import {
   LeaveRequest_Action,
   MediaSectionsRequirement,
   ParticipantInfo,
+  ConnectionQuality as ProtoConnectionQuality,
   PublishDataTrackResponse,
   ReconnectReason,
   type ReconnectResponse,
@@ -100,6 +101,7 @@ import {
   isVideoCodec,
   isVideoTrack,
   isWeb,
+  negotiateDependencyDescriptor,
   sleep,
   supportsAddTrack,
   supportsTransceiver,
@@ -108,6 +110,12 @@ import {
 
 const minReconnectWait = 2 * 1000;
 const leaveReconnect = 'leave-reconnect';
+
+/**
+ * How long local connection quality must stay `LOST` while connected and publishing before we
+ * force a full reconnect — `LOST` is the server's verdict that it isn't receiving our media.
+ */
+const connectionQualityLostTimeout = 10 * 1000;
 const reliabeReceiveStateTTL = 30_000;
 
 const initialMediaSectionsAudio = 3;
@@ -246,6 +254,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   /** used to indicate whether the browser is currently waiting to reconnect */
   private isWaitingForNetworkReconnect: boolean = false;
 
+  /** set while the local participant's connection quality is `LOST`; forces a full reconnect on timeout */
+  private lostQualityTimeout?: ReturnType<typeof setTimeout>;
+
+  /** timestamp (ms) the primary transport entered `CONNECTING`, used to bound how long we tolerate it */
+  private transportConnectingSince?: number;
+
   constructor(private options: InternalRoomOptions) {
     super();
     this.log = getLogger(options.loggerName ?? LoggerNames.Engine, () => this.logContext);
@@ -271,8 +285,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     this.client.onParticipantUpdate = (updates) =>
       this.emit(EngineEvent.ParticipantUpdate, updates);
-    this.client.onConnectionQuality = (update) =>
+    this.client.onConnectionQuality = (update) => {
+      this.handleLocalConnectionQuality(update);
       this.emit(EngineEvent.ConnectionQualityUpdate, update);
+    };
     this.client.onRoomUpdate = (update) => this.emit(EngineEvent.RoomUpdate, update);
     this.client.onSubscriptionError = (resp) => this.emit(EngineEvent.SubscriptionError, resp);
     this.client.onSubscriptionPermissionUpdate = (update) =>
@@ -429,6 +445,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.removeAllListeners();
       this.deregisterOnLineListener();
       this.clearPendingReconnect();
+      this.clearLostQualityTimeout();
       this.cleanupLossyDataStats();
       await this.cleanupPeerConnections();
       await this.cleanupClient();
@@ -442,6 +459,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     await this.pcManager?.close();
     this.pcManager = undefined;
+    // the connecting timestamp belongs to the transports we just tore down
+    this.transportConnectingSince = undefined;
 
     this.reliableReceivedState.clear();
   }
@@ -468,7 +487,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       throw new TrackInvalidError('a track with the same ID has already been published');
     }
     return new Promise<TrackInfo>((resolve, reject) => {
-      const publicationTimeout = setTimeout(() => {
+      const publicationTimeout = CriticalTimers.setTimeout(() => {
         delete this.pendingTrackResolvers[req.cid];
         reject(
           ConnectionError.timeout('publication of local track timed out, no response from server'),
@@ -476,11 +495,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }, 10_000);
       this.pendingTrackResolvers[req.cid] = {
         resolve: (info: TrackInfo) => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           resolve(info);
         },
         reject: () => {
-          clearTimeout(publicationTimeout);
+          CriticalTimers.clearTimeout(publicationTimeout);
           reject(new Error('Cancelled publication by calling unpublish'));
         },
       };
@@ -565,6 +584,16 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.pcManager.onStateChange = async (connectionState, publisherState, subscriberState) => {
       this.log.debug(`primary PC state changed ${connectionState}`);
 
+      // Record when the primary transport actually entered CONNECTING so
+      // verifyTransport() can bound how long we tolerate it. Deriving it from the
+      // real transition (this handler only fires on state changes) rather than from
+      // observation time keeps it from going stale across peer-connection rebuilds.
+      if (connectionState === PCTransportState.CONNECTING) {
+        this.transportConnectingSince = Date.now();
+      } else {
+        this.transportConnectingSince = undefined;
+      }
+
       if (['closed', 'disconnected', 'failed'].includes(publisherState)) {
         // reset publisher connection promise
         this.publisherConnectionPromise = undefined;
@@ -816,8 +845,15 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     for (let i: number = 0; i < numAudios; i++) {
       this.pcManager?.addPublisherTransceiverOfKind('audio', transceiverInit);
     }
+    // media only arrives on these sections when there is no subscriber connection to arrive on
+    const receivesMedia = this.pcManager?.mode === 'publisher-only';
     for (let i: number = 0; i < numVideos; i++) {
-      this.pcManager?.addPublisherTransceiverOfKind('video', transceiverInit);
+      const transceiver = this.pcManager?.addPublisherTransceiverOfKind('video', transceiverInit);
+      if (receivesMedia && transceiver) {
+        const negotiated = negotiateDependencyDescriptor(transceiver);
+
+        this.log.debug('dependency descriptor negotiated for received video', { negotiated });
+      }
     }
   }
 
@@ -1095,7 +1131,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!opts.videoCodec) {
       return;
     }
-    track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+    await track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
     return transceiver.sender;
   }
 
@@ -1157,6 +1193,73 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     );
   };
 
+  /**
+   * A sustained local `LOST` while connected and publishing means the server isn't receiving
+   * our media, so force a full reconnect; any non-`LOST` value cancels a pending trigger.
+   */
+  private handleLocalConnectionQuality(update: ConnectionQualityUpdate) {
+    if (!this.participantSid) {
+      return;
+    }
+    const localUpdate = update.updates.find((u) => u.participantSid === this.participantSid);
+    if (!localUpdate) {
+      return;
+    }
+    if (localUpdate.quality === ProtoConnectionQuality.LOST) {
+      this.scheduleLostQualityReconnect();
+    } else {
+      this.clearLostQualityTimeout();
+    }
+  }
+
+  private scheduleLostQualityReconnect() {
+    if (this.lostQualityTimeout) {
+      // already counting down towards a reconnect
+      return;
+    }
+    this.lostQualityTimeout = CriticalTimers.setTimeout(() => {
+      this.lostQualityTimeout = undefined;
+      if (this._isClosed || this.pcState !== PCState.Connected || this.attemptingReconnect) {
+        return;
+      }
+      if (!this.hasActivePublisherSenders()) {
+        return;
+      }
+      this.log.warn(
+        'local connection quality lost while publishing, triggering full reconnect',
+        this.logContext,
+      );
+      this.fullReconnectOnNext = true;
+      this.handleDisconnect('connection quality lost', ReconnectReason.RR_PUBLISHER_FAILED);
+    }, connectionQualityLostTimeout);
+  }
+
+  private clearLostQualityTimeout() {
+    if (this.lostQualityTimeout) {
+      CriticalTimers.clearTimeout(this.lostQualityTimeout);
+      this.lostQualityTimeout = undefined;
+    }
+  }
+
+  /** Whether the publisher currently has any sender with a live track. */
+  private hasActivePublisherSenders(): boolean {
+    return (
+      this.pcManager?.publisher
+        .getSenders()
+        .some((sender) => !!sender.track && sender.track.readyState === 'live') ?? false
+    );
+  }
+
+  /**
+   * Forces a full reconnect while keeping the engine (and its saved credentials) alive. Used by
+   * Room's connection-reconcile safety net when the transport silently died but we looked connected.
+   * @internal
+   */
+  reconnect(reason: ReconnectReason = ReconnectReason.RR_UNKNOWN) {
+    this.fullReconnectOnNext = true;
+    this.handleDisconnect('reconcile', reason);
+  }
+
   private async attemptReconnect(reason?: ReconnectReason) {
     if (this._isClosed) {
       return;
@@ -1166,6 +1269,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.log.warn('already attempting reconnect, returning early');
       return;
     }
+
+    // A pending Lost-quality countdown belongs to the session we're now leaving; cancel it so
+    // it can't fire against the reconnected session before the server has evaluated it. (A resume
+    // keeps the peer connections, so cleanupPeerConnections wouldn't cover this path.)
+    this.clearLostQualityTimeout();
+
     if (
       this.clientConfiguration?.resumeConnection === ClientConfigSetting.DISABLED ||
       // signaling state could change to closed due to hardware sleep
@@ -1175,15 +1284,23 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.fullReconnectOnNext = true;
     }
 
+    // Consume the flag up front: capture whether this attempt is a full reconnect, then reset
+    // it. From here on a `true` value unambiguously represents a *new* full-reconnect request
+    // that arrived while this attempt was running (e.g. a server RECONNECT leave), which the
+    // finally block dispatches — for both the resume and full-reconnect paths.
+    const fullReconnect = this.fullReconnectOnNext;
+    this.fullReconnectOnNext = false;
+
+    let succeeded = false;
     try {
       this.attemptingReconnect = true;
-      if (this.fullReconnectOnNext) {
+      if (fullReconnect) {
         await this.restartConnection();
       } else {
         await this.resumeConnection(reason);
       }
       this.clearPendingReconnect();
-      this.fullReconnectOnNext = false;
+      succeeded = true;
     } catch (e) {
       this.reconnectAttempts += 1;
       let recoverable = true;
@@ -1191,8 +1308,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.log.debug('received unrecoverable error', { error: e });
         // unrecoverable
         recoverable = false;
-      } else if (!(e instanceof SignalReconnectError)) {
-        // cannot resume
+      } else if (fullReconnect || !(e instanceof SignalReconnectError)) {
+        // a failed full reconnect stays a full reconnect; a failed resume can only be
+        // resumed again for a signal-level error, otherwise it escalates
         this.fullReconnectOnNext = true;
       }
 
@@ -1209,6 +1327,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
     } finally {
       this.attemptingReconnect = false;
+
+      // A full reconnect requested while this attempt was running (e.g. a `RECONNECT` leave
+      // during a resume or a restart) that a successful attempt didn't act on; dispatch it now
+      // (the failure path already retries).
+      if (succeeded && this.fullReconnectOnNext && !this._isClosed) {
+        this.log.debug('full reconnect requested during in-progress attempt, dispatching');
+        this.handleDisconnect('reconnect');
+      }
     }
   }
 
@@ -1591,11 +1717,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.pcManager) {
       return false;
     }
+    const state = this.pcManager.currentState;
     const allowedConnectionStates: PCTransportState[] = [
       PCTransportState.CONNECTING,
       PCTransportState.CONNECTED,
     ];
-    if (!allowedConnectionStates.includes(this.pcManager.currentState)) {
+    if (!allowedConnectionStates.includes(state)) {
       return false;
     }
 
@@ -1603,6 +1730,20 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.client.ws || this.client.ws.readyState === WebSocket.CLOSED) {
       return false;
     }
+
+    // A transport stuck in CONNECTING never reaches CONNECTED nor reports FAILED, so it would
+    // otherwise look healthy forever; bound how long we tolerate it. The entry time is recorded
+    // in the pcManager state-change handler (see configure()), so this is a pure read — an
+    // unrecorded CONNECTING fails open rather than measuring against a stale timestamp.
+    if (
+      state === PCTransportState.CONNECTING &&
+      this.transportConnectingSince !== undefined &&
+      Date.now() - this.transportConnectingSince > this.peerConnectionTimeout
+    ) {
+      this.log.warn('transport stuck in connecting state', this.logContext);
+      return false;
+    }
+
     return true;
   }
 

package/src/room/Room.test.ts

@@ -1,8 +1,22 @@
-import { ClientInfo_Capability, JoinResponse } from '@livekit/protocol';
+import {
+  ClientInfo_Capability,
+  JoinResponse,
+  StreamState as ProtoStreamState,
+  StreamStateUpdate,
+  SubscriptionError,
+  SubscriptionResponse,
+  TrackInfo,
+  TrackType,
+} from '@livekit/protocol';
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import Room from './Room';
+import MockMediaStreamTrack from '../test/MockMediaStreamTrack';
+import Room, { ConnectionState } from './Room';
 import { roomConnectOptionDefaults, roomOptionDefaults } from './defaults';
-import { RoomEvent } from './events';
+import { EngineEvent, ParticipantEvent, RoomEvent } from './events';
+import RemoteParticipant from './participant/RemoteParticipant';
+import RemoteTrackPublication from './track/RemoteTrackPublication';
+import RemoteVideoTrack from './track/RemoteVideoTrack';
+import { Track } from './track/Track';
 
 describe('Active device switch', () => {
   it('updates devices correctly', async () => {
@@ -190,3 +204,120 @@ describe('Room lifecycle', () => {
     }
   });
 });
+
+describe('remote track subscription', () => {
+  it('does not replay a deferred ontrack after the subscription failed', () => {
+    const room = new Room();
+    room.state = ConnectionState.Connecting;
+
+    const trackSid = 'TR_h264';
+    const mediaTrack = { id: trackSid } as MediaStreamTrack;
+    const stream = {
+      id: `PA_remote|${trackSid}`,
+      getTracks: () => [mediaTrack],
+    } as unknown as MediaStream;
+    const receiver = {} as RTCRtpReceiver;
+
+    room.engine.emit(EngineEvent.MediaTrackAdded, mediaTrack, stream, receiver);
+
+    const replay = vi.spyOn(
+      room as unknown as {
+        onTrackAdded(
+          mediaTrack: MediaStreamTrack,
+          stream: MediaStream,
+          receiver: RTCRtpReceiver,
+        ): void;
+      },
+      'onTrackAdded',
+    );
+
+    room.engine.emit(
+      EngineEvent.SubscriptionError,
+      new SubscriptionResponse({
+        trackSid,
+        err: SubscriptionError.SE_CODEC_UNSUPPORTED,
+      }),
+    );
+
+    room.state = ConnectionState.Connected;
+    room.emit(RoomEvent.Connected);
+
+    expect(replay).not.toHaveBeenCalled();
+  });
+});
+
+describe('stream state updates', () => {
+  const participantSid = 'PA_remote';
+  const participantIdentity = 'remote-user';
+  const trackSid = 'TR_video';
+
+  function setupSubscribedTrack() {
+    const room = new Room();
+    room.state = ConnectionState.Connected;
+
+    const participant = new RemoteParticipant(
+      room.engine.client,
+      participantSid,
+      participantIdentity,
+    );
+    const publication = new RemoteTrackPublication(
+      Track.Kind.Video,
+      new TrackInfo({ sid: trackSid, type: TrackType.VIDEO, name: 'camera' }),
+      true,
+    );
+    publication.setTrack(
+      new RemoteVideoTrack(new MockMediaStreamTrack(), trackSid, undefined as never, {}),
+    );
+    participant.trackPublications.set(trackSid, publication);
+
+    (
+      room as unknown as { remoteParticipants: Map<string, RemoteParticipant> }
+    ).remoteParticipants.set(participantIdentity, participant);
+    (room as unknown as { sidToIdentity: Map<string, string> }).sidToIdentity.set(
+      participantSid,
+      participantIdentity,
+    );
+
+    return { room, participant, publication };
+  }
+
+  function pushStreamState(room: Room, state: ProtoStreamState) {
+    (
+      room as unknown as { handleStreamStateUpdate: (update: StreamStateUpdate) => void }
+    ).handleStreamStateUpdate(
+      new StreamStateUpdate({
+        streamStates: [{ participantSid, trackSid, state }],
+      }),
+    );
+  }
+
+  it('emits TrackStreamStateChanged when the SFU pauses a subscribed track', () => {
+    const { room, participant, publication } = setupSubscribedTrack();
+
+    const roomEvents = vi.fn();
+    const participantEvents = vi.fn();
+    room.on(RoomEvent.TrackStreamStateChanged, roomEvents);
+    participant.on(ParticipantEvent.TrackStreamStateChanged, participantEvents);
+
+    pushStreamState(room, ProtoStreamState.PAUSED);
+
+    expect(publication.track?.streamState).toBe(Track.StreamState.Paused);
+    expect(roomEvents).toHaveBeenCalledWith(publication, Track.StreamState.Paused, participant);
+    expect(participantEvents).toHaveBeenCalledWith(publication, Track.StreamState.Paused);
+  });
+
+  it('does not emit TrackStreamStateChanged when the state is unchanged', () => {
+    const { room, participant } = setupSubscribedTrack();
+
+    const roomEvents = vi.fn();
+    const participantEvents = vi.fn();
+    room.on(RoomEvent.TrackStreamStateChanged, roomEvents);
+    participant.on(ParticipantEvent.TrackStreamStateChanged, participantEvents);
+
+    // The track starts Active; a redundant ACTIVE update must stay silent.
+    pushStreamState(room, ProtoStreamState.ACTIVE);
+
+    expect(roomEvents).not.toHaveBeenCalled();
+    expect(participantEvents).not.toHaveBeenCalled();
+  });
+});

package/src/room/Room.ts

@@ -113,6 +113,7 @@ import {
   Future,
   createDummyVideoStreamTrack,
   extractChatMessage,
+  extractTrackSid,
   extractTranscriptionSegments,
   getDisconnectReasonFromConnectionError,
   getEmptyAudioStreamTrack,
@@ -218,6 +219,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private isResuming: boolean = false;
 
+  private pendingTrackAddedCallbacks = new Map<Track.SID, Set<() => void>>();
+
   /**
    * map to store first point in time when a particular transcription segment was received
    */
@@ -636,10 +639,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.emitBufferedEvents();
       })
       .on(EngineEvent.SignalResumed, () => {
-        this.bufferedEvents = [];
         if (this.state === ConnectionState.Reconnecting || this.isResuming) {
           this.sendSyncState();
         }
+        this.emitBufferedEvents();
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
       .on(EngineEvent.Restarted, this.handleRestarted)
@@ -1588,24 +1591,38 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
+    if ([ConnectionState.Connecting, ConnectionState.Reconnecting].includes(this.state)) {
+      const pendingTrackSid = extractTrackSid(mediaTrack, stream);
+      this.log.debug('deferring on track for later', {
+        mediaTrackId: mediaTrack.id,
+        mediaStreamId: stream.id,
+        tracksInStream: stream.getTracks().map((track) => track.id),
+      });
       const reconnectedHandler = () => {
-        this.log.debug('deferring on track for later', {
-          mediaTrackId: mediaTrack.id,
-          mediaStreamId: stream.id,
-          tracksInStream: stream.getTracks().map((track) => track.id),
-        });
-        this.onTrackAdded(mediaTrack, stream, receiver);
         cleanup();
+        this.onTrackAdded(mediaTrack, stream, receiver);
       };
       const cleanup = () => {
         this.off(RoomEvent.Reconnected, reconnectedHandler);
         this.off(RoomEvent.Connected, reconnectedHandler);
         this.off(RoomEvent.Disconnected, cleanup);
+        if (pendingTrackSid) {
+          const pendingCallbacks = this.pendingTrackAddedCallbacks.get(pendingTrackSid);
+          pendingCallbacks?.delete(cleanup);
+          if (pendingCallbacks?.size === 0) {
+            this.pendingTrackAddedCallbacks.delete(pendingTrackSid);
+          }
+        }
       };
       this.once(RoomEvent.Reconnected, reconnectedHandler);
       this.once(RoomEvent.Connected, reconnectedHandler);
       this.once(RoomEvent.Disconnected, cleanup);
+      if (pendingTrackSid) {
+        const pendingCallbacks =
+          this.pendingTrackAddedCallbacks.get(pendingTrackSid) ?? new Set<() => void>();
+        pendingCallbacks.add(cleanup);
+        this.pendingTrackAddedCallbacks.set(pendingTrackSid, pendingCallbacks);
+      }
       return;
     }
     if (this.state === ConnectionState.Disconnected) {
@@ -1618,11 +1635,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     const parts = unpackStreamId(stream.id);
     const participantSid = parts[0];
-    let streamId = parts[1];
-    let trackId = mediaTrack.id;
+    const streamId = parts[1];
     // firefox will get streamId (pID|trackId) instead of (pID|streamId) as it doesn't support sync tracks by stream
     // and generates its own track id instead of infer from sdp track id.
-    if (streamId && streamId.startsWith('TR')) trackId = streamId;
+    let trackId = extractTrackSid(mediaTrack, stream) ?? mediaTrack.id;
 
     if (participantSid === this.localParticipant.sid) {
       this.log.warn('tried to create RemoteParticipant for local participant');
@@ -1691,6 +1707,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private cancelPendingTrackAdded(trackSid: Track.SID) {
+    this.pendingTrackAddedCallbacks.get(trackSid)?.forEach((cleanup) => cleanup());
+  }
+
   private handleLocalTrackSubscribed(subscribedSid: string) {
     const findPublication = () =>
       this.localParticipant
@@ -2008,8 +2028,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         return;
       }
       const newStreamState = Track.streamStateFromProto(streamState.state);
+      const prevStreamState = pub.track.streamState;
       pub.track.setStreamState(newStreamState);
-      if (newStreamState !== pub.track.streamState) {
+      if (newStreamState !== prevStreamState) {
         participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
         this.emitWhenConnected(
           RoomEvent.TrackStreamStateChanged,
@@ -2035,6 +2056,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleSubscriptionError = (update: SubscriptionResponse) => {
+    this.cancelPendingTrackAdded(update.trackSid);
+
     const participant = Array.from(this.remoteParticipants.values()).find((p) =>
       p.trackPublications.has(update.trackSid),
     );
@@ -2409,6 +2432,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         },
       )
       .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
+        this.cancelPendingTrackAdded(publication.trackSid);
         this.emit(RoomEvent.TrackUnpublished, publication, participant);
       })
       .on(
@@ -2581,11 +2605,20 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             : undefined,
         });
         if (consecutiveFailures >= 3) {
-          this.recreateEngine();
-          this.handleDisconnect(
-            this.options.stopLocalTrackOnUnpublish,
-            DisconnectReason.STATE_MISMATCH,
-          );
+          this.clearConnectionReconcile();
+          if (this.engine && !this.engine.isClosed) {
+            // The transport silently died while we still looked connected. Try a full reconnect
+            // (keeps the room alive; the engine falls back to Disconnected if it ultimately fails).
+            this.log.warn('detected connection state mismatch, attempting full reconnect');
+            this.engine.reconnect();
+          } else {
+            // No usable engine to reconnect with; tear down.
+            this.recreateEngine();
+            this.handleDisconnect(
+              this.options.stopLocalTrackOnUnpublish,
+              DisconnectReason.STATE_MISMATCH,
+            );
+          }
         }
       } else {
         consecutiveFailures = 0;
@@ -2607,7 +2640,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.log.info(`connection state changed: ${this.state} -> ${state}`);
     this.state = state;
     this.incomingDataStreamManager.setConnected(state === ConnectionState.Connected);
+
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
+
     return true;
   }
 

package/src/room/data-stream/incoming/IncomingDataStreamManager.ts

@@ -535,7 +535,7 @@ function bytesToChunks(streamId: string): TransformStream<Uint8Array, DataStream
  * synthesized text chunk decodes independently. The `flush` emits the decoder's trailing bytes.
  */
 function bytesToDecodedUtf8(streamId: string): TransformStream<Uint8Array, DataStream_Chunk> {
-  const decoder = new TextDecoder('utf-8', { fatal: true });
+  const decoder = new TextDecoder('utf-8');
   const encoder = new TextEncoder();
 
   let outIndex = 0;

package/src/room/data-stream/incoming/StreamReader.ts

@@ -204,7 +204,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
     // Suppress unhandled rejection on reader.closed — errors are
     // already propagated through reader.read() to the consumer.
     reader.closed.catch(() => {});
-    const decoder = new TextDecoder('utf-8', { fatal: true });
+    const decoder = new TextDecoder('utf-8');
     const signal = this.signal;
 
     const cleanup = () => {

package/src/room/errors.ts

@@ -248,8 +248,7 @@ export class PublishTrackError extends LivekitError {
 }
 
 export type RequestErrorReason =
-  | Exclude<RequestResponse_Reason, RequestResponse_Reason.OK>
-  | 'TimeoutError';
+  Exclude<RequestResponse_Reason, RequestResponse_Reason.OK> | 'TimeoutError';
 
 export class SignalRequestError extends LivekitReasonedError<RequestErrorReason> {
   readonly name = 'SignalRequestError';