livekit-client 1.12.3 → 1.13.1

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

@@ -54,8 +54,8 @@ export default abstract class LocalTrack extends Track {
      * the server.
      * this API is unsupported on Safari < 12 due to a bug
      **/
-    pauseUpstream: () => Promise<void>;
-    resumeUpstream: () => Promise<void>;
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
     /**
      * Sets a processor on this track.
      * See https://github.com/livekit/track-processors-js for example usage
@@ -67,7 +67,7 @@ export default abstract class LocalTrack extends Track {
      * @returns
      */
     setProcessor(processor: TrackProcessor<typeof this.kind>, showProcessedStreamLocally?: boolean): Promise<void>;
-    getProcessor(): TrackProcessor<Track.Kind> | undefined;
+    getProcessor(): TrackProcessor<Track.Kind, import("./processor/types").ProcessorOptions<Track.Kind>> | undefined;
     /**
      * Stops the track processor
      * See https://github.com/livekit/track-processors-js for example usage

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

@@ -3,7 +3,9 @@ import { VideoLayer, VideoQuality } from '../../proto/livekit_models_pb';
 import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import type { VideoSenderStats } from '../stats';
 import LocalTrack from './LocalTrack';
+import { Track } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
+import type { TrackProcessor } from './processor/types';
 export declare class SimulcastTrackInfo {
     codec: VideoCodec;
     mediaStreamTrack: MediaStreamTrack;
@@ -28,12 +30,16 @@ export default class LocalVideoTrack extends LocalTrack {
     get isSimulcast(): boolean;
     startMonitor(signalClient: SignalClient): void;
     stop(): void;
+    pauseUpstream(): Promise<void>;
+    resumeUpstream(): Promise<void>;
     mute(): Promise<LocalVideoTrack>;
     unmute(): Promise<LocalVideoTrack>;
+    protected setTrackMuted(muted: boolean): void;
     getSenderStats(): Promise<VideoSenderStats[]>;
     setPublishingQuality(maxQuality: VideoQuality): void;
     setDeviceId(deviceId: ConstrainDOMString): Promise<boolean>;
     restartTrack(options?: VideoCaptureOptions): Promise<void>;
+    setProcessor(processor: TrackProcessor<Track.Kind>, showProcessedStreamLocally?: boolean): Promise<void>;
     addSimulcastTrack(codec: VideoCodec, encodings?: RTCRtpEncodingParameters[]): SimulcastTrackInfo;
     setSimulcastTrackSender(codec: VideoCodec, sender: RTCRtpSender): void;
     /**

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

@@ -10,9 +10,21 @@ export type ProcessorOptions<T extends Track.Kind> = {
 /**
  * @experimental
  */
-export interface TrackProcessor<T extends Track.Kind> {
+export interface AudioProcessorOptions extends ProcessorOptions<Track.Kind.Audio> {
+    audioContext: AudioContext;
+}
+/**
+ * @experimental
+ */
+export interface VideoProcessorOptions extends ProcessorOptions<Track.Kind.Video> {
+}
+/**
+ * @experimental
+ */
+export interface TrackProcessor<T extends Track.Kind, U extends ProcessorOptions<T> = ProcessorOptions<T>> {
     name: string;
-    init: (opts: ProcessorOptions<T>) => void;
+    init: (opts: U) => Promise<void>;
+    restart: (opts: U) => Promise<void>;
     destroy: () => Promise<void>;
     processedTrack?: MediaStreamTrack;
 }

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

@@ -22,5 +22,5 @@ export type LiveKitReactNativeInfo = {
     platform: 'ios' | 'android' | 'windows' | 'macos' | 'web' | 'native';
     devicePixelRatio: number;
 };
-export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect';
+export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect' | 'subscriber-bandwidth';
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.12.3",
+  "version": "1.13.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -61,10 +61,10 @@
     "webrtc-adapter": "^8.1.1"
   },
   "devDependencies": {
-    "@babel/core": "7.22.1",
-    "@babel/preset-env": "7.22.4",
+    "@babel/core": "7.22.9",
+    "@babel/preset-env": "7.22.9",
     "@bufbuild/protoc-gen-es": "^1.3.0",
-    "@changesets/cli": "2.26.1",
+    "@changesets/cli": "2.26.2",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.3",
     "@rollup/plugin-commonjs": "24.1.0",
@@ -77,27 +77,26 @@
     "@types/events": "^3.0.0",
     "@types/sdp-transform": "2.4.6",
     "@types/ua-parser-js": "0.7.36",
-    "@typescript-eslint/eslint-plugin": "5.59.8",
-    "@typescript-eslint/parser": "5.59.8",
+    "@typescript-eslint/eslint-plugin": "5.62.0",
+    "@typescript-eslint/parser": "5.62.0",
     "downlevel-dts": "^0.11.0",
-    "eslint": "8.42.0",
-    "eslint-config-airbnb-typescript": "17.0.0",
-    "eslint-config-prettier": "8.8.0",
+    "eslint": "8.46.0",
+    "eslint-config-airbnb-typescript": "17.1.0",
+    "eslint-config-prettier": "8.9.0",
     "eslint-plugin-ecmascript-compat": "^3.0.0",
-    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-import": "2.28.0",
     "gh-pages": "5.0.0",
     "jsdom": "^22.1.0",
     "prettier": "^2.8.8",
-    "rollup": "3.23.1",
+    "rollup": "3.27.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-re": "1.0.7",
-    "rollup-plugin-typescript2": "0.34.1",
+    "rollup-plugin-typescript2": "0.35.0",
     "size-limit": "^8.2.4",
-    "ts-proto": "1.148.2",
     "typedoc": "0.24.8",
     "typedoc-plugin-no-inherit": "1.4.0",
-    "typescript": "5.1.3",
-    "vite": "4.3.9",
-    "vitest": "^0.32.0"
+    "typescript": "5.1.6",
+    "vite": "4.4.7",
+    "vitest": "^0.33.0"
   }
 }

package/src/api/SignalClient.ts

@@ -43,21 +43,13 @@ import { Mutex, getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../r
 import { AsyncQueue } from '../utils/AsyncQueue';
 
 // internal options
-interface ConnectOpts {
-  autoSubscribe: boolean;
+interface ConnectOpts extends SignalOptions {
   /** internal */
   reconnect?: boolean;
-
   /** internal */
   reconnectReason?: number;
-
   /** internal */
   sid?: string;
-
-  /** @deprecated */
-  publishOnly?: string;
-
-  adaptiveStream?: boolean;
 }
 
 // public options
@@ -68,6 +60,7 @@ export interface SignalOptions {
   adaptiveStream?: boolean;
   maxRetries: number;
   e2eeEnabled: boolean;
+  websocketTimeout: number;
 }
 
 type SignalMessage = SignalRequest['message'];
@@ -224,9 +217,15 @@ export class SignalClient {
     return new Promise<JoinResponse | ReconnectResponse | void>(async (resolve, reject) => {
       const abortHandler = async () => {
         this.close();
+        clearTimeout(wsTimeout);
         reject(new ConnectionError('room connection has been cancelled (signal)'));
       };
 
+      const wsTimeout = setTimeout(() => {
+        this.close();
+        reject(new ConnectionError('room connection has timed out (signal)'));
+      }, opts.websocketTimeout);
+
       if (abortSignal?.aborted) {
         abortHandler();
       }
@@ -238,8 +237,13 @@ export class SignalClient {
       this.ws = new WebSocket(url + params);
       this.ws.binaryType = 'arraybuffer';
 
+      this.ws.onopen = () => {
+        clearTimeout(wsTimeout);
+      };
+
       this.ws.onerror = async (ev: Event) => {
         if (!this.isConnected) {
+          clearTimeout(wsTimeout);
           try {
             const resp = await fetch(`http${url.substring(2)}/validate${params}`);
             if (resp.status.toFixed(0).startsWith('4')) {

package/src/connectionHelper/checks/turn.ts

@@ -12,6 +12,7 @@ export class TURNCheck extends Checker {
       autoSubscribe: true,
       maxRetries: 0,
       e2eeEnabled: false,
+      websocketTimeout: 15_000,
     });
 
     let hasTLS = false;

package/src/connectionHelper/checks/webrtc.ts

@@ -1,3 +1,4 @@
+import log from '../../logger';
 import { RoomEvent } from '../../room/events';
 import { Checker } from './Checker';
 
@@ -14,19 +15,20 @@ export class WebRTCCheck extends Checker {
 
       const candidates: RTCIceCandidate[] = [];
       this.room.engine.client.onTrickle = (sd, target) => {
-        console.log('got candidate', sd);
         if (sd.candidate) {
           const candidate = new RTCIceCandidate(sd);
           candidates.push(candidate);
           let str = `${candidate.protocol} ${candidate.address}:${candidate.port} ${candidate.type}`;
-          if (candidate.protocol === 'tcp' && candidate.tcpType === 'passive') {
-            hasTcp = true;
-            str += ' (active)';
-          } else if (candidate.protocol === 'udp' && candidate.address) {
+          if (candidate.address) {
             if (isIPPrivate(candidate.address)) {
               str += ' (private)';
             } else {
-              hasIpv4Udp = true;
+              if (candidate.protocol === 'tcp' && candidate.tcpType === 'passive') {
+                hasTcp = true;
+                str += ' (passive)';
+              } else if (candidate.protocol === 'udp') {
+                hasIpv4Udp = true;
+              }
             }
           }
           this.appendMessage(str);
@@ -48,7 +50,7 @@ export class WebRTCCheck extends Checker {
     });
     try {
       await this.connect();
-      console.log('now the room is connected');
+      log.info('now the room is connected');
     } catch (err) {
       this.appendWarning('ports need to be open on firewall in order to connect.');
       throw err;

package/src/connectionHelper/checks/websocket.ts

@@ -17,6 +17,7 @@ export class WebSocketCheck extends Checker {
       autoSubscribe: true,
       maxRetries: 0,
       e2eeEnabled: false,
+      websocketTimeout: 15_000,
     });
     this.appendMessage(`Connected to server, version ${joinRes.serverVersion}.`);
     if (joinRes.serverInfo?.edition === ServerInfo_Edition.Cloud && joinRes.serverInfo?.region) {

package/src/e2ee/E2eeManager.ts

@@ -13,8 +13,8 @@ import type { Track } from '../room/track/Track';
 import type { VideoCodec } from '../room/track/options';
 import type { BaseKeyProvider } from './KeyProvider';
 import { E2EE_FLAG } from './constants';
+import { type E2EEManagerCallbacks, EncryptionEvent, KeyProviderEvent } from './events';
 import type {
-  E2EEManagerCallbacks,
   E2EEOptions,
   E2EEWorkerMessage,
   EnableMessage,
@@ -25,9 +25,9 @@ import type {
   RatchetRequestMessage,
   RemoveTransformMessage,
   SetKeyMessage,
+  SifTrailerMessage,
   UpdateCodecMessage,
 } from './types';
-import { EncryptionEvent } from './types';
 import { isE2EESupported, isScriptTransformSupported, mimeTypeToVideoCodecString } from './utils';
 
 /**
@@ -42,10 +42,6 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
 
   private keyProvider: BaseKeyProvider;
 
-  get isEnabled() {
-    return this.encryptionEnabled;
-  }
-
   constructor(options: E2EEOptions) {
     super();
     this.keyProvider = options.keyProvider;
@@ -85,17 +81,19 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
   /**
    * @internal
    */
-  async setParticipantCryptorEnabled(enabled: boolean, participantId?: string) {
-    log.info(`set e2ee to ${enabled}`);
+  setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string) {
+    log.debug(`set e2ee to ${enabled} for participant ${participantIdentity}`);
+    this.postEnable(enabled, participantIdentity);
+  }
 
-    if (this.worker) {
-      const enableMsg: EnableMessage = {
-        kind: 'enable',
-        data: { enabled, participantId },
-      };
-      this.worker.postMessage(enableMsg);
+  /**
+   * @internal
+   */
+  setSifTrailer(trailer: Uint8Array) {
+    if (!trailer || trailer.length === 0) {
+      log.warn("ignoring server sent trailer as it's empty");
     } else {
-      throw new ReferenceError('failed to enable e2ee, worker is not ready');
+      this.postSifTrailer(trailer);
     }
   }
 
@@ -103,19 +101,35 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     const { kind, data } = ev.data;
     switch (kind) {
       case 'error':
-        console.error('error in worker', { data });
-        this.emit(EncryptionEvent.Error, data.error);
+        log.error(data.error.message);
+        this.emit(EncryptionEvent.EncryptionError, data.error);
         break;
+      case 'initAck':
+        if (data.enabled) {
+          this.keyProvider.getKeys().forEach((keyInfo) => {
+            this.postKey(keyInfo);
+          });
+        }
+        break;
+
       case 'enable':
-        if (this.encryptionEnabled !== data.enabled && !data.participantId) {
+        if (
+          this.encryptionEnabled !== data.enabled &&
+          data.participantIdentity === this.room?.localParticipant.identity
+        ) {
           this.emit(
             EncryptionEvent.ParticipantEncryptionStatusChanged,
             data.enabled,
-            this.room?.localParticipant,
+            this.room!.localParticipant,
           );
           this.encryptionEnabled = data.enabled;
-        } else if (data.participantId) {
-          const participant = this.room?.getParticipantByIdentity(data.participantId);
+        } else if (data.participantIdentity) {
+          const participant = this.room?.getParticipantByIdentity(data.participantIdentity);
+          if (!participant) {
+            throw TypeError(
+              `couldn't set encryption status, participant not found${data.participantIdentity}`,
+            );
+          }
           this.emit(EncryptionEvent.ParticipantEncryptionStatusChanged, data.enabled, participant);
         }
         if (this.encryptionEnabled) {
@@ -125,7 +139,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
         }
         break;
       case 'ratchetKey':
-        this.keyProvider.emit('keyRatcheted', data.material, data.keyIndex);
+        this.keyProvider.emit(KeyProviderEvent.KeyRatcheted, data.material, data.keyIndex);
         break;
       default:
         break;
@@ -134,7 +148,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
 
   private onWorkerError = (ev: ErrorEvent) => {
     log.error('e2ee worker encountered an error:', { error: ev.error });
-    this.emit(EncryptionEvent.Error, ev.error);
+    this.emit(EncryptionEvent.EncryptionError, ev.error);
   };
 
   public setupEngine(engine: RTCEngine) {
@@ -150,69 +164,78 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
         participant.identity,
       ),
     );
-    room.on(RoomEvent.ConnectionStateChanged, (state) => {
-      if (state === ConnectionState.Connected) {
-        room.participants.forEach((participant) => {
-          participant.tracks.forEach((pub) => {
-            this.setParticipantCryptorEnabled(
-              pub.trackInfo!.encryption !== Encryption_Type.NONE,
-              participant.identity,
-            );
+    room
+      .on(RoomEvent.ConnectionStateChanged, (state) => {
+        if (state === ConnectionState.Connected) {
+          room.participants.forEach((participant) => {
+            participant.tracks.forEach((pub) => {
+              this.setParticipantCryptorEnabled(
+                pub.trackInfo!.encryption !== Encryption_Type.NONE,
+                participant.identity,
+              );
+            });
           });
+        }
+      })
+      .on(RoomEvent.TrackUnsubscribed, (track, _, participant) => {
+        const msg: RemoveTransformMessage = {
+          kind: 'removeTransform',
+          data: {
+            participantIdentity: participant.identity,
+            trackId: track.mediaStreamID,
+          },
+        };
+        this.worker?.postMessage(msg);
+      })
+      .on(RoomEvent.TrackSubscribed, (track, pub, participant) => {
+        this.setupE2EEReceiver(track, participant.identity, pub.trackInfo);
+      })
+      .on(RoomEvent.SignalConnected, () => {
+        if (!this.room) {
+          throw new TypeError(`expected room to be present on signal connect`);
+        }
+        this.setParticipantCryptorEnabled(
+          this.room.localParticipant.isE2EEEnabled,
+          this.room.localParticipant.identity,
+        );
+        keyProvider.getKeys().forEach((keyInfo) => {
+          this.postKey(keyInfo);
         });
-      }
-    });
-
-    room.on(RoomEvent.TrackUnsubscribed, (track, _, participant) => {
-      const msg: RemoveTransformMessage = {
-        kind: 'removeTransform',
-        data: {
-          participantId: participant.identity,
-          trackId: track.mediaStreamID,
-        },
-      };
-      this.worker?.postMessage(msg);
-    });
-    room.on(RoomEvent.TrackSubscribed, (track, pub, participant) => {
-      this.setupE2EEReceiver(track, participant.identity, pub.trackInfo);
-    });
+      });
     room.localParticipant.on(ParticipantEvent.LocalTrackPublished, async (publication) => {
-      this.setupE2EESender(
-        publication.track!,
-        publication.track!.sender!,
-        room.localParticipant.identity,
-      );
+      this.setupE2EESender(publication.track!, publication.track!.sender!);
     });
 
     keyProvider
-      .on('setKey', (keyInfo) => this.postKey(keyInfo))
-      .on('ratchetRequest', (participantId, keyIndex) =>
+      .on(KeyProviderEvent.SetKey, (keyInfo) => this.postKey(keyInfo))
+      .on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) =>
         this.postRatchetRequest(participantId, keyIndex),
       );
   }
 
-  private postRatchetRequest(participantId?: string, keyIndex?: number) {
+  private postRatchetRequest(participantIdentity?: string, keyIndex?: number) {
     if (!this.worker) {
       throw Error('could not ratchet key, worker is missing');
     }
     const msg: RatchetRequestMessage = {
       kind: 'ratchetRequest',
       data: {
-        participantId,
+        participantIdentity: participantIdentity,
         keyIndex,
       },
     };
     this.worker.postMessage(msg);
   }
 
-  private postKey({ key, participantId, keyIndex }: KeyInfo) {
+  private postKey({ key, participantIdentity, keyIndex }: KeyInfo) {
     if (!this.worker) {
       throw Error('could not set key, worker is missing');
     }
     const msg: SetKeyMessage = {
       kind: 'setKey',
       data: {
-        participantId,
+        participantIdentity: participantIdentity,
+        isPublisher: participantIdentity === this.room?.localParticipant.identity,
         key,
         keyIndex,
       },
@@ -220,14 +243,46 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     this.worker.postMessage(msg);
   }
 
+  private postEnable(enabled: boolean, participantIdentity: string) {
+    if (this.worker) {
+      const enableMsg: EnableMessage = {
+        kind: 'enable',
+        data: {
+          enabled,
+          participantIdentity,
+        },
+      };
+      this.worker.postMessage(enableMsg);
+    } else {
+      throw new ReferenceError('failed to enable e2ee, worker is not ready');
+    }
+  }
+
   private postRTPMap(map: Map<number, VideoCodec>) {
     if (!this.worker) {
-      throw Error('could not post rtp map, worker is missing');
+      throw TypeError('could not post rtp map, worker is missing');
+    }
+    if (!this.room?.localParticipant.identity) {
+      throw TypeError('could not post rtp map, local participant identity is missing');
     }
     const msg: RTPVideoMapMessage = {
       kind: 'setRTPMap',
       data: {
         map,
+        participantIdentity: this.room.localParticipant.identity,
+      },
+    };
+    this.worker.postMessage(msg);
+  }
+
+  private postSifTrailer(trailer: Uint8Array) {
+    if (!this.worker) {
+      throw Error('could not post SIF trailer, worker is missing');
+    }
+    const msg: SifTrailerMessage = {
+      kind: 'setSifTrailer',
+      data: {
+        trailer,
       },
     };
     this.worker.postMessage(msg);
@@ -248,12 +303,12 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     );
   }
 
-  private setupE2EESender(track: Track, sender: RTCRtpSender, localId: string) {
+  private setupE2EESender(track: Track, sender: RTCRtpSender) {
     if (!(track instanceof LocalTrack) || !sender) {
       if (!sender) log.warn('early return because sender is not ready');
       return;
     }
-    this.handleSender(sender, track.mediaStreamID, localId, undefined);
+    this.handleSender(sender, track.mediaStreamID, undefined);
   }
 
   /**
@@ -264,7 +319,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
   private async handleReceiver(
     receiver: RTCRtpReceiver,
     trackId: string,
-    participantId: string,
+    participantIdentity: string,
     codec?: VideoCodec,
   ) {
     if (!this.worker) {
@@ -274,7 +329,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
     if (isScriptTransformSupported()) {
       const options = {
         kind: 'decode',
-        participantId,
+        participantIdentity,
         trackId,
         codec,
       };
@@ -288,7 +343,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
           data: {
             trackId,
             codec,
-            participantId,
+            participantIdentity: participantIdentity,
           },
         };
         this.worker.postMessage(msg);
@@ -316,7 +371,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
           writableStream: writable,
           trackId: trackId,
           codec,
-          participantId,
+          participantIdentity: participantIdentity,
         },
       };
       this.worker.postMessage(msg, [readable, writable]);
@@ -331,29 +386,27 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
    * a frame encoder.
    *
    */
-  private handleSender(
-    sender: RTCRtpSender,
-    trackId: string,
-    participantId: string,
-    codec?: VideoCodec,
-  ) {
+  private handleSender(sender: RTCRtpSender, trackId: string, codec?: VideoCodec) {
     if (E2EE_FLAG in sender || !this.worker) {
       return;
     }
 
-    if (isScriptTransformSupported()) {
-      log.warn('initialize script transform');
+    if (!this.room?.localParticipant.identity || this.room.localParticipant.identity === '') {
+      throw TypeError('local identity needs to be known in order to set up encrypted sender');
+    }
 
+    if (isScriptTransformSupported()) {
+      log.info('initialize script transform');
       const options = {
         kind: 'encode',
-        participantId,
+        participantIdentity: this.room.localParticipant.identity,
         trackId,
         codec,
       };
       // @ts-ignore
       sender.transform = new RTCRtpScriptTransform(this.worker, options);
     } else {
-      log.warn('initialize encoded streams');
+      log.info('initialize encoded streams');
       // @ts-ignore
       const senderStreams = sender.createEncodedStreams();
       const msg: EncodeMessage = {
@@ -363,7 +416,7 @@ export class E2EEManager extends (EventEmitter as new () => TypedEventEmitter<E2
           writableStream: senderStreams.writable,
           codec,
           trackId,
-          participantId,
+          participantIdentity: this.room.localParticipant.identity,
         },
       };
       this.worker.postMessage(msg, [senderStreams.readable, senderStreams.writable]);