livekit-client 2.8.1 → 2.9.1

package/src/room/participant/LocalParticipant.ts

@@ -4,6 +4,12 @@ import {
   Codec,
   DataPacket,
   DataPacket_Kind,
+  DataStream_ByteHeader,
+  DataStream_Chunk,
+  DataStream_Header,
+  DataStream_OperationType,
+  DataStream_TextHeader,
+  DataStream_Trailer,
   Encryption_Type,
   ParticipantInfo,
   ParticipantPermission,
@@ -23,6 +29,7 @@ import {
 import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
+import { TextStreamWriter } from '../StreamWriter';
 import { defaultVideoCodec } from '../defaults';
 import {
   DeviceUnsupportedError,
@@ -61,15 +68,27 @@ import {
   mimeTypeToVideoCodecString,
   screenCaptureToDisplayMediaStreamOptions,
 } from '../track/utils';
-import type { ChatMessage, DataPublishOptions } from '../types';
+import {
+  type ChatMessage,
+  type DataPublishOptions,
+  type SendTextOptions,
+  type StreamTextOptions,
+  type TextStreamInfo,
+} from '../types';
 import {
   Future,
   compareVersions,
+  isAudioTrack,
   isE2EESimulcastSupported,
   isFireFox,
+  isLocalAudioTrack,
+  isLocalTrack,
+  isLocalVideoTrack,
   isSVCCodec,
   isSafari17,
+  isVideoTrack,
   isWeb,
+  numberToBigInt,
   sleep,
   supportsAV1,
   supportsVP9,
@@ -84,6 +103,8 @@ import {
   mediaTrackToLocalTrack,
 } from './publishUtils';
 
+const STREAM_CHUNK_SIZE = 15_000;
+
 export default class LocalParticipant extends Participant {
   audioTrackPublications: Map<string, LocalTrackPublication>;
 
@@ -119,6 +140,8 @@ export default class LocalParticipant extends Participant {
 
   private reconnectFuture?: Future<void>;
 
+  private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>;
+
   private pendingSignalRequests: Map<
     number,
     {
@@ -130,8 +153,6 @@ export default class LocalParticipant extends Participant {
 
   private enabledPublishVideoCodecs: Codec[] = [];
 
-  private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>> = new Map();
-
   private pendingAcks = new Map<string, { resolve: () => void; participantIdentity: string }>();
 
   private pendingResponses = new Map<
@@ -143,7 +164,13 @@ export default class LocalParticipant extends Participant {
   >();
 
   /** @internal */
-  constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions) {
+  constructor(
+    sid: string,
+    identity: string,
+    engine: RTCEngine,
+    options: InternalRoomOptions,
+    roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>,
+  ) {
     super(sid, identity, undefined, undefined, undefined, {
       loggerName: options.loggerName,
       loggerContextCb: () => this.engine.logContext,
@@ -160,6 +187,7 @@ export default class LocalParticipant extends Participant {
       ['audiooutput', 'default'],
     ]);
     this.pendingSignalRequests = new Map();
+    this.rpcHandlers = roomRpcHandlers;
   }
 
   get lastCameraError(): Error | undefined {
@@ -251,17 +279,6 @@ export default class LocalParticipant extends Participant {
 
   private handleDataPacket = (packet: DataPacket) => {
     switch (packet.value.case) {
-      case 'rpcRequest':
-        let rpcRequest = packet.value.value as RpcRequest;
-        this.handleIncomingRpcRequest(
-          packet.participantIdentity,
-          rpcRequest.id,
-          rpcRequest.method,
-          rpcRequest.payload,
-          rpcRequest.responseTimeoutMs,
-          rpcRequest.version,
-        );
-        break;
       case 'rpcResponse':
         let rpcResponse = packet.value.value as RpcResponse;
         let payload: string | null = null;
@@ -497,6 +514,7 @@ export default class LocalParticipant extends Participant {
           if (e instanceof Error) {
             this.emit(ParticipantEvent.MediaDevicesError, e);
           }
+          this.pendingPublishing.delete(source);
           throw e;
         }
         try {
@@ -640,9 +658,9 @@ export default class LocalParticipant extends Participant {
           track.setAudioContext(this.audioContext);
         }
         track.mediaStream = stream;
-        if (track instanceof LocalAudioTrack && audioProcessor) {
+        if (isAudioTrack(track) && audioProcessor) {
           await track.setProcessor(audioProcessor);
-        } else if (track instanceof LocalVideoTrack && videoProcessor) {
+        } else if (isVideoTrack(track) && videoProcessor) {
           await track.setProcessor(videoProcessor);
         }
         return track;
@@ -717,7 +735,7 @@ export default class LocalParticipant extends Participant {
     options?: TrackPublishOptions,
     isRepublish = false,
   ): Promise<LocalTrackPublication> {
-    if (track instanceof LocalAudioTrack) {
+    if (isLocalAudioTrack(track)) {
       track.setAudioContext(this.audioContext);
     }
 
@@ -725,7 +743,7 @@ export default class LocalParticipant extends Participant {
     if (this.republishPromise && !isRepublish) {
       await this.republishPromise;
     }
-    if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
+    if (isLocalTrack(track) && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
     }
     let defaultConstraints: MediaTrackConstraints | undefined;
@@ -857,7 +875,7 @@ export default class LocalParticipant extends Participant {
 
   private async publish(track: LocalTrack, opts: TrackPublishOptions, isStereo: boolean) {
     const existingTrackOfSource = Array.from(this.trackPublications.values()).find(
-      (publishedTrack) => track instanceof LocalTrack && publishedTrack.source === track.source,
+      (publishedTrack) => isLocalTrack(track) && publishedTrack.source === track.source,
     );
     if (existingTrackOfSource && track.source !== Track.Source.Unknown) {
       this.log.info(`publishing a second track with the same source: ${track.source}`, {
@@ -865,7 +883,7 @@ export default class LocalParticipant extends Participant {
         ...getLogContextFromTrack(track),
       });
     }
-    if (opts.stopMicTrackOnMute && track instanceof LocalAudioTrack) {
+    if (opts.stopMicTrackOnMute && isAudioTrack(track)) {
       track.stopOnMute = true;
     }
 
@@ -919,6 +937,7 @@ export default class LocalParticipant extends Participant {
       stereo: isStereo,
       disableRed: this.isE2EEEnabled || !(opts.red ?? true),
       stream: opts?.stream,
+      backupCodecPolicy: opts?.backupCodecPolicy,
     });
 
     // compute encodings and layers for video
@@ -950,7 +969,7 @@ export default class LocalParticipant extends Participant {
       req.width = dims.width;
       req.height = dims.height;
       // for svc codecs, disable simulcast and use vp8 for backup codec
-      if (track instanceof LocalVideoTrack) {
+      if (isLocalVideoTrack(track)) {
         if (isSVCCodec(videoCodec)) {
           if (track.source === Track.Source.ScreenShare) {
             // vp9 svc with screenshare cannot encode multiple spatial layers
@@ -1036,7 +1055,7 @@ export default class LocalParticipant extends Participant {
 
       track.sender = await this.engine.createSender(track, opts, encodings);
 
-      if (track instanceof LocalVideoTrack) {
+      if (isLocalVideoTrack(track)) {
         opts.degradationPreference ??= getDefaultDegradationPreference(track);
         track.setDegradationPreference(opts.degradationPreference);
       }
@@ -1126,9 +1145,9 @@ export default class LocalParticipant extends Participant {
       trackInfo: ti,
     });
 
-    if (track instanceof LocalVideoTrack) {
+    if (isLocalVideoTrack(track)) {
       track.startMonitor(this.engine.client);
-    } else if (track instanceof LocalAudioTrack) {
+    } else if (isLocalAudioTrack(track)) {
       track.startMonitor();
     }
 
@@ -1169,7 +1188,7 @@ export default class LocalParticipant extends Participant {
       throw new TrackInvalidError('track is not published');
     }
 
-    if (!(track instanceof LocalVideoTrack)) {
+    if (!isLocalVideoTrack(track)) {
       throw new TrackInvalidError('track is not a video track');
     }
 
@@ -1236,7 +1255,7 @@ export default class LocalParticipant extends Participant {
     track: LocalTrack | MediaStreamTrack,
     stopOnUnpublish?: boolean,
   ): Promise<LocalTrackPublication | undefined> {
-    if (track instanceof LocalTrack) {
+    if (isLocalTrack(track)) {
       const publishPromise = this.pendingPublishPromises.get(track);
       if (publishPromise) {
         this.log.info('awaiting publish promise before attempting to unpublish', {
@@ -1303,7 +1322,7 @@ export default class LocalParticipant extends Participant {
         if (this.engine.removeTrack(trackSender)) {
           negotiationNeeded = true;
         }
-        if (track instanceof LocalVideoTrack) {
+        if (isLocalVideoTrack(track)) {
           for (const [, trackInfo] of track.simulcastCodecs) {
             if (trackInfo.sender) {
               if (this.engine.removeTrack(trackInfo.sender)) {
@@ -1349,9 +1368,7 @@ export default class LocalParticipant extends Participant {
     tracks: LocalTrack[] | MediaStreamTrack[],
   ): Promise<LocalTrackPublication[]> {
     const results = await Promise.all(tracks.map((track) => this.unpublishTrack(track)));
-    return results.filter(
-      (track) => track instanceof LocalTrackPublication,
-    ) as LocalTrackPublication[];
+    return results.filter((track) => !!track);
   }
 
   async republishAllTracks(options?: TrackPublishOptions, restartTracks: boolean = true) {
@@ -1379,7 +1396,7 @@ export default class LocalParticipant extends Participant {
               !track.isMuted &&
               track.source !== Track.Source.ScreenShare &&
               track.source !== Track.Source.ScreenShareAudio &&
-              (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
+              (isLocalAudioTrack(track) || isLocalVideoTrack(track)) &&
               !track.isUserProvided
             ) {
               // generally we need to restart the track before publishing, often a full reconnect
@@ -1453,11 +1470,12 @@ export default class LocalParticipant extends Participant {
     await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
   }
 
-  async sendChatMessage(text: string): Promise<ChatMessage> {
+  async sendChatMessage(text: string, options?: SendTextOptions): Promise<ChatMessage> {
     const msg = {
       id: crypto.randomUUID(),
       message: text,
       timestamp: Date.now(),
+      attachedFiles: options?.attachments,
     } as const satisfies ChatMessage;
     const packet = new DataPacket({
       value: {
@@ -1469,6 +1487,7 @@ export default class LocalParticipant extends Participant {
       },
     });
     await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+
     this.emit(ParticipantEvent.ChatMessage, msg);
     return msg;
   }
@@ -1494,6 +1513,263 @@ export default class LocalParticipant extends Participant {
     return msg;
   }
 
+  async sendText(text: string, options?: SendTextOptions): Promise<TextStreamInfo> {
+    const streamId = crypto.randomUUID();
+    const textInBytes = new TextEncoder().encode(text);
+    const totalTextLength = textInBytes.byteLength;
+
+    const fileIds = options?.attachments?.map(() => crypto.randomUUID());
+
+    const progresses = new Array<number>(fileIds ? fileIds.length + 1 : 1).fill(0);
+
+    const handleProgress = (progress: number, idx: number) => {
+      progresses[idx] = progress;
+      const totalProgress = progresses.reduce((acc, val) => acc + val, 0);
+      options?.onProgress?.(totalProgress);
+    };
+
+    const writer = await this.streamText({
+      streamId,
+      totalSize: totalTextLength,
+      destinationIdentities: options?.destinationIdentities,
+      topic: options?.topic,
+      attachedStreamIds: fileIds,
+    });
+
+    const textChunkSize = Math.floor(STREAM_CHUNK_SIZE / 4); // utf8 is at most 4 bytes long, so play it safe and take a quarter of the byte size to slice the string
+    const totalTextChunks = Math.ceil(totalTextLength / textChunkSize);
+
+    for (let i = 0; i < totalTextChunks; i++) {
+      const chunkData = text.slice(
+        i * textChunkSize,
+        Math.min((i + 1) * textChunkSize, totalTextLength),
+      );
+      await this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+      await writer.write(chunkData);
+
+      handleProgress(Math.ceil((i + 1) / totalTextChunks), 0);
+    }
+
+    await writer.close();
+
+    if (options?.attachments && fileIds) {
+      await Promise.all(
+        options.attachments.map(async (file, idx) =>
+          this._sendFile(fileIds[idx], file, {
+            topic: options.topic,
+            mimeType: file.type,
+            onProgress: (progress) => {
+              handleProgress(progress, idx + 1);
+            },
+          }),
+        ),
+      );
+    }
+    return writer.info;
+  }
+
+  /**
+   * @internal
+   * @experimental CAUTION, might get removed in a minor release
+   */
+  async streamText(options?: StreamTextOptions): Promise<TextStreamWriter> {
+    const streamId = options?.streamId ?? crypto.randomUUID();
+
+    const info: TextStreamInfo = {
+      id: streamId,
+      mimeType: 'text/plain',
+      timestamp: Date.now(),
+      topic: options?.topic ?? '',
+      size: options?.totalSize,
+    };
+    const header = new DataStream_Header({
+      streamId,
+      mimeType: info.mimeType,
+      topic: info.topic,
+      timestamp: numberToBigInt(info.timestamp),
+      totalLength: numberToBigInt(options?.totalSize),
+      contentHeader: {
+        case: 'textHeader',
+        value: new DataStream_TextHeader({
+          version: options?.version,
+          attachedStreamIds: options?.attachedStreamIds,
+          replyToStreamId: options?.replyToStreamId,
+          operationType:
+            options?.type === 'update'
+              ? DataStream_OperationType.UPDATE
+              : DataStream_OperationType.CREATE,
+        }),
+      },
+    });
+    const destinationIdentities = options?.destinationIdentities;
+    const packet = new DataPacket({
+      destinationIdentities,
+      value: {
+        case: 'streamHeader',
+        value: header,
+      },
+    });
+    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+
+    let chunkId = 0;
+    const localP = this;
+
+    const writableStream = new WritableStream<[string, number?]>({
+      // Implement the sink
+      write([textChunk]) {
+        const textInBytes = new TextEncoder().encode(textChunk);
+
+        if (textInBytes.byteLength > STREAM_CHUNK_SIZE) {
+          this.abort?.();
+          throw new Error('chunk size too large');
+        }
+
+        return new Promise(async (resolve) => {
+          await localP.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+          const chunk = new DataStream_Chunk({
+            content: textInBytes,
+            streamId,
+            chunkIndex: numberToBigInt(chunkId),
+          });
+          const chunkPacket = new DataPacket({
+            destinationIdentities,
+            value: {
+              case: 'streamChunk',
+              value: chunk,
+            },
+          });
+          await localP.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+
+          chunkId += 1;
+          resolve();
+        });
+      },
+      async close() {
+        const trailer = new DataStream_Trailer({
+          streamId,
+        });
+        const trailerPacket = new DataPacket({
+          destinationIdentities,
+          value: {
+            case: 'streamTrailer',
+            value: trailer,
+          },
+        });
+        await localP.engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+      },
+      abort(err) {
+        console.log('Sink error:', err);
+        // TODO handle aborts to signal something to receiver side
+      },
+    });
+
+    let onEngineClose = async () => {
+      await writer.close();
+    };
+
+    localP.engine.once(EngineEvent.Closing, onEngineClose);
+
+    const writer = new TextStreamWriter(writableStream, info, () =>
+      this.engine.off(EngineEvent.Closing, onEngineClose),
+    );
+
+    return writer;
+  }
+
+  async sendFile(
+    file: File,
+    options?: {
+      mimeType?: string;
+      topic?: string;
+      destinationIdentities?: Array<string>;
+      onProgress?: (progress: number) => void;
+    },
+  ): Promise<{ id: string }> {
+    const streamId = crypto.randomUUID();
+    await this._sendFile(streamId, file, options);
+    return { id: streamId };
+  }
+
+  private async _sendFile(
+    streamId: string,
+    file: File,
+    options?: {
+      mimeType?: string;
+      topic?: string;
+      encryptionType?: Encryption_Type.NONE;
+      destinationIdentities?: Array<string>;
+      onProgress?: (progress: number) => void;
+    },
+  ) {
+    const totalLength = file.size;
+    const header = new DataStream_Header({
+      totalLength: numberToBigInt(totalLength),
+      mimeType: options?.mimeType ?? file.type,
+      streamId,
+      topic: options?.topic,
+      encryptionType: options?.encryptionType,
+      timestamp: numberToBigInt(Date.now()),
+      contentHeader: {
+        case: 'byteHeader',
+        value: new DataStream_ByteHeader({
+          name: file.name,
+        }),
+      },
+    });
+
+    const destinationIdentities = options?.destinationIdentities;
+    const packet = new DataPacket({
+      destinationIdentities,
+      value: {
+        case: 'streamHeader',
+        value: header,
+      },
+    });
+
+    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    function read(b: Blob): Promise<Uint8Array> {
+      return new Promise((resolve) => {
+        const fr = new FileReader();
+        fr.onload = () => {
+          resolve(new Uint8Array(fr.result as ArrayBuffer));
+        };
+        fr.readAsArrayBuffer(b);
+      });
+    }
+    const totalChunks = Math.ceil(totalLength / STREAM_CHUNK_SIZE);
+    for (let i = 0; i < totalChunks; i++) {
+      const chunkData = await read(
+        file.slice(i * STREAM_CHUNK_SIZE, Math.min((i + 1) * STREAM_CHUNK_SIZE, totalLength)),
+      );
+      await this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
+      const chunk = new DataStream_Chunk({
+        content: chunkData,
+        streamId,
+        chunkIndex: numberToBigInt(i),
+      });
+      const chunkPacket = new DataPacket({
+        destinationIdentities,
+        value: {
+          case: 'streamChunk',
+          value: chunk,
+        },
+      });
+      await this.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
+      options?.onProgress?.((i + 1) / totalChunks);
+    }
+    const trailer = new DataStream_Trailer({
+      streamId,
+    });
+    const trailerPacket = new DataPacket({
+      destinationIdentities,
+      value: {
+        case: 'streamTrailer',
+        value: trailer,
+      },
+    });
+    await this.engine.sendDataPacket(trailerPacket, DataPacket_Kind.RELIABLE);
+  }
+
   /**
    * Initiate an RPC call to a remote participant
    * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}
@@ -1571,39 +1847,20 @@ export default class LocalParticipant extends Participant {
   }
 
   /**
-   * Establishes the participant as a receiver for calls of the specified RPC method.
-   * Will overwrite any existing callback for the same method.
-   *
-   * @param method - The name of the indicated RPC method
-   * @param handler - Will be invoked when an RPC request for this method is received
-   * @returns A promise that resolves when the method is successfully registered
-   *
-   * @example
-   * ```typescript
-   * room.localParticipant?.registerRpcMethod(
-   *   'greet',
-   *   async (data: RpcInvocationData) => {
-   *     console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
-   *     return `Hello, ${data.callerIdentity}!`;
-   *   }
-   * );
-   * ```
-   *
-   * The handler should return a Promise that resolves to a string.
-   * If unable to respond within `responseTimeout`, the request will result in an error on the caller's side.
-   *
-   * You may throw errors of type `RpcError` with a string `message` in the handler,
-   * and they will be received on the caller's side with the message intact.
-   * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+   * @deprecated use `room.registerRpcMethod` instead
    */
   registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>) {
+    if (this.rpcHandlers.has(method)) {
+      this.log.warn(
+        `you're overriding the RPC handler for method ${method}, in the future this will throw an error`,
+      );
+    }
+
     this.rpcHandlers.set(method, handler);
   }
 
   /**
-   * Unregisters a previously registered RPC method.
-   *
-   * @param method - The name of the RPC method to unregister
+   * @deprecated use `room.unregisterRpcMethod` instead
    */
   unregisterRpcMethod(method: string) {
     this.rpcHandlers.delete(method);
@@ -1661,68 +1918,6 @@ export default class LocalParticipant extends Participant {
     }
   }
 
-  private async handleIncomingRpcRequest(
-    callerIdentity: string,
-    requestId: string,
-    method: string,
-    payload: string,
-    responseTimeout: number,
-    version: number,
-  ) {
-    await this.publishRpcAck(callerIdentity, requestId);
-
-    if (version !== 1) {
-      await this.publishRpcResponse(
-        callerIdentity,
-        requestId,
-        null,
-        RpcError.builtIn('UNSUPPORTED_VERSION'),
-      );
-      return;
-    }
-
-    const handler = this.rpcHandlers.get(method);
-
-    if (!handler) {
-      await this.publishRpcResponse(
-        callerIdentity,
-        requestId,
-        null,
-        RpcError.builtIn('UNSUPPORTED_METHOD'),
-      );
-      return;
-    }
-
-    let responseError: RpcError | null = null;
-    let responsePayload: string | null = null;
-
-    try {
-      const response = await handler({
-        requestId,
-        callerIdentity,
-        payload,
-        responseTimeout,
-      });
-      if (byteLength(response) > MAX_PAYLOAD_BYTES) {
-        responseError = RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE');
-        console.warn(`RPC Response payload too large for ${method}`);
-      } else {
-        responsePayload = response;
-      }
-    } catch (error) {
-      if (error instanceof RpcError) {
-        responseError = error;
-      } else {
-        console.warn(
-          `Uncaught error returned by RPC handler for ${method}. Returning APPLICATION_ERROR instead.`,
-          error,
-        );
-        responseError = RpcError.builtIn('APPLICATION_ERROR');
-      }
-    }
-    await this.publishRpcResponse(callerIdentity, requestId, responsePayload, responseError);
-  }
-
   /** @internal */
   private async publishRpcRequest(
     destinationIdentity: string,
@@ -1749,46 +1944,6 @@ export default class LocalParticipant extends Participant {
     await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
   }
 
-  /** @internal */
-  private async publishRpcResponse(
-    destinationIdentity: string,
-    requestId: string,
-    payload: string | null,
-    error: RpcError | null,
-  ) {
-    const packet = new DataPacket({
-      destinationIdentities: [destinationIdentity],
-      kind: DataPacket_Kind.RELIABLE,
-      value: {
-        case: 'rpcResponse',
-        value: new RpcResponse({
-          requestId,
-          value: error
-            ? { case: 'error', value: error.toProto() }
-            : { case: 'payload', value: payload ?? '' },
-        }),
-      },
-    });
-
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-  }
-
-  /** @internal */
-  private async publishRpcAck(destinationIdentity: string, requestId: string) {
-    const packet = new DataPacket({
-      destinationIdentities: [destinationIdentity],
-      kind: DataPacket_Kind.RELIABLE,
-      value: {
-        case: 'rpcAck',
-        value: new RpcAck({
-          requestId,
-        }),
-      },
-    });
-
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
-  }
-
   /** @internal */
   handleParticipantDisconnected(participantIdentity: string) {
     for (const [id, { participantIdentity: pendingIdentity }] of this.pendingAcks) {
@@ -1962,7 +2117,7 @@ export default class LocalParticipant extends Participant {
       this.unpublishTrack(track);
     } else if (track.isUserProvided) {
       await track.mute();
-    } else if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+    } else if (isLocalAudioTrack(track) || isLocalVideoTrack(track)) {
       try {
         if (isWeb()) {
           try {
@@ -1997,7 +2152,7 @@ export default class LocalParticipant extends Participant {
             ...this.logContext,
             ...getLogContextFromTrack(track),
           });
-          if (track instanceof LocalAudioTrack) {
+          if (isLocalAudioTrack(track)) {
             // fall back to default device if available
             await track.restartTrack({ deviceId: 'default' });
           } else {
@@ -2026,7 +2181,7 @@ export default class LocalParticipant extends Participant {
 
       // this looks overly complicated due to this object tree
       if (track instanceof MediaStreamTrack) {
-        if (localTrack instanceof LocalAudioTrack || localTrack instanceof LocalVideoTrack) {
+        if (isLocalAudioTrack(localTrack) || isLocalVideoTrack(localTrack)) {
           if (localTrack.mediaStreamTrack === track) {
             publication = <LocalTrackPublication>pub;
           }