browser-pilot 0.0.7 → 0.0.9

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

@@ -5,8 +5,1315 @@ import {
   createProvider
 } from "./chunk-R3PS4PCM.mjs";
 import {
-  BatchExecutor
-} from "./chunk-6RB3GKQP.mjs";
+  BatchExecutor,
+  ElementNotFoundError,
+  TimeoutError
+} 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 {
@@ -258,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 = {}) {
@@ -284,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 };
 }
@@ -313,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 };
 }
@@ -362,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);
@@ -422,33 +1729,256 @@ async function waitForNetworkIdle(cdp, options = {}) {
   });
 }
 
-// src/browser/types.ts
-var ElementNotFoundError = class extends Error {
-  selectors;
-  constructor(selectors) {
-    const selectorList = Array.isArray(selectors) ? selectors : [selectors];
-    super(`Element not found: ${selectorList.join(", ")}`);
-    this.name = "ElementNotFoundError";
-    this.selectors = selectorList;
+// src/browser/fuzzy-match.ts
+function jaroWinkler(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0 || b.length === 0) return 0;
+  if (a === b) return 1;
+  const s1 = a.toLowerCase();
+  const s2 = b.toLowerCase();
+  const matchWindow = Math.max(0, Math.floor(Math.max(s1.length, s2.length) / 2) - 1);
+  const s1Matches = new Array(s1.length).fill(false);
+  const s2Matches = new Array(s2.length).fill(false);
+  let matches = 0;
+  let transpositions = 0;
+  for (let i = 0; i < s1.length; i++) {
+    const start = Math.max(0, i - matchWindow);
+    const end = Math.min(i + matchWindow + 1, s2.length);
+    for (let j = start; j < end; j++) {
+      if (s2Matches[j] || s1[i] !== s2[j]) continue;
+      s1Matches[i] = true;
+      s2Matches[j] = true;
+      matches++;
+      break;
+    }
+  }
+  if (matches === 0) return 0;
+  let k = 0;
+  for (let i = 0; i < s1.length; i++) {
+    if (!s1Matches[i]) continue;
+    while (!s2Matches[k]) k++;
+    if (s1[i] !== s2[k]) transpositions++;
+    k++;
+  }
+  const jaro = (matches / s1.length + matches / s2.length + (matches - transpositions / 2) / matches) / 3;
+  let prefix = 0;
+  for (let i = 0; i < Math.min(4, Math.min(s1.length, s2.length)); i++) {
+    if (s1[i] === s2[i]) {
+      prefix++;
+    } else {
+      break;
+    }
   }
-};
-var TimeoutError = class extends Error {
-  constructor(message = "Operation timed out") {
-    super(message);
-    this.name = "TimeoutError";
+  const WINKLER_SCALING = 0.1;
+  return jaro + prefix * WINKLER_SCALING * (1 - jaro);
+}
+function stringSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const lowerA = a.toLowerCase();
+  const lowerB = b.toLowerCase();
+  if (lowerA === lowerB) return 1;
+  const jw = jaroWinkler(a, b);
+  let containsBonus = 0;
+  if (lowerB.includes(lowerA)) {
+    containsBonus = 0.2;
+  } else if (lowerA.includes(lowerB)) {
+    containsBonus = 0.1;
+  }
+  return Math.min(1, jw + containsBonus);
+}
+function scoreElement(query, element) {
+  const lowerQuery = query.toLowerCase();
+  const words = lowerQuery.split(/\s+/).filter((w) => w.length > 0);
+  let nameScore = 0;
+  if (element.name) {
+    const lowerName = element.name.toLowerCase();
+    if (lowerName === lowerQuery) {
+      nameScore = 1;
+    } else if (lowerName.includes(lowerQuery)) {
+      nameScore = 0.8;
+    } else if (words.length > 0) {
+      const matchedWords = words.filter((w) => lowerName.includes(w));
+      nameScore = matchedWords.length / words.length * 0.7;
+    } else {
+      nameScore = stringSimilarity(query, element.name) * 0.6;
+    }
   }
-};
-var NavigationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NavigationError";
+  let roleScore = 0;
+  const lowerRole = element.role.toLowerCase();
+  if (lowerRole === lowerQuery || lowerQuery.includes(lowerRole)) {
+    roleScore = 0.3;
+  } else if (words.some((w) => lowerRole.includes(w))) {
+    roleScore = 0.2;
   }
+  let selectorScore = 0;
+  const lowerSelector = element.selector.toLowerCase();
+  if (words.some((w) => lowerSelector.includes(w))) {
+    selectorScore = 0.2;
+  }
+  const totalScore = nameScore * 0.6 + roleScore * 0.25 + selectorScore * 0.15;
+  return totalScore;
+}
+function explainMatch(query, element, score) {
+  const reasons = [];
+  const lowerQuery = query.toLowerCase();
+  const words = lowerQuery.split(/\s+/).filter((w) => w.length > 0);
+  if (element.name) {
+    const lowerName = element.name.toLowerCase();
+    if (lowerName === lowerQuery) {
+      reasons.push("exact name match");
+    } else if (lowerName.includes(lowerQuery)) {
+      reasons.push("name contains query");
+    } else if (words.some((w) => lowerName.includes(w))) {
+      const matchedWords = words.filter((w) => lowerName.includes(w));
+      reasons.push(`name contains: ${matchedWords.join(", ")}`);
+    } else if (stringSimilarity(query, element.name) > 0.5) {
+      reasons.push("similar name");
+    }
+  }
+  const lowerRole = element.role.toLowerCase();
+  if (lowerRole === lowerQuery || words.some((w) => w === lowerRole)) {
+    reasons.push(`role: ${element.role}`);
+  }
+  if (words.some((w) => element.selector.toLowerCase().includes(w))) {
+    reasons.push("selector match");
+  }
+  if (reasons.length === 0) {
+    reasons.push(`fuzzy match (score: ${score.toFixed(2)})`);
+  }
+  return reasons.join(", ");
+}
+function fuzzyMatchElements(query, elements, maxResults = 5) {
+  if (!query || query.length === 0) {
+    return [];
+  }
+  const THRESHOLD = 0.3;
+  const scored = elements.map((element) => ({
+    element,
+    score: scoreElement(query, element)
+  }));
+  return scored.filter((s) => s.score >= THRESHOLD).sort((a, b) => b.score - a.score).slice(0, maxResults).map((s) => ({
+    element: s.element,
+    score: s.score,
+    matchReason: explainMatch(query, s.element, s.score)
+  }));
+}
+
+// src/browser/hint-generator.ts
+var ACTION_ROLE_MAP = {
+  click: ["button", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "tab", "option"],
+  fill: ["textbox", "searchbox", "textarea"],
+  type: ["textbox", "searchbox", "textarea"],
+  submit: ["button", "form"],
+  select: ["combobox", "listbox", "option"],
+  check: ["checkbox", "radio", "switch"],
+  uncheck: ["checkbox", "switch"],
+  focus: [],
+  // Any focusable element
+  hover: [],
+  // Any element
+  clear: ["textbox", "searchbox", "textarea"]
 };
+function extractIntent(selectors) {
+  const patterns = [];
+  let text = "";
+  for (const selector of selectors) {
+    if (selector.startsWith("ref:")) {
+      continue;
+    }
+    const idMatch = selector.match(/#([a-zA-Z0-9_-]+)/);
+    if (idMatch) {
+      patterns.push(idMatch[1]);
+    }
+    const ariaMatch = selector.match(/\[aria-label=["']([^"']+)["']\]/);
+    if (ariaMatch) {
+      patterns.push(ariaMatch[1]);
+    }
+    const testidMatch = selector.match(/\[data-testid=["']([^"']+)["']\]/);
+    if (testidMatch) {
+      patterns.push(testidMatch[1]);
+    }
+    const classMatch = selector.match(/\.([a-zA-Z0-9_-]+)/);
+    if (classMatch) {
+      patterns.push(classMatch[1]);
+    }
+  }
+  patterns.sort((a, b) => b.length - a.length);
+  text = patterns[0] ?? selectors[0] ?? "";
+  return { text, patterns };
+}
+function getHintType(selector) {
+  if (selector.startsWith("ref:")) return "ref";
+  if (selector.includes("data-testid")) return "testid";
+  if (selector.includes("aria-label")) return "aria";
+  if (selector.startsWith("#")) return "id";
+  return "css";
+}
+function getConfidence(score) {
+  if (score >= 0.8) return "high";
+  if (score >= 0.5) return "medium";
+  return "low";
+}
+function diversifyHints(candidates, maxHints) {
+  const hints = [];
+  const usedTypes = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (hints.length >= maxHints) break;
+    const refSelector = `ref:${candidate.element.ref}`;
+    const hintType = getHintType(refSelector);
+    if (!usedTypes.has(hintType)) {
+      hints.push({
+        selector: refSelector,
+        reason: candidate.matchReason,
+        confidence: getConfidence(candidate.score),
+        element: {
+          ref: candidate.element.ref,
+          role: candidate.element.role,
+          name: candidate.element.name,
+          disabled: candidate.element.disabled
+        }
+      });
+      usedTypes.add(hintType);
+    } else if (hints.length < maxHints) {
+      hints.push({
+        selector: refSelector,
+        reason: candidate.matchReason,
+        confidence: getConfidence(candidate.score),
+        element: {
+          ref: candidate.element.ref,
+          role: candidate.element.role,
+          name: candidate.element.name,
+          disabled: candidate.element.disabled
+        }
+      });
+    }
+  }
+  return hints;
+}
+async function generateHints(page, failedSelectors, actionType, maxHints = 3) {
+  let snapshot;
+  try {
+    snapshot = await page.snapshot();
+  } catch {
+    return [];
+  }
+  const intent = extractIntent(failedSelectors);
+  const roleFilter = ACTION_ROLE_MAP[actionType] ?? [];
+  let candidates = snapshot.interactiveElements;
+  if (roleFilter.length > 0) {
+    candidates = candidates.filter((el) => roleFilter.includes(el.role));
+  }
+  const matches = fuzzyMatchElements(intent.text, candidates, maxHints * 2);
+  if (matches.length === 0) {
+    return [];
+  }
+  return diversifyHints(matches, maxHints);
+}
 
 // src/browser/page.ts
 var DEFAULT_TIMEOUT = 3e4;
 var Page = class {
   cdp;
+  _targetId;
   rootNodeId = null;
   batchExecutor;
   emulationState = {};
@@ -467,10 +1997,23 @@ var Page = class {
   frameExecutionContexts = /* @__PURE__ */ new Map();
   /** Current frame's execution context ID (null = main frame default) */
   currentFrameContextId = null;
-  constructor(cdp) {
+  /** 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;
     this.batchExecutor = new BatchExecutor(this);
   }
+  /**
+   * Get the CDP target ID for this page
+   */
+  get targetId() {
+    return this._targetId;
+  }
   /**
    * Get the underlying CDP client for advanced operations.
    * Use with caution - prefer high-level Page methods when possible.
@@ -478,6 +2021,13 @@ var Page = class {
   get cdpClient() {
     return this.cdp;
   }
+  /**
+   * Get the last matched selector from findElement (for selectorUsed tracking).
+   * Returns undefined if no selector has been matched yet.
+   */
+  getLastMatchedSelector() {
+    return this._lastMatchedSelector;
+  }
   /**
    * Initialize the page (enable required CDP domains)
    */
@@ -597,7 +2147,9 @@ var Page = class {
       const element = await this.findElement(selector, options);
       if (!element) {
         if (options.optional) return false;
-        throw new ElementNotFoundError(selector);
+        const selectorList = Array.isArray(selector) ? selector : [selector];
+        const hints = await generateHints(this, selectorList, "click");
+        throw new ElementNotFoundError(selector, hints);
       }
       await this.scrollIntoView(element.nodeId);
       const submitResult = await this.evaluateInFrame(
@@ -633,7 +2185,9 @@ var Page = class {
       const element = await this.findElement(selector, options);
       if (!element) {
         if (options.optional) return false;
-        throw new ElementNotFoundError(selector);
+        const selectorList = Array.isArray(selector) ? selector : [selector];
+        const hints = await generateHints(this, selectorList, "fill");
+        throw new ElementNotFoundError(selector, hints);
       }
       await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
       if (clear) {
@@ -696,7 +2250,7 @@ var Page = class {
         key: char
       });
       if (delay > 0) {
-        await sleep2(delay);
+        await sleep3(delay);
       }
     }
     return true;
@@ -711,7 +2265,9 @@ var Page = class {
     const element = await this.findElement(selector, options);
     if (!element) {
       if (options.optional) return false;
-      throw new ElementNotFoundError(selector);
+      const selectorList = Array.isArray(selector) ? selector : [selector];
+      const hints = await generateHints(this, selectorList, "select");
+      throw new ElementNotFoundError(selector, hints);
     }
     const values = Array.isArray(value) ? value : [value];
     await this.cdp.send("Runtime.evaluate", {
@@ -735,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") {
@@ -772,7 +2328,9 @@ var Page = class {
     const element = await this.findElement(selector, options);
     if (!element) {
       if (options.optional) return false;
-      throw new ElementNotFoundError(selector);
+      const selectorList = Array.isArray(selector) ? selector : [selector];
+      const hints = await generateHints(this, selectorList, "check");
+      throw new ElementNotFoundError(selector, hints);
     }
     const result = await this.cdp.send("Runtime.evaluate", {
       expression: `(() => {
@@ -792,7 +2350,9 @@ var Page = class {
     const element = await this.findElement(selector, options);
     if (!element) {
       if (options.optional) return false;
-      throw new ElementNotFoundError(selector);
+      const selectorList = Array.isArray(selector) ? selector : [selector];
+      const hints = await generateHints(this, selectorList, "uncheck");
+      throw new ElementNotFoundError(selector, hints);
     }
     const result = await this.cdp.send("Runtime.evaluate", {
       expression: `(() => {
@@ -812,13 +2372,40 @@ var Page = class {
    * - 'auto' (default): Attempt to detect navigation for 1 second, then assume client-side handling
    * - true: Wait for full navigation (traditional forms)
    * - false: Return immediately (AJAX forms where you'll wait for something else)
+   *
+   * When targeting a <form> element directly, uses form.requestSubmit() which fires
+   * the submit event and triggers HTML5 validation.
    */
   async submit(selector, options = {}) {
     const { method = "enter+click", waitForNavigation: shouldWait = "auto" } = options;
     const element = await this.findElement(selector, options);
     if (!element) {
       if (options.optional) return false;
-      throw new ElementNotFoundError(selector);
+      const selectorList = Array.isArray(selector) ? selector : [selector];
+      const hints = await generateHints(this, selectorList, "submit");
+      throw new ElementNotFoundError(selector, hints);
+    }
+    const isFormElement = await this.evaluateInFrame(
+      `(() => {
+        const el = document.querySelector(${JSON.stringify(element.selector)});
+        return el instanceof HTMLFormElement;
+      })()`
+    );
+    if (isFormElement.result.value) {
+      await this.evaluateInFrame(
+        `(() => {
+          const form = document.querySelector(${JSON.stringify(element.selector)});
+          if (form && form instanceof HTMLFormElement) {
+            form.requestSubmit();
+          }
+        })()`
+      );
+      if (shouldWait === true) {
+        await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT });
+      } else if (shouldWait === "auto") {
+        await Promise.race([this.waitForNavigation({ timeout: 1e3, optional: true }), sleep3(500)]);
+      }
+      return true;
     }
     await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
     if (method.includes("enter")) {
@@ -834,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;
@@ -848,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;
@@ -889,7 +2476,9 @@ var Page = class {
     const element = await this.findElement(selector, options);
     if (!element) {
       if (options.optional) return false;
-      throw new ElementNotFoundError(selector);
+      const selectorList = Array.isArray(selector) ? selector : [selector];
+      const hints = await generateHints(this, selectorList, "focus");
+      throw new ElementNotFoundError(selector, hints);
     }
     await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
     return true;
@@ -902,7 +2491,9 @@ var Page = class {
       const element = await this.findElement(selector, options);
       if (!element) {
         if (options.optional) return false;
-        throw new ElementNotFoundError(selector);
+        const selectorList = Array.isArray(selector) ? selector : [selector];
+        const hints = await generateHints(this, selectorList, "hover");
+        throw new ElementNotFoundError(selector, hints);
       }
       await this.scrollIntoView(element.nodeId);
       const box = await this.getBoxModel(element.nodeId);
@@ -1841,7 +3432,7 @@ var Page = class {
           lastError = e;
           if (attempt < retries) {
             this.rootNodeId = null;
-            await sleep2(delay);
+            await sleep3(delay);
             continue;
           }
         }
@@ -1857,6 +3448,7 @@ var Page = class {
   async findElement(selectors, options = {}) {
     const { timeout = DEFAULT_TIMEOUT } = options;
     const selectorList = Array.isArray(selectors) ? selectors : [selectors];
+    this._lastMatchedSelector = void 0;
     for (const selector of selectorList) {
       if (selector.startsWith("ref:")) {
         const ref = selector.slice(4);
@@ -1873,6 +3465,7 @@ var Page = class {
             }
           );
           if (pushResult.nodeIds?.[0]) {
+            this._lastMatchedSelector = selector;
             return {
               nodeId: pushResult.nodeIds[0],
               backendNodeId,
@@ -1906,6 +3499,7 @@ var Page = class {
         "DOM.describeNode",
         { nodeId: queryResult.nodeId }
       );
+      this._lastMatchedSelector = result.selector;
       return {
         nodeId: queryResult.nodeId,
         backendNodeId: describeResult2.node.backendNodeId,
@@ -1933,6 +3527,7 @@ var Page = class {
       "DOM.describeNode",
       { nodeId: nodeResult.nodeId }
     );
+    this._lastMatchedSelector = result.selector;
     return {
       nodeId: nodeResult.nodeId,
       backendNodeId: describeResult.node.backendNodeId,
@@ -2009,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));
 }
 
@@ -2039,14 +3733,24 @@ var Browser = class _Browser {
    * Get or create a page by name
    * If no name is provided, returns the first available page or creates a new one
    */
-  async page(name) {
+  async page(name, options) {
     const pageName = name ?? "default";
     const cached = this.pages.get(pageName);
     if (cached) return cached;
     const targets = await this.cdp.send("Target.getTargets");
     const pageTargets = targets.targetInfos.filter((t) => t.type === "page");
     let targetId;
-    if (pageTargets.length > 0) {
+    if (options?.targetId) {
+      const targetExists = pageTargets.some((t) => t.targetId === options.targetId);
+      if (targetExists) {
+        targetId = options.targetId;
+      } else {
+        console.warn(`[browser-pilot] Target ${options.targetId} no longer exists, falling back`);
+        targetId = pageTargets.length > 0 ? pageTargets[0].targetId : (await this.cdp.send("Target.createTarget", {
+          url: "about:blank"
+        })).targetId;
+      }
+    } else if (pageTargets.length > 0) {
       targetId = pageTargets[0].targetId;
     } else {
       const result = await this.cdp.send("Target.createTarget", {
@@ -2055,7 +3759,7 @@ var Browser = class _Browser {
       targetId = result.targetId;
     }
     await this.cdp.attachToTarget(targetId);
-    const page = new Page(this.cdp);
+    const page = new Page(this.cdp, targetId);
     await page.init();
     this.pages.set(pageName, page);
     return page;
@@ -2068,7 +3772,7 @@ var Browser = class _Browser {
       url
     });
     await this.cdp.attachToTarget(result.targetId);
-    const page = new Page(this.cdp);
+    const page = new Page(this.cdp, result.targetId);
     await page.init();
     const name = `page-${this.pages.size + 1}`;
     this.pages.set(name, page);
@@ -2140,14 +3844,20 @@ function connect(options) {
 }
 
 export {
+  bufferToBase64,
+  calculateRMS,
+  pcmToWav,
+  parseWavHeader,
+  generateSilence,
+  generateTone,
+  grantAudioPermissions,
+  AudioInput,
+  AudioOutput,
   RequestInterceptor,
   waitForElement,
   waitForAnyElement,
   waitForNavigation,
   waitForNetworkIdle,
-  ElementNotFoundError,
-  TimeoutError,
-  NavigationError,
   Page,
   Browser,
   connect