livekit-client 2.5.1 → 2.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -36,23 +36,23 @@
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@livekit/protocol": "1.20.1",
+    "@livekit/protocol": "1.22.0",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
     "sdp-transform": "^2.14.1",
     "ts-debounce": "^4.0.0",
-    "tslib": "2.6.3",
+    "tslib": "2.7.0",
     "typed-emitter": "^2.1.0",
     "webrtc-adapter": "^9.0.0"
   },
   "devDependencies": {
     "@babel/core": "7.25.2",
-    "@babel/preset-env": "7.25.3",
+    "@babel/preset-env": "7.25.4",
     "@bufbuild/protoc-gen-es": "^1.3.0",
     "@changesets/cli": "2.27.7",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.4",
-    "@rollup/plugin-commonjs": "25.0.8",
+    "@rollup/plugin-commonjs": "26.0.1",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "15.2.3",
     "@rollup/plugin-terser": "^0.4.0",
@@ -69,19 +69,19 @@
     "eslint-config-airbnb-typescript": "18.0.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-ecmascript-compat": "^3.0.0",
-    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-import": "2.30.0",
     "gh-pages": "6.1.1",
     "jsdom": "^24.0.0",
     "prettier": "^3.0.0",
-    "rollup": "4.19.2",
+    "rollup": "4.22.4",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-re": "1.0.7",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^8.2.4",
-    "typedoc": "0.26.5",
+    "typedoc": "0.26.6",
     "typedoc-plugin-no-inherit": "1.4.0",
     "typescript": "5.5.4",
-    "vite": "5.3.5",
+    "vite": "5.4.6",
     "vitest": "^1.0.0"
   },
   "scripts": {

package/src/connectionHelper/checks/Checker.ts

@@ -105,7 +105,7 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
     if (this.room.state === ConnectionState.Connected) {
       return this.room;
     }
-    await this.room.connect(this.url, this.token);
+    await this.room.connect(this.url, this.token, this.connectOptions);
     return this.room;
   }
 

package/src/e2ee/worker/FrameCryptor.ts

@@ -360,6 +360,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         }
       } catch (error) {
         if (error instanceof CryptorError && error.reason === CryptorErrorReason.InvalidKey) {
+          // emit an error if the key handler thinks we have a valid key
           if (this.keys.hasValidKey) {
             this.emit(CryptorEvent.Error, error);
             this.keys.decryptionFailure();
@@ -369,7 +370,7 @@ export class FrameCryptor extends BaseFrameCryptor {
         }
       }
     } else if (!this.keys.getKeySet(keyIndex) && this.keys.hasValidKey) {
-      // emit an error in case the key index is out of bounds but the key handler thinks we still have a valid key
+      // emit an error if the key index is out of bounds but the key handler thinks we still have a valid key
       workerLogger.warn(`skipping decryption due to missing key at index ${keyIndex}`);
       this.emit(
         CryptorEvent.Error,
@@ -379,6 +380,7 @@ export class FrameCryptor extends BaseFrameCryptor {
           this.participantIdentity,
         ),
       );
+      this.keys.decryptionFailure();
     }
   }
 

package/src/room/PCTransportManager.ts

@@ -57,6 +57,8 @@ export class PCTransportManager {
 
   private connectionLock: Mutex;
 
+  private remoteOfferLock: Mutex;
+
   private log = log;
 
   private loggerOptions: LoggerOptions;
@@ -100,6 +102,7 @@ export class PCTransportManager {
     this.state = PCTransportState.NEW;
 
     this.connectionLock = new Mutex();
+    this.remoteOfferLock = new Mutex();
   }
 
   private get logContext() {
@@ -171,11 +174,16 @@ export class PCTransportManager {
       sdp: sd.sdp,
       signalingState: this.subscriber.getSignallingState().toString(),
     });
-    await this.subscriber.setRemoteDescription(sd);
+    const unlock = await this.remoteOfferLock.lock();
+    try {
+      await this.subscriber.setRemoteDescription(sd);
 
-    // answer the offer
-    const answer = await this.subscriber.createAndSetAnswer();
-    return answer;
+      // answer the offer
+      const answer = await this.subscriber.createAndSetAnswer();
+      return answer;
+    } finally {
+      unlock();
+    }
   }
 
   updateConfiguration(config: RTCConfiguration, iceRestart?: boolean) {

package/src/room/Room.ts

@@ -1,4 +1,5 @@
 import {
+  ChatMessage as ChatMessageModel,
   ConnectionQualityUpdate,
   type DataPacket,
   DataPacket_Kind,
@@ -57,6 +58,7 @@ import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
 import CriticalTimers from './timers';
 import LocalAudioTrack from './track/LocalAudioTrack';
+import type LocalTrack from './track/LocalTrack';
 import LocalTrackPublication from './track/LocalTrackPublication';
 import LocalVideoTrack from './track/LocalVideoTrack';
 import type RemoteTrack from './track/RemoteTrack';
@@ -66,11 +68,17 @@ import type { TrackPublication } from './track/TrackPublication';
 import type { TrackProcessor } from './track/processor/types';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext, sourceToKind } from './track/utils';
-import type { SimulationOptions, SimulationScenario, TranscriptionSegment } from './types';
+import type {
+  ChatMessage,
+  SimulationOptions,
+  SimulationScenario,
+  TranscriptionSegment,
+} from './types';
 import {
   Future,
   Mutex,
   createDummyVideoStreamTrack,
+  extractChatMessage,
   extractTranscriptionSegments,
   getEmptyAudioStreamTrack,
   isBrowserSupported,
@@ -406,9 +414,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   /**
    * getLocalDevices abstracts navigator.mediaDevices.enumerateDevices.
-   * In particular, it handles Chrome's unique behavior of creating `default`
-   * devices. When encountered, it'll be removed from the list of devices.
-   * The actual default device will be placed at top.
+   * In particular, it requests device permissions by default if needed
+   * and makes sure the returned device does not consist of dummy devices
    * @param kind
    * @returns a list of available local devices
    */
@@ -1073,7 +1080,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     let success = true;
     const deviceConstraint = exact ? { exact: deviceId } : deviceId;
     if (kind === 'audioinput') {
-      const prevDeviceId = this.options.audioCaptureDefaults!.deviceId;
+      const prevDeviceId =
+        this.getActiveDevice(kind) ?? this.options.audioCaptureDefaults!.deviceId;
       this.options.audioCaptureDefaults!.deviceId = deviceConstraint;
       deviceHasChanged = prevDeviceId !== deviceConstraint;
       const tracks = Array.from(this.localParticipant.audioTrackPublications.values()).filter(
@@ -1088,7 +1096,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         throw e;
       }
     } else if (kind === 'videoinput') {
-      const prevDeviceId = this.options.videoCaptureDefaults!.deviceId;
+      const prevDeviceId =
+        this.getActiveDevice(kind) ?? this.options.videoCaptureDefaults!.deviceId;
       this.options.videoCaptureDefaults!.deviceId = deviceConstraint;
       deviceHasChanged = prevDeviceId !== deviceConstraint;
       const tracks = Array.from(this.localParticipant.videoTrackPublications.values()).filter(
@@ -1115,7 +1124,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           (await DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) ?? '';
       }
       this.options.audioOutput ??= {};
-      const prevDeviceId = this.options.audioOutput.deviceId;
+      const prevDeviceId = this.getActiveDevice(kind) ?? this.options.audioOutput.deviceId;
       this.options.audioOutput.deviceId = deviceId;
       deviceHasChanged = prevDeviceId !== deviceConstraint;
 
@@ -1154,6 +1163,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
       .on(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
       .on(ParticipantEvent.AudioStreamAcquired, this.startAudio)
+      .on(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent)
       .on(
         ParticipantEvent.ParticipantPermissionsChanged,
         this.onLocalParticipantPermissionsChanged,
@@ -1334,6 +1344,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         .off(ParticipantEvent.ConnectionQualityChanged, this.onLocalConnectionQualityChanged)
         .off(ParticipantEvent.MediaDevicesError, this.onMediaDevicesError)
         .off(ParticipantEvent.AudioStreamAcquired, this.startAudio)
+        .off(ParticipantEvent.ChatMessage, this.onLocalChatMessageSent)
         .off(
           ParticipantEvent.ParticipantPermissionsChanged,
           this.onLocalParticipantPermissionsChanged,
@@ -1527,6 +1538,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.handleTranscription(participant, packet.value.value);
     } else if (packet.value.case === 'sipDtmf') {
       this.handleSipDtmf(participant, packet.value.value);
+    } else if (packet.value.case === 'chatMessage') {
+      this.handleChatMessage(participant, packet.value.value);
     }
   };
 
@@ -1568,6 +1581,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.TranscriptionReceived, segments, participant, publication);
   };
 
+  private handleChatMessage = (
+    participant: RemoteParticipant | undefined,
+    chatMessage: ChatMessageModel,
+  ) => {
+    const msg = extractChatMessage(chatMessage);
+    this.emit(RoomEvent.ChatMessage, msg, participant);
+  };
+
   private handleAudioPlaybackStarted = () => {
     if (this.canPlaybackAudio) {
       return;
@@ -1600,6 +1621,21 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleDeviceChange = async () => {
+    // check for available devices, but don't request permissions in order to avoid prompts for kinds that haven't been used before
+    const availableDevices = await DeviceManager.getInstance().getDevices(undefined, false);
+    // inputs are automatically handled via TrackEvent.Ended causing a TrackEvent.Restarted. Here we only need to worry about audiooutputs changing
+    const kinds: MediaDeviceKind[] = ['audiooutput'];
+    for (let kind of kinds) {
+      // switch to first available device if previously active device is not available any more
+      const devicesOfKind = availableDevices.filter((d) => d.kind === kind);
+      if (
+        devicesOfKind.length > 0 &&
+        !devicesOfKind.find((deviceInfo) => deviceInfo.deviceId === this.getActiveDevice(kind))
+      ) {
+        await this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
+      }
+    }
+
     this.emit(RoomEvent.MediaDevicesChanged);
   };
 
@@ -1923,6 +1959,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private onLocalTrackPublished = async (pub: LocalTrackPublication) => {
     pub.track?.on(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
+    pub.track?.on(TrackEvent.Restarted, this.onLocalTrackRestarted);
     pub.track?.getProcessor()?.onPublish?.(this);
 
     this.emit(RoomEvent.LocalTrackPublished, pub, this.localParticipant);
@@ -1947,9 +1984,27 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private onLocalTrackUnpublished = (pub: LocalTrackPublication) => {
     pub.track?.off(TrackEvent.TrackProcessorUpdate, this.onTrackProcessorUpdate);
+    pub.track?.off(TrackEvent.Restarted, this.onLocalTrackRestarted);
     this.emit(RoomEvent.LocalTrackUnpublished, pub, this.localParticipant);
   };
 
+  private onLocalTrackRestarted = async (track: LocalTrack) => {
+    const deviceId = await track.getDeviceId(false);
+    const deviceKind = sourceToKind(track.source);
+    if (
+      deviceKind &&
+      deviceId &&
+      deviceId !== this.localParticipant.activeDeviceMap.get(deviceKind)
+    ) {
+      this.log.debug(
+        `local track restarted, setting ${deviceKind} ${deviceId} active`,
+        this.logContext,
+      );
+      this.localParticipant.activeDeviceMap.set(deviceKind, deviceId);
+      this.emit(RoomEvent.ActiveDeviceChanged, deviceKind, deviceId);
+    }
+  };
+
   private onLocalConnectionQualityChanged = (quality: ConnectionQuality) => {
     this.emit(RoomEvent.ConnectionQualityChanged, quality, this.localParticipant);
   };
@@ -1962,6 +2017,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, this.localParticipant);
   };
 
+  private onLocalChatMessageSent = (msg: ChatMessage) => {
+    this.emit(RoomEvent.ChatMessage, msg, this.localParticipant);
+  };
+
   /**
    * Allows to populate a room with simulated participants.
    * No actual connection to a server will be established, all state is
@@ -2228,5 +2287,6 @@ export type RoomEventCallbacks = {
   encryptionError: (error: Error) => void;
   dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
   activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
+  chatMessage: (message: ChatMessage, participant?: RemoteParticipant | LocalParticipant) => void;
   localTrackSubscribed: (publication: LocalTrackPublication, participant: LocalParticipant) => void;
 };

package/src/room/events.ts

@@ -324,6 +324,7 @@ export enum RoomEvent {
    */
   ActiveDeviceChanged = 'activeDeviceChanged',
 
+  ChatMessage = 'chatMessage',
   /**
    * fired when the first remote participant has subscribed to the localParticipant's track
    */
@@ -519,6 +520,9 @@ export enum ParticipantEvent {
    * fired on local participant only, when the first remote participant has subscribed to the track specified in the payload
    */
   LocalTrackSubscribed = 'localTrackSubscribed',
+
+  /** only emitted on local participant */
+  ChatMessage = 'chatMessage',
 }
 
 /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -1,5 +1,6 @@
 import {
   AddTrackRequest,
+  ChatMessage as ChatMessageModel,
   Codec,
   DataPacket,
   DataPacket_Kind,
@@ -13,6 +14,7 @@ import {
   TrackInfo,
   TrackUnpublishedResponse,
   UserPacket,
+  protoInt64,
 } from '@livekit/protocol';
 import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
@@ -31,6 +33,7 @@ import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
 import { Track } from '../track/Track';
+import { extractProcessorsFromOptions } from '../track/create';
 import type {
   AudioCaptureOptions,
   BackupVideoCodec,
@@ -40,7 +43,6 @@ import type {
   VideoCaptureOptions,
 } from '../track/options';
 import { ScreenSharePresets, VideoPresets, isBackupCodec } from '../track/options';
-import type { TrackProcessor } from '../track/processor/types';
 import {
   constraintsForOptions,
   getLogContextFromTrack,
@@ -48,7 +50,7 @@ import {
   mimeTypeToVideoCodecString,
   screenCaptureToDisplayMediaStreamOptions,
 } from '../track/utils';
-import type { DataPublishOptions } from '../types';
+import type { ChatMessage, DataPublishOptions } from '../types';
 import {
   Future,
   isE2EESimulcastSupported,
@@ -88,6 +90,8 @@ export default class LocalParticipant extends Participant {
 
   private pendingPublishPromises = new Map<LocalTrack, Promise<LocalTrackPublication>>();
 
+  private republishPromise: Promise<void> | undefined;
+
   private cameraError: Error | undefined;
 
   private microphoneError: Error | undefined;
@@ -380,6 +384,9 @@ export default class LocalParticipant extends Participant {
     publishOptions?: TrackPublishOptions,
   ) {
     this.log.debug('setTrackEnabled', { ...this.logContext, source, enabled });
+    if (this.republishPromise) {
+      await this.republishPromise;
+    }
     let track = this.getTrackPublication(source);
     if (enabled) {
       if (track) {
@@ -387,9 +394,12 @@ export default class LocalParticipant extends Participant {
       } else {
         let localTracks: Array<LocalTrack> | undefined;
         if (this.pendingPublishing.has(source)) {
-          this.log.info('skipping duplicate published source', { ...this.logContext, source });
-          // no-op it's already been requested
-          return;
+          const pendingTrack = await this.waitForPendingPublicationOfSource(source);
+          if (!pendingTrack) {
+            this.log.info('skipping duplicate published source', { ...this.logContext, source });
+          }
+          await pendingTrack?.unmute();
+          return pendingTrack;
         }
         this.pendingPublishing.add(source);
         try {
@@ -437,16 +447,22 @@ export default class LocalParticipant extends Participant {
           this.pendingPublishing.delete(source);
         }
       }
-    } else if (track && track.track) {
-      // screenshare cannot be muted, unpublish instead
-      if (source === Track.Source.ScreenShare) {
-        track = await this.unpublishTrack(track.track);
-        const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
-        if (screenAudioTrack && screenAudioTrack.track) {
-          this.unpublishTrack(screenAudioTrack.track);
+    } else {
+      if (!track?.track) {
+        // if there's no track available yet first wait for pending publishing promises of that source to see if it becomes available
+        track = await this.waitForPendingPublicationOfSource(source);
+      }
+      if (track && track.track) {
+        // screenshare cannot be muted, unpublish instead
+        if (source === Track.Source.ScreenShare) {
+          track = await this.unpublishTrack(track.track);
+          const screenAudioTrack = this.getTrackPublication(Track.Source.ScreenShareAudio);
+          if (screenAudioTrack && screenAudioTrack.track) {
+            this.unpublishTrack(screenAudioTrack.track);
+          }
+        } else {
+          await track.mute();
         }
-      } else {
-        await track.mute();
       }
     }
     return track;
@@ -486,6 +502,9 @@ export default class LocalParticipant extends Participant {
    * @returns
    */
   async createTracks(options?: CreateLocalTracksOptions): Promise<LocalTrack[]> {
+    options ??= {};
+    const { audioProcessor, videoProcessor } = extractProcessorsFromOptions(options);
+
     const mergedOptions = mergeDefaultOptions(
       options,
       this.roomOptions?.audioCaptureDefaults,
@@ -540,12 +559,10 @@ export default class LocalParticipant extends Participant {
           track.setAudioContext(this.audioContext);
         }
         track.mediaStream = stream;
-        if (trackOptions.processor) {
-          if (track instanceof LocalAudioTrack) {
-            await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Audio>);
-          } else {
-            await track.setProcessor(trackOptions.processor as TrackProcessor<Track.Kind.Video>);
-          }
+        if (track instanceof LocalAudioTrack && audioProcessor) {
+          await track.setProcessor(audioProcessor);
+        } else if (track instanceof LocalVideoTrack && videoProcessor) {
+          await track.setProcessor(videoProcessor);
         }
         return track;
       }),
@@ -610,15 +627,23 @@ export default class LocalParticipant extends Participant {
    * @param track
    * @param options
    */
-  async publishTrack(
+  async publishTrack(track: LocalTrack | MediaStreamTrack, options?: TrackPublishOptions) {
+    return this.publishOrRepublishTrack(track, options);
+  }
+
+  private async publishOrRepublishTrack(
     track: LocalTrack | MediaStreamTrack,
     options?: TrackPublishOptions,
+    isRepublish = false,
   ): Promise<LocalTrackPublication> {
     if (track instanceof LocalAudioTrack) {
       track.setAudioContext(this.audioContext);
     }
 
     await this.reconnectFuture?.promise;
+    if (this.republishPromise && !isRepublish) {
+      await this.republishPromise;
+    }
     if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
     }
@@ -1247,39 +1272,53 @@ export default class LocalParticipant extends Participant {
   }
 
   async republishAllTracks(options?: TrackPublishOptions, restartTracks: boolean = true) {
-    const localPubs: LocalTrackPublication[] = [];
-    this.trackPublications.forEach((pub) => {
-      if (pub.track) {
-        if (options) {
-          pub.options = { ...pub.options, ...options };
-        }
-        localPubs.push(pub);
+    if (this.republishPromise) {
+      await this.republishPromise;
+    }
+    this.republishPromise = new Promise(async (resolve, reject) => {
+      try {
+        const localPubs: LocalTrackPublication[] = [];
+        this.trackPublications.forEach((pub) => {
+          if (pub.track) {
+            if (options) {
+              pub.options = { ...pub.options, ...options };
+            }
+            localPubs.push(pub);
+          }
+        });
+
+        await Promise.all(
+          localPubs.map(async (pub) => {
+            const track = pub.track!;
+            await this.unpublishTrack(track, false);
+            if (
+              restartTracks &&
+              !track.isMuted &&
+              track.source !== Track.Source.ScreenShare &&
+              track.source !== Track.Source.ScreenShareAudio &&
+              (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
+              !track.isUserProvided
+            ) {
+              // generally we need to restart the track before publishing, often a full reconnect
+              // is necessary because computer had gone to sleep.
+              this.log.debug('restarting existing track', {
+                ...this.logContext,
+                track: pub.trackSid,
+              });
+              await track.restartTrack();
+            }
+            await this.publishOrRepublishTrack(track, pub.options, true);
+          }),
+        );
+        resolve();
+      } catch (error: any) {
+        reject(error);
+      } finally {
+        this.republishPromise = undefined;
       }
     });
 
-    await Promise.all(
-      localPubs.map(async (pub) => {
-        const track = pub.track!;
-        await this.unpublishTrack(track, false);
-        if (
-          restartTracks &&
-          !track.isMuted &&
-          track.source !== Track.Source.ScreenShare &&
-          track.source !== Track.Source.ScreenShareAudio &&
-          (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
-          !track.isUserProvided
-        ) {
-          // generally we need to restart the track before publishing, often a full reconnect
-          // is necessary because computer had gone to sleep.
-          this.log.debug('restarting existing track', {
-            ...this.logContext,
-            track: pub.trackSid,
-          });
-          await track.restartTrack();
-        }
-        await this.publishTrack(track, pub.options);
-      }),
-    );
+    await this.republishPromise;
   }
 
   /**
@@ -1310,6 +1349,47 @@ export default class LocalParticipant extends Participant {
     await this.engine.sendDataPacket(packet, kind);
   }
 
+  async sendChatMessage(text: string): Promise<ChatMessage> {
+    const msg = {
+      id: crypto.randomUUID(),
+      message: text,
+      timestamp: Date.now(),
+    } as const satisfies ChatMessage;
+    const packet = new DataPacket({
+      value: {
+        case: 'chatMessage',
+        value: new ChatMessageModel({
+          ...msg,
+          timestamp: protoInt64.parse(msg.timestamp),
+        }),
+      },
+    });
+    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    this.emit(ParticipantEvent.ChatMessage, msg);
+    return msg;
+  }
+
+  async editChatMessage(editText: string, originalMessage: ChatMessage) {
+    const msg = {
+      ...originalMessage,
+      message: editText,
+      editTimestamp: Date.now(),
+    } as const satisfies ChatMessage;
+    const packet = new DataPacket({
+      value: {
+        case: 'chatMessage',
+        value: new ChatMessageModel({
+          ...msg,
+          timestamp: protoInt64.parse(msg.timestamp),
+          editTimestamp: protoInt64.parse(msg.editTimestamp),
+        }),
+      },
+    });
+    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    this.emit(ParticipantEvent.ChatMessage, msg);
+    return msg;
+  }
+
   /**
    * Control who can subscribe to LocalParticipant's published tracks.
    *
@@ -1530,7 +1610,12 @@ export default class LocalParticipant extends Participant {
             ...this.logContext,
             ...getLogContextFromTrack(track),
           });
-          await track.restartTrack();
+          if (track instanceof LocalAudioTrack) {
+            // fall back to default device if available
+            await track.restartTrack({ deviceId: 'default' });
+          } else {
+            await track.restartTrack();
+          }
         }
       } catch (e) {
         this.log.warn(`could not restart track, muting instead`, {
@@ -1565,4 +1650,13 @@ export default class LocalParticipant extends Participant {
     });
     return publication;
   }
+
+  private async waitForPendingPublicationOfSource(source: Track.Source) {
+    const publishPromiseEntry = Array.from(this.pendingPublishPromises.entries()).find(
+      ([pendingTrack]) => pendingTrack.source === source,
+    );
+    if (publishPromiseEntry) {
+      return publishPromiseEntry[1];
+    }
+  }
 }

package/src/room/participant/Participant.ts

@@ -19,7 +19,7 @@ import type RemoteTrackPublication from '../track/RemoteTrackPublication';
 import { Track } from '../track/Track';
 import type { TrackPublication } from '../track/TrackPublication';
 import { diffAttributes } from '../track/utils';
-import type { LoggerOptions, TranscriptionSegment } from '../types';
+import type { ChatMessage, LoggerOptions, TranscriptionSegment } from '../types';
 
 export enum ConnectionQuality {
   Excellent = 'excellent',
@@ -387,4 +387,5 @@ export type ParticipantEventCallbacks = {
   ) => void;
   attributesChanged: (changedAttributes: Record<string, string>) => void;
   localTrackSubscribed: (trackPublication: LocalTrackPublication) => void;
+  chatMessage: (msg: ChatMessage) => void;
 };