livekit-client 2.18.1 → 2.18.2

package/src/room/Room.ts

@@ -187,6 +187,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private e2eeManager: BaseE2EEManager | undefined;
 
+  private e2eeStateMutex: Mutex = new Mutex();
+
   private connectionReconcileInterval?: ReturnType<typeof setInterval>;
 
   private regionUrlProvider?: RegionUrlProvider;
@@ -293,7 +295,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       });
 
     this.disconnectLock = new Mutex();
-
     this.localParticipant = new LocalParticipant(
       '',
       '',
@@ -411,13 +412,21 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * @experimental
    */
   async setE2EEEnabled(enabled: boolean) {
-    if (this.e2eeManager) {
-      await Promise.all([this.localParticipant.setE2EEEnabled(enabled)]);
-      if (this.localParticipant.identity !== '') {
-        this.e2eeManager.setParticipantCryptorEnabled(enabled, this.localParticipant.identity);
+    const unlock = await this.e2eeStateMutex.lock();
+    try {
+      if (this.e2eeManager) {
+        if (this.isE2EEEnabled !== enabled) {
+          await this.localParticipant.setE2EEEnabled(enabled);
+
+          if (this.localParticipant.identity !== '') {
+            this.e2eeManager.setParticipantCryptorEnabled(enabled, this.localParticipant.identity);
+          }
+        }
+      } else {
+        throw Error('e2ee not configured, please set e2ee settings within the room options');
       }
-    } else {
-      throw Error('e2ee not configured, please set e2ee settings within the room options');
+    } finally {
+      unlock();
     }
   }
 
@@ -450,6 +459,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.emit(RoomEvent.EncryptionError, error, participant);
       });
       this.e2eeManager?.setup(this);
+      this.e2eeManager?.setupEngine(this.engine);
     }
   }
 
@@ -895,7 +905,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     roomOptions: InternalRoomOptions,
     abortController: AbortController,
   ): Promise<JoinResponse> => {
-    const joinResponse = await engine.join(
+    const { joinResponse, serverInfo } = await engine.join(
       url,
       token,
       {
@@ -910,23 +920,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       !roomOptions.singlePeerConnection,
     );
 
-    let serverInfo: Partial<ServerInfo> | undefined = joinResponse.serverInfo;
-    if (!serverInfo) {
-      serverInfo = { version: joinResponse.serverVersion, region: joinResponse.serverRegion };
-    }
     this.serverInfo = serverInfo;
 
-    this.log.debug(
-      `connected to Livekit Server ${Object.entries(serverInfo)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(', ')}`,
-      {
-        room: joinResponse.room?.name,
-        roomSid: joinResponse.room?.sid,
-        identity: joinResponse.participant?.identity,
-      },
-    );
-
     if (!serverInfo.version) {
       throw new UnsupportedServer('unknown server version');
     }
@@ -2475,6 +2470,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       return false;
     }
     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

@@ -27,6 +27,25 @@ export default class IncomingDataStreamManager {
 
   private textStreamHandlers = new Map<string, TextStreamHandler>();
 
+  private isConnected = false;
+
+  private bufferedPackets: Array<{ packet: DataPacket; encryptionType: Encryption_Type }> = [];
+
+  setConnected(connected: boolean) {
+    this.isConnected = connected;
+    if (connected) {
+      this.flushBufferedPackets();
+    }
+  }
+
+  private flushBufferedPackets() {
+    const packets = this.bufferedPackets;
+    this.bufferedPackets = [];
+    for (const { packet, encryptionType } of packets) {
+      this.handleDataStreamPacket(packet, encryptionType);
+    }
+  }
+
   registerTextStreamHandler(topic: string, callback: TextStreamHandler) {
     if (this.textStreamHandlers.has(topic)) {
       throw new DataStreamError(
@@ -58,6 +77,7 @@ export default class IncomingDataStreamManager {
   clearControllers() {
     this.byteStreamControllers.clear();
     this.textStreamControllers.clear();
+    this.bufferedPackets = [];
   }
 
   validateParticipantHasNoActiveDataStreams(participantIdentity: string) {
@@ -88,7 +108,11 @@ export default class IncomingDataStreamManager {
     }
   }
 
-  async handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type) {
+  handleDataStreamPacket(packet: DataPacket, encryptionType: Encryption_Type) {
+    if (!this.isConnected) {
+      this.bufferedPackets.push({ packet, encryptionType });
+      return;
+    }
     switch (packet.value.case) {
       case 'streamHeader':
         return this.handleStreamHeader(
@@ -105,7 +129,7 @@ export default class IncomingDataStreamManager {
     }
   }
 
-  private async handleStreamHeader(
+  private handleStreamHeader(
     streamHeader: DataStream_Header,
     participantIdentity: string,
     encryptionType: Encryption_Type,

package/src/room/data-track/incoming/IncomingDataTrackManager.ts

@@ -436,6 +436,9 @@ export default class IncomingDataTrackManager extends (EventEmitter as new () =>
     this.descriptors.delete(sid);
 
     if (descriptor.subscription.type === 'active') {
+      descriptor.subscription.streamControllers.forEach((controller) => {
+        controller.close();
+      });
       this.subscriptionHandles.delete(descriptor.subscription.subcriptionHandle);
     }
 
@@ -583,6 +586,10 @@ export default class IncomingDataTrackManager extends (EventEmitter as new () =>
       if (descriptor.subscription.type === 'pending') {
         descriptor.subscription.completionFuture.reject?.(DataTrackSubscribeError.disconnected());
       }
+
+      if (descriptor.subscription.type === 'active') {
+        descriptor.subscription.streamControllers.forEach((controller) => controller.close());
+      }
     }
     this.descriptors.clear();
   }

package/src/room/participant/LocalParticipant.ts

@@ -1,3 +1,4 @@
+import { Mutex } from '@livekit/mutex';
 import {
   AddTrackRequest,
   AudioTrackFeature,
@@ -143,6 +144,8 @@ export default class LocalParticipant extends Participant {
 
   private encryptionType: Encryption_Type = Encryption_Type.NONE;
 
+  private e2eeStateMutex = new Mutex();
+
   private reconnectFuture?: Future<void, Error>;
 
   private signalConnectedFuture?: Future<void, Error>;
@@ -499,8 +502,20 @@ export default class LocalParticipant extends Participant {
 
   /** @internal */
   async setE2EEEnabled(enabled: boolean) {
-    this.encryptionType = enabled ? Encryption_Type.GCM : Encryption_Type.NONE;
-    await this.republishAllTracks(undefined, false);
+    const unlock = await this.e2eeStateMutex.lock();
+    try {
+      this.encryptionType = enabled ? Encryption_Type.GCM : Encryption_Type.NONE;
+      await Promise.all(this.pendingPublishPromises.values());
+      if (
+        this.trackPublications.size === 0 ||
+        Array.from(this.trackPublications.values()).every((pub) => pub.isEncrypted === enabled)
+      ) {
+        return;
+      }
+      await this.republishAllTracks(undefined, false);
+    } finally {
+      unlock();
+    }
   }
 
   /**

package/src/utils/serializer.ts

@@ -0,0 +1,72 @@
+const SerializerSymbol = Symbol.for('lk.serializer');
+
+/**
+ * A bidirectional data format descriptor for message payloads.
+ *
+ * - `parse(raw)` decodes an incoming wire string into `Input` (used by handlers)
+ * - `serialize(val)` encodes an `Output` value to a wire string (used by handlers)
+ *
+ * For symmetric serializers (`serializers.raw`), `Input === Output === string`.
+ * For `serializers.json`, both default to `any` so each handler can annotate its own types.
+ * Use `serializers.custom` to supply your own `parse`/`serialize` pair.
+ *
+ * @beta
+ */
+export type Serializer<Input, Output> = {
+  symbol: typeof SerializerSymbol;
+  parse: (raw: string) => Input;
+  serialize: (val: Output) => string;
+};
+
+export function isSerializer(v: unknown): v is Serializer<any, any> {
+  return typeof v === 'object' && v !== null && 'symbol' in v && v.symbol === SerializerSymbol;
+}
+
+export type SerializerInput<S> = S extends Serializer<infer Input, any> ? Input : any;
+export type SerializerOutput<S> = S extends Serializer<any, infer Output> ? Output : any;
+
+/** @internal */
+function base<Input = any, Output = any>(
+  params: Omit<Serializer<Input, Output>, 'symbol'>,
+): Serializer<Input, Output> {
+  return { ...params, symbol: SerializerSymbol };
+}
+
+/**
+ * JSON serializer — `JSON.parse` on the way in, `JSON.stringify` on the way out.
+ * Defaults to `any` so individual handlers can annotate their own payload types.
+ */
+function json<Input = any, Output = any>(): Serializer<Input, Output> {
+  return base({
+    parse: (rawString: string) => JSON.parse(rawString) as Input,
+    serialize: (val: unknown) => JSON.stringify(val),
+  });
+}
+
+/** Raw string serializer — passes payloads through as plain strings with no encoding. */
+function raw() {
+  return base({
+    parse: (rawString: string) => rawString,
+    serialize: (val: string) => val,
+  });
+}
+
+/** Custom serializer - allows custom defined parse and serialize functions */
+function custom<Input = any, Output = any>(
+  params: Omit<Serializer<Input, Output>, 'symbol'>,
+): Serializer<Input, Output> {
+  return base(params);
+}
+
+/**
+ * Serializer helpers for message payload encoding.
+ *
+ * @example
+ * ```ts
+ * const a = serializers.raw(); // Serializer<string, string>
+ * const b = serializer.json<{ foo: string }, { bar: string }>(); // Serializer<{ foo: string }, { bar: string }>
+ * ```
+ *
+ * @beta
+ */
+export const serializers = { json, raw, custom };