livekit-client 2.13.0 → 2.13.2

package/src/room/participant/LocalParticipant.ts

@@ -1,6 +1,7 @@
 import { Mutex } from '@livekit/mutex';
 import {
   AddTrackRequest,
+  AudioTrackFeature,
   BackupCodecPolicy,
   ChatMessage as ChatMessageModel,
   Codec,
@@ -13,6 +14,7 @@ import {
   DataStream_TextHeader,
   DataStream_Trailer,
   Encryption_Type,
+  JoinResponse,
   ParticipantInfo,
   ParticipantPermission,
   RequestResponse,
@@ -71,6 +73,7 @@ import {
   mergeDefaultOptions,
   mimeTypeToVideoCodecString,
   screenCaptureToDisplayMediaStreamOptions,
+  sourceToKind,
 } from '../track/utils';
 import {
   type ByteStreamInfo,
@@ -102,6 +105,7 @@ import {
 import Participant from './Participant';
 import type { ParticipantTrackPermission } from './ParticipantTrackPermission';
 import { trackPermissionToProto } from './ParticipantTrackPermission';
+import type RemoteParticipant from './RemoteParticipant';
 import {
   computeTrackBackupEncodings,
   computeVideoEncodings,
@@ -145,6 +149,12 @@ export default class LocalParticipant extends Participant {
 
   private reconnectFuture?: Future<void>;
 
+  private signalConnectedFuture?: Future<void>;
+
+  private activeAgentFuture?: Future<RemoteParticipant>;
+
+  private firstActiveAgent?: RemoteParticipant;
+
   private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>;
 
   private pendingSignalRequests: Map<
@@ -240,6 +250,7 @@ export default class LocalParticipant extends Participant {
 
     this.engine
       .on(EngineEvent.Connected, this.handleReconnected)
+      .on(EngineEvent.SignalConnected, this.handleSignalConnected)
       .on(EngineEvent.SignalRestarted, this.handleReconnected)
       .on(EngineEvent.SignalResumed, this.handleReconnected)
       .on(EngineEvent.Restarting, this.handleReconnecting)
@@ -269,6 +280,25 @@ export default class LocalParticipant extends Participant {
       this.reconnectFuture?.reject?.('Got disconnected during reconnection attempt');
       this.reconnectFuture = undefined;
     }
+    if (this.signalConnectedFuture) {
+      this.signalConnectedFuture.reject?.('Got disconnected without signal connected');
+      this.signalConnectedFuture = undefined;
+    }
+
+    this.activeAgentFuture?.reject?.('Got disconnected without active agent present');
+    this.activeAgentFuture = undefined;
+    this.firstActiveAgent = undefined;
+  };
+
+  private handleSignalConnected = (joinResponse: JoinResponse) => {
+    if (joinResponse.participant) {
+      this.updateInfo(joinResponse.participant);
+    }
+    if (!this.signalConnectedFuture) {
+      this.signalConnectedFuture = new Future<void>();
+    }
+
+    this.signalConnectedFuture.resolve?.();
   };
 
   private handleSignalRequestResponse = (response: RequestResponse) => {
@@ -517,11 +547,25 @@ export default class LocalParticipant extends Participant {
             tr.stop();
           });
           if (e instanceof Error) {
-            this.emit(ParticipantEvent.MediaDevicesError, e);
+            this.emit(ParticipantEvent.MediaDevicesError, e, sourceToKind(source));
           }
           this.pendingPublishing.delete(source);
           throw e;
         }
+
+        for (const localTrack of localTracks) {
+          if (
+            source === Track.Source.Microphone &&
+            isAudioTrack(localTrack) &&
+            publishOptions?.preConnectBuffer
+          ) {
+            this.log.info('starting preconnect buffer for microphone', {
+              ...this.logContext,
+            });
+            localTrack.startPreConnectBuffer();
+          }
+        }
+
         try {
           const publishPromises: Array<Promise<LocalTrackPublication>> = [];
           for (const localTrack of localTracks) {
@@ -848,16 +892,8 @@ export default class LocalParticipant extends Participant {
             ...this.logContext,
             track: getLogContextFromTrack(track),
           });
-          const onSignalConnected = async () => {
-            try {
-              const publication = await this.publish(track, opts, isStereo);
-              resolve(publication);
-            } catch (e) {
-              reject(e);
-            }
-          };
-          setTimeout(() => {
-            this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
+
+          const timeout = setTimeout(() => {
             reject(
               new PublishTrackError(
                 'publishing rejected as engine not connected within timeout',
@@ -865,11 +901,10 @@ export default class LocalParticipant extends Participant {
               ),
             );
           }, 15_000);
-          this.engine.once(EngineEvent.SignalConnected, onSignalConnected);
-          this.engine.on(EngineEvent.Closing, () => {
-            this.engine.off(EngineEvent.SignalConnected, onSignalConnected);
-            reject(new PublishTrackError('publishing rejected as engine closed', 499));
-          });
+          await this.waitUntilEngineConnected();
+          clearTimeout(timeout);
+          const publication = await this.publish(track, opts, isStereo);
+          resolve(publication);
         } else {
           try {
             const publication = await this.publish(track, opts, isStereo);
@@ -893,6 +928,13 @@ export default class LocalParticipant extends Participant {
     }
   }
 
+  private waitUntilEngineConnected() {
+    if (!this.signalConnectedFuture) {
+      this.signalConnectedFuture = new Future<void>();
+    }
+    return this.signalConnectedFuture.promise;
+  }
+
   private hasPermissionsToPublish(track: LocalTrack): boolean {
     if (!this.permissions) {
       this.log.warn('no permissions present for publishing track', {
@@ -970,6 +1012,30 @@ export default class LocalParticipant extends Participant {
     track.on(TrackEvent.UpstreamResumed, this.onTrackUpstreamResumed);
     track.on(TrackEvent.AudioTrackFeatureUpdate, this.onTrackFeatureUpdate);
 
+    const audioFeatures: AudioTrackFeature[] = [];
+    const disableDtx = !(opts.dtx ?? true);
+
+    const settings = track.getSourceTrackSettings();
+
+    if (settings.autoGainControl) {
+      audioFeatures.push(AudioTrackFeature.TF_AUTO_GAIN_CONTROL);
+    }
+    if (settings.echoCancellation) {
+      audioFeatures.push(AudioTrackFeature.TF_ECHO_CANCELLATION);
+    }
+    if (settings.noiseSuppression) {
+      audioFeatures.push(AudioTrackFeature.TF_NOISE_SUPPRESSION);
+    }
+    if (settings.channelCount && settings.channelCount > 1) {
+      audioFeatures.push(AudioTrackFeature.TF_STEREO);
+    }
+    if (disableDtx) {
+      audioFeatures.push(AudioTrackFeature.TF_NO_DTX);
+    }
+    if (isLocalAudioTrack(track) && track.hasPreConnectBuffer) {
+      audioFeatures.push(AudioTrackFeature.TF_PRECONNECT_BUFFER);
+    }
+
     // create track publication from track
     const req = new AddTrackRequest({
       // get local track id for use during publishing
@@ -978,12 +1044,13 @@ export default class LocalParticipant extends Participant {
       type: Track.kindToProto(track.kind),
       muted: track.isMuted,
       source: Track.sourceToProto(track.source),
-      disableDtx: !(opts.dtx ?? true),
+      disableDtx,
       encryption: this.encryptionType,
       stereo: isStereo,
       disableRed: this.isE2EEEnabled || !(opts.red ?? true),
       stream: opts?.stream,
       backupCodecPolicy: opts?.backupCodecPolicy as BackupCodecPolicy,
+      audioFeatures,
     });
 
     // compute encodings and layers for video
@@ -1142,11 +1209,32 @@ export default class LocalParticipant extends Participant {
     };
 
     let ti: TrackInfo;
+    const addTrackPromise = new Promise<TrackInfo>(async (resolve, reject) => {
+      try {
+        ti = await this.engine.addTrack(req);
+        resolve(ti);
+      } catch (err) {
+        if (track.sender && this.engine.pcManager?.publisher) {
+          this.engine.pcManager.publisher.removeTrack(track.sender);
+          await this.engine.negotiate().catch((negotiateErr) => {
+            this.log.error(
+              'failed to negotiate after removing track due to failed add track request',
+              {
+                ...this.logContext,
+                ...getLogContextFromTrack(track),
+                error: negotiateErr,
+              },
+            );
+          });
+        }
+        reject(err);
+      }
+    });
     if (this.enabledPublishVideoCodecs.length > 0) {
-      const rets = await Promise.all([this.engine.addTrack(req), negotiate()]);
+      const rets = await Promise.all([addTrackPromise, negotiate()]);
       ti = rets[0];
     } else {
-      ti = await this.engine.addTrack(req);
+      ti = await addTrackPromise;
       // server might not support the codec the client has requested, in that case, fallback
       // to a supported codec
       let primaryCodecMime: string | undefined;
@@ -1200,6 +1288,79 @@ export default class LocalParticipant extends Participant {
     this.addTrackPublication(publication);
     // send event for publication
     this.emit(ParticipantEvent.LocalTrackPublished, publication);
+
+    if (
+      isLocalAudioTrack(track) &&
+      ti.audioFeatures.includes(AudioTrackFeature.TF_PRECONNECT_BUFFER)
+    ) {
+      const stream = track.getPreConnectBuffer();
+      // TODO: we're registering the listener after negotiation, so there might be a race
+      this.on(ParticipantEvent.LocalTrackSubscribed, (pub) => {
+        if (pub.trackSid === ti.sid) {
+          if (!track.hasPreConnectBuffer) {
+            this.log.warn('subscribe event came to late, buffer already closed', this.logContext);
+            return;
+          }
+          this.log.debug('finished recording preconnect buffer', {
+            ...this.logContext,
+            ...getLogContextFromTrack(track),
+          });
+          track.stopPreConnectBuffer();
+        }
+      });
+
+      if (stream) {
+        const bufferStreamPromise = new Promise<void>(async (resolve, reject) => {
+          try {
+            this.log.debug('waiting for agent', {
+              ...this.logContext,
+              ...getLogContextFromTrack(track),
+            });
+            const agentActiveTimeout = setTimeout(() => {
+              reject(new Error('agent not active within 10 seconds'));
+            }, 10_000);
+            const agent = await this.waitUntilActiveAgentPresent();
+            clearTimeout(agentActiveTimeout);
+            this.log.debug('sending preconnect buffer', {
+              ...this.logContext,
+              ...getLogContextFromTrack(track),
+            });
+            const writer = await this.streamBytes({
+              name: 'preconnect-buffer',
+              mimeType: 'audio/opus',
+              topic: 'lk.agent.pre-connect-audio-buffer',
+              destinationIdentities: [agent.identity],
+              attributes: {
+                trackId: publication.trackSid,
+                sampleRate: String(settings.sampleRate ?? '48000'),
+                channels: String(settings.channelCount ?? '1'),
+              },
+            });
+            for await (const chunk of stream) {
+              await writer.write(chunk);
+            }
+            await writer.close();
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+        bufferStreamPromise
+          .then(() => {
+            this.log.debug('preconnect buffer sent successfully', {
+              ...this.logContext,
+              ...getLogContextFromTrack(track),
+            });
+          })
+          .catch((e) => {
+            this.log.error('error sending preconnect buffer', {
+              ...this.logContext,
+              ...getLogContextFromTrack(track),
+              error: e,
+            });
+          });
+      }
+    }
     return publication;
   }
 
@@ -2091,6 +2252,30 @@ export default class LocalParticipant extends Participant {
     );
   };
 
+  /** @internal */
+  setActiveAgent(agent: RemoteParticipant | undefined) {
+    this.firstActiveAgent = agent;
+    if (agent && !this.firstActiveAgent) {
+      this.firstActiveAgent = agent;
+    }
+    if (agent) {
+      this.activeAgentFuture?.resolve?.(agent);
+    } else {
+      this.activeAgentFuture?.reject?.('Agent disconnected');
+    }
+    this.activeAgentFuture = undefined;
+  }
+
+  private waitUntilActiveAgentPresent() {
+    if (this.firstActiveAgent) {
+      return Promise.resolve(this.firstActiveAgent);
+    }
+    if (!this.activeAgentFuture) {
+      this.activeAgentFuture = new Future<RemoteParticipant>();
+    }
+    return this.activeAgentFuture.promise;
+  }
+
   /** @internal */
   private onTrackUnmuted = (track: LocalTrack) => {
     this.onTrackMuted(track, track.isUpstreamPaused);
@@ -2154,22 +2339,18 @@ export default class LocalParticipant extends Participant {
       });
       return;
     }
-    if (update.subscribedCodecs.length > 0) {
-      if (!pub.videoTrack) {
-        return;
-      }
-      const newCodecs = await pub.videoTrack.setPublishingCodecs(update.subscribedCodecs);
-      for await (const codec of newCodecs) {
-        if (isBackupCodec(codec)) {
-          this.log.debug(`publish ${codec} for ${pub.videoTrack.sid}`, {
-            ...this.logContext,
-            ...getLogContextFromTrack(pub),
-          });
-          await this.publishAdditionalCodecForTrack(pub.videoTrack, codec, pub.options);
-        }
+    if (!pub.videoTrack) {
+      return;
+    }
+    const newCodecs = await pub.videoTrack.setPublishingCodecs(update.subscribedCodecs);
+    for await (const codec of newCodecs) {
+      if (isBackupCodec(codec)) {
+        this.log.debug(`publish ${codec} for ${pub.videoTrack.sid}`, {
+          ...this.logContext,
+          ...getLogContextFromTrack(pub),
+        });
+        await this.publishAdditionalCodecForTrack(pub.videoTrack, codec, pub.options);
       }
-    } else if (update.subscribedQualities.length > 0) {
-      await pub.videoTrack?.setPublishingLayers(update.subscribedQualities);
     }
   };
 

package/src/room/participant/Participant.ts

@@ -421,7 +421,7 @@ export type ParticipantEventCallbacks = {
     publication: RemoteTrackPublication,
     status: TrackPublication.PermissionStatus,
   ) => void;
-  mediaDevicesError: (error: Error) => void;
+  mediaDevicesError: (error: Error, kind?: MediaDeviceKind) => void;
   audioStreamAcquired: () => void;
   participantPermissionsChanged: (prevPermissions?: ParticipantPermission) => void;
   trackSubscriptionStatusChanged: (

package/src/room/participant/publishUtils.ts

@@ -19,6 +19,7 @@ import {
   isReactNative,
   isSVCCodec,
   isSafari,
+  isSafariSvcApi,
   unwrapConstraint,
 } from '../utils';
 
@@ -158,12 +159,15 @@ export function computeVideoEncodings(
       (browser?.name === 'Chrome' && compareVersions(browser?.version, '113') < 0)
     ) {
       const bitratesRatio = sm.suffix == 'h' ? 2 : 3;
+      // safari 18.4 uses a different svc API that requires scaleResolutionDownBy to be set.
+      const requireScale = isSafariSvcApi(browser);
       for (let i = 0; i < sm.spatial; i += 1) {
         // in legacy SVC, scaleResolutionDownBy cannot be set
         encodings.push({
           rid: videoRids[2 - i],
           maxBitrate: videoEncoding.maxBitrate / bitratesRatio ** i,
           maxFramerate: original.encoding.maxFramerate,
+          scaleResolutionDownBy: requireScale ? 2 ** i : undefined,
         });
       }
       // legacy SVC, scalabilityMode is set only on the first encoding

package/src/room/track/LocalTrack.ts

@@ -9,15 +9,19 @@ import { compareVersions, isMobile, sleep, unwrapConstraint } from '../utils';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
 import type { TrackProcessor } from './processor/types';
+import { LocalTrackRecorder } from './record';
 import type { ReplaceTrackOptions } from './types';
 
-const defaultDimensionsTimeout = 1000;
+const DEFAULT_DIMENSIONS_TIMEOUT = 1000;
+const PRE_CONNECT_BUFFER_TIMEOUT = 10_000;
 
 export default abstract class LocalTrack<
   TrackKind extends Track.Kind = Track.Kind,
 > extends Track<TrackKind> {
   protected _sender?: RTCRtpSender;
 
+  private autoStopPreConnectBuffer: ReturnType<typeof setTimeout> | undefined;
+
   /** @internal */
   get sender(): RTCRtpSender | undefined {
     return this._sender;
@@ -35,6 +39,10 @@ export default abstract class LocalTrack<
     return this._constraints;
   }
 
+  get hasPreConnectBuffer() {
+    return !!this.localTrackRecorder;
+  }
+
   protected _constraints: MediaTrackConstraints;
 
   protected reacquireTrack: boolean;
@@ -55,6 +63,8 @@ export default abstract class LocalTrack<
 
   protected manuallyStopped: boolean = false;
 
+  protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
+
   private restartLock: Mutex;
 
   /**
@@ -203,7 +213,7 @@ export default abstract class LocalTrack<
     }
   }
 
-  async waitForDimensions(timeout = defaultDimensionsTimeout): Promise<Track.Dimensions> {
+  async waitForDimensions(timeout = DEFAULT_DIMENSIONS_TIMEOUT): Promise<Track.Dimensions> {
     if (this.kind === Track.Kind.Audio) {
       throw new Error('cannot get dimensions for audio tracks');
     }
@@ -585,5 +595,40 @@ export default abstract class LocalTrack<
     this.emit(TrackEvent.TrackProcessorUpdate);
   }
 
+  /** @internal */
+  startPreConnectBuffer(timeslice: number = 100) {
+    if (!this.localTrackRecorder) {
+      this.localTrackRecorder = new LocalTrackRecorder(this, {
+        mimeType: 'audio/webm;codecs=opus',
+      });
+    } else {
+      this.log.warn('preconnect buffer already started');
+      return;
+    }
+
+    this.localTrackRecorder.start(timeslice);
+    this.autoStopPreConnectBuffer = setTimeout(() => {
+      this.log.warn(
+        'preconnect buffer timed out, stopping recording automatically',
+        this.logContext,
+      );
+      this.stopPreConnectBuffer();
+    }, PRE_CONNECT_BUFFER_TIMEOUT);
+  }
+
+  /** @internal */
+  stopPreConnectBuffer() {
+    clearTimeout(this.autoStopPreConnectBuffer);
+    if (this.localTrackRecorder) {
+      this.localTrackRecorder.stop();
+      this.localTrackRecorder = undefined;
+    }
+  }
+
+  /** @internal */
+  getPreConnectBuffer() {
+    return this.localTrackRecorder?.byteStream;
+  }
+
   protected abstract monitorSender(): void;
 }

package/src/room/track/LocalVideoTrack.ts

@@ -12,7 +12,7 @@ import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
-import { compareVersions, isFireFox, isMobile, isWeb } from '../utils';
+import { compareVersions, isFireFox, isMobile, isSVCCodec, isWeb } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track, VideoQuality } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
@@ -239,7 +239,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
       );
     }
     this.log.debug(`setting publishing quality. max quality ${maxQuality}`, this.logContext);
-    this.setPublishingLayers(qualities);
+    this.setPublishingLayers(isSVCCodec(this.codec), qualities);
   }
 
   async restartTrack(options?: VideoCaptureOptions) {
@@ -334,7 +334,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     });
     // only enable simulcast codec for preference codec setted
     if (!this.codec && codecs.length > 0) {
-      await this.setPublishingLayers(codecs[0].qualities);
+      await this.setPublishingLayers(isSVCCodec(codecs[0].codec), codecs[0].qualities);
       return [];
     }
 
@@ -343,7 +343,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     const newCodecs: VideoCodec[] = [];
     for await (const codec of codecs) {
       if (!this.codec || this.codec === codec.codec) {
-        await this.setPublishingLayers(codec.qualities);
+        await this.setPublishingLayers(isSVCCodec(codec.codec), codec.qualities);
       } else {
         const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec as VideoCodec);
         this.log.debug(`try setPublishingCodec for ${codec.codec}`, {
@@ -364,6 +364,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
             simulcastCodecInfo.encodings!,
             codec.qualities,
             this.senderLock,
+            isSVCCodec(codec.codec),
             this.log,
             this.logContext,
           );
@@ -377,7 +378,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
    * @internal
    * Sets layers that should be publishing
    */
-  async setPublishingLayers(qualities: SubscribedQuality[]) {
+  async setPublishingLayers(isSvc: boolean, qualities: SubscribedQuality[]) {
     this.log.debug('setting publishing layers', { ...this.logContext, qualities });
     if (!this.sender || !this.encodings) {
       return;
@@ -388,6 +389,7 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
       this.encodings,
       qualities,
       this.senderLock,
+      isSvc,
       this.log,
       this.logContext,
     );
@@ -434,6 +436,7 @@ async function setPublishingLayersForSender(
   senderEncodings: RTCRtpEncodingParameters[],
   qualities: SubscribedQuality[],
   senderLock: Mutex,
+  isSVC: boolean,
   log: StructuredLogger,
   logContext: Record<string, unknown>,
 ) {
@@ -498,6 +501,12 @@ async function setPublishingLayersForSender(
         }
       }
     } else {
+      if (isSVC) {
+        const hasEnabledEncoding = qualities.some((q) => q.enabled);
+        if (hasEnabledEncoding) {
+          qualities.forEach((q) => (q.enabled = true));
+        }
+      }
       // simulcast dynacast encodings
       encodings.forEach((encoding, idx) => {
         let rid = encoding.rid ?? '';

package/src/room/track/Track.ts

@@ -528,4 +528,5 @@ export type TrackEventCallbacks = {
   trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
   audioTrackFeatureUpdate: (track: any, feature: AudioTrackFeature, enabled: boolean) => void;
   timeSyncUpdate: (update: { timestamp: number; rtpTimestamp: number }) => void;
+  preConnectBufferFlushed: (buffer: Uint8Array[]) => void;
 };

package/src/room/track/options.ts

@@ -119,6 +119,15 @@ export interface TrackPublishDefaults {
    * defaults to false
    */
   stopMicTrackOnMute?: boolean;
+
+  /**
+   * Enables preconnect buffer for a user's microphone track.
+   * This is useful for reducing perceived latency when the user starts to speak before the connection is established.
+   * Only works for agent use cases.
+   *
+   * Defaults to false.
+   */
+  preConnectBuffer?: boolean;
 }
 
 /**

package/src/room/track/record.ts

@@ -0,0 +1,51 @@
+import type LocalTrack from './LocalTrack';
+
+export class LocalTrackRecorder<T extends LocalTrack> extends MediaRecorder {
+  byteStream: ReadableStream<Uint8Array>;
+
+  constructor(track: T, options?: MediaRecorderOptions) {
+    super(new MediaStream([track.mediaStreamTrack]), options);
+
+    let dataListener: (event: BlobEvent) => void;
+
+    let streamController: ReadableStreamDefaultController<Uint8Array> | undefined;
+
+    const isClosed = () => streamController === undefined;
+
+    const onStop = () => {
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController?.close();
+      streamController = undefined;
+    };
+
+    const onError = (event: Event) => {
+      streamController?.error(event);
+      this.removeEventListener('dataavailable', dataListener);
+      this.removeEventListener('stop', onStop);
+      this.removeEventListener('error', onError);
+      streamController = undefined;
+    };
+
+    this.byteStream = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+        dataListener = async (event: BlobEvent) => {
+          const arrayBuffer = await event.data.arrayBuffer();
+          if (isClosed()) {
+            return;
+          }
+          controller.enqueue(new Uint8Array(arrayBuffer));
+        };
+        this.addEventListener('dataavailable', dataListener);
+      },
+      cancel: () => {
+        onStop();
+      },
+    });
+
+    this.addEventListener('stop', onStop);
+    this.addEventListener('error', onError);
+  }
+}

package/src/room/utils.ts

@@ -5,7 +5,7 @@ import {
   DisconnectReason,
   Transcription as TranscriptionModel,
 } from '@livekit/protocol';
-import { getBrowser } from '../utils/browserParser';
+import { type BrowserDetails, getBrowser } from '../utils/browserParser';
 import { protocolVersion, version } from '../version';
 import { type ConnectionError, ConnectionErrorReason } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
@@ -143,11 +143,24 @@ export function isSafari(): boolean {
   return getBrowser()?.name === 'Safari';
 }
 
+export function isSafariBased(): boolean {
+  const b = getBrowser();
+  return b?.name === 'Safari' || b?.os === 'iOS';
+}
+
 export function isSafari17(): boolean {
   const b = getBrowser();
   return b?.name === 'Safari' && b.version.startsWith('17.');
 }
 
+export function isSafariSvcApi(browser?: BrowserDetails): boolean {
+  if (!browser) {
+    browser = getBrowser();
+  }
+  // Safari 18.4 requires legacy svc api and scaleResolutionDown to be set
+  return browser?.name === 'Safari' && compareVersions(browser.version, '18.3') > 0;
+}
+
 export function isMobile(): boolean {
   if (!isWeb()) return false;