livekit-client 2.22.0 → 2.22.1

package/src/api/utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { createRtcUrl, createValidateUrl } from './utils';
+import { createRtcUrl, createValidateUrl, getAbortReasonAsString } from './utils';
 
 describe('createRtcUrl', () => {
   it('should create a basic RTC URL', () => {
@@ -125,3 +125,22 @@ describe('createValidateUrl', () => {
     expect(parsedResult.pathname).toBe('/sub/path/rtc/validate');
   });
 });
+
+describe('getAbortReasonAsString', () => {
+  it('uses an error message, which is how the connect timeout describes itself', () => {
+    // the timeout hands the abort handler an Error, not a signal
+    expect(
+      getAbortReasonAsString(new Error('room connection has timed out (signal)'), 'fallback'),
+    ).toBe('room connection has timed out (signal)');
+  });
+
+  it("reads an abort signal's reason", () => {
+    const controller = new AbortController();
+    controller.abort('user navigated away');
+    expect(getAbortReasonAsString(controller.signal, 'fallback')).toBe('user navigated away');
+  });
+
+  it('falls back when there is nothing to describe', () => {
+    expect(getAbortReasonAsString(undefined, 'fallback')).toBe('fallback');
+  });
+});

package/src/api/utils.ts

@@ -45,6 +45,11 @@ export function getAbortReasonAsString(
   signal: AbortSignal | Error | unknown,
   defaultMessage = 'Unknown reason',
 ) {
+  // the connect timeout hands this an Error rather than a signal, and its message is the only
+  // description of what went wrong — without this a timeout reports itself as a generic abort
+  if (signal instanceof Error) {
+    return signal.message;
+  }
   if (!(signal instanceof AbortSignal)) {
     return defaultMessage;
   }

package/src/index.ts

@@ -53,12 +53,14 @@ import {
   isLocalTrack,
   isRemoteParticipant,
   isRemoteTrack,
+  isSVCCodec,
   isVideoCodec,
   isVideoTrack,
   supportsAV1,
   supportsAdaptiveStream,
   supportsAudioOutputSelection,
   supportsDynacast,
+  supportsH265,
   supportsVP9,
 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
@@ -149,12 +151,14 @@ export {
   supportsAdaptiveStream,
   supportsAudioOutputSelection,
   supportsDynacast,
+  supportsH265,
   supportsVP9,
   Mutex,
   isAudioCodec,
   isAudioTrack,
   isLocalTrack,
   isRemoteTrack,
+  isSVCCodec,
   isVideoCodec,
   isVideoTrack,
   isLocalParticipant,
@@ -180,6 +184,7 @@ export type {
   DataTrackSubscribeOptions,
   RemoteDataTrackPipelineOptions,
 };
+export { type DataTrackFrame } from './room/data-track/frame';
 export { DataTrackPacket, type DataTrackPacketHeader } from './room/data-track/packet';
 export {
   type DataTrackExtensions,

package/src/logger.ts

@@ -24,6 +24,7 @@ export enum LoggerNames {
   DataTracks = 'livekit-data-tracks',
   Region = 'livekit-region',
   ICE = 'livekit-ice',
+  Stats = 'livekit-stats',
 }
 
 type LogLevelString = keyof typeof LogLevel;

package/src/options.ts

@@ -120,6 +120,30 @@ export interface InternalRoomOptions {
    * @default true
    */
   singlePeerConnection: boolean;
+
+  /**
+   * Options controlling data stream behavior for this room.
+   */
+  dataStream?: RoomDataStreamOptions;
+}
+
+/**
+ * Options controlling data stream behavior for a room.
+ */
+export interface RoomDataStreamOptions {
+  /**
+   * Maximum size, in bytes, of the payload this client accepts from a single incoming data stream.
+   *
+   * A compressed stream can inflate to an arbitrarily large payload, so the decompressed output is
+   * bounded rather than trusting the size declared on the wire. An incoming stream that exceeds the
+   * cap fails with a `DataStreamErrorReason.PayloadTooLarge` error on the next read instead of
+   * buffering without bound.
+   *
+   * This is enforced on the receiving side only: raising it on a sender has no effect.
+   *
+   * @default 5_000_000_000 (5 GB)
+   */
+  maxPayloadByteLength?: number;
 }
 
 /**

package/src/room/PCTransport.ts

@@ -597,8 +597,9 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     return this.pc?.remoteDescription;
   }
 
+  /** stats of the underlying connection, `undefined` when there is none */
   getStats() {
-    return this.pc.getStats();
+    return this._pc?.getStats();
   }
 
   getMaxMessageSize() {

package/src/room/RTCEngine.ts

@@ -432,7 +432,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   }
 
-  async close() {
+  /**
+   * @param reason why the session is ending, recorded by the signal lifecycle. Worth passing
+   * wherever the caller knows more than "someone called close" — the server's leave reason, or
+   * having given up on reconnecting.
+   */
+  async close(reason?: string) {
     const unlock = await this.closingLock.lock();
     if (this.isClosed) {
       unlock();
@@ -448,7 +453,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.clearLostQualityTimeout();
       this.cleanupLossyDataStats();
       await this.cleanupPeerConnections();
-      await this.cleanupClient();
+      await this.cleanupClient(reason);
     } finally {
       unlock();
     }
@@ -469,8 +474,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.lossyChannel.stopThresholdTuning();
   }
 
-  async cleanupClient() {
-    await this.client.close();
+  async cleanupClient(reason?: string) {
+    await this.client.close(true, reason);
     this.client.resetCallbacks();
     // Any in-flight addTrack requests are orphaned by the signal reconnect — the new session
     // won't deliver `trackPublishedResponse` for them, so reject the pending resolvers and
@@ -751,7 +756,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       switch (leave.action) {
         case LeaveRequest_Action.DISCONNECT:
           this.emit(EngineEvent.Disconnected, leave?.reason);
-          this.close();
+          this.close(`server leave: ${DisconnectReason[leave.reason] ?? leave.reason}`);
           break;
         case LeaveRequest_Action.RECONNECT:
           this.fullReconnectOnNext = true;
@@ -1161,7 +1166,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         `could not recover connection after ${this.reconnectAttempts} attempts, ${duration}ms. giving up`,
       );
       this.emit(EngineEvent.Disconnected);
-      this.close();
+      this.close(`gave up reconnecting after ${this.reconnectAttempts} attempts, ${duration}ms`);
     };
 
     const duration = Date.now() - this.reconnectStart;
@@ -1323,7 +1328,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
           }ms. giving up`,
         );
         this.emit(EngineEvent.Disconnected);
-        await this.close();
+        await this.close(
+          `gave up reconnecting after ${this.reconnectAttempts} attempts, ${
+            Date.now() - this.reconnectStart
+          }ms`,
+        );
       }
     } finally {
       this.attemptingReconnect = false;

package/src/room/Room.ts

@@ -91,6 +91,7 @@ import {
   type RpcInvocationData,
   RpcServerManager,
 } from './rpc';
+import { summarizeStatsReport } from './statsSummary';
 import CriticalTimers from './timers';
 import LocalAudioTrack from './track/LocalAudioTrack';
 import type LocalTrack from './track/LocalTrack';
@@ -143,6 +144,7 @@ export enum ConnectionState {
 }
 
 const CONNECTION_RECONCILE_FREQUENCY_MS = 4 * 1000;
+const STATS_LOG_FREQUENCY_MS = 30 * 1000;
 
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
@@ -207,6 +209,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private connectionReconcileInterval?: ReturnType<typeof setInterval>;
 
+  private statsLogInterval?: ReturnType<typeof setInterval>;
+
   private regionUrlProvider?: RegionUrlProvider;
 
   private regionUrl?: string;
@@ -215,6 +219,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private log = log;
 
+  private statsLog = log;
+
   private bufferedEvents: Array<any> = [];
 
   private isResuming: boolean = false;
@@ -254,6 +260,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.options = { ...roomOptionDefaults, ...options };
 
     this.log = getLogger(this.options.loggerName ?? LoggerNames.Room, () => this.logContext);
+    // its own logger name, so the stats dumps can be silenced or routed
+    // separately from the rest of the room's logs
+    this.statsLog = getLogger(LoggerNames.Stats, () => this.logContext);
     this.transcriptionReceivedTimes = new Map();
 
     this.options.audioCaptureDefaults = {
@@ -271,7 +280,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.maybeCreateEngine();
 
-    this.incomingDataStreamManager = new IncomingDataStreamManager();
+    this.incomingDataStreamManager = new IncomingDataStreamManager(
+      this.options.dataStream?.maxPayloadByteLength,
+    );
     this.outgoingDataStreamManager = new OutgoingDataStreamManager(
       this.engine,
       this.log,
@@ -1913,7 +1924,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
       // when it's disconnected, send updates
       if (info.state === ParticipantInfo_State.DISCONNECTED) {
-        this.handleParticipantDisconnected(info.identity, remoteParticipant);
+        this.handleParticipantDisconnected(
+          info.identity,
+          remoteParticipant,
+          info.disconnectReason === DisconnectReason.UNKNOWN_REASON
+            ? undefined
+            : info.disconnectReason,
+        );
       } else {
         // create participant if doesn't exist
         this.getOrCreateParticipant(info.identity, info);
@@ -1931,7 +1948,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.incomingDataTrackManager.receiveSfuPublicationUpdates(mapped);
   };
 
-  private handleParticipantDisconnected(identity: string, participant?: RemoteParticipant) {
+  private handleParticipantDisconnected(
+    identity: string,
+    participant?: RemoteParticipant,
+    disconnectReason?: DisconnectReason,
+  ) {
     // remove and send event
     this.remoteParticipants.delete(identity);
     if (!participant) {
@@ -1944,7 +1965,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     participant.trackPublications.forEach((publication) => {
       participant.unpublishTrack(publication.trackSid, true);
     });
-    this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.emit(RoomEvent.ParticipantDisconnected, participant, disconnectReason);
     participant.setDisconnected();
     this.rpcClientManager.handleParticipantDisconnected(participant.identity);
   }
@@ -2582,6 +2603,46 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     );
   }
 
+  private setStatsLogging(enabled: boolean) {
+    if (enabled) {
+      if (!this.statsLogInterval) {
+        this.statsLogInterval = CriticalTimers.setInterval(() => {
+          // logWebRTCStats handles its own errors, nothing to await here
+          this.logWebRTCStats();
+        }, STATS_LOG_FREQUENCY_MS);
+      }
+    } else if (this.statsLogInterval) {
+      CriticalTimers.clearInterval(this.statsLogInterval);
+      this.statsLogInterval = undefined;
+    }
+  }
+
+  /**
+   * Dumps stats of both peer connections.
+   */
+  private logWebRTCStats = async () => {
+    const pcManager = this.engine?.pcManager;
+    if (!pcManager) {
+      return;
+    }
+    try {
+      const [publisher, subscriber] = await Promise.all([
+        pcManager.publisher.getStats(),
+        pcManager.subscriber?.getStats(),
+      ]);
+      const publisherStats = publisher && summarizeStatsReport(publisher);
+      const subscriberStats = subscriber && summarizeStatsReport(subscriber);
+      this.statsLog.info(`webrtc stats`, {
+        publisher: publisherStats?.connection,
+        subscriber: subscriberStats?.connection,
+        inbound: [...(publisherStats?.inbound ?? []), ...(subscriberStats?.inbound ?? [])],
+        outbound: publisherStats?.outbound,
+      });
+    } catch (error) {
+      this.statsLog.debug('could not collect webrtc stats', { error });
+    }
+  };
+
   private registerConnectionReconcile() {
     this.clearConnectionReconcile();
     let consecutiveFailures = 0;
@@ -2640,6 +2701,7 @@ 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.setStatsLogging(state === ConnectionState.Connected);
 
     this.emit(RoomEvent.ConnectionStateChanged, this.state);
 
@@ -2948,7 +3010,10 @@ export type RoomEventCallbacks = {
   moved: (name: string) => void;
   mediaDevicesChanged: () => void;
   participantConnected: (participant: RemoteParticipant) => void;
-  participantDisconnected: (participant: RemoteParticipant) => void;
+  participantDisconnected: (
+    participant: RemoteParticipant,
+    disconnectReason?: DisconnectReason,
+  ) => void;
   trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
   trackSubscribed: (
     track: RemoteTrack,

package/src/room/events.ts

@@ -80,7 +80,7 @@ export enum RoomEvent {
    * When a [[RemoteParticipant]] leaves *after* the local
    * participant has joined.
    *
-   * args: ([[RemoteParticipant]])
+   * args: ([[RemoteParticipant]], [[DisconnectReason]] | undefined)
    */
   ParticipantDisconnected = 'participantDisconnected',
 

package/src/room/statsSummary.ts

@@ -0,0 +1,187 @@
+/** one summarised stats entry; keys without a value are dropped */
+type Summary = Record<string, unknown>;
+
+function compact<T extends Summary>(summary: T): Summary {
+  const compacted: Summary = {};
+  for (const [key, value] of Object.entries(summary)) {
+    if (value !== undefined) {
+      compacted[key] = value;
+    }
+  }
+  return compacted;
+}
+
+function resolution(width?: number, height?: number): string | undefined {
+  return width && height ? `${width}x${height}` : undefined;
+}
+
+/** keeps the derived durations readable; reported values are logged as they are */
+function round(seconds: number): number {
+  return Math.round(seconds * 10_000) / 10_000;
+}
+
+/**
+ * Average time media spent in the jitter buffer, in s. Both counters are
+ * cumulative, so this is the average over the lifetime of the stream.
+ */
+function jitterBuffer(stat: Summary): number | undefined {
+  const delay = stat.jitterBufferDelay as number | undefined;
+  const emitted = stat.jitterBufferEmittedCount as number | undefined;
+  return delay !== undefined && emitted ? round(delay / emitted) : undefined;
+}
+
+/**
+ * Playout delay in s. Video receive reports it directly, the audio path keeps it
+ * in the linked `media-playout` stats summed over the samples played out. Pairs
+ * with `RemoteTrack.setPlayoutDelay`.
+ */
+function playoutDelay(stat: Summary, playout?: Summary): number | undefined {
+  if (stat.playoutDelay !== undefined) {
+    return round(stat.playoutDelay as number);
+  }
+  const total = playout?.totalPlayoutDelay as number | undefined;
+  const samples = playout?.totalSamplesCount as number | undefined;
+  return total !== undefined && samples ? round(total / samples) : undefined;
+}
+
+/**
+ * Picks the interesting fields out of a `getStats()` report and groups them by
+ * RTP stream, so a stats dump can be read without unfolding the raw report.
+ */
+export function summarizeStatsReport(report: RTCStatsReport) {
+  const byId = new Map<string, Summary>();
+  const candidatePairs: Summary[] = [];
+  const inbound: Summary[] = [];
+  const outbound: Summary[] = [];
+  let transport: Summary | undefined;
+
+  report.forEach((stat) => byId.set(stat.id, stat));
+
+  const codecOf = (stat: Summary) =>
+    stat.codecId ? byId.get(stat.codecId as string)?.mimeType : undefined;
+  const relatedOf = (stat: Summary, key: 'remoteId' | 'mediaSourceId' | 'playoutId') =>
+    stat[key] ? byId.get(stat[key] as string) : undefined;
+
+  report.forEach((stat) => {
+    switch (stat.type) {
+      case 'inbound-rtp': {
+        const playout = relatedOf(stat, 'playoutId');
+        inbound.push(
+          compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            // matches `streamTrackID` in the track's own log context
+            trackId: stat.trackIdentifier,
+            codec: codecOf(stat),
+            decoder: stat.decoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            bytesReceived: stat.bytesReceived,
+            packetsReceived: stat.packetsReceived,
+            packetsLost: stat.packetsLost,
+            packetsDiscarded: stat.packetsDiscarded,
+            // frames received without frames decoded is a decode failure
+            framesReceived: stat.framesReceived,
+            framesDecoded: stat.framesDecoded,
+            framesDropped: stat.framesDropped,
+            keyFramesDecoded: stat.keyFramesDecoded,
+            freezeCount: stat.freezeCount,
+            totalFreezesDuration: stat.totalFreezesDuration,
+            pauseCount: stat.pauseCount,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            jitter: stat.jitter,
+            jitterBuffer: jitterBuffer(stat),
+            playoutDelay: playoutDelay(stat, playout),
+            audioLevel: stat.audioLevel,
+            totalSamplesReceived: stat.totalSamplesReceived,
+            concealedSamples: stat.concealedSamples,
+          }),
+        );
+        break;
+      }
+      case 'outbound-rtp': {
+        const remote = relatedOf(stat, 'remoteId');
+        const source = relatedOf(stat, 'mediaSourceId');
+        outbound.push(
+          compact({
+            kind: stat.kind,
+            ssrc: stat.ssrc,
+            mid: stat.mid,
+            rid: stat.rid,
+            trackId: source?.trackIdentifier,
+            active: stat.active,
+            codec: codecOf(stat),
+            encoder: stat.encoderImplementation,
+            resolution: resolution(stat.frameWidth, stat.frameHeight),
+            fps: stat.framesPerSecond,
+            // what the source produces, to tell a stalled capture from a stalled encoder
+            captureResolution: resolution(
+              source?.width as number | undefined,
+              source?.height as number | undefined,
+            ),
+            captureFps: source?.framesPerSecond,
+            audioLevel: source?.audioLevel,
+            targetBitrate: stat.targetBitrate,
+            bytesSent: stat.bytesSent,
+            packetsSent: stat.packetsSent,
+            retransmittedPacketsSent: stat.retransmittedPacketsSent,
+            framesEncoded: stat.framesEncoded,
+            keyFramesEncoded: stat.keyFramesEncoded,
+            limitedBy:
+              stat.qualityLimitationReason === 'none' ? undefined : stat.qualityLimitationReason,
+            nackCount: stat.nackCount,
+            pliCount: stat.pliCount,
+            firCount: stat.firCount,
+            // loss, jitter and RTT are only known from what the remote reports
+            remotePacketsLost: remote?.packetsLost,
+            remoteFractionLost: remote?.fractionLost,
+            remoteJitter: remote?.jitter,
+            remoteRoundTripTime: remote?.roundTripTime,
+          }),
+        );
+        break;
+      }
+      case 'transport':
+        transport = stat;
+        break;
+      case 'candidate-pair':
+        candidatePairs.push(stat);
+        break;
+      default:
+    }
+  });
+
+  const selectedPairId = transport?.selectedCandidatePairId as string | undefined;
+  const pair =
+    (selectedPairId ? byId.get(selectedPairId) : undefined) ??
+    candidatePairs.find((candidate) => candidate.selected) ??
+    candidatePairs.find((candidate) => candidate.nominated);
+  const local = pair?.localCandidateId ? byId.get(pair.localCandidateId as string) : undefined;
+  const remote = pair?.remoteCandidateId ? byId.get(pair.remoteCandidateId as string) : undefined;
+
+  const connection = compact({
+    ice: transport?.iceState,
+    dtls: transport?.dtlsState,
+    route:
+      local && remote
+        ? `${local.candidateType}/${local.protocol} -> ${remote.candidateType}`
+        : undefined,
+    network: local?.networkType,
+    currentRoundTripTime: pair?.currentRoundTripTime,
+    // the send bandwidth estimate; no RTP stream reports it
+    availableOutgoingBitrate: pair?.availableOutgoingBitrate,
+    availableIncomingBitrate: pair?.availableIncomingBitrate,
+    bytesSent: pair?.bytesSent,
+    bytesReceived: pair?.bytesReceived,
+    candidatePairChanges: transport?.selectedCandidatePairChanges,
+  });
+
+  return {
+    connection: Object.keys(connection).length > 0 ? connection : undefined,
+    outbound: outbound.length > 0 ? outbound : undefined,
+    inbound: inbound.length > 0 ? inbound : undefined,
+  };
+}

package/src/room/token-source/test-tokens.ts

@@ -1,3 +1,11 @@
+// Builds an unsigned (`alg: none`) JWT. These aren't signed at all, so they can only be used in
+// tests which don't care about the signature.
+function unsignedToken(payload: Record<string, unknown>) {
+  const encode = (value: Record<string, unknown>) =>
+    btoa(JSON.stringify(value)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+  return `${encode({ alg: 'none', typ: 'JWT' })}.${encode(payload)}.`;
+}
+
 // Test JWTs created for test purposes only.
 // None of these actually auth against anything.
 export const TOKENS = {
@@ -25,4 +33,16 @@ export const TOKENS = {
   // A dummy roomConfig value is also set, with room_config.name = "test room name", room_config.extraField = "extra field value", and room_config.agents = [{"agentName": "test agent name","metadata":"test agent metadata","extraField":"extra field value"}]
   EXTRA_FIELDS:
     'eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwiZXhwIjo5ODc2NTQzMjEwLCJuYmYiOjEyMzQ1Njc4OTAsImlhdCI6MTIzNDU2Nzg5MCwicm9vbUNvbmZpZyI6eyJuYW1lIjoidGVzdCByb29tIG5hbWUiLCJlbXB0eVRpbWVvdXQiOjAsImRlcGFydHVyZVRpbWVvdXQiOjAsIm1heFBhcnRpY2lwYW50cyI6MCwibWluUGxheW91dERlbGF5IjowLCJtYXhQbGF5b3V0RGVsYXkiOjAsInN5bmNTdHJlYW1zIjpmYWxzZSwiYWdlbnRzIjpbeyJhZ2VudE5hbWUiOiJ0ZXN0IGFnZW50IG5hbWUiLCJtZXRhZGF0YSI6InRlc3QgYWdlbnQgbWV0YWRhdGEiLCJleHRyYUZpZWxkIjoiZXh0cmEgZmllbGQgdmFsdWUifV0sIm1ldGFkYXRhIjoiIiwiZXh0cmFGaWVsZCI6ImV4dHJhIGZpZWxkIHZhbHVlIn19Cg.EDetpHG8cSubaApzgWJaQrpCiSy9KDBlfCfVdIydbQ-_CHiNnXOK_f_mCJbTf9A-duT1jmvPOkLrkkWFT60XPQ',
+
+  // Nbf date set at 1234567890 seconds (Fri Feb 13 2009 23:31:30 GMT+0000)
+  // No exp date set at all
+  NO_EXP: unsignedToken({ sub: '1234567890', nbf: 1234567890, iat: 1234567890 }),
+
+  // No nbf date set at all
+  // Exp date set at 1234567891 seconds (Fri Feb 13 2009 23:31:31 GMT+0000)
+  EXP_IN_PAST_NO_NBF: unsignedToken({ sub: '1234567890', exp: 1234567891, iat: 1234567890 }),
+
+  // No nbf date set at all
+  // Exp date set at 9876543210 seconds (Fri Dec 22 2282 20:13:30 GMT+0000)
+  VALID_NO_NBF: unsignedToken({ sub: '1234567890', exp: 9876543210, iat: 1234567890 }),
 };

package/src/room/token-source/utils.test.ts

@@ -31,6 +31,33 @@ describe('isResponseTokenValid', () => {
     );
     expect(isValid).toBe(false);
   });
+  it('should treat a jwt without exp as expired', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.NO_EXP,
+      }),
+    );
+    expect(isValid).toBe(false);
+  });
+  it('should honor exp when nbf is absent', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.EXP_IN_PAST_NO_NBF,
+      }),
+    );
+    expect(isValid).toBe(false);
+  });
+  it('should accept a non-expired jwt that omits nbf', () => {
+    const isValid = isResponseTokenValid(
+      TokenSourceResponse.fromJson({
+        serverUrl: 'ws://localhost:7800',
+        participantToken: TOKENS.VALID_NO_NBF,
+      }),
+    );
+    expect(isValid).toBe(true);
+  });
 });
 
 describe('decodeTokenPayload', () => {

package/src/room/token-source/utils.ts

@@ -7,19 +7,26 @@ const ONE_MINUTE_IN_MILLISECONDS = 60 * ONE_SECOND_IN_MILLISECONDS;
 
 export function isResponseTokenValid(response: TokenSourceResponse) {
   const jwtPayload = decodeTokenPayload(response.participantToken);
-  if (!jwtPayload?.nbf || !jwtPayload?.exp) {
-    return true;
+  // Missing exp: TokenSourceCached would otherwise return this response forever.
+  // nbf is optional (RFC 7519); do not skip the exp check when it is absent.
+  if (!jwtPayload?.exp) {
+    return false;
   }
 
   const now = new Date();
 
-  const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
-  const nbfDate = new Date(nbfInMilliseconds);
+  if (jwtPayload.nbf) {
+    const nbfInMilliseconds = jwtPayload.nbf * ONE_SECOND_IN_MILLISECONDS;
+    const nbfDate = new Date(nbfInMilliseconds);
+    if (nbfDate > now) {
+      return false;
+    }
+  }
 
   const expInMilliseconds = jwtPayload.exp * ONE_SECOND_IN_MILLISECONDS;
   const expDate = new Date(expInMilliseconds - ONE_MINUTE_IN_MILLISECONDS);
 
-  return nbfDate <= now && expDate > now;
+  return expDate > now;
 }
 
 /** Given a LiveKit generated participant token, decodes and returns the associated {@link TokenPayload} data. */

package/src/room/track/LocalAudioTrack.ts

@@ -245,12 +245,18 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
           type: 'audio',
           streamId: v.id,
           packetsSent: v.packetsSent,
-          packetsLost: v.packetsLost,
           bytesSent: v.bytesSent,
           timestamp: v.timestamp,
-          roundTripTime: v.roundTripTime,
-          jitter: v.jitter,
         };
+
+        // loss, jitter and RTT are only known from what the remote reports back,
+        // the same way the video sender picks them up
+        const remote = stats.get(v.remoteId);
+        if (remote) {
+          audioStats.packetsLost = remote.packetsLost;
+          audioStats.jitter = remote.jitter;
+          audioStats.roundTripTime = remote.roundTripTime;
+        }
       }
     });