livekit-client 2.15.4 → 2.15.6

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -1,13 +1,14 @@
 import { Codec, ParticipantInfo, ParticipantPermission } from '@livekit/protocol';
 import type { InternalRoomOptions } from '../../options';
 import type RTCEngine from '../RTCEngine';
-import { ByteStreamWriter, TextStreamWriter } from '../StreamWriter';
+import type OutgoingDataStreamManager from '../data-stream/outgoing/OutgoingDataStreamManager';
+import type { TextStreamWriter } from '../data-stream/outgoing/StreamWriter';
 import type { PerformRpcParams, RpcInvocationData } from '../rpc';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import { Track } from '../track/Track';
 import type { AudioCaptureOptions, BackupVideoCodec, CreateLocalTracksOptions, ScreenShareCaptureOptions, TrackPublishOptions, VideoCaptureOptions } from '../track/options';
-import type { ChatMessage, DataPublishOptions, SendTextOptions, StreamTextOptions, TextStreamInfo } from '../types';
+import type { ChatMessage, DataPublishOptions, SendFileOptions, SendTextOptions, StreamBytesOptions, StreamTextOptions, TextStreamInfo } from '../types';
 import Participant from './Participant';
 import type { ParticipantTrackPermission } from './ParticipantTrackPermission';
 import type RemoteParticipant from './RemoteParticipant';
@@ -34,12 +35,13 @@ export default class LocalParticipant extends Participant {
     private activeAgentFuture?;
     private firstActiveAgent?;
     private rpcHandlers;
+    private roomOutgoingDataStreamManager;
     private pendingSignalRequests;
     private enabledPublishVideoCodecs;
     private pendingAcks;
     private pendingResponses;
     /** @internal */
-    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>);
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>, roomOutgoingDataStreamManager: OutgoingDataStreamManager);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
     get isE2EEEnabled(): boolean;
@@ -156,7 +158,9 @@ export default class LocalParticipant extends Participant {
      * @param digit DTMF digit
      */
     publishDtmf(code: number, digit: string): Promise<void>;
+    /** @deprecated Consider migrating to {@link sendText} */
     sendChatMessage(text: string, options?: SendTextOptions): Promise<ChatMessage>;
+    /** @deprecated Consider migrating to {@link sendText} */
     editChatMessage(editText: string, originalMessage: ChatMessage): Promise<{
         readonly message: string;
         readonly editTimestamp: number;
@@ -164,30 +168,39 @@ export default class LocalParticipant extends Participant {
         readonly timestamp: number;
         readonly attachedFiles?: Array<File>;
     }>;
+    /**
+     * Sends the given string to participants in the room via the data channel.
+     * For longer messages, consider using {@link streamText} instead.
+     *
+     * @param text The text payload
+     * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+     */
     sendText(text: string, options?: SendTextOptions): Promise<TextStreamInfo>;
     /**
+     * Creates a new TextStreamWriter which can be used to stream text incrementally
+     * to participants in the room via the data channel.
+     *
+     * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+     *
      * @internal
      * @experimental CAUTION, might get removed in a minor release
      */
     streamText(options?: StreamTextOptions): Promise<TextStreamWriter>;
-    sendFile(file: File, options?: {
-        mimeType?: string;
-        topic?: string;
-        destinationIdentities?: Array<string>;
-        onProgress?: (progress: number) => void;
-    }): Promise<{
+    /** Send a File to all participants in the room via the data channel.
+     * @param file The File object payload
+     * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+     * @param options.onProgress A callback function used to monitor the upload progress percentage.
+     */
+    sendFile(file: File, options?: SendFileOptions): Promise<{
         id: string;
     }>;
-    private _sendFile;
-    streamBytes(options?: {
-        name?: string;
-        topic?: string;
-        attributes?: Record<string, string>;
-        destinationIdentities?: Array<string>;
-        streamId?: string;
-        mimeType?: string;
-        totalSize?: number;
-    }): Promise<ByteStreamWriter>;
+    /**
+     * Stream bytes incrementally to participants in the room via the data channel.
+     * For sending files, consider using {@link sendFile} instead.
+     *
+     * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+     */
+    streamBytes(options?: StreamBytesOptions): Promise<import("../data-stream/outgoing/StreamWriter").ByteStreamWriter>;
     /**
      * Initiate an RPC call to a remote participant
      * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -23,11 +23,10 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     protected pauseUpstreamLock: Mutex;
     protected processorElement?: HTMLMediaElement;
     protected processor?: TrackProcessor<TrackKind, any>;
-    protected processorLock: Mutex;
     protected audioContext?: AudioContext;
     protected manuallyStopped: boolean;
     protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
-    private restartLock;
+    protected trackChangeLock: Mutex;
     /**
      *
      * @param mediaTrack
@@ -104,6 +103,12 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
      * @returns
      */
     stopProcessor(keepElement?: boolean): Promise<void>;
+    /**
+     * @internal
+     * This method assumes the caller has acquired a trackChangeLock already.
+     * The public facing method for stopping the processor is `stopProcessor` and it wraps this method in the trackChangeLock.
+     */
+    protected internalStopProcessor(keepElement?: boolean): Promise<void>;
     /** @internal */
     startPreConnectBuffer(timeslice?: number): void;
     /** @internal */

package/dist/ts4.2/src/room/track/RemoteVideoTrack.d.ts

@@ -11,6 +11,7 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     private lastDimensions?;
     constructor(mediaTrack: MediaStreamTrack, sid: string, receiver: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
     get isAdaptiveStream(): boolean;
+    setStreamState(value: Track.StreamState): void;
     /**
      * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start
      */

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -15,6 +15,7 @@ export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> e
     attachedElements: HTMLMediaElement[];
     isMuted: boolean;
     source: Track.Source;
+    private _streamState;
     /**
      * sid is set after track is published to server, or if it's a remote track
      */
@@ -27,7 +28,9 @@ export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> e
      * indicates current state of stream, it'll indicate `paused` if the track
      * has been paused by congestion controller
      */
-    streamState: Track.StreamState;
+    get streamState(): Track.StreamState;
+    /** @internal */
+    setStreamState(value: Track.StreamState): void;
     /** @internal */
     rtpTimestamp: number | undefined;
     protected _mediaStreamTrack: MediaStreamTrack;

package/dist/ts4.2/src/room/types.d.ts

@@ -1,4 +1,5 @@
-import type { DataStream_Chunk } from '@livekit/protocol';
+import type { DataStream_Chunk, Encryption_Type } from '@livekit/protocol';
+import type { Future } from './utils';
 export type SimulationOptions = {
     publish?: {
         audio?: boolean;
@@ -30,6 +31,19 @@ export interface StreamTextOptions {
     totalSize?: number;
     attributes?: Record<string, string>;
 }
+export type StreamBytesOptions = {
+    name?: string;
+    topic?: string;
+    attributes?: Record<string, string>;
+    destinationIdentities?: Array<string>;
+    streamId?: string;
+    mimeType?: string;
+    totalSize?: number;
+};
+export type SendFileOptions = Pick<StreamBytesOptions, 'topic' | 'mimeType' | 'destinationIdentities'> & {
+    onProgress?: (progress: number) => void;
+    encryptionType?: Encryption_Type.NONE;
+};
 export type DataPublishOptions = {
     /**
      * whether to send this as reliable or lossy.
@@ -76,6 +90,8 @@ export interface StreamController<T extends DataStream_Chunk> {
     controller: ReadableStreamDefaultController<T>;
     startTime: number;
     endTime?: number;
+    sendingParticipantIdentity: string;
+    outOfBandFailureRejectingFuture: Future<never>;
 }
 export interface BaseStreamInfo {
     id: string;

package/dist/ts4.2/src/room/utils.d.ts

@@ -44,6 +44,14 @@ export declare function isReactNative(): boolean;
 export declare function isCloud(serverUrl: URL): boolean;
 export declare function getReactNativeOs(): string | undefined;
 export declare function getDevicePixelRatio(): number;
+/**
+ * @param v1 - The first version string to compare.
+ * @param v2 - The second version string to compare.
+ * @returns A number indicating the order of the versions:
+ *   - 1 if v1 is greater than v2
+ *   - -1 if v1 is less than v2
+ *   - 0 if v1 and v2 are equal
+ */
 export declare function compareVersions(v1: string, v2: string): number;
 export declare const getResizeObserver: () => ResizeObserver;
 export declare const getIntersectionObserver: () => IntersectionObserver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.15.4",
+  "version": "2.15.6",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -50,8 +50,8 @@
     "@types/dom-mediacapture-record": "^1"
   },
   "devDependencies": {
-    "@babel/core": "7.28.0",
-    "@babel/preset-env": "7.28.0",
+    "@babel/core": "7.28.3",
+    "@babel/preset-env": "7.28.3",
     "@bufbuild/protoc-gen-es": "^1.10.0",
     "@changesets/cli": "2.29.5",
     "@livekit/changesets-changelog-github": "^0.0.4",
@@ -71,21 +71,21 @@
     "downlevel-dts": "^0.11.0",
     "eslint": "8.57.1",
     "eslint-config-airbnb-typescript": "18.0.0",
-    "eslint-config-prettier": "10.1.5",
+    "eslint-config-prettier": "10.1.8",
     "eslint-plugin-ecmascript-compat": "^3.2.1",
     "eslint-plugin-import": "2.32.0",
     "gh-pages": "6.3.0",
     "happy-dom": "^17.2.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.44.1",
+    "rollup": "4.46.2",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
-    "typedoc": "0.28.7",
+    "typedoc": "0.28.10",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
-    "vite": "7.0.0",
+    "vite": "7.1.2",
     "vitest": "^3.0.0"
   },
   "scripts": {

package/src/e2ee/E2eeManager.ts

@@ -11,7 +11,7 @@ import type RemoteTrack from '../room/track/RemoteTrack';
 import type { Track } from '../room/track/Track';
 import type { VideoCodec } from '../room/track/options';
 import { mimeTypeToVideoCodecString } from '../room/track/utils';
-import { isLocalTrack } from '../room/utils';
+import { isLocalTrack, isSafariBased, isVideoTrack } from '../room/utils';
 import type { BaseKeyProvider } from './KeyProvider';
 import { E2EE_FLAG } from './constants';
 import { type E2EEManagerCallbacks, EncryptionEvent, KeyProviderEvent } from './events';
@@ -226,6 +226,23 @@ export class E2EEManager
       this.setupE2EESender(track, sender);
     });
 
+    room.localParticipant.on(ParticipantEvent.LocalTrackPublished, (publication) => {
+      // Safari doesn't support retrieving payload information on RTCEncodedVideoFrame, so we need to update the codec manually once we have the trackInfo from the server
+      if (!isVideoTrack(publication.track) || !isSafariBased()) {
+        return;
+      }
+      const msg: UpdateCodecMessage = {
+        kind: 'updateCodec',
+        data: {
+          trackId: publication.track!.mediaStreamID,
+          codec: mimeTypeToVideoCodecString(publication.trackInfo!.codecs[0].mimeType),
+          participantIdentity: this.room!.localParticipant.identity,
+        },
+      };
+
+      this.worker.postMessage(msg);
+    });
+
     keyProvider
       .on(KeyProviderEvent.SetKey, (keyInfo) => this.postKey(keyInfo))
       .on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) =>

package/src/e2ee/worker/FrameCryptor.ts

@@ -10,7 +10,8 @@ import { type CryptorCallbacks, CryptorEvent } from '../events';
 import type { DecodeRatchetOptions, KeyProviderOptions, KeySet, RatchetResult } from '../types';
 import { deriveKeys, isVideoFrame, needsRbspUnescaping, parseRbsp, writeRbsp } from '../utils';
 import type { ParticipantKeyHandler } from './ParticipantKeyHandler';
-import { SifGuard } from './SifGuard';
+import { processNALUsForEncryption } from './naluUtils';
+import { identifySifPayload } from './sifPayload';
 
 export const encryptionEnabledMap: Map<string, boolean> = new Map();
 
@@ -65,8 +66,6 @@ export class FrameCryptor extends BaseFrameCryptor {
    */
   private sifTrailer: Uint8Array;
 
-  private sifGuard: SifGuard;
-
   private detectedCodec?: VideoCodec;
 
   private isTransformActive: boolean = false;
@@ -84,7 +83,6 @@ export class FrameCryptor extends BaseFrameCryptor {
     this.rtpMap = new Map();
     this.keyProviderOptions = opts.keyProviderOptions;
     this.sifTrailer = opts.sifTrailer ?? Uint8Array.from([]);
-    this.sifGuard = new SifGuard();
   }
 
   private get logContext() {
@@ -116,7 +114,6 @@ export class FrameCryptor extends BaseFrameCryptor {
     }
     this.participantIdentity = id;
     this.keys = keys;
-    this.sifGuard.reset();
   }
 
   unsetParticipant() {
@@ -304,7 +301,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         newDataWithoutHeader.set(new Uint8Array(iv), cipherText.byteLength); // append IV.
         newDataWithoutHeader.set(frameTrailer, cipherText.byteLength + iv.byteLength); // append frame trailer.
 
-        if (frameInfo.isH264) {
+        if (frameInfo.requiresNALUProcessing) {
           newDataWithoutHeader = writeRbsp(newDataWithoutHeader);
         }
 
@@ -347,27 +344,21 @@ export class FrameCryptor extends BaseFrameCryptor {
       // skip for decryption for empty dtx frames
       encodedFrame.data.byteLength === 0
     ) {
-      workerLogger.debug('skipping empty frame', this.logContext);
-      this.sifGuard.recordUserFrame();
       return controller.enqueue(encodedFrame);
     }
 
     if (isFrameServerInjected(encodedFrame.data, this.sifTrailer)) {
-      workerLogger.debug('enqueue SIF', this.logContext);
-      this.sifGuard.recordSif();
-
-      if (this.sifGuard.isSifAllowed()) {
-        encodedFrame.data = encodedFrame.data.slice(
-          0,
-          encodedFrame.data.byteLength - this.sifTrailer.byteLength,
-        );
+      encodedFrame.data = encodedFrame.data.slice(
+        0,
+        encodedFrame.data.byteLength - this.sifTrailer.byteLength,
+      );
+      if (await identifySifPayload(encodedFrame.data)) {
+        workerLogger.debug('enqueue SIF', this.logContext);
         return controller.enqueue(encodedFrame);
       } else {
-        workerLogger.warn('SIF limit reached, dropping frame');
+        workerLogger.warn('Unexpected SIF frame payload, dropping frame', this.logContext);
         return;
       }
-    } else {
-      this.sifGuard.recordUserFrame();
     }
     const data = new Uint8Array(encodedFrame.data);
     const keyIndex = data[encodedFrame.data.byteLength - 1];
@@ -441,7 +432,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         frameHeader.length,
         encodedFrame.data.byteLength - frameHeader.length,
       );
-      if (frameInfo.isH264 && needsRbspUnescaping(encryptedData)) {
+      if (frameInfo.requiresNALUProcessing && needsRbspUnescaping(encryptedData)) {
         encryptedData = parseRbsp(encryptedData);
         const newUint8 = new Uint8Array(frameHeader.byteLength + encryptedData.byteLength);
         newUint8.set(frameHeader);
@@ -584,66 +575,58 @@ export class FrameCryptor extends BaseFrameCryptor {
 
   private getUnencryptedBytes(frame: RTCEncodedVideoFrame | RTCEncodedAudioFrame): {
     unencryptedBytes: number;
-    isH264: boolean;
+    requiresNALUProcessing: boolean;
   } {
-    var frameInfo = { unencryptedBytes: 0, isH264: false };
-    if (isVideoFrame(frame)) {
-      let detectedCodec = this.getVideoCodec(frame) ?? this.videoCodec;
-      if (detectedCodec !== this.detectedCodec) {
-        workerLogger.debug('detected different codec', {
-          detectedCodec,
-          oldCodec: this.detectedCodec,
-          ...this.logContext,
-        });
-        this.detectedCodec = detectedCodec;
-      }
-
-      if (detectedCodec === 'av1') {
-        throw new Error(`${detectedCodec} is not yet supported for end to end encryption`);
-      }
+    // Handle audio frames
+    if (!isVideoFrame(frame)) {
+      return { unencryptedBytes: UNENCRYPTED_BYTES.audio, requiresNALUProcessing: false };
+    }
 
-      if (detectedCodec === 'vp8') {
-        frameInfo.unencryptedBytes = UNENCRYPTED_BYTES[frame.type];
-      } else if (detectedCodec === 'vp9') {
-        frameInfo.unencryptedBytes = 0;
-        return frameInfo;
-      }
+    // Detect and track codec changes
+    const detectedCodec = this.getVideoCodec(frame) ?? this.videoCodec;
+    if (detectedCodec !== this.detectedCodec) {
+      workerLogger.debug('detected different codec', {
+        detectedCodec,
+        oldCodec: this.detectedCodec,
+        ...this.logContext,
+      });
+      this.detectedCodec = detectedCodec;
+    }
 
-      const data = new Uint8Array(frame.data);
-      try {
-        const naluIndices = findNALUIndices(data);
+    // Check for unsupported codecs
+    if (detectedCodec === 'av1') {
+      throw new Error(`${detectedCodec} is not yet supported for end to end encryption`);
+    }
 
-        // if the detected codec is undefined we test whether it _looks_ like a h264 frame as a best guess
-        frameInfo.isH264 =
-          detectedCodec === 'h264' ||
-          naluIndices.some((naluIndex) =>
-            [NALUType.SLICE_IDR, NALUType.SLICE_NON_IDR].includes(parseNALUType(data[naluIndex])),
-          );
+    // Handle VP8/VP9 codecs (no NALU processing needed)
+    if (detectedCodec === 'vp8') {
+      return { unencryptedBytes: UNENCRYPTED_BYTES[frame.type], requiresNALUProcessing: false };
+    }
+    if (detectedCodec === 'vp9') {
+      return { unencryptedBytes: 0, requiresNALUProcessing: false };
+    }
 
-        if (frameInfo.isH264) {
-          for (const index of naluIndices) {
-            let type = parseNALUType(data[index]);
-            switch (type) {
-              case NALUType.SLICE_IDR:
-              case NALUType.SLICE_NON_IDR:
-                frameInfo.unencryptedBytes = index + 2;
-                return frameInfo;
-              default:
-                break;
-            }
-          }
-          throw new TypeError('Could not find NALU');
-        }
-      } catch (e) {
-        // no op, we just continue and fallback to vp8
+    // Try NALU processing for H.264/H.265 codecs
+    try {
+      const knownCodec =
+        detectedCodec === 'h264' || detectedCodec === 'h265' ? detectedCodec : undefined;
+      const naluResult = processNALUsForEncryption(new Uint8Array(frame.data), knownCodec);
+
+      if (naluResult.requiresNALUProcessing) {
+        return {
+          unencryptedBytes: naluResult.unencryptedBytes,
+          requiresNALUProcessing: true,
+        };
       }
-
-      frameInfo.unencryptedBytes = UNENCRYPTED_BYTES[frame.type];
-      return frameInfo;
-    } else {
-      frameInfo.unencryptedBytes = UNENCRYPTED_BYTES.audio;
-      return frameInfo;
+    } catch (e) {
+      workerLogger.debug('NALU processing failed, falling back to VP8 handling', {
+        error: e,
+        ...this.logContext,
+      });
     }
+
+    // Fallback to VP8 handling
+    return { unencryptedBytes: UNENCRYPTED_BYTES[frame.type], requiresNALUProcessing: false };
   }
 
   /**
@@ -659,90 +642,6 @@ export class FrameCryptor extends BaseFrameCryptor {
   }
 }
 
-/**
- * Slice the NALUs present in the supplied buffer, assuming it is already byte-aligned
- * code adapted from https://github.com/medooze/h264-frame-parser/blob/main/lib/NalUnits.ts to return indices only
- */
-export function findNALUIndices(stream: Uint8Array): number[] {
-  const result: number[] = [];
-  let start = 0,
-    pos = 0,
-    searchLength = stream.length - 2;
-  while (pos < searchLength) {
-    // skip until end of current NALU
-    while (
-      pos < searchLength &&
-      !(stream[pos] === 0 && stream[pos + 1] === 0 && stream[pos + 2] === 1)
-    )
-      pos++;
-    if (pos >= searchLength) pos = stream.length;
-    // remove trailing zeros from current NALU
-    let end = pos;
-    while (end > start && stream[end - 1] === 0) end--;
-    // save current NALU
-    if (start === 0) {
-      if (end !== start) throw TypeError('byte stream contains leading data');
-    } else {
-      result.push(start);
-    }
-    // begin new NALU
-    start = pos = pos + 3;
-  }
-  return result;
-}
-
-export function parseNALUType(startByte: number): NALUType {
-  return startByte & kNaluTypeMask;
-}
-
-const kNaluTypeMask = 0x1f;
-
-export enum NALUType {
-  /** Coded slice of a non-IDR picture */
-  SLICE_NON_IDR = 1,
-  /** Coded slice data partition A */
-  SLICE_PARTITION_A = 2,
-  /** Coded slice data partition B */
-  SLICE_PARTITION_B = 3,
-  /** Coded slice data partition C */
-  SLICE_PARTITION_C = 4,
-  /** Coded slice of an IDR picture */
-  SLICE_IDR = 5,
-  /** Supplemental enhancement information */
-  SEI = 6,
-  /** Sequence parameter set */
-  SPS = 7,
-  /** Picture parameter set */
-  PPS = 8,
-  /** Access unit delimiter */
-  AUD = 9,
-  /** End of sequence */
-  END_SEQ = 10,
-  /** End of stream */
-  END_STREAM = 11,
-  /** Filler data */
-  FILLER_DATA = 12,
-  /** Sequence parameter set extension */
-  SPS_EXT = 13,
-  /** Prefix NAL unit */
-  PREFIX_NALU = 14,
-  /** Subset sequence parameter set */
-  SUBSET_SPS = 15,
-  /** Depth parameter set */
-  DPS = 16,
-
-  // 17, 18 reserved
-
-  /** Coded slice of an auxiliary coded picture without partitioning */
-  SLICE_AUX = 19,
-  /** Coded slice extension */
-  SLICE_EXT = 20,
-  /** Coded slice extension for a depth view component or a 3D-AVC texture view component */
-  SLICE_LAYER_EXT = 21,
-
-  // 22, 23 reserved
-}
-
 /**
  * we use a magic frame trailer to detect whether a frame is injected
  * by the livekit server and thus to be treated as unencrypted

package/src/e2ee/worker/e2ee.worker.ts

@@ -98,6 +98,11 @@ onmessage = (ev) => {
         break;
       case 'updateCodec':
         getTrackCryptor(data.participantIdentity, data.trackId).setVideoCodec(data.codec);
+        workerLogger.info('updated codec', {
+          participantIdentity: data.participantIdentity,
+          trackId: data.trackId,
+          codec: data.codec,
+        });
         break;
       case 'setRTPMap':
         // this is only used for the local participant
@@ -151,7 +156,7 @@ function getTrackCryptor(participantIdentity: string, trackId: string) {
   }
   let cryptor = cryptors[0];
   if (!cryptor) {
-    workerLogger.info('creating new cryptor for', { participantIdentity });
+    workerLogger.info('creating new cryptor for', { participantIdentity, trackId });
     if (!keyProviderOptions) {
       throw Error('Missing keyProvider options');
     }