browser-pilot 0.0.8 → 0.0.10

package/dist/{chunk-JN44FHTK.mjs → chunk-7OSR2CAE.mjs}

@@ -8,7 +8,1312 @@ import {
   BatchExecutor,
   ElementNotFoundError,
   TimeoutError
-} from "./chunk-ZTQ37YQT.mjs";
+} from "./chunk-KKW2SZLV.mjs";
+
+// src/audio/encoding.ts
+function bufferToBase64(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBuffer(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function calculateRMS(samples) {
+  if (samples.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    sum += samples[i] * samples[i];
+  }
+  return Math.sqrt(sum / samples.length);
+}
+function pcmToWav(options) {
+  const { left, right, sampleRate } = options;
+  const numChannels = right ? 2 : 1;
+  const numSamples = left.length;
+  const bitsPerSample = 16;
+  const bytesPerSample = bitsPerSample / 8;
+  const blockAlign = numChannels * bytesPerSample;
+  const dataLength = numSamples * blockAlign;
+  const headerLength = 44;
+  const buffer = new ArrayBuffer(headerLength + dataLength);
+  const view = new DataView(buffer);
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataLength, true);
+  writeString(view, 8, "WAVE");
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeString(view, 36, "data");
+  view.setUint32(40, dataLength, true);
+  let offset = 44;
+  for (let i = 0; i < numSamples; i++) {
+    const leftSample = Math.max(-1, Math.min(1, left[i]));
+    view.setInt16(offset, leftSample < 0 ? leftSample * 32768 : leftSample * 32767, true);
+    offset += 2;
+    if (right) {
+      const rightSample = Math.max(-1, Math.min(1, right[i]));
+      view.setInt16(offset, rightSample < 0 ? rightSample * 32768 : rightSample * 32767, true);
+      offset += 2;
+    }
+  }
+  return buffer;
+}
+function parseWavHeader(data) {
+  const view = new DataView(data);
+  if (data.byteLength < 44) {
+    throw new Error("Invalid WAV: file too small");
+  }
+  const riff = readString(view, 0, 4);
+  const wave = readString(view, 8, 4);
+  if (riff !== "RIFF" || wave !== "WAVE") {
+    throw new Error("Invalid WAV: missing RIFF/WAVE header");
+  }
+  const fmt = readString(view, 12, 4);
+  if (fmt !== "fmt ") {
+    throw new Error("Invalid WAV: missing fmt chunk");
+  }
+  const channels = view.getUint16(22, true);
+  const sampleRate = view.getUint32(24, true);
+  const bitsPerSample = view.getUint16(34, true);
+  let dataOffset = 36;
+  while (dataOffset < data.byteLength - 8) {
+    const chunkId = readString(view, dataOffset, 4);
+    const chunkSize = view.getUint32(dataOffset + 4, true);
+    if (chunkId === "data") {
+      return {
+        sampleRate,
+        channels,
+        bitsPerSample,
+        dataOffset: dataOffset + 8,
+        dataLength: chunkSize
+      };
+    }
+    dataOffset += 8 + chunkSize;
+  }
+  throw new Error("Invalid WAV: missing data chunk");
+}
+function generateSilence(durationMs, sampleRate = 48e3) {
+  return new Float32Array(Math.ceil(sampleRate * durationMs / 1e3));
+}
+function generateTone(frequency, durationMs, sampleRate = 48e3, amplitude = 0.5) {
+  const numSamples = Math.ceil(sampleRate * durationMs / 1e3);
+  const samples = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    samples[i] = amplitude * Math.sin(2 * Math.PI * frequency * i / sampleRate);
+  }
+  return samples;
+}
+function writeString(view, offset, str) {
+  for (let i = 0; i < str.length; i++) {
+    view.setUint8(offset + i, str.charCodeAt(i));
+  }
+}
+function readString(view, offset, length) {
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += String.fromCharCode(view.getUint8(offset + i));
+  }
+  return str;
+}
+
+// src/audio/permissions.ts
+async function grantAudioPermissions(cdp, origin) {
+  await cdp.send("Browser.grantPermissions", {
+    permissions: ["audioCapture"],
+    origin: origin ?? ""
+  });
+  await cdp.send("Page.addScriptToEvaluateOnNewDocument", {
+    source: PERMISSIONS_OVERRIDE_SCRIPT
+  });
+}
+var PERMISSIONS_OVERRIDE_SCRIPT = `
+(function() {
+  if (window.__bpPermissionsPatched) return;
+  window.__bpPermissionsPatched = true;
+
+  var origQuery = navigator.permissions.query.bind(navigator.permissions);
+  navigator.permissions.query = function(desc) {
+    if (desc && (desc.name === 'microphone' || desc.name === 'audio-capture')) {
+      return Promise.resolve({
+        state: 'granted',
+        onchange: null,
+        addEventListener: function() {},
+        removeEventListener: function() {},
+        dispatchEvent: function() { return true; }
+      });
+    }
+    return origQuery(desc);
+  };
+})();
+`;
+
+// src/audio/input.ts
+var INPUT_BINDING = "__bpAudioInputDone";
+var AUDIO_INPUT_SCRIPT = `
+(function() {
+  if (window.__bpAudioInput) return;
+
+  var audioCtx = null;
+  var sourceNode = null;
+  var destinationNode = null;
+  var fakeStream = null;
+  var silenceGain = null;
+  var silenceOsc = null;
+  var isPlaying = false;
+
+  function ensureFakeStream() {
+    if (fakeStream) return fakeStream;
+    // Use the original AudioContext to avoid being tracked by our output override
+    var CtorToUse = window.__bpOrigAudioContext || window.AudioContext || window.webkitAudioContext;
+    audioCtx = new CtorToUse({ sampleRate: 48000 });
+    // Auto-resume if suspended (CDP automation has no user gesture)
+    if (audioCtx.state === 'suspended') {
+      console.log('[bp:input] AudioContext suspended, auto-resuming...');
+      audioCtx.resume().then(function() {
+        console.log('[bp:input] AudioContext resumed (' + audioCtx.state + ')');
+      }).catch(function(e) {
+        console.warn('[bp:input] AudioContext resume failed:', e);
+      });
+    }
+    destinationNode = audioCtx.createMediaStreamDestination();
+
+    // Start with silence so the stream always has active tracks
+    silenceGain = audioCtx.createGain();
+    silenceGain.gain.value = 0;
+    silenceOsc = audioCtx.createOscillator();
+    silenceOsc.connect(silenceGain);
+    silenceGain.connect(destinationNode);
+    silenceOsc.start();
+
+    fakeStream = destinationNode.stream;
+    console.log('[bp:input] Fake mic stream created (48kHz, ' + fakeStream.getAudioTracks().length + ' tracks)');
+    return fakeStream;
+  }
+
+  function playAudio(base64Data) {
+    ensureFakeStream();
+
+    var resumePromise = audioCtx.state === 'suspended'
+      ? audioCtx.resume()
+      : Promise.resolve();
+
+    return resumePromise.then(function() {
+      if (sourceNode) {
+        try { sourceNode.stop(); } catch(e) {}
+        sourceNode.disconnect();
+        sourceNode = null;
+      }
+
+      var binaryStr = atob(base64Data);
+      var bytes = new Uint8Array(binaryStr.length);
+      for (var i = 0; i < binaryStr.length; i++) {
+        bytes[i] = binaryStr.charCodeAt(i);
+      }
+      console.log('[bp:input] Decoding audio (' + bytes.length + ' bytes)...');
+
+      return audioCtx.decodeAudioData(bytes.buffer.slice(0));
+    }).then(function(audioBuffer) {
+      sourceNode = audioCtx.createBufferSource();
+      sourceNode.buffer = audioBuffer;
+      sourceNode.connect(destinationNode);
+
+      var durationMs = Math.round(audioBuffer.duration * 1000);
+      console.log('[bp:input] Playing ' + durationMs + 'ms audio (' + audioBuffer.sampleRate + 'Hz, ' + audioBuffer.numberOfChannels + 'ch)');
+
+      return new Promise(function(resolve) {
+        sourceNode.onended = function() {
+          isPlaying = false;
+          console.log('[bp:input] Playback ended');
+          resolve(true);
+          try {
+            if (typeof window.__bpAudioInputDone === 'function') {
+              window.__bpAudioInputDone('done');
+            }
+          } catch(e) {}
+        };
+        isPlaying = true;
+        sourceNode.start();
+      });
+    });
+  }
+
+  function stopAudio() {
+    if (sourceNode) {
+      try { sourceNode.stop(); } catch(e) {}
+      sourceNode.disconnect();
+      sourceNode = null;
+    }
+    isPlaying = false;
+    console.log('[bp:input] Stopped');
+  }
+
+  var origGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+
+  navigator.mediaDevices.getUserMedia = function(constraints) {
+    if (constraints && constraints.audio) {
+      var stream = ensureFakeStream();
+      console.log('[bp:input] getUserMedia intercepted \u2014 returning fake mic' + (constraints.video ? ' + real video' : ''));
+
+      if (constraints.video) {
+        // Get real video + our fake audio
+        return origGetUserMedia({ video: constraints.video }).then(function(realStream) {
+          var combined = new MediaStream(
+            stream.getAudioTracks().concat(realStream.getVideoTracks())
+          );
+          return combined;
+        });
+      }
+
+      // Return a clone so consumers can't stop our source track
+      return Promise.resolve(stream.clone());
+    }
+    return origGetUserMedia(constraints);
+  };
+
+  var origEnumerate = navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
+  navigator.mediaDevices.enumerateDevices = function() {
+    return origEnumerate().then(function(devices) {
+      var hasMic = devices.some(function(d) { return d.kind === 'audioinput'; });
+      if (!hasMic) {
+        devices.push({
+          deviceId: 'bp-fake-mic',
+          kind: 'audioinput',
+          label: 'Default Audio Input',
+          groupId: 'bp-audio',
+          toJSON: function() {
+            return { deviceId: this.deviceId, kind: this.kind, label: this.label, groupId: this.groupId };
+          }
+        });
+      }
+      return devices;
+    });
+  };
+
+  window.__bpAudioInput = {
+    play: playAudio,
+    stop: stopAudio,
+    isPlaying: function() { return isPlaying; },
+    getState: function() {
+      return {
+        contextState: audioCtx ? audioCtx.state : 'not-created',
+        isPlaying: isPlaying,
+        sampleRate: audioCtx ? audioCtx.sampleRate : 0
+      };
+    },
+    getContext: function() { return audioCtx; }
+  };
+
+  console.log('[bp:input] Audio input override installed (getUserMedia + enumerateDevices)');
+})();
+`;
+var AudioInput = class {
+  cdp;
+  injected = false;
+  bindingRegistered = false;
+  bindingHandler = null;
+  constructor(cdp) {
+    this.cdp = cdp;
+  }
+  /** Whether the audio input system has been set up */
+  get isSetup() {
+    return this.injected;
+  }
+  /**
+   * Set up audio input injection.
+   * Must be called before navigating to the page that will use getUserMedia.
+   * Grants permissions and injects the getUserMedia override.
+   */
+  async setup() {
+    if (this.injected) return;
+    try {
+      const resp = await this.cdp.send("Runtime.evaluate", {
+        expression: "location.href",
+        returnByValue: true
+      });
+      const href = resp.result?.value;
+      if (typeof href === "string" && (href === "about:blank" || href === "about:srcdoc")) {
+        throw new Error(
+          'Cannot set up audio on about:blank. Navigate to a page first.\nExample: await page.goto("https://your-voice-app.com")'
+        );
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("Cannot set up audio")) throw e;
+    }
+    let origin;
+    try {
+      const resp = await this.cdp.send("Runtime.evaluate", {
+        expression: "location.origin",
+        returnByValue: true
+      });
+      const val = resp.result?.value;
+      if (typeof val === "string" && val !== "null") {
+        origin = val;
+      }
+    } catch {
+    }
+    await grantAudioPermissions(this.cdp, origin);
+    if (!this.bindingRegistered) {
+      await this.cdp.send("Runtime.addBinding", { name: INPUT_BINDING });
+      this.bindingRegistered = true;
+    }
+    await this.cdp.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: AUDIO_INPUT_SCRIPT
+    });
+    await this.cdp.send("Runtime.evaluate", {
+      expression: AUDIO_INPUT_SCRIPT,
+      awaitPromise: false,
+      userGesture: true
+    });
+    this.injected = true;
+  }
+  /**
+   * Play audio bytes into the page's fake microphone.
+   * Accepts any format that Web Audio API can decode (WAV, MP3, OGG, etc.).
+   *
+   * @param audioData - Raw audio file bytes
+   * @param options - Playback options
+   */
+  async play(audioData, options) {
+    if (!this.injected) {
+      await this.setup();
+    }
+    await this.cdp.send("Runtime.evaluate", {
+      expression: `(function() {
+        var resumed = [];
+        (window.__bpTrackedAudioContexts || []).forEach(function(ctx) {
+          if (ctx.state === 'suspended') {
+            ctx.resume().then(function() {
+              console.log('[bp:input] Resumed suspended AudioContext (' + ctx.sampleRate + 'Hz)');
+            });
+            resumed.push(ctx.sampleRate);
+          }
+        });
+        // Also resume the input context itself
+        if (window.__bpAudioInput && window.__bpAudioInput.getContext) {
+          var inputCtx = window.__bpAudioInput.getContext();
+          if (inputCtx && inputCtx.state === 'suspended') {
+            inputCtx.resume().then(function() {
+              console.log('[bp:input] Resumed input AudioContext (' + inputCtx.sampleRate + 'Hz)');
+            });
+            resumed.push('input-' + inputCtx.sampleRate);
+          }
+        }
+        return resumed.length > 0 ? 'resumed: ' + resumed.join(',') : 'all running';
+      })()`,
+      awaitPromise: false,
+      userGesture: true
+    });
+    const base64 = bufferToBase64(audioData);
+    const waitForEnd = options?.waitForEnd ?? true;
+    const timeout = options?.timeout ?? 6e4;
+    if (waitForEnd) {
+      const donePromise = this.waitForBinding(timeout);
+      await this.cdp.send("Runtime.evaluate", {
+        expression: `window.__bpAudioInput.play('${base64}')`,
+        awaitPromise: false
+      });
+      await donePromise;
+    } else {
+      await this.cdp.send("Runtime.evaluate", {
+        expression: `window.__bpAudioInput.play('${base64}')`,
+        awaitPromise: false
+      });
+    }
+  }
+  /**
+   * Stop any currently playing audio.
+   */
+  async stop() {
+    if (!this.injected) return;
+    await this.cdp.send("Runtime.evaluate", {
+      expression: "window.__bpAudioInput && window.__bpAudioInput.stop()",
+      awaitPromise: false
+    });
+  }
+  /**
+   * Get current state of the injected audio input system.
+   */
+  async getState() {
+    if (!this.injected) {
+      return { contextState: "not-created", isPlaying: false, sampleRate: 0 };
+    }
+    const result = await this.cdp.send("Runtime.evaluate", {
+      expression: "window.__bpAudioInput ? window.__bpAudioInput.getState() : null",
+      returnByValue: true
+    });
+    return result.result.value ?? { contextState: "not-created", isPlaying: false, sampleRate: 0 };
+  }
+  /**
+   * Clean up: remove binding handler.
+   */
+  async teardown() {
+    if (this.bindingHandler) {
+      this.cdp.off("Runtime.bindingCalled", this.bindingHandler);
+      this.bindingHandler = null;
+    }
+    await this.stop();
+    this.injected = false;
+    this.bindingRegistered = false;
+  }
+  /**
+   * Wait for the playback-complete binding to fire.
+   */
+  waitForBinding(timeout) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.bindingHandler) {
+          this.cdp.off("Runtime.bindingCalled", this.bindingHandler);
+          this.bindingHandler = null;
+        }
+        reject(new Error(`AudioInput: playback timed out after ${timeout}ms`));
+      }, timeout);
+      if (this.bindingHandler) {
+        this.cdp.off("Runtime.bindingCalled", this.bindingHandler);
+      }
+      this.bindingHandler = (params) => {
+        if (params["name"] === INPUT_BINDING) {
+          clearTimeout(timer);
+          if (this.bindingHandler) {
+            this.cdp.off("Runtime.bindingCalled", this.bindingHandler);
+            this.bindingHandler = null;
+          }
+          resolve();
+        }
+      };
+      this.cdp.on("Runtime.bindingCalled", this.bindingHandler);
+    });
+  }
+};
+
+// src/audio/output.ts
+var OUTPUT_BINDING = "__bpAudioOutputData";
+var AUDIO_OUTPUT_SCRIPT = `
+(function() {
+  // If already installed, stop any active capture but allow re-initialization
+  // so that updated scripts (e.g. with new capture strategies) take effect.
+  if (window.__bpAudioOutput) {
+    if (window.__bpAudioOutput.isCapturing()) window.__bpAudioOutput.stop();
+    // Keep existing allAudioContexts if available (preserves pre-override tracking)
+  }
+
+  var BUFFER_SIZE = 4096;
+  var FLUSH_SAMPLES = 48000; // flush every ~1s at 48kHz (scales with sample rate)
+  var capturing = false;
+  var capturedChunks = [];
+  var totalSamples = 0;
+  var flushCount = 0;
+  var pendingTracks = [];
+  var tappedTrackIds = {};
+
+  // --- Per-context tap infrastructure ---
+  // Preserve any AudioContexts tracked by a previous script version
+  var allAudioContexts = window.__bpTrackedAudioContexts || [];
+  // Use a WeakMap to associate taps with AudioContext instances
+  // (native objects like AudioContext may not support custom properties)
+  var contextTapMap = typeof WeakMap !== 'undefined' ? new WeakMap() : null;
+  var contextTapList = []; // fallback: [{ctx, proc}]
+
+  var OrigAudioContext = window.__bpOrigAudioContext || window.AudioContext || window.webkitAudioContext;
+  // Save the native connect function once; on re-injection, reuse it to avoid double-wrapping
+  var origConnect = window.__bpOrigConnect || AudioNode.prototype.connect;
+  window.__bpOrigConnect = origConnect;
+
+  // Our own capture context (48kHz) for WebRTC tracks and media elements
+  var captureCtx = null;
+  var captureProcessor = null;
+
+  // Save original AudioContext constructor once
+  if (!window.__bpOrigAudioContext) {
+    window.__bpOrigAudioContext = OrigAudioContext;
+  }
+
+  // Override AudioContext constructor to track all instances (skip if already overridden)
+  if (OrigAudioContext && !window.__bpAudioContextOverridden) {
+    window.__bpAudioContextOverridden = true;
+    window.AudioContext = function() {
+      var ctx = new (Function.prototype.bind.apply(OrigAudioContext, [null].concat(Array.prototype.slice.call(arguments))))();
+      allAudioContexts.push(ctx);
+      // Auto-resume suspended contexts \u2014 CDP automation has no user gesture,
+      // so Chrome suspends new AudioContexts by default. Without this, voice
+      // agents' ScriptProcessorNodes never fire and no audio flows.
+      if (ctx.state === 'suspended') {
+        console.log('[bp:output] AudioContext created suspended (' + ctx.sampleRate + 'Hz), auto-resuming...');
+        ctx.resume().then(function() {
+          console.log('[bp:output] AudioContext resumed successfully (' + ctx.sampleRate + 'Hz, state: ' + ctx.state + ')');
+        }).catch(function(e) {
+          console.warn('[bp:output] AudioContext resume failed (' + ctx.sampleRate + 'Hz):', e);
+        });
+      } else {
+        console.log('[bp:output] AudioContext created (' + ctx.sampleRate + 'Hz, state: ' + ctx.state + ')');
+      }
+      return ctx;
+    };
+    window.AudioContext.prototype = OrigAudioContext.prototype;
+    Object.keys(OrigAudioContext).forEach(function(k) {
+      try { window.AudioContext[k] = OrigAudioContext[k]; } catch(e) {}
+    });
+    if (window.webkitAudioContext) {
+      window.webkitAudioContext = window.AudioContext;
+    }
+  }
+
+  // Expose tracked contexts on window so re-injections preserve them
+  window.__bpTrackedAudioContexts = allAudioContexts;
+
+  // Look up an existing tap for a given AudioContext
+  function findTap(ctx) {
+    if (contextTapMap) return contextTapMap.get(ctx) || null;
+    for (var i = 0; i < contextTapList.length; i++) {
+      if (contextTapList[i].ctx === ctx) return contextTapList[i].proc;
+    }
+    return null;
+  }
+
+  // Store a tap for a given AudioContext
+  function storeTap(ctx, proc) {
+    if (contextTapMap) { contextTapMap.set(ctx, proc); }
+    else { contextTapList.push({ ctx: ctx, proc: proc }); }
+  }
+
+  // Count stored taps
+  function tapCount() {
+    if (contextTapMap) {
+      var count = 0;
+      for (var i = 0; i < allAudioContexts.length; i++) {
+        if (contextTapMap.has(allAudioContexts[i])) count++;
+      }
+      return count;
+    }
+    return contextTapList.length;
+  }
+
+  // Create or retrieve a ScriptProcessorNode tap for a specific AudioContext.
+  // The tap lives in the SAME context as the source, avoiding cross-context errors.
+  function getOrCreateTap(ctx) {
+    var existing = findTap(ctx);
+    if (existing) return existing;
+
+    try {
+      if (ctx.state === 'closed') return null;
+      var channels = Math.min(ctx.destination.channelCount || 2, 2);
+      if (channels < 1) channels = 1;
+      var proc = ctx.createScriptProcessor(BUFFER_SIZE, channels, channels);
+      proc.onaudioprocess = function(e) {
+        if (!capturing) return;
+        var left = new Float32Array(e.inputBuffer.getChannelData(0));
+        var right = e.inputBuffer.numberOfChannels > 1
+          ? new Float32Array(e.inputBuffer.getChannelData(1))
+          : new Float32Array(left.length);
+        capturedChunks.push({ left: left, right: right, sampleRate: ctx.sampleRate });
+        totalSamples += left.length;
+        if (totalSamples >= FLUSH_SAMPLES) {
+          flushToNodeJs();
+        }
+      };
+      // Must connect to destination to keep ScriptProcessorNode alive
+      origConnect.call(proc, ctx.destination);
+      storeTap(ctx, proc);
+      return proc;
+    } catch(e) {
+      return null;
+    }
+  }
+
+  // Override AudioNode.prototype.connect to tap connections to any AudioDestinationNode
+  AudioNode.prototype.connect = function(destination) {
+    var result = origConnect.apply(this, arguments);
+
+    if (capturing && destination instanceof AudioDestinationNode) {
+      try {
+        var tap = getOrCreateTap(destination.context);
+        // Don't connect the tap to itself
+        if (tap && tap !== this) {
+          origConnect.call(this, tap);
+        }
+      } catch(e) {}
+    }
+    return result;
+  };
+
+  var origPlay = window.__bpOrigPlay || HTMLMediaElement.prototype.play;
+  window.__bpOrigPlay = origPlay;
+  HTMLMediaElement.prototype.play = function() {
+    if (capturing && !this.__bpCaptured) {
+      this.__bpCaptured = true;
+      try {
+        if (!captureCtx) initCaptureCtx();
+        var stream = this.captureStream ? this.captureStream() : null;
+        if (stream && captureCtx) {
+          var source = captureCtx.createMediaStreamSource(stream);
+          origConnect.call(source, captureProcessor);
+        }
+      } catch(e) {}
+    }
+    return origPlay.apply(this, arguments);
+  };
+
+  // Intercept srcObject assignment to catch WebRTC streams attached to media elements
+  var origSrcObjectDesc = Object.getOwnPropertyDescriptor(HTMLMediaElement.prototype, 'srcObject');
+  if (origSrcObjectDesc && origSrcObjectDesc.set) {
+    Object.defineProperty(HTMLMediaElement.prototype, 'srcObject', {
+      set: function(stream) {
+        origSrcObjectDesc.set.call(this, stream);
+        if (stream && stream.getAudioTracks) {
+          var tracks = stream.getAudioTracks();
+          for (var i = 0; i < tracks.length; i++) {
+            if (capturing) {
+              tapAudioTrack(tracks[i]);
+            } else {
+              pendingTracks.push(tracks[i]);
+            }
+          }
+        }
+      },
+      get: origSrcObjectDesc.get,
+      configurable: true
+    });
+  }
+
+  // Initialize our own 48kHz capture context for WebRTC and media element tapping
+  function initCaptureCtx() {
+    captureCtx = new OrigAudioContext({ sampleRate: 48000 });
+    captureProcessor = captureCtx.createScriptProcessor(BUFFER_SIZE, 2, 2);
+    captureProcessor.onaudioprocess = function(e) {
+      if (!capturing) return;
+      var left = new Float32Array(e.inputBuffer.getChannelData(0));
+      var right = new Float32Array(e.inputBuffer.getChannelData(1));
+      capturedChunks.push({ left: left, right: right, sampleRate: 48000 });
+      totalSamples += left.length;
+      if (totalSamples >= FLUSH_SAMPLES) {
+        flushToNodeJs();
+      }
+    };
+    origConnect.call(captureProcessor, captureCtx.destination);
+  }
+
+  function uint8ToBase64(bytes) {
+    var CHUNK = 8192;
+    var parts = [];
+    for (var i = 0; i < bytes.length; i += CHUNK) {
+      var slice = bytes.subarray(i, Math.min(i + CHUNK, bytes.length));
+      var binary = '';
+      for (var j = 0; j < slice.length; j++) {
+        binary += String.fromCharCode(slice[j]);
+      }
+      parts.push(binary);
+    }
+    return btoa(parts.join(''));
+  }
+
+  function flushGroup(chunks, rate) {
+    var totalLen = 0;
+    for (var i = 0; i < chunks.length; i++) {
+      totalLen += chunks[i].left.length;
+    }
+    if (totalLen === 0) return;
+
+    var left = new Float32Array(totalLen);
+    var right = new Float32Array(totalLen);
+    var offset = 0;
+    for (var i = 0; i < chunks.length; i++) {
+      left.set(chunks[i].left, offset);
+      right.set(chunks[i].right, offset);
+      offset += chunks[i].left.length;
+    }
+
+    var leftB64 = uint8ToBase64(new Uint8Array(left.buffer));
+    var rightB64 = uint8ToBase64(new Uint8Array(right.buffer));
+
+    flushCount++;
+
+    try {
+      if (typeof window.__bpAudioOutputData === 'function') {
+        window.__bpAudioOutputData(JSON.stringify({
+          left: leftB64,
+          right: rightB64,
+          sampleRate: rate,
+          samples: totalLen
+        }));
+      }
+    } catch(e) {}
+  }
+
+  function flushToNodeJs() {
+    if (capturedChunks.length === 0) return;
+
+    // Group chunks by sample rate to avoid mixing different-rate audio
+    var byRate = {};
+    for (var i = 0; i < capturedChunks.length; i++) {
+      var rate = capturedChunks[i].sampleRate || 48000;
+      if (!byRate[rate]) byRate[rate] = [];
+      byRate[rate].push(capturedChunks[i]);
+    }
+
+    // Flush each sample rate group separately
+    for (var rateKey in byRate) {
+      if (byRate.hasOwnProperty(rateKey)) {
+        flushGroup(byRate[rateKey], Number(rateKey));
+      }
+    }
+
+    capturedChunks = [];
+    totalSamples = 0;
+  }
+
+  // --- WebRTC interception (for apps that use RTCPeerConnection) ---
+  var rtcTrackedStreams = [];
+  var rtcPeerConnections = [];
+
+  function tapAudioTrack(track) {
+    try {
+      if (tappedTrackIds[track.id]) return;
+      tappedTrackIds[track.id] = true;
+      if (!captureCtx) initCaptureCtx();
+      var stream = new MediaStream([track]);
+      var source = captureCtx.createMediaStreamSource(stream);
+      origConnect.call(source, captureProcessor);
+      rtcTrackedStreams.push(source);
+    } catch(e) {}
+  }
+
+  function tapExistingPeerConnection(pc) {
+    try {
+      var receivers = pc.getReceivers ? pc.getReceivers() : [];
+      for (var i = 0; i < receivers.length; i++) {
+        if (receivers[i].track && receivers[i].track.kind === 'audio') {
+          tapAudioTrack(receivers[i].track);
+        }
+      }
+    } catch(e) {}
+  }
+
+  if (typeof RTCPeerConnection !== 'undefined') {
+    var OrigRTC = RTCPeerConnection;
+
+    window.RTCPeerConnection = function() {
+      var pc = new (Function.prototype.bind.apply(OrigRTC, [null].concat(Array.prototype.slice.call(arguments))))();
+      rtcPeerConnections.push(pc);
+
+      pc.addEventListener('track', function(event) {
+        if (event.track && event.track.kind === 'audio') {
+          if (capturing) {
+            tapAudioTrack(event.track);
+          } else {
+            pendingTracks.push(event.track);
+          }
+        }
+      });
+
+      return pc;
+    };
+    window.RTCPeerConnection.prototype = OrigRTC.prototype;
+    Object.keys(OrigRTC).forEach(function(k) {
+      try { window.RTCPeerConnection[k] = OrigRTC[k]; } catch(e) {}
+    });
+
+    window.__bpTrackedPCs = rtcPeerConnections;
+  }
+
+  window.__bpAudioOutput = {
+    start: function() {
+      capturing = true;
+      capturedChunks = [];
+      totalSamples = 0;
+      flushCount = 0;
+      tappedTrackIds = {};
+
+      // Resume any suspended capture context
+      if (captureCtx && captureCtx.state === 'suspended') captureCtx.resume();
+
+      // Create taps for all tracked AudioContexts (catches contexts created before capture)
+      for (var i = 0; i < allAudioContexts.length; i++) {
+        var ctx = allAudioContexts[i];
+        if (ctx.state !== 'closed') {
+          getOrCreateTap(ctx);
+        }
+      }
+
+      // Drain pending WebRTC tracks
+      for (var j = 0; j < pendingTracks.length; j++) {
+        tapAudioTrack(pendingTracks[j]);
+      }
+      pendingTracks = [];
+
+      // Tap existing peer connections
+      for (var k = 0; k < rtcPeerConnections.length; k++) {
+        tapExistingPeerConnection(rtcPeerConnections[k]);
+      }
+
+      // Scan existing media elements for srcObject with audio tracks
+      var mediaEls = document.querySelectorAll('audio, video');
+      for (var i = 0; i < mediaEls.length; i++) {
+        var el = mediaEls[i];
+        if (el.srcObject && el.srcObject.getAudioTracks && !el.__bpCaptured) {
+          el.__bpCaptured = true;
+          var tracks = el.srcObject.getAudioTracks();
+          for (var j = 0; j < tracks.length; j++) {
+            tapAudioTrack(tracks[j]);
+          }
+        }
+      }
+
+      // Watch for dynamically added media elements with srcObject
+      if (typeof MutationObserver !== 'undefined') {
+        if (window.__bpMediaObserver) {
+          window.__bpMediaObserver.disconnect();
+        }
+        window.__bpMediaObserver = new MutationObserver(function(mutations) {
+          for (var i = 0; i < mutations.length; i++) {
+            var added = mutations[i].addedNodes;
+            for (var j = 0; j < added.length; j++) {
+              var node = added[j];
+              if (node.nodeType !== 1) continue;
+              var els = [];
+              if (node.tagName === 'AUDIO' || node.tagName === 'VIDEO') els.push(node);
+              else if (node.querySelectorAll) {
+                var nested = node.querySelectorAll('audio, video');
+                for (var k = 0; k < nested.length; k++) els.push(nested[k]);
+              }
+              for (var m = 0; m < els.length; m++) {
+                var el = els[m];
+                if (el.srcObject && el.srcObject.getAudioTracks && !el.__bpCaptured) {
+                  el.__bpCaptured = true;
+                  var tracks = el.srcObject.getAudioTracks();
+                  for (var t = 0; t < tracks.length; t++) tapAudioTrack(tracks[t]);
+                }
+              }
+            }
+          }
+        });
+        window.__bpMediaObserver.observe(document, { childList: true, subtree: true });
+      }
+    },
+    stop: function() {
+      capturing = false;
+      flushToNodeJs();
+      // Disconnect MutationObserver
+      if (window.__bpMediaObserver) {
+        window.__bpMediaObserver.disconnect();
+        window.__bpMediaObserver = null;
+      }
+    },
+    isCapturing: function() { return capturing; },
+    getBufferedSamples: function() { return totalSamples; },
+    tapPC: function(pc) {
+      if (!pc || typeof pc.getReceivers !== 'function') return false;
+      if (rtcPeerConnections.indexOf(pc) === -1) {
+        rtcPeerConnections.push(pc);
+      }
+      if (capturing) {
+        tapExistingPeerConnection(pc);
+      }
+      pc.addEventListener('track', function(event) {
+        if (event.track && event.track.kind === 'audio') {
+          if (capturing) {
+            tapAudioTrack(event.track);
+          } else {
+            pendingTracks.push(event.track);
+          }
+        }
+      });
+      return true;
+    },
+    getStats: function() {
+      return {
+        audioContexts: allAudioContexts.filter(function(c) { return c.state !== 'closed'; }).length,
+        contextTaps: tapCount(),
+        audioNodes: captureCtx ? captureCtx.destination.numberOfInputs : 0,
+        rtcConnections: rtcPeerConnections.length,
+        mediaElements: document.querySelectorAll('audio, video').length,
+        pendingTracks: pendingTracks.length,
+        tappedTracks: Object.keys(tappedTrackIds).length,
+        capturing: capturing,
+        bufferedSamples: totalSamples,
+        rtcDetails: rtcPeerConnections.map(function(pc) {
+          try {
+            var receivers = pc.getReceivers ? pc.getReceivers() : [];
+            var senders = pc.getSenders ? pc.getSenders() : [];
+            var audioReceivers = receivers.filter(function(r) { return r.track && r.track.kind === 'audio'; }).length;
+            var audioSenders = senders.filter(function(s) { return s.track && s.track.kind === 'audio'; }).length;
+            return {
+              state: pc.connectionState || pc.iceConnectionState || 'unknown',
+              audioReceivers: audioReceivers,
+              audioSenders: audioSenders,
+              tapped: receivers.some(function(r) { return r.track && tappedTrackIds[r.track.id]; })
+            };
+          } catch(e) { return { state: 'error', audioReceivers: 0, audioSenders: 0, tapped: false }; }
+        }),
+        mediaElementDetails: (function() {
+          try {
+            var els = document.querySelectorAll('audio, video');
+            var details = [];
+            for (var i = 0; i < els.length; i++) {
+              var el = els[i];
+              var hasSrcObject = !!(el.srcObject);
+              var audioTracks = 0;
+              if (el.srcObject && el.srcObject.getAudioTracks) {
+                audioTracks = el.srcObject.getAudioTracks().length;
+              }
+              details.push({
+                tag: el.tagName.toLowerCase(),
+                hasSrcObject: hasSrcObject,
+                hasSrc: !!(el.src || el.currentSrc),
+                audioTracks: audioTracks,
+                tapped: !!(el.__bpCaptured)
+              });
+            }
+            return details;
+          } catch(e) { return []; }
+        })()
+      };
+    }
+  };
+})();
+`;
+var AudioOutput = class {
+  cdp;
+  chunks = [];
+  injected = false;
+  capturing = false;
+  bindingHandler = null;
+  onChunkHandler;
+  onDiagHandler;
+  /** Timestamp of the first non-silent chunk received */
+  firstChunkTime = null;
+  constructor(cdp) {
+    this.cdp = cdp;
+  }
+  /** Whether the audio output system has been set up */
+  get isSetup() {
+    return this.injected;
+  }
+  /** Whether audio is currently being captured */
+  get isCapturing() {
+    return this.capturing;
+  }
+  /**
+   * Set up audio output capture.
+   * Registers bindings and injects the capture script.
+   */
+  async setup() {
+    if (this.injected) return;
+    await this.cdp.send("Runtime.addBinding", { name: OUTPUT_BINDING });
+    this.bindingHandler = (params) => {
+      if (params["name"] === OUTPUT_BINDING) {
+        this.handleAudioData(params["payload"]);
+      }
+    };
+    this.cdp.on("Runtime.bindingCalled", this.bindingHandler);
+    await this.cdp.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: AUDIO_OUTPUT_SCRIPT
+    });
+    await this.cdp.send("Runtime.evaluate", {
+      expression: AUDIO_OUTPUT_SCRIPT,
+      awaitPromise: false,
+      userGesture: true
+    });
+    this.injected = true;
+  }
+  /**
+   * Start capturing audio output.
+   */
+  async start() {
+    if (!this.injected) {
+      await this.setup();
+    }
+    this.chunks = [];
+    this.firstChunkTime = null;
+    this.capturing = true;
+    await this.cdp.send("Runtime.evaluate", {
+      expression: `(function() {
+        var resumed = [];
+        (window.__bpTrackedAudioContexts || []).forEach(function(ctx) {
+          if (ctx.state === 'suspended') {
+            ctx.resume().then(function() {
+              console.log('[bp:output] Resumed AudioContext (' + ctx.sampleRate + 'Hz) before capture');
+            });
+            resumed.push(ctx.sampleRate);
+          }
+        });
+        if (window.__bpAudioInput && window.__bpAudioInput.getContext) {
+          var inputCtx = window.__bpAudioInput.getContext();
+          if (inputCtx && inputCtx.state === 'suspended') {
+            inputCtx.resume();
+            resumed.push('input-' + inputCtx.sampleRate);
+          }
+        }
+        if (resumed.length) console.log('[bp:output] Resumed ' + resumed.length + ' contexts: ' + resumed.join(', '));
+      })()`,
+      awaitPromise: false,
+      userGesture: true
+    });
+    await this.cdp.send("Runtime.evaluate", {
+      expression: "window.__bpAudioOutput && window.__bpAudioOutput.start()",
+      awaitPromise: false
+    });
+    await this.discoverExistingPeerConnections();
+    if (this.onDiagHandler) {
+      try {
+        const statsResult = await this.cdp.send(
+          "Runtime.evaluate",
+          {
+            expression: "window.__bpAudioOutput && window.__bpAudioOutput.getStats()",
+            returnByValue: true
+          }
+        );
+        const stats = statsResult.result.value;
+        if (stats) {
+          this.onDiagHandler(
+            `started \u2014 ${stats["audioContexts"]} AudioContexts, ${stats["contextTaps"]} taps, ${stats["rtcConnections"]} RTCPeerConnections, ${stats["mediaElements"]} MediaElements, ${stats["tappedTracks"]} tapped tracks`
+          );
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Stop capturing and return all collected audio.
+   */
+  async stop() {
+    if (!this.injected) {
+      return emptyCaptureResult();
+    }
+    await this.cdp.send("Runtime.evaluate", {
+      expression: "window.__bpAudioOutput && window.__bpAudioOutput.stop()",
+      awaitPromise: false
+    });
+    this.capturing = false;
+    await sleep(250);
+    return this.mergeChunks();
+  }
+  /**
+   * Capture audio until silence is detected.
+   *
+   * Two-phase approach:
+   * 1. **Wait phase**: Wait up to `maxDuration` for the first non-silent chunk.
+   *    The silence countdown does NOT tick during this phase, so slow voice agents
+   *    (STT → LLM → TTS can take 5-15s) don't cause premature timeout.
+   * 2. **Capture phase**: Once audio is detected, capture until `silenceTimeout` ms
+   *    of consecutive silence pass, then stop.
+   */
+  async captureUntilSilence(options) {
+    const silenceTimeout = options?.silenceTimeout ?? 1500;
+    const silenceThreshold = options?.silenceThreshold ?? 0.01;
+    const maxDuration = options?.maxDuration ?? 3e5;
+    const noAudioTimeout = options?.noAudioTimeout ?? 15e3;
+    if (!this.capturing) {
+      await this.start();
+    }
+    return new Promise((resolve) => {
+      let heardAudio = false;
+      let lastSoundTime = 0;
+      const startTime = Date.now();
+      const checkInterval = setInterval(async () => {
+        const elapsed = Date.now() - startTime;
+        if (elapsed > maxDuration) {
+          clearInterval(checkInterval);
+          this.onDiagHandler?.(`max duration reached (${maxDuration}ms), stopping`);
+          resolve(await this.stop());
+          return;
+        }
+        const latest = this.chunks[this.chunks.length - 1];
+        if (latest) {
+          const rms = calculateRMS(latest.left);
+          if (rms > silenceThreshold) {
+            if (!heardAudio) {
+              heardAudio = true;
+              this.onDiagHandler?.("first audio detected \u2014 silence countdown begins");
+            }
+            lastSoundTime = Date.now();
+          }
+        }
+        if (!heardAudio && elapsed > noAudioTimeout) {
+          clearInterval(checkInterval);
+          this.onDiagHandler?.(`no audio detected after ${noAudioTimeout}ms, stopping early`);
+          resolve(await this.stop());
+          return;
+        }
+        if (heardAudio && Date.now() - lastSoundTime > silenceTimeout) {
+          clearInterval(checkInterval);
+          resolve(await this.stop());
+        }
+      }, 200);
+    });
+  }
+  /**
+   * Subscribe to real-time audio chunks as they arrive.
+   */
+  onData(handler) {
+    this.onChunkHandler = handler;
+  }
+  /**
+   * Subscribe to diagnostic messages (for --verbose).
+   */
+  onDiag(handler) {
+    this.onDiagHandler = handler;
+  }
+  /**
+   * Clean up: remove binding handler.
+   */
+  async teardown() {
+    if (this.capturing) {
+      await this.stop();
+    }
+    if (this.bindingHandler) {
+      this.cdp.off("Runtime.bindingCalled", this.bindingHandler);
+      this.bindingHandler = null;
+    }
+    this.onChunkHandler = void 0;
+    this.onDiagHandler = void 0;
+    this.injected = false;
+  }
+  /**
+   * Use CDP Runtime.queryObjects to find RTCPeerConnection instances
+   * that were created before our override was injected, and tap their audio tracks.
+   */
+  async discoverExistingPeerConnections() {
+    try {
+      const protoResult = await this.cdp.send("Runtime.evaluate", {
+        expression: 'typeof RTCPeerConnection !== "undefined" ? RTCPeerConnection.prototype : null',
+        returnByValue: false
+      });
+      const protoId = protoResult.result.objectId;
+      if (!protoId) return;
+      const queryResult = await this.cdp.send("Runtime.queryObjects", {
+        prototypeObjectId: protoId
+      });
+      const arrayId = queryResult.objects.objectId;
+      if (!arrayId) return;
+      const propsResult = await this.cdp.send("Runtime.getProperties", {
+        objectId: arrayId,
+        ownProperties: true
+      });
+      let tapped = 0;
+      for (const prop of propsResult.result) {
+        if (prop.name === "length" || prop.name === "__proto__") continue;
+        const pcObjectId = prop.value?.objectId;
+        if (!pcObjectId) continue;
+        await this.cdp.send("Runtime.callFunctionOn", {
+          objectId: pcObjectId,
+          functionDeclaration: "function() { if (window.__bpAudioOutput && window.__bpAudioOutput.tapPC) { return window.__bpAudioOutput.tapPC(this); } return false; }",
+          returnByValue: true
+        });
+        tapped++;
+      }
+      if (tapped > 0) {
+        this.onDiagHandler?.(`retroactively discovered ${tapped} existing RTCPeerConnection(s)`);
+      }
+      await this.cdp.send("Runtime.releaseObject", { objectId: arrayId });
+      await this.cdp.send("Runtime.releaseObject", { objectId: protoId });
+    } catch {
+    }
+  }
+  handleAudioData(payload) {
+    try {
+      const data = JSON.parse(payload);
+      const leftBytes = base64ToBuffer(data.left);
+      const rightBytes = base64ToBuffer(data.right);
+      const chunk = {
+        left: new Float32Array(leftBytes.buffer),
+        right: new Float32Array(rightBytes.buffer),
+        sampleRate: data.sampleRate,
+        samples: data.samples,
+        timestamp: Date.now()
+      };
+      this.chunks.push(chunk);
+      if (this.onDiagHandler) {
+        const rms = calculateRMS(chunk.left);
+        const label = rms > 0.01 ? "audio" : "silence";
+        this.onDiagHandler(`chunk: ${chunk.samples} samples, RMS=${rms.toFixed(4)} (${label})`);
+      }
+      if (this.firstChunkTime === null) {
+        const rms = calculateRMS(chunk.left);
+        if (rms > 1e-3) {
+          this.firstChunkTime = Date.now();
+        }
+      }
+      this.onChunkHandler?.(chunk);
+    } catch {
+    }
+  }
+  mergeChunks() {
+    if (this.chunks.length === 0) {
+      return emptyCaptureResult();
+    }
+    const byRate = /* @__PURE__ */ new Map();
+    for (const chunk of this.chunks) {
+      const rate = chunk.sampleRate;
+      if (!byRate.has(rate)) byRate.set(rate, []);
+      byRate.get(rate).push(chunk);
+    }
+    let bestRate = this.chunks[0].sampleRate;
+    let bestNonSilentSamples = 0;
+    for (const [rate, chunks] of byRate) {
+      let nonSilentSamples = 0;
+      for (const chunk of chunks) {
+        const rms = calculateRMS(chunk.left);
+        if (rms > 0.01) {
+          nonSilentSamples += chunk.left.length;
+        }
+      }
+      if (nonSilentSamples > bestNonSilentSamples) {
+        bestNonSilentSamples = nonSilentSamples;
+        bestRate = rate;
+      }
+    }
+    const bestChunks = byRate.get(bestRate);
+    let totalLen = 0;
+    for (const chunk of bestChunks) {
+      totalLen += chunk.left.length;
+    }
+    const left = new Float32Array(totalLen);
+    const right = new Float32Array(totalLen);
+    let offset = 0;
+    for (const chunk of bestChunks) {
+      left.set(chunk.left, offset);
+      right.set(chunk.right, offset);
+      offset += chunk.left.length;
+    }
+    if (byRate.size > 1) {
+      this.onDiagHandler?.(
+        `mergeChunks: ${byRate.size} sample rates detected, using ${bestRate}Hz (${bestNonSilentSamples} non-silent samples)`
+      );
+    }
+    return {
+      left,
+      right,
+      sampleRate: bestRate,
+      durationMs: totalLen / bestRate * 1e3,
+      chunkCount: bestChunks.length
+    };
+  }
+};
+function emptyCaptureResult() {
+  return {
+    left: new Float32Array(0),
+    right: new Float32Array(0),
+    sampleRate: 48e3,
+    durationMs: 0,
+    chunkCount: 0
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 // src/network/interceptor.ts
 var RequestInterceptor = class {
@@ -260,7 +1565,7 @@ async function isElementAttached(cdp, selector, contextId) {
   const result = await cdp.send("Runtime.evaluate", params);
   return result.result.value === true;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function waitForElement(cdp, selector, options = {}) {
@@ -286,7 +1591,7 @@ async function waitForElement(cdp, selector, options = {}) {
     if (conditionMet) {
       return { success: true, waitedMs: Date.now() - startTime };
     }
-    await sleep(pollInterval);
+    await sleep2(pollInterval);
   }
   return { success: false, waitedMs: Date.now() - startTime };
 }
@@ -315,7 +1620,7 @@ async function waitForAnyElement(cdp, selectors, options = {}) {
         return { success: true, selector, waitedMs: Date.now() - startTime };
       }
     }
-    await sleep(pollInterval);
+    await sleep2(pollInterval);
   }
   return { success: false, waitedMs: Date.now() - startTime };
 }
@@ -364,7 +1669,7 @@ async function waitForNavigation(cdp, options = {}) {
     }
     const pollUrl = async () => {
       while (!resolved && Date.now() < startTime + timeout) {
-        await sleep(100);
+        await sleep2(100);
         if (resolved) return;
         try {
           const currentUrl = await getCurrentUrl(cdp);
@@ -694,6 +1999,10 @@ var Page = class {
   currentFrameContextId = null;
   /** Last matched selector from findElement (for selectorUsed tracking) */
   _lastMatchedSelector;
+  /** Audio input controller (lazy-initialized) */
+  _audioInput;
+  /** Audio output controller (lazy-initialized) */
+  _audioOutput;
   constructor(cdp, targetId) {
     this.cdp = cdp;
     this._targetId = targetId;
@@ -941,7 +2250,7 @@ var Page = class {
         key: char
       });
       if (delay > 0) {
-        await sleep2(delay);
+        await sleep3(delay);
       }
     }
     return true;
@@ -982,7 +2291,7 @@ var Page = class {
   async selectCustom(config, options = {}) {
     const { trigger, option, value, match = "text" } = config;
     await this.click(trigger, options);
-    await sleep2(100);
+    await sleep3(100);
     let optionSelector;
     const optionSelectors = Array.isArray(option) ? option : [option];
     if (match === "contains") {
@@ -1094,7 +2403,7 @@ var Page = class {
       if (shouldWait === true) {
         await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT });
       } else if (shouldWait === "auto") {
-        await Promise.race([this.waitForNavigation({ timeout: 1e3, optional: true }), sleep2(500)]);
+        await Promise.race([this.waitForNavigation({ timeout: 1e3, optional: true }), sleep3(500)]);
       }
       return true;
     }
@@ -1112,7 +2421,7 @@ var Page = class {
           this.waitForNavigation({ timeout: 1e3, optional: true }).then(
             (success) => success ? "nav" : null
           ),
-          sleep2(500).then(() => "timeout")
+          sleep3(500).then(() => "timeout")
         ]);
         if (navigationDetected === "nav") {
           return true;
@@ -1126,7 +2435,7 @@ var Page = class {
       if (shouldWait === true) {
         await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT });
       } else if (shouldWait === "auto") {
-        await sleep2(100);
+        await sleep3(100);
       }
     }
     return true;
@@ -2123,7 +3432,7 @@ var Page = class {
           lastError = e;
           if (attempt < retries) {
             this.rootNodeId = null;
-            await sleep2(delay);
+            await sleep3(delay);
             continue;
           }
         }
@@ -2295,8 +3604,107 @@ var Page = class {
       clickCount: 1
     });
   }
+  // ============ Audio I/O ============
+  /**
+   * Audio input controller (fake microphone).
+   * Lazy-initialized on first access.
+   */
+  get audioInput() {
+    if (!this._audioInput) {
+      this._audioInput = new AudioInput(this.cdp);
+    }
+    return this._audioInput;
+  }
+  /**
+   * Audio output capture controller.
+   * Lazy-initialized on first access.
+   */
+  get audioOutput() {
+    if (!this._audioOutput) {
+      this._audioOutput = new AudioOutput(this.cdp);
+    }
+    return this._audioOutput;
+  }
+  /**
+   * Set up both audio input (fake microphone) and output (capture).
+   * Must be called before navigating to the page that will use audio.
+   */
+  async setupAudio() {
+    try {
+      await this.cdp.send("Input.dispatchMouseEvent", {
+        type: "mousePressed",
+        x: 0,
+        y: 0,
+        button: "left",
+        clickCount: 1
+      });
+      await this.cdp.send("Input.dispatchMouseEvent", {
+        type: "mouseReleased",
+        x: 0,
+        y: 0,
+        button: "left",
+        clickCount: 1
+      });
+    } catch {
+    }
+    await this.audioInput.setup();
+    await this.audioOutput.setup();
+  }
+  /**
+   * Full audio round-trip: feed input audio, capture the response.
+   *
+   * 1. Starts capturing output
+   * 2. Feeds input audio as microphone data
+   * 3. Waits for the page to respond and then go silent
+   * 4. Returns the captured response audio with latency metrics
+   *
+   * @example
+   * ```typescript
+   * await page.setupAudio();
+   * await page.goto('https://voice-agent.example.com');
+   * const result = await page.audioRoundTrip({
+   *   input: wavFileBytes,
+   *   silenceTimeout: 3000,
+   * });
+   * console.log(`Response: ${result.audio.durationMs}ms, latency: ${result.latencyMs}ms`);
+   * ```
+   */
+  async audioRoundTrip(options) {
+    if (!this.audioInput.isSetup || !this.audioOutput.isSetup) {
+      await this.setupAudio();
+    }
+    const start = Date.now();
+    await this.audioOutput.start();
+    if (options.preDelay && options.preDelay > 0) {
+      await sleep3(options.preDelay);
+    }
+    const inputDone = this.audioInput.play(options.input, {
+      waitForEnd: !!options.sendSelector
+    });
+    if (options.sendSelector) {
+      await inputDone.catch(() => {
+      });
+      await this.click(options.sendSelector);
+    }
+    const audio = await this.audioOutput.captureUntilSilence({
+      silenceTimeout: options.silenceTimeout ?? 1500,
+      silenceThreshold: options.silenceThreshold ?? 0.01,
+      maxDuration: options.timeout ?? 12e4
+    });
+    await this.audioInput.stop();
+    if (!options.sendSelector) {
+      await inputDone.catch(() => {
+      });
+    }
+    const firstChunkTime = this.audioOutput.firstChunkTime;
+    return {
+      audio,
+      latencyMs: firstChunkTime !== null ? firstChunkTime - start : -1,
+      totalMs: Date.now() - start
+    };
+  }
 };
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -2436,13 +3844,20 @@ function connect(options) {
 }
 
 export {
+  bufferToBase64,
+  calculateRMS,
+  pcmToWav,
+  parseWavHeader,
+  generateSilence,
+  generateTone,
+  grantAudioPermissions,
+  AudioInput,
+  AudioOutput,
   RequestInterceptor,
-  DEEP_QUERY_SCRIPT,
   waitForElement,
   waitForAnyElement,
   waitForNavigation,
   waitForNetworkIdle,
-  fuzzyMatchElements,
   Page,
   Browser,
   connect