Summary of Additional Fixes

  1. Idempotency guard in _startRecorderWithDevice()
  (src/index.ts:894-898)

  Added early return guard to prevent multiple begin() calls: if
  (this.recorderStarted || this._hasLiveRecorderStream()) {
  console.debug('_startRecorderWithDevice: already started, skipping');
  return; }

  2. Concurrency protection in requestPermission()
  (src/wavtools/lib/wav_recorder.js:246-274)

  Added _permissionPromise deduplication to prevent concurrent
  getUserMedia calls: if (this._permissionPromise) { return
  this._permissionPromise; } this._permissionPromise = (async () => { //
  ... getUserMedia logic })(); return this._permissionPromise;

  3. Skip first device callback flag (src/index.ts:286, 368, 893,
  1410-1418, 1497)

  Added _skipFirstDeviceCallback flag to explicitly skip device
  switching on the first callback after starting the recorder: - Set to
  true in audioInputConnect() before _setupDeviceChangeListener() -
  Checked and cleared in deviceChangeListener callback - Reset in
  _performDisconnectCleanup()

  4. Set useSystemDefaultDevice correctly (src/index.ts:877-884)

  When starting with no specific device, mark useSystemDefaultDevice =
  true so the device change listener logic works correctly.

  Final Flow

  Now when audioInput is enabled: 1. audioInputConnect() →
  _startRecorderWithDevice() → begin() → single getUserMedia 2. Set
  _skipFirstDeviceCallback = true 3. _setupDeviceChangeListener() →
  listDevices() → requestPermission() → skipped (has permission) 4.
  First device callback → skipped (flag is set), flag cleared,
  lastKnownSystemDefaultDeviceKey initialized 5. Future callbacks work
  normally for real device changes

  This reduces iOS Safari connection time from ~10s (3× getUserMedia) to
  ~2-3s (1× getUserMedia).

Author: dctanner

src/index.ts

@@ -282,6 +282,8 @@ class LayercodeClient implements ILayercodeClient {
   private deviceChangeListener: ((devices: any[]) => Promise<void>) | null;
   // private audioPauseTime: number | null; // Track when audio was paused for VAD
   private recorderRestartChain: Promise<void>;
+  // Flag to skip the first device callback after starting recorder to avoid redundant device switching
+  private _skipFirstDeviceCallback: boolean;
   private deviceListenerReady: Promise<void> | null;
   private resolveDeviceListenerReady: (() => void) | null;
   _websocketUrl: string;
@@ -363,6 +365,7 @@ class LayercodeClient implements ILayercodeClient {
     this.stopRecorderAmplitude = undefined;
     this.deviceChangeListener = null;
     this.recorderRestartChain = Promise.resolve();
+    this._skipFirstDeviceCallback = false;
     this.deviceListenerReady = null;
     this.resolveDeviceListenerReady = null;
     // this.audioPauseTime = null;
@@ -872,14 +875,22 @@ class LayercodeClient implements ILayercodeClient {
     // 2. THEN setting up device change listeners (which will skip getUserMedia since permission is cached)
     console.log('audioInputConnect: recorderStarted =', this.recorderStarted);
 
-    // If the recorder hasn't spun up yet, start it first with the default device
+    // If the recorder hasn't spun up yet, start it first with the preferred or default device
     // This ensures we only make ONE getUserMedia call instead of multiple sequential ones
     if (!this.recorderStarted) {
-      console.log('audioInputConnect: starting recorder with default device');
-      await this._startRecorderWithDevice(undefined);
+      // Use preferred device if set, otherwise use system default
+      const targetDeviceId = this.useSystemDefaultDevice ? undefined : this.deviceId || undefined;
+      // Mark as using system default if no specific device is set
+      if (!targetDeviceId) {
+        this.useSystemDefaultDevice = true;
+      }
+      console.log('audioInputConnect: starting recorder with device:', targetDeviceId ?? 'system default');
+      await this._startRecorderWithDevice(targetDeviceId);
     }
 
     // Now set up device change listeners - permission is already granted so listDevices() won't call getUserMedia
+    // Skip the first callback since we've already started with the correct device
+    this._skipFirstDeviceCallback = true;
     console.log('audioInputConnect: setting up device change listener');
     await this._setupDeviceChangeListener();
 
@@ -888,9 +899,16 @@ class LayercodeClient implements ILayercodeClient {
 
   /**
    * Starts the recorder with a specific device (or default if undefined)
-   * This is the single point where getUserMedia is called during initial setup
+   * This is the single point where getUserMedia is called during initial setup.
+   * Idempotent: returns early if recorder is already started or has a live stream.
    */
   private async _startRecorderWithDevice(deviceId: string | undefined): Promise<void> {
+    // Idempotency guard: don't start again if already running
+    if (this.recorderStarted || this._hasLiveRecorderStream()) {
+      console.debug('_startRecorderWithDevice: already started, skipping');
+      return;
+    }
+
     try {
       this._stopRecorderAmplitudeMonitoring();
       try {
@@ -1379,7 +1397,7 @@ class LayercodeClient implements ILayercodeClient {
       });
 
       this.deviceChangeListener = async (devices: any[]) => {
-        console.log('deviceChangeListener called, devices:', devices.length, 'recorderStarted:', this.recorderStarted);
+        console.log('deviceChangeListener called, devices:', devices.length, 'recorderStarted:', this.recorderStarted, '_skipFirstDeviceCallback:', this._skipFirstDeviceCallback);
         try {
           // Notify user that devices have changed
           this.options.onDevicesChanged(devices);
@@ -1389,6 +1407,16 @@ class LayercodeClient implements ILayercodeClient {
           const previousDefaultDeviceKey = this.lastKnownSystemDefaultDeviceKey;
           const currentDefaultDeviceKey = this._getDeviceComparisonKey(defaultDevice);
 
+          // Skip switching on the first callback after starting the recorder to avoid redundant begin() calls
+          // This is set by audioInputConnect() after _startRecorderWithDevice() completes
+          if (this._skipFirstDeviceCallback) {
+            console.log('deviceChangeListener: skipping first callback after recorder start');
+            this._skipFirstDeviceCallback = false;
+            this.lastKnownSystemDefaultDeviceKey = currentDefaultDeviceKey;
+            this.resolveDeviceListenerReady?.();
+            return;
+          }
+
           let shouldSwitch = !this.recorderStarted;
           console.log('deviceChangeListener: shouldSwitch initial:', shouldSwitch);
 
@@ -1466,6 +1494,7 @@ class LayercodeClient implements ILayercodeClient {
     this.lastKnownSystemDefaultDeviceKey = null;
     this.recorderStarted = false;
     this.readySent = false;
+    this._skipFirstDeviceCallback = false;
 
     this._stopAmplitudeMonitoring();
     this._teardownDeviceListeners();

src/wavtools/lib/wav_recorder.js

@@ -42,6 +42,8 @@ export class WavRecorder {
     // Track whether we've already obtained microphone permission
     // This avoids redundant getUserMedia calls which are expensive on iOS Safari
     this._hasPermission = false;
+    // Promise used to dedupe concurrent requestPermission() calls
+    this._permissionPromise = null;
     // Event handling with AudioWorklet
     this._lastEventId = 0;
     this.eventReceipts = {};
@@ -237,27 +239,39 @@ export class WavRecorder {
 
   /**
    * Manually request permission to use the microphone
-   * Skips if permission has already been granted to avoid expensive redundant getUserMedia calls
+   * Skips if permission has already been granted to avoid expensive redundant getUserMedia calls.
+   * Dedupes concurrent calls to prevent multiple getUserMedia requests.
    * @returns {Promise<true>}
    */
   async requestPermission() {
     // Skip if we already have permission - each getUserMedia is expensive on iOS Safari
     if (this._hasPermission) {
       return true;
     }
-    console.log('ensureUserMediaAccess');
-    try {
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: true,
-      });
-      // Stop the tracks immediately after getting permission
-      stream.getTracks().forEach((track) => track.stop());
-      this._hasPermission = true;
-    } catch (fallbackError) {
-      console.error('getUserMedia failed:', fallbackError.name, fallbackError.message);
-      throw fallbackError;
+    // Dedupe concurrent calls: if a permission request is already in flight, wait for it
+    if (this._permissionPromise) {
+      return this._permissionPromise;
     }
-    return true;
+
+    console.log('ensureUserMediaAccess');
+    this._permissionPromise = (async () => {
+      try {
+        const stream = await navigator.mediaDevices.getUserMedia({
+          audio: true,
+        });
+        // Stop the tracks immediately after getting permission
+        stream.getTracks().forEach((track) => track.stop());
+        this._hasPermission = true;
+        return true;
+      } catch (fallbackError) {
+        console.error('getUserMedia failed:', fallbackError.name, fallbackError.message);
+        throw fallbackError;
+      } finally {
+        this._permissionPromise = null;
+      }
+    })();
+
+    return this._permissionPromise;
   }
 
   /**