livekit-client 2.8.1 → 2.9.0

package/src/room/participant/Participant.ts

@@ -11,15 +11,14 @@ import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
 import log, { LoggerNames, type StructuredLogger, getLogger } from '../../logger';
 import { ParticipantEvent, TrackEvent } from '../events';
-import LocalAudioTrack from '../track/LocalAudioTrack';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
-import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
 import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
 import { diffAttributes } from '../track/utils';
 import type { ChatMessage, LoggerOptions, TranscriptionSegment } from '../types';
+import { isAudioTrack } from '../utils';
 
 export enum ConnectionQuality {
   Excellent = 'excellent',
@@ -317,9 +316,7 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   setAudioContext(ctx: AudioContext | undefined) {
     this.audioContext = ctx;
     this.audioTrackPublications.forEach(
-      (track) =>
-        (track.track instanceof RemoteAudioTrack || track.track instanceof LocalAudioTrack) &&
-        track.track.setAudioContext(ctx),
+      (track) => isAudioTrack(track.track) && track.track.setAudioContext(ctx),
     );
   }
 

package/src/room/participant/RemoteParticipant.ts

@@ -16,6 +16,7 @@ import type { AudioOutputOptions } from '../track/options';
 import type { AdaptiveStreamSettings } from '../track/types';
 import { getLogContextFromTrack } from '../track/utils';
 import type { LoggerOptions } from '../types';
+import { isAudioTrack, isRemoteTrack } from '../utils';
 import Participant, { ParticipantKind } from './Participant';
 import type { ParticipantEventCallbacks } from './Participant';
 
@@ -239,7 +240,7 @@ export default class RemoteParticipant extends Participant {
 
     publication.setTrack(track);
     // set participant volumes on new audio tracks
-    if (this.volumeMap.has(publication.source) && track instanceof RemoteAudioTrack) {
+    if (this.volumeMap.has(publication.source) && isRemoteTrack(track) && isAudioTrack(track)) {
       track.setVolume(this.volumeMap.get(publication.source)!);
     }
 
@@ -367,7 +368,7 @@ export default class RemoteParticipant extends Participant {
     this.audioOutput = output;
     const promises: Promise<void>[] = [];
     this.audioTrackPublications.forEach((pub) => {
-      if (pub.track instanceof RemoteAudioTrack) {
+      if (isAudioTrack(pub.track) && isRemoteTrack(pub.track)) {
         promises.push(pub.track.setSinkId(output.deviceId ?? 'default'));
       }
     });

package/src/room/{participant/LocalParticipant.test.ts → rpc.test.ts}

@@ -1,44 +1,37 @@
 import { DataPacket, DataPacket_Kind } from '@livekit/protocol';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { InternalRoomOptions } from '../../options';
-import type RTCEngine from '../RTCEngine';
-import { RpcError } from '../rpc';
-import LocalParticipant from './LocalParticipant';
-import { ParticipantKind } from './Participant';
-import RemoteParticipant from './RemoteParticipant';
+import type { InternalRoomOptions } from '../options';
+import type RTCEngine from './RTCEngine';
+import Room from './Room';
+import LocalParticipant from './participant/LocalParticipant';
+import { ParticipantKind } from './participant/Participant';
+import RemoteParticipant from './participant/RemoteParticipant';
+import { RpcError } from './rpc';
 
 describe('LocalParticipant', () => {
   describe('registerRpcMethod', () => {
-    let localParticipant: LocalParticipant;
-    let mockEngine: RTCEngine;
-    let mockRoomOptions: InternalRoomOptions;
+    let room: Room;
     let mockSendDataPacket: ReturnType<typeof vi.fn>;
 
     beforeEach(() => {
       mockSendDataPacket = vi.fn();
-      mockEngine = {
-        client: {
-          sendUpdateLocalMetadata: vi.fn(),
-        },
-        on: vi.fn().mockReturnThis(),
-        sendDataPacket: mockSendDataPacket,
-      } as unknown as RTCEngine;
 
-      mockRoomOptions = {} as InternalRoomOptions;
+      room = new Room();
+      room.engine.client = {
+        sendUpdateLocalMetadata: vi.fn(),
+      };
+      room.engine.on = vi.fn().mockReturnThis();
+      room.engine.sendDataPacket = mockSendDataPacket;
 
-      localParticipant = new LocalParticipant(
-        'test-sid',
-        'test-identity',
-        mockEngine,
-        mockRoomOptions,
-      );
+      room.localParticipant.sid = 'test-sid';
+      room.localParticipant.identity = 'test-identity';
     });
 
     it('should register an RPC method handler', async () => {
       const methodName = 'testMethod';
       const handler = vi.fn().mockResolvedValue('test response');
 
-      localParticipant.registerRpcMethod(methodName, handler);
+      room.registerRpcMethod(methodName, handler);
 
       const mockCaller = new RemoteParticipant(
         {} as any,
@@ -51,7 +44,7 @@ describe('LocalParticipant', () => {
         ParticipantKind.STANDARD,
       );
 
-      await localParticipant.handleIncomingRpcRequest(
+      await room.handleIncomingRpcRequest(
         mockCaller.identity,
         'test-request-id',
         methodName,
@@ -84,7 +77,7 @@ describe('LocalParticipant', () => {
       const errorMessage = 'Test error';
       const handler = vi.fn().mockRejectedValue(new Error(errorMessage));
 
-      localParticipant.registerRpcMethod(methodName, handler);
+      room.registerRpcMethod(methodName, handler);
 
       const mockCaller = new RemoteParticipant(
         {} as any,
@@ -97,7 +90,7 @@ describe('LocalParticipant', () => {
         ParticipantKind.STANDARD,
       );
 
-      await localParticipant.handleIncomingRpcRequest(
+      await room.handleIncomingRpcRequest(
         mockCaller.identity,
         'test-error-request-id',
         methodName,
@@ -127,7 +120,7 @@ describe('LocalParticipant', () => {
       const errorMessage = 'some-error-message';
       const handler = vi.fn().mockRejectedValue(new RpcError(errorCode, errorMessage));
 
-      localParticipant.registerRpcMethod(methodName, handler);
+      room.localParticipant.registerRpcMethod(methodName, handler);
 
       const mockCaller = new RemoteParticipant(
         {} as any,
@@ -140,7 +133,7 @@ describe('LocalParticipant', () => {
         ParticipantKind.STANDARD,
       );
 
-      await localParticipant.handleIncomingRpcRequest(
+      await room.handleIncomingRpcRequest(
         mockCaller.identity,
         'test-rpc-error-request-id',
         methodName,

package/src/room/track/LocalAudioTrack.ts

@@ -3,7 +3,7 @@ import { TrackEvent } from '../events';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { AudioSenderStats } from '../stats';
 import type { LoggerOptions } from '../types';
-import { isWeb, unwrapConstraint } from '../utils';
+import { isReactNative, isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { AudioCaptureOptions } from './options';
@@ -171,7 +171,7 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   async setProcessor(processor: TrackProcessor<Track.Kind.Audio, AudioProcessorOptions>) {
     const unlock = await this.processorLock.lock();
     try {
-      if (!this.audioContext) {
+      if (!isReactNative() && !this.audioContext) {
         throw Error(
           'Audio context needs to be set on LocalAudioTrack in order to enable processors',
         );
@@ -183,7 +183,8 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
       const processorOptions = {
         kind: this.kind,
         track: this._mediaStreamTrack,
-        audioContext: this.audioContext,
+        // RN won't have or use AudioContext
+        audioContext: this.audioContext as AudioContext,
       };
       this.log.debug(`setting up audio processor ${processor.name}`, this.logContext);
 

package/src/room/track/LocalTrack.ts

@@ -120,6 +120,10 @@ export default abstract class LocalTrack<
     return this.processor?.processedTrack ?? this._mediaStreamTrack;
   }
 
+  get isLocal() {
+    return true;
+  }
+
   /**
    * @internal
    * returns mediaStreamTrack settings of the capturing mediastreamtrack source - ignoring processors
@@ -179,7 +183,7 @@ export default abstract class LocalTrack<
         unlock();
       }
     }
-    if (this.sender) {
+    if (this.sender && this.sender.transport?.state !== 'closed') {
       await this.sender.replaceTrack(processedTrack ?? newTrack);
     }
     // if `newTrack` is different from the existing track, stop the
@@ -446,7 +450,9 @@ export default abstract class LocalTrack<
         // https://bugs.webkit.org/show_bug.cgi?id=184911
         throw new DeviceUnsupportedError('pauseUpstream is not supported on Safari < 12.');
       }
-      await this.sender.replaceTrack(null);
+      if (this.sender.transport?.state !== 'closed') {
+        await this.sender.replaceTrack(null);
+      }
     } finally {
       unlock();
     }
@@ -465,8 +471,10 @@ export default abstract class LocalTrack<
       this._isUpstreamPaused = false;
       this.emit(TrackEvent.UpstreamResumed, this);
 
-      // this operation is noop if mediastreamtrack is already being sent
-      await this.sender.replaceTrack(this.mediaStreamTrack);
+      if (this.sender.transport?.state !== 'closed') {
+        // this operation is noop if mediastreamtrack is already being sent
+        await this.sender.replaceTrack(this.mediaStreamTrack);
+      }
     } finally {
       unlock();
     }

package/src/room/track/LocalTrackPublication.ts

@@ -1,6 +1,7 @@
 import { AudioTrackFeature, TrackInfo } from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
+import { isAudioTrack } from '../utils';
 import LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
@@ -51,6 +52,10 @@ export default class LocalTrackPublication extends TrackPublication {
     return super.videoTrack as LocalVideoTrack | undefined;
   }
 
+  get isLocal() {
+    return true;
+  }
+
   /**
    * Mute the track associated with this publication
    */
@@ -83,7 +88,7 @@ export default class LocalTrackPublication extends TrackPublication {
   }
 
   getTrackFeatures() {
-    if (this.track instanceof LocalAudioTrack) {
+    if (isAudioTrack(this.track)) {
       const settings = this.track!.getSourceTrackSettings();
       const features: Set<AudioTrackFeature> = new Set();
       if (settings.autoGainControl) {

package/src/room/track/LocalVideoTrack.ts

@@ -252,7 +252,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     await this.restart(constraints);
 
     for await (const sc of this.simulcastCodecs.values()) {
-      if (sc.sender) {
+      if (sc.sender && sc.sender.transport?.state !== 'closed') {
         sc.mediaStreamTrack = this.mediaStreamTrack.clone();
         await sc.sender.replaceTrack(sc.mediaStreamTrack);
       }

package/src/room/track/RemoteTrack.ts

@@ -23,6 +23,10 @@ export default abstract class RemoteTrack<
     this.receiver = receiver;
   }
 
+  get isLocal() {
+    return false;
+  }
+
   /** @internal */
   setMuted(muted: boolean) {
     if (this.isMuted !== muted) {

package/src/room/track/RemoteTrackPublication.ts

@@ -7,8 +7,8 @@ import {
 } from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
+import { isRemoteVideoTrack } from '../utils';
 import type RemoteTrack from './RemoteTrack';
-import RemoteVideoTrack from './RemoteVideoTrack';
 import { Track, VideoQuality } from './Track';
 import { TrackPublication } from './TrackPublication';
 
@@ -108,6 +108,10 @@ export default class RemoteTrackPublication extends TrackPublication {
     return !this.disabled;
   }
 
+  get isLocal() {
+    return false;
+  }
+
   /**
    * disable server from sending down data for this track. this is useful when
    * the participant is off screen, you may disable streaming down their video
@@ -150,7 +154,7 @@ export default class RemoteTrackPublication extends TrackPublication {
     ) {
       return;
     }
-    if (this.track instanceof RemoteVideoTrack) {
+    if (isRemoteVideoTrack(this.track)) {
       this.videoDimensions = dimensions;
     }
     this.currentVideoQuality = undefined;
@@ -163,7 +167,7 @@ export default class RemoteTrackPublication extends TrackPublication {
       return;
     }
 
-    if (!(this.track instanceof RemoteVideoTrack)) {
+    if (!isRemoteVideoTrack(this.track)) {
       return;
     }
 
@@ -276,7 +280,7 @@ export default class RemoteTrackPublication extends TrackPublication {
   };
 
   protected get isAdaptiveStream(): boolean {
-    return this.track instanceof RemoteVideoTrack && this.track.isAdaptiveStream;
+    return isRemoteVideoTrack(this.track) && this.track.isAdaptiveStream;
   }
 
   protected handleVisibilityChange = (visible: boolean) => {

package/src/room/track/Track.ts

@@ -106,6 +106,8 @@ export abstract class Track<
     return this._mediaStreamTrack;
   }
 
+  abstract get isLocal(): boolean;
+
   /**
    * @internal
    * used for keep mediaStream's first id, since it's id might change

package/src/room/track/TrackPublication.ts

@@ -10,6 +10,7 @@ import type TypedEventEmitter from 'typed-emitter';
 import log, { LoggerNames, getLogger } from '../../logger';
 import { TrackEvent } from '../events';
 import type { LoggerOptions, TranscriptionSegment } from '../types';
+import { isAudioTrack, isVideoTrack } from '../utils';
 import LocalAudioTrack from './LocalAudioTrack';
 import LocalVideoTrack from './LocalVideoTrack';
 import RemoteAudioTrack from './RemoteAudioTrack';
@@ -18,7 +19,7 @@ import RemoteVideoTrack from './RemoteVideoTrack';
 import { Track } from './Track';
 import { getLogContextFromTrack } from './utils';
 
-export class TrackPublication extends (EventEmitter as new () => TypedEventEmitter<PublicationEventCallbacks>) {
+export abstract class TrackPublication extends (EventEmitter as new () => TypedEventEmitter<PublicationEventCallbacks>) {
   kind: Track.Kind;
 
   trackName: string;
@@ -99,11 +100,13 @@ export class TrackPublication extends (EventEmitter as new () => TypedEventEmitt
     return this.encryption !== Encryption_Type.NONE;
   }
 
+  abstract get isLocal(): boolean;
+
   /**
    * an [AudioTrack] if this publication holds an audio track
    */
   get audioTrack(): LocalAudioTrack | RemoteAudioTrack | undefined {
-    if (this.track instanceof LocalAudioTrack || this.track instanceof RemoteAudioTrack) {
+    if (isAudioTrack(this.track)) {
       return this.track;
     }
   }
@@ -112,7 +115,7 @@ export class TrackPublication extends (EventEmitter as new () => TypedEventEmitt
    * an [VideoTrack] if this publication holds a video track
    */
   get videoTrack(): LocalVideoTrack | RemoteVideoTrack | undefined {
-    if (this.track instanceof LocalVideoTrack || this.track instanceof RemoteVideoTrack) {
+    if (isVideoTrack(this.track)) {
       return this.track;
     }
   }

package/src/room/track/create.ts

@@ -2,7 +2,7 @@ import DeviceManager from '../DeviceManager';
 import { audioDefaults, videoDefaults } from '../defaults';
 import { DeviceUnsupportedError, TrackInvalidError } from '../errors';
 import { mediaTrackToLocalTrack } from '../participant/publishUtils';
-import { isSafari17 } from '../utils';
+import { isAudioTrack, isSafari17, isVideoTrack } from '../utils';
 import LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import LocalVideoTrack from './LocalVideoTrack';
@@ -81,9 +81,10 @@ export async function createLocalTracks(
         track.source = Track.Source.Microphone;
       }
       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);
       }
 

package/src/room/track/facingMode.ts

@@ -1,4 +1,5 @@
 import log from '../../logger';
+import { isLocalTrack } from '../utils';
 import LocalTrack from './LocalTrack';
 import type { VideoCaptureOptions } from './options';
 
@@ -37,7 +38,7 @@ export function facingModeFromLocalTrack(
   localTrack: LocalTrack | MediaStreamTrack,
   options: FacingModeFromLocalTrackOptions = {},
 ): FacingModeFromLocalTrackReturnValue {
-  const track = localTrack instanceof LocalTrack ? localTrack.mediaStreamTrack : localTrack;
+  const track = isLocalTrack(localTrack) ? localTrack.mediaStreamTrack : localTrack;
   const trackSettings = track.getSettings();
   let result: FacingModeFromLocalTrackReturnValue = {
     facingMode: options.defaultFacingMode ?? 'user',

package/src/room/track/options.ts

@@ -12,8 +12,7 @@ export interface TrackPublishDefaults {
   videoEncoding?: VideoEncoding;
 
   /**
-   * Multi-codec Simulcast
-   * VP9 and AV1 are not supported by all browser clients. When backupCodec is
+   * Advanced codecs (VP9/AV1/H265) are not supported by all browser clients. When backupCodec is
    * set, when an incompatible client attempts to subscribe to the track, LiveKit
    * will automatically publish a secondary track encoded with the backup codec.
    *
@@ -24,6 +23,20 @@ export interface TrackPublishDefaults {
    */
   backupCodec?: true | false | { codec: BackupVideoCodec; encoding?: VideoEncoding };
 
+  /**
+   * When backup codec is enabled, there are two options to decide whether to
+   * send the primary codec at the same time:
+   *   * codec regression: publisher stops sending primary codec and all subscribers
+   *       will receive backup codec even if the primary codec is supported on their browser. It is the default
+   *       behavior and provides maximum compatibility. It also reduces CPU
+   *       and bandwidth consumption for publisher.
+   *   * multi-codec simulcast: publisher encodes and sends both codecs at same time,
+   *       subscribers will get most efficient codec. It will provide most bandwidth
+   *       efficiency, especially in the large 1:N room but requires more device performance
+   *       and bandwidth consumption for publisher.
+   */
+  backupCodecPolicy?: BackupCodecPolicy;
+
   /**
    * encoding parameters for screen share track
    */
@@ -375,6 +388,11 @@ export function isBackupCodec(codec: string): codec is BackupVideoCodec {
   return !!backupCodecs.find((backup) => backup === codec);
 }
 
+export enum BackupCodecPolicy {
+  REGRESSION = 0,
+  SIMULCAST = 1,
+}
+
 /**
  * scalability modes for svc.
  */

package/src/room/track/utils.ts

@@ -222,7 +222,7 @@ export function getTrackPublicationInfo<T extends TrackPublication>(
 }
 
 export function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown> {
-  if (track instanceof Track) {
+  if ('mediaStreamTrack' in track) {
     return {
       trackID: track.sid,
       source: track.source,

package/src/room/types.ts

@@ -1,3 +1,5 @@
+import type { DataStream_Chunk } from '@livekit/protocol';
+
 export type SimulationOptions = {
   publish?: {
     audio?: boolean;
@@ -12,6 +14,25 @@ export type SimulationOptions = {
   };
 };
 
+export interface SendTextOptions {
+  topic?: string;
+  // replyToMessageId?: string;
+  destinationIdentities?: Array<string>;
+  attachments?: Array<File>;
+  onProgress?: (progress: number) => void;
+}
+
+export interface StreamTextOptions {
+  topic?: string;
+  destinationIdentities?: Array<string>;
+  type?: 'create' | 'update';
+  streamId?: string;
+  version?: number;
+  attachedStreamIds?: Array<string>;
+  replyToStreamId?: string;
+  totalSize?: number;
+}
+
 export type DataPublishOptions = {
   /**
    * whether to send this as reliable or lossy.
@@ -74,4 +95,33 @@ export interface ChatMessage {
   timestamp: number;
   message: string;
   editTimestamp?: number;
+  attachedFiles?: Array<File>;
+}
+
+export interface StreamController<T extends DataStream_Chunk> {
+  info: BaseStreamInfo;
+  controller: ReadableStreamDefaultController<T>;
+  startTime: number;
+  endTime?: number;
+}
+
+export interface BaseStreamInfo {
+  id: string;
+  mimeType: string;
+  topic: string;
+  timestamp: number;
+  /** total size in bytes for finite streams and undefined for streams of unknown size */
+  size?: number;
+  attributes?: Record<string, string>;
 }
+export interface ByteStreamInfo extends BaseStreamInfo {
+  name: string;
+}
+
+export interface TextStreamInfo extends BaseStreamInfo {}
+
+export type TextStreamChunk = {
+  index: number;
+  current: string;
+  collected: string;
+};

package/src/room/utils.ts

@@ -8,9 +8,20 @@ import {
 import { getBrowser } from '../utils/browserParser';
 import { protocolVersion, version } from '../version';
 import { type ConnectionError, ConnectionErrorReason } from './errors';
+import type LocalParticipant from './participant/LocalParticipant';
+import type Participant from './participant/Participant';
+import type RemoteParticipant from './participant/RemoteParticipant';
 import CriticalTimers from './timers';
 import type LocalAudioTrack from './track/LocalAudioTrack';
+import type LocalTrack from './track/LocalTrack';
+import type LocalTrackPublication from './track/LocalTrackPublication';
+import type LocalVideoTrack from './track/LocalVideoTrack';
 import type RemoteAudioTrack from './track/RemoteAudioTrack';
+import type RemoteTrack from './track/RemoteTrack';
+import type RemoteTrackPublication from './track/RemoteTrackPublication';
+import type RemoteVideoTrack from './track/RemoteVideoTrack';
+import { Track } from './track/Track';
+import type { TrackPublication } from './track/TrackPublication';
 import { type VideoCodec, videoCodecs } from './track/options';
 import { getNewAudioContext } from './track/utils';
 import type { ChatMessage, LiveKitReactNativeInfo, TranscriptionSegment } from './types';
@@ -548,3 +559,69 @@ export function getDisconnectReasonFromConnectionError(e: ConnectionError) {
       return DisconnectReason.UNKNOWN_REASON;
   }
 }
+
+/** convert bigints to numbers preserving undefined values */
+export function bigIntToNumber<T extends BigInt | undefined>(
+  value: T,
+): T extends BigInt ? number : undefined {
+  return (value !== undefined ? Number(value) : undefined) as T extends BigInt ? number : undefined;
+}
+
+/** convert numbers to bigints preserving undefined values */
+export function numberToBigInt<T extends number | undefined>(
+  value: T,
+): T extends number ? bigint : undefined {
+  return (value !== undefined ? BigInt(value) : undefined) as T extends number ? bigint : undefined;
+}
+
+export function isLocalTrack(track: Track | MediaStreamTrack | undefined): track is LocalTrack {
+  return !!track && !(track instanceof MediaStreamTrack) && track.isLocal;
+}
+
+export function isAudioTrack(
+  track: Track | undefined,
+): track is LocalAudioTrack | RemoteAudioTrack {
+  return !!track && track.kind == Track.Kind.Audio;
+}
+
+export function isVideoTrack(
+  track: Track | undefined,
+): track is LocalVideoTrack | RemoteVideoTrack {
+  return !!track && track.kind == Track.Kind.Video;
+}
+
+export function isLocalVideoTrack(
+  track: Track | MediaStreamTrack | undefined,
+): track is LocalVideoTrack {
+  return isLocalTrack(track) && isVideoTrack(track);
+}
+
+export function isLocalAudioTrack(
+  track: Track | MediaStreamTrack | undefined,
+): track is LocalAudioTrack {
+  return isLocalTrack(track) && isAudioTrack(track);
+}
+
+export function isRemoteTrack(track: Track | undefined): track is RemoteTrack {
+  return !!track && !track.isLocal;
+}
+
+export function isRemotePub(pub: TrackPublication | undefined): pub is RemoteTrackPublication {
+  return !!pub && !pub.isLocal;
+}
+
+export function isLocalPub(pub: TrackPublication | undefined): pub is LocalTrackPublication {
+  return !!pub && !pub.isLocal;
+}
+
+export function isRemoteVideoTrack(track: Track | undefined): track is RemoteVideoTrack {
+  return isRemoteTrack(track) && isVideoTrack(track);
+}
+
+export function isLocalParticipant(p: Participant): p is LocalParticipant {
+  return p.isLocal;
+}
+
+export function isRemoteParticipant(p: Participant): p is RemoteParticipant {
+  return !p.isLocal;
+}