browser-pilot 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AudioInput: () => AudioInput,
+  AudioOutput: () => AudioOutput,
   BatchExecutor: () => BatchExecutor,
   Browser: () => Browser,
   BrowserBaseProvider: () => BrowserBaseProvider,
@@ -33,6 +35,8 @@ __export(src_exports, {
   TimeoutError: () => TimeoutError,
   Tracer: () => Tracer,
   addBatchToPage: () => addBatchToPage,
+  bufferToBase64: () => bufferToBase64,
+  calculateRMS: () => calculateRMS,
   connect: () => connect,
   createCDPClient: () => createCDPClient,
   createProvider: () => createProvider,
@@ -40,8 +44,17 @@ __export(src_exports, {
   disableTracing: () => disableTracing,
   discoverTargets: () => discoverTargets,
   enableTracing: () => enableTracing,
+  generateSilence: () => generateSilence,
+  generateTone: () => generateTone,
+  getAudioChromeFlags: () => getAudioChromeFlags,
   getBrowserWebSocketUrl: () => getBrowserWebSocketUrl,
   getTracer: () => getTracer,
+  grantAudioPermissions: () => grantAudioPermissions,
+  isTranscriptionAvailable: () => isTranscriptionAvailable,
+  parseWavHeader: () => parseWavHeader,
+  pcmToWav: () => pcmToWav,
+  transcribe: () => transcribe,
+  validateSteps: () => validateSteps,
   waitForAnyElement: () => waitForAnyElement,
   waitForElement: () => waitForElement,
   waitForNavigation: () => waitForNavigation,
@@ -302,27 +315,1901 @@ var BatchExecutor = class {
         await this.page.switchToMain();
         return {};
       }
-      default:
+      default: {
+        const action = step.action;
+        const aliases = {
+          execute: "evaluate",
+          navigate: "goto",
+          input: "fill",
+          tap: "click",
+          go: "goto",
+          run: "evaluate",
+          capture: "screenshot",
+          inspect: "snapshot",
+          enter: "press",
+          open: "goto",
+          visit: "goto",
+          eval: "evaluate",
+          js: "evaluate",
+          snap: "snapshot",
+          frame: "switchFrame"
+        };
+        const suggestion = aliases[action.toLowerCase()];
+        const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+        const valid = "goto, click, fill, type, select, check, uncheck, submit, press, focus, hover, scroll, wait, snapshot, screenshot, evaluate, text, switchFrame, switchToMain";
+        throw new Error(`Unknown action "${action}".${hint}
+
+Valid actions: ${valid}`);
+      }
+    }
+  }
+  /**
+   * Get the actual selector that matched the element.
+   * Uses the last matched selector tracked by Page, falls back to first selector if unavailable.
+   */
+  getUsedSelector(selector) {
+    const matched = this.page.getLastMatchedSelector();
+    if (matched) return matched;
+    return Array.isArray(selector) ? selector[0] : selector;
+  }
+};
+function addBatchToPage(page) {
+  const executor = new BatchExecutor(page);
+  return Object.assign(page, {
+    batch: (steps, options) => executor.execute(steps, options)
+  });
+}
+
+// src/actions/validate.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+var ACTION_ALIASES = {
+  execute: "evaluate",
+  navigate: "goto",
+  input: "fill",
+  tap: "click",
+  go: "goto",
+  run: "evaluate",
+  capture: "screenshot",
+  inspect: "snapshot",
+  enter: "press",
+  keypress: "press",
+  nav: "goto",
+  open: "goto",
+  visit: "goto",
+  browse: "goto",
+  load: "goto",
+  write: "fill",
+  set: "fill",
+  pick: "select",
+  choose: "select",
+  send: "press",
+  eval: "evaluate",
+  js: "evaluate",
+  script: "evaluate",
+  snap: "snapshot",
+  accessibility: "snapshot",
+  a11y: "snapshot",
+  image: "screenshot",
+  pic: "screenshot",
+  frame: "switchFrame",
+  iframe: "switchFrame"
+};
+var PROPERTY_ALIASES = {
+  expression: "value",
+  href: "url",
+  target: "selector",
+  element: "selector",
+  code: "value",
+  script: "value",
+  src: "url",
+  link: "url",
+  char: "key",
+  text: "value",
+  query: "selector",
+  el: "selector",
+  elem: "selector",
+  css: "selector",
+  xpath: "selector",
+  input: "value",
+  content: "value",
+  keys: "key",
+  button: "key",
+  address: "url",
+  page: "url",
+  path: "url"
+};
+var ACTION_RULES = {
+  goto: {
+    required: { url: { type: "string" } },
+    optional: {}
+  },
+  click: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {
+      waitForNavigation: { type: "boolean" }
+    }
+  },
+  fill: {
+    required: { selector: { type: "string|string[]" }, value: { type: "string" } },
+    optional: {
+      clear: { type: "boolean" },
+      blur: { type: "boolean" }
+    }
+  },
+  type: {
+    required: { selector: { type: "string|string[]" }, value: { type: "string" } },
+    optional: {
+      delay: { type: "number" }
+    }
+  },
+  select: {
+    required: {},
+    optional: {
+      selector: { type: "string|string[]" },
+      value: { type: "string|string[]" },
+      trigger: { type: "string|string[]" },
+      option: { type: "string|string[]" },
+      match: { type: "string", enum: ["text", "value", "contains"] }
+    }
+  },
+  check: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {}
+  },
+  uncheck: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {}
+  },
+  submit: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {
+      method: { type: "string", enum: ["enter", "click", "enter+click"] }
+    }
+  },
+  press: {
+    required: { key: { type: "string" } },
+    optional: {}
+  },
+  focus: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {}
+  },
+  hover: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {}
+  },
+  scroll: {
+    required: {},
+    optional: {
+      selector: { type: "string|string[]" },
+      x: { type: "number" },
+      y: { type: "number" },
+      direction: { type: "string", enum: ["up", "down", "left", "right"] },
+      amount: { type: "number" }
+    }
+  },
+  wait: {
+    required: {},
+    optional: {
+      selector: { type: "string|string[]" },
+      waitFor: {
+        type: "string",
+        enum: ["visible", "hidden", "attached", "detached", "navigation", "networkIdle"]
+      }
+    }
+  },
+  snapshot: {
+    required: {},
+    optional: {}
+  },
+  screenshot: {
+    required: {},
+    optional: {
+      format: { type: "string", enum: ["png", "jpeg", "webp"] },
+      quality: { type: "number" },
+      fullPage: { type: "boolean" }
+    }
+  },
+  evaluate: {
+    required: { value: { type: "string" } },
+    optional: {}
+  },
+  text: {
+    required: {},
+    optional: {
+      selector: { type: "string|string[]" }
+    }
+  },
+  switchFrame: {
+    required: { selector: { type: "string|string[]" } },
+    optional: {}
+  },
+  switchToMain: {
+    required: {},
+    optional: {}
+  }
+};
+var VALID_ACTIONS = Object.keys(ACTION_RULES);
+var VALID_ACTIONS_LIST = VALID_ACTIONS.join(", ");
+var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
+  "action",
+  "selector",
+  "url",
+  "value",
+  "key",
+  "waitFor",
+  "timeout",
+  "optional",
+  "method",
+  "clear",
+  "blur",
+  "delay",
+  "waitForNavigation",
+  "trigger",
+  "option",
+  "match",
+  "x",
+  "y",
+  "direction",
+  "amount",
+  "format",
+  "quality",
+  "fullPage"
+]);
+function resolveAction(name) {
+  if (VALID_ACTIONS.includes(name)) {
+    return { action: name };
+  }
+  const lower = name.toLowerCase();
+  if (ACTION_ALIASES[lower]) {
+    return {
+      action: ACTION_ALIASES[lower],
+      suggestion: `Did you mean "${ACTION_ALIASES[lower]}"?`
+    };
+  }
+  let best = null;
+  let bestDist = Infinity;
+  for (const valid of VALID_ACTIONS) {
+    const dist = levenshtein(lower, valid);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = valid;
+    }
+  }
+  if (best && bestDist <= 2) {
+    return { action: best, suggestion: `Did you mean "${best}"?` };
+  }
+  return null;
+}
+function suggestProperty(name) {
+  if (PROPERTY_ALIASES[name]) {
+    return PROPERTY_ALIASES[name];
+  }
+  let best = null;
+  let bestDist = Infinity;
+  for (const known of KNOWN_STEP_FIELDS) {
+    if (known === "action") continue;
+    const dist = levenshtein(name, known);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = known;
+    }
+  }
+  if (best && bestDist <= 2) {
+    return best;
+  }
+  return void 0;
+}
+function checkFieldType(value, rule) {
+  switch (rule.type) {
+    case "string":
+      if (typeof value !== "string") return `expected string, got ${typeof value}`;
+      if (rule.enum && !rule.enum.includes(value)) {
+        return `must be one of: ${rule.enum.join(", ")}`;
+      }
+      return null;
+    case "string|string[]":
+      if (typeof value !== "string" && !Array.isArray(value)) {
+        return `expected string or string[], got ${typeof value}`;
+      }
+      if (Array.isArray(value) && value.some((v) => typeof v !== "string")) {
+        return "array elements must be strings";
+      }
+      return null;
+    case "number":
+      if (typeof value !== "number") return `expected number, got ${typeof value}`;
+      return null;
+    case "boolean":
+      if (typeof value !== "boolean") return `expected boolean, got ${typeof value}`;
+      return null;
+  }
+}
+function validateSteps(steps) {
+  const errors = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (!step || typeof step !== "object" || Array.isArray(step)) {
+      errors.push({
+        stepIndex: i,
+        field: "step",
+        message: "step must be a JSON object."
+      });
+      continue;
+    }
+    const obj = step;
+    if (!("action" in obj)) {
+      errors.push({
+        stepIndex: i,
+        field: "action",
+        message: 'missing required "action" field.'
+      });
+      continue;
+    }
+    const actionName = obj["action"];
+    if (typeof actionName !== "string") {
+      errors.push({
+        stepIndex: i,
+        field: "action",
+        message: `"action" must be a string, got ${typeof actionName}.`
+      });
+      continue;
+    }
+    const resolved = resolveAction(actionName);
+    if (!resolved) {
+      errors.push({
+        stepIndex: i,
+        field: "action",
+        message: `unknown action "${actionName}".`,
+        suggestion: `Valid actions: ${VALID_ACTIONS_LIST}`
+      });
+      continue;
+    }
+    if (resolved.suggestion) {
+      errors.push({
+        stepIndex: i,
+        field: "action",
+        message: `unknown action "${actionName}". ${resolved.suggestion}`,
+        suggestion: resolved.suggestion
+      });
+      continue;
+    }
+    const action = resolved.action;
+    const rule = ACTION_RULES[action];
+    for (const key of Object.keys(obj)) {
+      if (key === "action") continue;
+      if (!KNOWN_STEP_FIELDS.has(key)) {
+        const suggestion = suggestProperty(key);
+        errors.push({
+          stepIndex: i,
+          field: key,
+          message: suggestion ? `unknown property "${key}". Did you mean "${suggestion}"?` : `unknown property "${key}".`,
+          suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
+        });
+      }
+    }
+    for (const [field, fieldRule] of Object.entries(rule.required)) {
+      if (!(field in obj) || obj[field] === void 0) {
+        errors.push({
+          stepIndex: i,
+          field,
+          message: `missing required "${field}" (${fieldRule.type}).`
+        });
+      } else {
+        const typeErr = checkFieldType(obj[field], fieldRule);
+        if (typeErr) {
+          errors.push({
+            stepIndex: i,
+            field,
+            message: `"${field}" ${typeErr}.`
+          });
+        }
+      }
+    }
+    for (const [field, fieldRule] of Object.entries(rule.optional)) {
+      if (field in obj && obj[field] !== void 0) {
+        const typeErr = checkFieldType(obj[field], fieldRule);
+        if (typeErr) {
+          errors.push({
+            stepIndex: i,
+            field,
+            message: `"${field}" ${typeErr}.`
+          });
+        }
+      }
+    }
+    if ("timeout" in obj && obj["timeout"] !== void 0) {
+      if (typeof obj["timeout"] !== "number") {
+        errors.push({
+          stepIndex: i,
+          field: "timeout",
+          message: `"timeout" expected number, got ${typeof obj["timeout"]}.`
+        });
+      }
+    }
+    if ("optional" in obj && obj["optional"] !== void 0) {
+      if (typeof obj["optional"] !== "boolean") {
+        errors.push({
+          stepIndex: i,
+          field: "optional",
+          message: `"optional" expected boolean, got ${typeof obj["optional"]}.`
+        });
+      }
+    }
+    if (action === "select") {
+      const hasNative = "selector" in obj && "value" in obj;
+      const hasCustom = "trigger" in obj && "option" in obj && "value" in obj;
+      if (!hasNative && !hasCustom) {
+        errors.push({
+          stepIndex: i,
+          field: "selector",
+          message: "select requires either (selector + value) for native select, or (trigger + option + value) for custom select."
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    formatted() {
+      if (errors.length === 0) return "";
+      const lines = [`Validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):`];
+      for (const err of errors) {
+        const stepLabel = err.field === "action" || err.field === "step" ? `Step ${err.stepIndex}` : `Step ${err.stepIndex}`;
+        lines.push("");
+        lines.push(`  ${stepLabel}: ${err.message}`);
+        if (err.suggestion && !err.message.includes(err.suggestion)) {
+          lines.push(`    ${err.suggestion}`);
+        }
+        const step = steps[err.stepIndex];
+        if (step && typeof step === "object") {
+          lines.push(`    Got: ${JSON.stringify(step)}`);
+        }
+      }
+      const hasEvaluateError = errors.some((err) => {
+        const step = steps[err.stepIndex];
+        return step && typeof step === "object" && step["action"] === "evaluate";
+      });
+      if (hasEvaluateError) {
+        lines.push("");
+        lines.push(
+          "Tip: For JavaScript evaluation, use 'bp eval' instead \u2014 no JSON wrapping needed:"
+        );
+        lines.push("  bp eval 'your.expression.here'");
+      }
+      lines.push("");
+      lines.push(`Valid actions: ${VALID_ACTIONS_LIST}`);
+      return lines.join("\n");
+    }
+  };
+}
+
+// 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/flags.ts
+function getAudioChromeFlags(options) {
+  const flags = [
+    "--use-fake-device-for-media-stream",
+    "--use-fake-ui-for-media-stream",
+    "--autoplay-policy=no-user-gesture-required"
+  ];
+  if (options?.inputWavPath) {
+    let path = options.inputWavPath;
+    if (options.noLoop) {
+      path += "%noloop";
+    }
+    flags.push(`--use-file-for-fake-audio-capture=${path}`);
+  }
+  return flags;
+}
+
+// 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(
-          `Unknown action: ${step.action}. Run 'bp actions' for available actions.`
+          '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 {
+      }
     }
   }
   /**
-   * Get the actual selector that matched the element.
-   * Uses the last matched selector tracked by Page, falls back to first selector if unavailable.
+   * Stop capturing and return all collected audio.
    */
-  getUsedSelector(selector) {
-    const matched = this.page.getLastMatchedSelector();
-    if (matched) return matched;
-    return Array.isArray(selector) ? selector[0] : selector;
+  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 addBatchToPage(page) {
-  const executor = new BatchExecutor(page);
-  return Object.assign(page, {
-    batch: (steps, options) => executor.execute(steps, options)
+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/audio/transcribe.ts
+async function transcribe(audio, options) {
+  const apiKey = options?.apiKey ?? getEnvVar("OPENAI_API_KEY");
+  if (!apiKey) {
+    throw new Error(
+      "OpenAI API key required for transcription. Set OPENAI_API_KEY environment variable or pass apiKey option."
+    );
+  }
+  if (audio.left.length === 0) {
+    return { text: "", audioDurationMs: 0, apiDurationMs: 0 };
+  }
+  const model = options?.model ?? "whisper-1";
+  const responseFormat = options?.responseFormat ?? "text";
+  const wavBuffer = pcmToWav({
+    left: audio.left,
+    right: audio.right.length > 0 ? audio.right : void 0,
+    sampleRate: audio.sampleRate
   });
+  const boundary = `----bpAudio${Date.now()}`;
+  const parts = [];
+  appendFormField(parts, boundary, "file", new Uint8Array(wavBuffer), "audio.wav", "audio/wav");
+  appendFormTextField(parts, boundary, "model", model);
+  appendFormTextField(parts, boundary, "response_format", responseFormat);
+  if (options?.language) {
+    appendFormTextField(parts, boundary, "language", options.language);
+  }
+  if (options?.prompt) {
+    appendFormTextField(parts, boundary, "prompt", options.prompt);
+  }
+  const closing = new TextEncoder().encode(`\r
+--${boundary}--\r
+`);
+  parts.push(closing);
+  const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of parts) {
+    body.set(part, offset);
+    offset += part.length;
+  }
+  const start = Date.now();
+  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": `multipart/form-data; boundary=${boundary}`
+    },
+    body
+  });
+  const apiDurationMs = Date.now() - start;
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    throw new Error(`Whisper API error (${response.status}): ${errorBody}`);
+  }
+  let text;
+  if (responseFormat === "text") {
+    text = (await response.text()).trim();
+  } else {
+    const json = await response.json();
+    text = json.text ?? "";
+  }
+  return {
+    text,
+    audioDurationMs: audio.durationMs,
+    apiDurationMs
+  };
+}
+function isTranscriptionAvailable() {
+  return !!getEnvVar("OPENAI_API_KEY");
+}
+function getEnvVar(name) {
+  if (typeof globalThis.process !== "undefined" && globalThis.process.env) {
+    return globalThis.process.env[name];
+  }
+  return void 0;
+}
+function appendFormTextField(parts, boundary, name, value) {
+  const text = `\r
+--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}`;
+  parts.push(new TextEncoder().encode(text));
+}
+function appendFormField(parts, boundary, name, data, filename, contentType) {
+  const header = `\r
+--${boundary}\r
+Content-Disposition: form-data; name="${name}"; filename="${filename}"\r
+Content-Type: ${contentType}\r
+\r
+`;
+  parts.push(new TextEncoder().encode(header));
+  parts.push(data);
 }
 
 // src/cdp/protocol.ts
@@ -1020,7 +2907,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 = {}) {
@@ -1046,7 +2933,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 };
 }
@@ -1075,7 +2962,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 };
 }
@@ -1124,7 +3011,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);
@@ -1454,6 +3341,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;
@@ -1701,7 +3592,7 @@ var Page = class {
         key: char
       });
       if (delay > 0) {
-        await sleep2(delay);
+        await sleep3(delay);
       }
     }
     return true;
@@ -1742,7 +3633,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") {
@@ -1854,7 +3745,7 @@ var Page = class {
       if (shouldWait === true) {
         await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT2 });
       } 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;
     }
@@ -1872,7 +3763,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;
@@ -1886,7 +3777,7 @@ var Page = class {
       if (shouldWait === true) {
         await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT2 });
       } else if (shouldWait === "auto") {
-        await sleep2(100);
+        await sleep3(100);
       }
     }
     return true;
@@ -2883,7 +4774,7 @@ var Page = class {
           lastError = e;
           if (attempt < retries) {
             this.rootNodeId = null;
-            await sleep2(delay);
+            await sleep3(delay);
             continue;
           }
         }
@@ -3055,8 +4946,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));
 }
 
@@ -3415,6 +5405,8 @@ function disableTracing() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AudioInput,
+  AudioOutput,
   BatchExecutor,
   Browser,
   BrowserBaseProvider,
@@ -3428,6 +5420,8 @@ function disableTracing() {
   TimeoutError,
   Tracer,
   addBatchToPage,
+  bufferToBase64,
+  calculateRMS,
   connect,
   createCDPClient,
   createProvider,
@@ -3435,8 +5429,17 @@ function disableTracing() {
   disableTracing,
   discoverTargets,
   enableTracing,
+  generateSilence,
+  generateTone,
+  getAudioChromeFlags,
   getBrowserWebSocketUrl,
   getTracer,
+  grantAudioPermissions,
+  isTranscriptionAvailable,
+  parseWavHeader,
+  pcmToWav,
+  transcribe,
+  validateSteps,
   waitForAnyElement,
   waitForElement,
   waitForNavigation,