bwb-browser 4.0.0 → 4.1.0

package/lib/fetch.mjs

@@ -6,8 +6,23 @@
  * nothing until the first static fetch. Called by browser_goto before CDP.
  */
 
+import { assertOutbound, UrlPolicyError } from "./urlpolicy.mjs";
+
 const FETCH_MAX_BYTES = 2_000_000; // never buffer more than 2MB per page
 const MIN_TEXT_CHARS = 500; // below this + JS markers => probably a JS shell
+const MAX_REDIRECTS = 5;
+const DEFAULT_MAX_CHARS = 20_000;
+const MAX_LINKS = 40;
+
+let USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 bwb-static";
+try {
+  const { readFileSync } = await import("fs");
+  const { join, dirname } = await import("path");
+  const { fileURLToPath } = await import("url");
+  const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const { version } = JSON.parse(readFileSync(pkgPath, "utf8"));
+  if (version) USER_AGENT = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 bwb-static/${version}`;
+} catch { /* keep the fallback UA */ }
 
 // Framework shells / client-rendered markers — presence + thin text = escalate
 const JS_MARKERS = [
@@ -18,110 +33,207 @@ const JS_MARKERS = [
 // Login / auth walls — static fetch can't pass, but the browser (sessions) might
 const AUTH_MARKERS = ["password", "sign in", "log in", "login", "captcha"];
 
-const TEXT_TYPES = ["text/html", "text/plain", "application/xhtml+xml"];
+// Rendered through Readability
+const HTML_TYPES = ["text/html", "application/xhtml+xml"];
+// Served as-is: no article extraction, no "thin body" heuristics. A 31-byte
+// robots.txt or a JSON file must NOT cost a Chromium spawn.
+const VERBATIM_TYPES = [
+  "text/plain", "application/json", "application/ld+json", "text/xml",
+  "application/xml", "application/rss+xml", "application/atom+xml",
+  "text/markdown", "text/csv", "text/tab-separated-values",
+];
+const TEXT_TYPES = [...HTML_TYPES, ...VERBATIM_TYPES];
+
+const STATIC_FETCH_DEFAULTS = {
+  timeout: 15000,
+  allowPrivate: false,
+  allowDomains: null,
+  raw: false,
+  maxChars: DEFAULT_MAX_CHARS,
+};
 
 /**
  * Fetch + extract without Chromium.
  * @returns {mode:'static',...} | {mode:'escalate', reason} | {mode:'error', error}
  */
-export async function staticFetch(url, { timeout = 15000 } = {}) {
+export async function staticFetch(url, options = {}) {
+  const { timeout, allowPrivate, allowDomains, raw, maxChars } =
+    { ...STATIC_FETCH_DEFAULTS, ...options };
+
+  // One abort timer for the whole exchange — headers AND body. Previously the
+  // timer was cleared in `finally` as soon as headers arrived, so a server that
+  // sent headers then trickled bytes hung forever.
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeout);
   let res;
+  let target;
+
   try {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), timeout);
-    try {
-      res = await fetch(url, {
+    target = url;
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+      const u = await assertOutbound(target, { allowPrivate, allowDomains });
+      res = await fetch(u.href, {
         signal: ctrl.signal,
-        redirect: "follow",
+        // Manual so every hop is re-validated: a public URL can redirect to
+        // 169.254.169.254 or file://.
+        redirect: "manual",
         headers: {
-          "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 bwb-static/4.0",
-          Accept: "text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.1",
+          "User-Agent": USER_AGENT,
+          Accept: "text/html,application/xhtml+xml,application/json;q=0.9,text/plain;q=0.9,*/*;q=0.1",
+          "Accept-Language": "en-US,en;q=0.9",
         },
       });
-    } finally {
-      clearTimeout(timer);
+      const location = res.headers.get("location");
+      if ([301, 302, 303, 307, 308].includes(res.status) && location) {
+        try { await res.body?.cancel(); } catch {}
+        target = new URL(location, u).href;
+        res = null;
+        continue;
+      }
+      break;
+    }
+    if (!res) {
+      return { mode: "error", error: `Too many redirects (>${MAX_REDIRECTS}) for ${url}` };
     }
   } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof UrlPolicyError) return { mode: "error", error: err.message };
     // Network-level failure — CDP shares the same network, but surfaces
     // better diagnostics (diagnosePage). Escalate rather than hard-fail.
     return { mode: "escalate", reason: `static fetch failed (${err.name}): ${err.message}` };
   }
 
-  // Auth walls: the browser (with sessions/cookies) may pass where fetch can't
-  if (res.status === 401 || res.status === 403 || res.status === 429) {
-    return { mode: "escalate", reason: `HTTP ${res.status} — possible auth wall / rate limit` };
-  }
-  if (!res.ok) {
-    // Dead URL — CDP won't resurrect it. Don't spawn Chromium for a 404.
-    return { mode: "error", error: `HTTP ${res.status} ${res.statusText} for ${url}` };
-  }
+  try {
+    // Auth walls: the browser (with sessions/cookies) may pass where fetch can't
+    if (res.status === 401 || res.status === 403 || res.status === 429) {
+      return { mode: "escalate", reason: `HTTP ${res.status} — possible auth wall / rate limit` };
+    }
+    if (!res.ok) {
+      // Dead URL — CDP won't resurrect it. Don't spawn Chromium for a 404.
+      return { mode: "error", error: `HTTP ${res.status} ${res.statusText} for ${res.url || url}` };
+    }
 
-  const contentType = (res.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
-  if (contentType && !TEXT_TYPES.some((t) => contentType.startsWith(t))) {
-    return { mode: "escalate", reason: `non-text content (${contentType || "unknown"})` };
-  }
+    const rawType = (res.headers.get("content-type") || "").split(";")[0].trim().toLowerCase();
+    const contentType = rawType || "text/html";
+    if (!TEXT_TYPES.some((t) => contentType.startsWith(t))) {
+      return { mode: "escalate", reason: `non-text content (${rawType || "unknown"})` };
+    }
 
-  // Bounded body read — never buffer a whole ISO / stream
-  let html = "";
-  try {
-    const reader = res.body.getReader();
-    let received = 0;
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      received += value.length;
-      if (received > FETCH_MAX_BYTES) {
-        try { await reader.cancel(); } catch {}
-        return { mode: "escalate", reason: "page exceeds 2MB static cap — needs browser" };
+    // Bounded body read. Chunks are concatenated as BYTES and decoded once —
+    // decoding per chunk mangles every multibyte character that straddles a
+    // network boundary (real servers split at arbitrary byte offsets).
+    let buf;
+    try {
+      const chunks = [];
+      let received = 0;
+      const reader = res.body.getReader();
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        received += value.length;
+        if (received > FETCH_MAX_BYTES) {
+          try { await reader.cancel(); } catch {}
+          return { mode: "escalate", reason: "page exceeds 2MB static cap — needs browser" };
+        }
+        chunks.push(Buffer.from(value));
       }
-      html += Buffer.from(value).toString("utf8");
+      buf = Buffer.concat(chunks, received);
+    } catch (err) {
+      return { mode: "escalate", reason: `body read failed: ${err.message}` };
     }
-  } catch (err) {
-    return { mode: "escalate", reason: `body read failed: ${err.message}` };
-  }
 
-  if (contentType.startsWith("text/plain")) {
-    const text = html.trim();
-    if (text.length < MIN_TEXT_CHARS) {
-      return { mode: "escalate", reason: "plain-text body too thin to trust" };
+    const charset =
+      /charset=["']?([\w-]+)/i.exec(res.headers.get("content-type") || "")?.[1]
+      || /<meta[^>]+charset=["']?([\w-]+)/i.exec(buf.subarray(0, 4096).toString("latin1"))?.[1];
+    let body;
+    try {
+      body = new TextDecoder(charset || "utf-8", { fatal: false }).decode(buf);
+    } catch {
+      body = new TextDecoder("utf-8", { fatal: false }).decode(buf);
     }
-    return { mode: "static", title: "", text, finalUrl: res.url, bytes: html.length, confidence: "high" };
-  }
 
-  // HTML → Readability (lazy deps: zero cost until first use)
-  let article;
-  try {
-    const { parseHTML } = await import("linkedom");
-    const { Readability } = await import("@mozilla/readability");
-    const { document } = parseHTML(html);
-    article = new Readability(document).parse();
-  } catch (err) {
-    return { mode: "escalate", reason: `extraction crashed: ${err.message}` };
-  }
-  if (!article || !(article.textContent || "").trim()) {
-    return { mode: "escalate", reason: "no readable article found" };
-  }
+    const finalUrl = res.url || target;
+    const cap = capText(body, maxChars);
+
+    if (VERBATIM_TYPES.some((t) => contentType.startsWith(t))) {
+      return {
+        mode: "static", title: "", text: cap.text, finalUrl, bytes: buf.length,
+        contentType, ...(cap.truncated ? { truncated: true, nextOffset: cap.nextOffset } : {}),
+        confidence: "high",
+      };
+    }
+
+    if (raw) {
+      return {
+        mode: "static", title: "", text: cap.text, finalUrl, bytes: buf.length,
+        contentType, raw: true,
+        ...(cap.truncated ? { truncated: true, nextOffset: cap.nextOffset } : {}),
+        confidence: "high",
+      };
+    }
+
+    // HTML → Readability (lazy deps: zero cost until first use)
+    let article, links = [];
+    try {
+      const { parseHTML } = await import("linkedom");
+      const { Readability } = await import("@mozilla/readability");
+      const { document } = parseHTML(body);
+      links = collectLinks(document);
+      article = new Readability(document).parse();
+    } catch (err) {
+      return { mode: "escalate", reason: `extraction crashed: ${err.message}` };
+    }
+    if (!article || !(article.textContent || "").trim()) {
+      return { mode: "escalate", reason: "no readable article found" };
+    }
 
-  const text = article.textContent.trim().replace(/\n{3,}/g, "\n\n");
-  const lower = html.toLowerCase();
-  const hasJsShell = JS_MARKERS.some((m) => lower.includes(m.toLowerCase()));
-  const looksAuthed = AUTH_MARKERS.some((m) => lower.includes(m)) && text.length < MIN_TEXT_CHARS;
+    const articleText = article.textContent.trim().replace(/\n{3,}/g, "\n\n");
+    const capped = capText(articleText, maxChars);
+    const lower = body.toLowerCase();
+    const hasJsShell = JS_MARKERS.some((m) => lower.includes(m.toLowerCase()));
+    const looksAuthed = AUTH_MARKERS.some((m) => lower.includes(m)) && articleText.length < MIN_TEXT_CHARS;
+
+    if (articleText.length < MIN_TEXT_CHARS && (hasJsShell || looksAuthed)) {
+      return {
+        mode: "escalate",
+        reason: looksAuthed && !hasJsShell
+          ? "thin text behind possible login wall"
+          : "thin text + JS shell markers — needs rendering",
+      };
+    }
 
-  if (text.length < MIN_TEXT_CHARS && (hasJsShell || looksAuthed)) {
     return {
-      mode: "escalate",
-      reason: looksAuthed && !hasJsShell
-        ? "thin text behind possible login wall"
-        : "thin text + JS shell markers — needs rendering",
+      mode: "static",
+      title: article.title || "",
+      text: capped.text,
+      finalUrl,
+      bytes: buf.length,
+      links,
+      ...(capped.truncated ? { truncated: true, nextOffset: capped.nextOffset } : {}),
+      confidence: articleText.length >= MIN_TEXT_CHARS ? "high" : "medium",
     };
+  } finally {
+    clearTimeout(timer);
   }
+}
 
-  return {
-    mode: "static",
-    title: article.title || "",
-    text,
-    finalUrl: res.url,
-    bytes: html.length,
-    confidence: text.length >= MIN_TEXT_CHARS ? "high" : "medium",
-  };
+/** Cap text at maxChars, reporting whether more remains. */
+export function capText(text, maxChars = DEFAULT_MAX_CHARS) {
+  if (!maxChars || maxChars < 0 || text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  return { text: text.slice(0, maxChars), truncated: true, nextOffset: maxChars };
 }
+
+function collectLinks(document) {
+  const out = [];
+  try {
+    for (const a of document.querySelectorAll("a[href]")) {
+      if (out.length >= MAX_LINKS) break;
+      const href = a.getAttribute("href") || "";
+      if (!href || href.startsWith("#") || href.startsWith("javascript:")) continue;
+      out.push({ text: (a.textContent || "").trim().slice(0, 80), href });
+    }
+  } catch {}
+  return out;
+}

package/lib/fingerprint.mjs

@@ -1,31 +1,67 @@
 /**
- * bwb-browser — Realistic Browser Fingerprint
+ * bwb-browser — Anti-automation fingerprint patches
  *
- * Applies standard browser fingerprint countermeasures to reduce
- * false-positive automation detection in CI/testing environments.
- *
- * These techniques are the same ones used by Playwright's Stealth plugin
- * and Puppeteer Extra — common tools for testing your own site's
- * bot-detection systems in a realistic browser environment.
+ * Applies the standard browser-fingerprint countermeasures used by test rigs
+ * (Playwright's Stealth plugin, puppeteer-extra-plugin-stealth) so that
+ * bot-detection on a site you own does not fire purely because the browser is
+ * headless and automated. These patches are exactly what "stealth mode" means;
+ * the previous docs claimed they were "not stealth mode".
  *
  * How it works:
- *   - Override navigator.webdriver → false
- *   - Set realistic navigator.plugins
- *   - Configure sensible language preferences
- *   - Override chrome.runtime references
- *   - Set a standard desktop User-Agent
+ *   - navigator.webdriver → false
+ *   - navigator.plugins — a plausible list
+ *   - navigator.languages — ['en-US', 'en']
+ *   - chrome.runtime — normalized
+ *   - user agent — derived from the REAL Chromium via Browser.getVersion(),
+ *     with only the HeadlessChrome token swapped for Chrome. Hardcoding
+ *     "Chrome/126 … Linux x86_64" on a Termux ARM device with a Chromium 140
+ *     binary is MORE detectable than saying nothing, and it disagreed with
+ *     navigator.userAgentData and navigator.platform.
  *
- * NOTE: Scripts are injected via Page.addScriptToEvaluateOnNewDocument,
- * which means they only affect pages loaded AFTER applyRealisticProfile
- * is called. Call before browser_goto for best results.
+ * NOTE: scripts are injected via Page.addScriptToEvaluateOnNewDocument, so
+ * they only affect pages loaded AFTER applyRealisticProfile. Call before
+ * browser_goto.
  */
 
+import { platform } from "os";
+
+const PLATFORM_STRING = {
+  linux: "Linux x86_64",
+  darwin: "Macintosh; Intel Mac OS X 10_15_7",
+  win32: "Windows NT 10.0; Win64; x86",
+};
+
+function uaPlatform() {
+  const p = platform();
+  if (PLATFORM_STRING[p]) return PLATFORM_STRING[p];
+  // Termux/Android reports linux; a phone is not x86_64.
+  if (process.env.TERMUX_VERSION) return "Linux; Android 13";
+  return PLATFORM_STRING.linux;
+}
+
 /**
- * Apply a realistic browser fingerprint to reduce automation detection.
- * Injects anti-fingerprinting scripts before page JS executes.
+ * Build a user agent that agrees with the actual browser build.
+ * Returns null when the version cannot be determined (keep Chromium's own).
  */
+async function deriveUserAgent(protocol) {
+  const product = uaPlatform();
+  let version = null;
+  try {
+    const { Browser } = protocol;
+    const info = await Browser.getVersion();
+    version = (info?.product || "").match(/\d+\.\d+\.\d+\.\d+/)?.[0] || null;
+  } catch {}
+  if (!version) return null;
+  const headless = process.env.BWB_HEADLESS !== "false";
+  const engine = headless ? "HeadlessChrome" : "Chrome";
+  return (
+    `Mozilla/5.0 (${product}) AppleWebKit/537.36 (KHTML, like Gecko) ` +
+    `${engine}/${version} Safari/537.36`
+  );
+}
+
 export async function applyRealisticProfile(protocol) {
-  const { Page, Network } = protocol;
+  const { Page, Network, Emulation } = protocol;
 
   // Inject fingerprint-normalizing script for ALL new documents
   await Page.addScriptToEvaluateOnNewDocument({
@@ -45,7 +81,7 @@ export async function applyRealisticProfile(protocol) {
 
       // Realistic language preferences
       Object.defineProperty(navigator, 'languages', {
-        get: () => ['en-US', 'en', 'es'],
+        get: () => ['en-US', 'en'],
         configurable: true,
       });
 
@@ -82,24 +118,33 @@ export async function applyRealisticProfile(protocol) {
     `,
   });
 
-  // Set a standard desktop user-agent
-  try {
-    await Network.setUserAgentOverride({
-      userAgent:
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
-    });
-  } catch {}
+  // User agent derived from the real browser, with matching userAgentData so
+  // the override does not contradict itself.
+  let userAgent = null;
+  try { userAgent = await deriveUserAgent(protocol); } catch {}
+  if (userAgent) {
+    try { await Network.setUserAgentOverride({ userAgent }); } catch {}
+    try {
+      await Emulation?.setUserAgentOverride?.({
+        userAgent,
+        acceptLanguage: "en-US,en;q=0.9",
+        platform: uaPlatform(),
+      });
+    } catch {}
+  }
 
   return {
     status: "profile applied",
     note: "Only affects pages loaded after this call. Navigate to a new page for the profile to take effect.",
+    userAgent: userAgent || "unchanged (real Chromium user agent kept)",
+    intendedUse: "Testing sites you own or have permission to test.",
     techniques: [
       "navigator.webdriver → false",
       "navigator.plugins — realistic list",
       "navigator.languages — configured",
       "chrome.runtime — normalized",
       "Permissions query — overridden",
-      "User-Agent — standard desktop",
+      "User-Agent — derived from the real Chromium build",
     ],
   };
-}
+}

package/lib/helpers.mjs

@@ -2,46 +2,76 @@
  * bwb-browser — Shared interaction helpers
  *
  * Functions for navigating, clicking, filling, and waiting for page elements
- * using raw CDP protocol.
+ * over the CDP protocol.
  */
 
+import { assertNavigable } from "./urlpolicy.mjs";
+
 // ─── Navigation Helper ────────────────────────────────────────────────────────
 
-export async function gotoUrl(page, runtime, url, timeoutMs) {
+/**
+ * Navigate and wait for load.
+ * @returns {{title: string, url: string, timedOut: boolean}}
+ *   `url` is the URL the page ACTUALLY landed on (post-redirect), and
+ *   `timedOut` says whether the load event simply never arrived. Reporting the
+ *   *requested* URL as if it were loaded is how "went to X" quietly became
+ *   "still on about:blank".
+ */
+export async function gotoUrl(page, runtime, url, timeoutMs, { allowDomains = null } = {}) {
+  assertNavigable(url, { allowDomains });
   await page.enable();
 
-  const loadPromise = page.loadEventFired().then(() => true);
-  const domPromise = page.domContentEventFired().then(() => true);
+  let settled = false;
+  const loadPromise = page.loadEventFired().then(() => { settled = true; });
+  const domPromise = page.domContentEventFired().then(() => { settled = true; });
 
-  await page.navigate({ url });
+  const nav = await page.navigate({ url });
+  if (nav?.errorText) {
+    throw new Error(`Navigation failed: ${nav.errorText} (${url})`);
+  }
 
   await Promise.race([
     Promise.all([loadPromise, domPromise]),
-    new Promise(r => setTimeout(() => r(false), timeoutMs)),
+    new Promise((r) => setTimeout(r, timeoutMs)),
   ]);
 
   // Small grace for JS framework rendering
-  await new Promise(r => setTimeout(r, 500));
+  await new Promise((r) => setTimeout(r, 500));
 
+  let finalUrl = url;
+  try {
+    const { result } = await runtime.evaluate({ expression: "location.href" });
+    if (result?.value) finalUrl = result.value;
+  } catch {}
   const { result } = await runtime.evaluate({ expression: "document.title" });
-  return { title: result?.value || "", url };
+  return { title: result?.value || "", url: finalUrl, timedOut: !settled };
 }
 
 // ─── Click Helper (uses CDP Input.dispatchMouseEvent) ─────────────────────────
 
+/**
+ * Scroll the element into view, hit-test the click point, then dispatch real
+ * mouse events. Without the scroll + hit-test an off-screen element silently
+ * "clicked" whatever happened to be at those coordinates.
+ */
 export async function clickElement(page, runtime, input, selector) {
   const { result } = await runtime.evaluate({
     expression: `(() => {
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return JSON.stringify({ error: 'NOT_FOUND' });
+      try { el.scrollIntoView({ block: 'center', inline: 'center' }); } catch {}
       const rect = el.getBoundingClientRect();
+      const x = Math.round(rect.x + rect.width / 2);
+      const y = Math.round(rect.y + rect.height / 2);
+      const at = document.elementFromPoint(x, y);
       return JSON.stringify({
-        x: rect.x + rect.width / 2,
-        y: rect.y + rect.height / 2,
+        x, y,
         width: rect.width,
         height: rect.height,
         tag: el.tagName,
-        text: (el.textContent || '').trim().slice(0, 50),
+        text: (el.innerText || el.textContent || '').trim().slice(0, 80),
+        landedOn: at ? at.tagName.toLowerCase() + (at.className ? '.' + String(at.className).split(' ')[0] : '') : null,
+        hit: !!(at && (at === el || el.contains(at) || at.contains(el))),
       });
     })()`,
   });
@@ -54,10 +84,13 @@ export async function clickElement(page, runtime, input, selector) {
   if (info.error === "NOT_FOUND") {
     throw new Error(`Element not found: ${selector}`);
   }
+  if (!info.width || !info.height) {
+    throw new Error(`Element is not visible (zero size): ${selector}`);
+  }
 
   // Dispatch real mouse events via CDP Input domain (ONLY — no native JS click)
-  const x = Math.round(info.x);
-  const y = Math.round(info.y);
+  const { x, y } = info;
+  await input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" });
   await input.dispatchMouseEvent({ type: "mousePressed", x, y, button: "left", clickCount: 1 });
   await input.dispatchMouseEvent({ type: "mouseReleased", x, y, button: "left", clickCount: 1 });
 
@@ -70,28 +103,36 @@ export async function fillElement(page, runtime, input, selector, text) {
   const { result } = await runtime.evaluate({
     expression: `(() => {
       const el = document.querySelector(${JSON.stringify(selector)});
-      if (!el) return 'NOT_FOUND';
+      if (!el) return JSON.stringify({ error: 'NOT_FOUND' });
       el.focus();
-      el.value = '';
-      return 'FOCUSED';
+      // Select existing content so insertText REPLACES it. focus() alone
+      // appends, and a bare Ctrl+A without the modifier bit does nothing.
+      try {
+        if (el.isContentEditable) { document.execCommand('selectAll'); }
+        else if (typeof el.select === 'function') { el.select(); }
+        else if ('value' in el) { el.value = ''; }
+      } catch {}
+      return JSON.stringify({
+        focused: true,
+        tag: el.tagName ? el.tagName.toLowerCase() : '',
+        type: (el.type || '').toLowerCase(),
+        contenteditable: String(el.isContentEditable) === 'true',
+      });
     })()`,
     returnByValue: true,
   });
 
-  if (result.value === "NOT_FOUND") {
+  let info;
+  try { info = JSON.parse(result.value); } catch { info = { error: "NOT_FOUND" }; }
+
+  if (info.error === "NOT_FOUND") {
     throw new Error(`Element not found: ${selector}`);
   }
 
-  // Clear existing text via CDP Input domain
-  await input.dispatchKeyEvent({ type: "keyDown", key: "Control" });
-  await input.dispatchKeyEvent({ type: "keyDown", key: "a" });
-  await input.dispatchKeyEvent({ type: "keyUp", key: "a" });
-  await input.dispatchKeyEvent({ type: "keyUp", key: "Control" });
-  await input.dispatchKeyEvent({ type: "keyDown", key: "Delete" });
-  await input.dispatchKeyEvent({ type: "keyUp", key: "Delete" });
-
-  // Insert text via CDP Input domain
+  // Insert text via CDP Input domain (goes through the page's own input
+  // handlers, so React/Vue bindings see it).
   await input.insertText({ text });
+  return info;
 }
 
 // ─── waitForSelector Helper ──────────────────────────────────────────────────
@@ -102,18 +143,24 @@ export async function waitForSelector(runtime, selector, opts = {}) {
   const start = Date.now();
 
   while (Date.now() - start < timeout) {
-    const { result } = await runtime.evaluate({
-      expression: `(() => {
-        const el = document.querySelector(${JSON.stringify(selector)});
-        if (!el) return JSON.stringify({ status: "NOT_FOUND" });
-        const rect = el.getBoundingClientRect();
-        const hidden = rect.width === 0 || rect.height === 0;
-        const text = (el.textContent || "").trim().slice(0, 200);
-        return JSON.stringify({ status: "FOUND", tag: el.tagName, text, hidden });
-      })()`,
-    });
-
-    const info = JSON.parse(result?.value || "{}");
+    let info = {};
+    try {
+      const { result } = await runtime.evaluate({
+        expression: `(() => {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (!el) return JSON.stringify({ status: "NOT_FOUND" });
+          const rect = el.getBoundingClientRect();
+          const hidden = rect.width === 0 || rect.height === 0;
+          const text = (el.innerText || el.textContent || "").trim().slice(0, 200);
+          return JSON.stringify({ status: "FOUND", tag: el.tagName, text, hidden });
+        })()`,
+      });
+      info = JSON.parse(result?.value || "{}");
+    } catch {
+      // "Execution context was destroyed" fires on every navigation; keep
+      // polling instead of aborting the whole wait.
+      info = {};
+    }
 
     if (disappear && info.status === "NOT_FOUND") return true;
     if (!disappear && info.status === "FOUND" && (!opts.visible || !info.hidden)) return true;
@@ -122,4 +169,4 @@ export async function waitForSelector(runtime, selector, opts = {}) {
   }
 
   throw new Error(`browser_waitForSelector: "${selector}" not ${disappear ? "disappeared" : "found"} within ${timeout}ms`);
-}
+}