Pup - the AI's own browser

@@ -0,0 +1,1195 @@+// adom-native-browser :: CDP helpers (chrome.debugger)+// --------------------------------------------------------+// Used ONLY for verbs that need DevTools Protocol parity with pup: full-page screenshots and+// arbitrary expression eval. Navigation/tabs/windows go through native chrome.* APIs (native.js) so+// they never raise the "started debugging this browser" banner.+//+// Banner policy: attach lazily on first CDP use of a tab, auto-detach after IDLE_MS of no CDP use, so+// the banner only shows while actively driving. On Adom-managed machines the browser is launched with+// --silent-debugger-extension-api, which removes it entirely.+//+// DEBOUNCE (John, 2026-07-14): the banner slides IN on attach and OUT on detach, and each transition+// REFLOWS the page (content shifts up/down), which moves where a click lands and ruins the user's own+// clicks in a window they're looking at. A short idle window made it flicker in/out between every verb+// burst (think/page-load pauses > 8s detached it, then the next verb re-attached). So IDLE_MS is long+// enough to span normal per-verb gaps: the banner stays STEADY through a drive session and only slides+// out once the AI has genuinely stopped for a while (not left up forever - screen real estate matters).+// We also NEVER attach to a tab the caller didn't explicitly target (see resolveTabId requireTarget), so+// the banner can only ever appear on a window the AI is actually driving, not the user's active tab.++const PROTO = '1.3';+const IDLE_MS = 45000; // was 8000 — long enough to not flicker between verbs, short enough to not linger+const attached = new Map(); // tabId -> idleTimer++function debuggee(tabId) { return { tabId }; }++function send(tabId, method, params) {+  return new Promise((resolve, reject) => {+    chrome.debugger.sendCommand(debuggee(tabId), method, params || {}, (res) => {+      const err = chrome.runtime.lastError;+      if (err) reject(new Error(err.message)); else resolve(res);+    });+  });+}++function bumpIdle(tabId) {+  const t = attached.get(tabId);+  if (t) clearTimeout(t);+  attached.set(tabId, setTimeout(() => detach(tabId).catch(() => {}), IDLE_MS));+}++async function attach(tabId) {+  if (attached.has(tabId)) { bumpIdle(tabId); return; }+  await new Promise((resolve, reject) => {+    chrome.debugger.attach(debuggee(tabId), PROTO, () => {+      const err = chrome.runtime.lastError;+      if (err && !/already attached/i.test(err.message)) reject(new Error(err.message));+      else resolve();+    });+  });+  attached.set(tabId, null);+  await send(tabId, 'Page.enable').catch(() => {});+  await send(tabId, 'Runtime.enable').catch(() => {});+  await send(tabId, 'Log.enable').catch(() => {});+  // CRITICAL for BACKGROUND clicking: a window fully occluded by another (e.g. the user's maximized+  // window over our background one) is marked hidden by Chrome's native-occlusion tracking, so+  // Input.dispatchMouseEvent stops hit-testing and clicks silently land NOWHERE (eval/screenshot still+  // work - they don't need a hit-testable frame). Emulating focus makes the page behave as focused+visible+  // so isTrusted CDP input lands, WITHOUT ever raising the window (stays background, no focus theft).+  await send(tabId, 'Emulation.setFocusEmulationEnabled', { enabled: true }).catch(() => {});+  bumpIdle(tabId);+}++// pup (2.0.578) drives its extension-lane windows through THIS driver instead of a second one: one raw+// DevTools call on nbe's own attach + idle-detach lifecycle. Additive; nothing else here changes.+export async function raw(tabId, method, params) {+  await attach(tabId);+  const r = await send(tabId, method, params || {});+  bumpIdle(tabId);+  return r;+}++export async function detach(tabId) {+  const t = attached.get(tabId);+  if (t) clearTimeout(t);+  if (!attached.has(tabId)) return;+  attached.delete(tabId);+  await new Promise((resolve) => chrome.debugger.detach(debuggee(tabId), () => { void chrome.runtime.lastError; resolve(); }));+}++// ---- BACKGROUND CAPTURE: force a frame, never a foreground -----------------+// (John, 2026-08-22) The excuse an AI reaches for when a background capture comes back blank is "I had+// to bring the window forward to get a good screenshot." That is the single rudest thing nb can cause,+// and it is ALSO unnecessary - it is a compositor problem, not a focus problem. Chrome stops painting a+// window it believes is occluded (CalculateNativeWinOcclusion) and FREEZES a backgrounded page's+// rendering, so Page.captureScreenshot can hand back a stale or uniform frame. The answer is to make the+// renderer produce a frame, which we can do without touching the user's focus:+//   1. Page.setWebLifecycleState{active} - the documented CDP un-freeze for a backgrounded page+//   2. a double-rAF round-trip in the page - forces the renderer to commit one fresh frame+//   3. re-capture, and only judge the result after that+// Best-effort at every step; a window that never needed it pays two animation frames. If we ever CANNOT+// get a live frame we still refuse to foreground - we say so, and hand the AI the WGC fallback, which+// captures an occluded window at the OS level.+async function forceFrame(tabId) {+  const used = [];+  try { await send(tabId, 'Page.setWebLifecycleState', { state: 'active' }); used.push('lifecycle:active'); } catch {}+  try {+    await send(tabId, 'Runtime.evaluate', {+      expression: 'new Promise(r=>requestAnimationFrame(()=>requestAnimationFrame(()=>r(1))))',+      awaitPromise: true, returnByValue: true,+    });+    used.push('raf');+  } catch {}+  return used;+}+// A capture that is one flat colour is the occlusion signature (Chrome handed us an unpainted surface).+// Sampled at <=64x64 so the check costs microseconds on a full-page shot.+async function frameIsBlank(b64) {+  try {+    const bmp = await bitmapFromB64(b64);+    const w = Math.max(1, Math.min(bmp.width, 64)), h = Math.max(1, Math.min(bmp.height, 64));+    const canvas = new OffscreenCanvas(w, h);+    const g = canvas.getContext('2d', { willReadFrequently: true });+    g.drawImage(bmp, 0, 0, w, h);+    bmp.close && bmp.close();+    const d = g.getImageData(0, 0, w, h).data;+    let min = 255, max = 0;+    for (let i = 0; i < d.length; i += 4) {+      const v = (d[i] + d[i + 1] + d[i + 2]) / 3;+      if (v < min) min = v;+      if (v > max) max = v;+    }+    return (max - min) < 3;+  } catch { return false; }+}++// ---- nbrowser_screenshot / nbrowser_screenshot_full_res --------------------+export async function screenshot(tabId, { fullPage = false, maxWidth = 1568, resize = true } = {}) {+  await attach(tabId);+  const forced = await forceFrame(tabId);+  const params = { format: 'png', captureBeyondViewport: !!fullPage };+  if (fullPage) {+    const m = await send(tabId, 'Page.getLayoutMetrics');+    const css = m.cssContentSize || m.contentSize;+    params.clip = { x: 0, y: 0, width: Math.ceil(css.width), height: Math.ceil(css.height), scale: 1 };+  }+  let res = await send(tabId, 'Page.captureScreenshot', params);+  // Blank frame = the compositor never painted (occluded window). Re-force and re-capture ONCE. We do+  // NOT foreground to fix this, ever - that is the user's focus, not ours to take.+  let recovered = false, stillBlank = false;+  if (await frameIsBlank(res.data)) {+    forced.push(...(await forceFrame(tabId)), 'recapture');+    const res2 = await send(tabId, 'Page.captureScreenshot', params);+    if (await frameIsBlank(res2.data)) stillBlank = true;+    else { res = res2; recovered = true; }+  }+  bumpIdle(tabId);+  const out = resize ? await resizePng(res.data, maxWidth) : await pngDims(res.data);+  const iw = out.width, ih = out.height, ow = out.origWidth ?? out.width, oh = out.origHeight ?? out.height;+  // Viewport coordinate-map, sampled AT capture time, so screenshot-pixel -> click-coordinate mapping is+  // exact and never needs a separate probe (and can't drift from a later scroll). To turn a pixel (sx,sy)+  // in the RETURNED image into a viewport click coordinate (CSS px, what nbrowser_click/input_dispatch+  // take): clickX = sx * cssPerImageX, clickY = sy * cssPerImageY. scrollX/scrollY are included for+  // page-absolute math; devicePixelRatio + captured/image dims are given so any custom mapping is possible.+  let viewport = null;+  try {+    const m = await evaluate(tabId, '({iw:innerWidth,ih:innerHeight,dpr:devicePixelRatio,sx:Math.round(scrollX),sy:Math.round(scrollY),dw:Math.round(document.documentElement.scrollWidth),dh:Math.round(document.documentElement.scrollHeight)})');+    if (m && typeof m === 'object') {+      const spanW = fullPage ? m.dw : m.iw, spanH = fullPage ? m.dh : m.ih;   // CSS px the image spans+      viewport = {+        innerWidth: m.iw, innerHeight: m.ih, devicePixelRatio: m.dpr,+        scrollX: m.sx, scrollY: m.sy,+        capturedWidth: ow, capturedHeight: oh,       // raw CDP capture px (~ span*dpr)+        imageWidth: iw, imageHeight: ih,             // the returned (possibly downscaled) image px+        resizeRatio: ow ? +(iw / ow).toFixed(6) : 1,+        fullPage: !!fullPage,                        // true = image spans the whole page; coords are page-absolute+        cssPerImageX: iw ? +(spanW / iw).toFixed(6) : 1,   // <- multiply a screenshot X by this to get a click X (CSS px)+        cssPerImageY: ih ? +(spanH / ih).toFixed(6) : 1,+      };+    }+  } catch (e) {}+  const shot = { ok: true, base64: out.base64, width: iw, height: ih, origWidth: ow, origHeight: oh,+    resized: !!out.resized, sizeKB: Math.round((out.base64.length * 3 / 4) / 1024), viewport,+    // Tell the AI what we did to get a live frame WITHOUT focus, so "I had to foreground it to see the+    // page" is never a conclusion it can honestly reach.+    capture: { forcedRepaint: forced, blankRecovered: recovered, blank: stillBlank } };+  if (stillBlank) {+    shot._hint = 'The page composited a BLANK frame even after a forced repaint (lifecycle:active + double rAF). ' ++      'Do NOT foreground the window to fix this - that steals the user\'s focus and is not the fix anyway. ' ++      'Use ab desktop_screenshot_window {hwnd} instead: WGC captures an OCCLUDED window at the OS level, ' ++      'chrome included. If you own this Chrome, relaunching it with --disable-features=CalculateNativeWinOcclusion ' ++      '--disable-backgrounding-occluded-windows --disable-renderer-backgrounding stops it happening at all.';+  } else if (recovered) {+    shot._hint = 'This window was NOT painting (occluded/backgrounded); nbe forced a repaint and captured a live ' ++      'frame with the window still in the background. You never need to foreground a window to screenshot it.';+  }+  // A native JS dialog does NOT appear in a CDP capture (it's browser chrome, not page content), so tell+  // the AI explicitly - otherwise it screenshots, sees a normal page, and never realizes a modal is up.+  const dlg = _openDialogs.get(Number(tabId));+  if (dlg) shot._modal = `⚠️ a native ${dlg.type} dialog is open ("${(dlg.message || '').slice(0, 120)}") - it is NOT in this screenshot (dialogs are browser chrome) and it is BLOCKING the page. Dismiss it with nbrowser_handle_dialog {sessionId, accept:true|false} before doing anything else.`;+  return shot;+}++// ---- nbrowser_eval / nbrowser_evaluate ------------------------------------+export async function evaluate(tabId, expr) {+  await attach(tabId);+  // SPA route changes (e.g. Gusto's wizard steps) tear down the execution+  // context; for a short window Runtime.evaluate can throw "Cannot find+  // context with specified id" or come back with neither result nor+  // exceptionDetails. Retry a few times so callers don't see a phantom+  // empty/undefined right after an in-app navigation.+  let res;+  for (let attempt = 0; attempt < 4; attempt++) {+    try {+      res = await send(tabId, 'Runtime.evaluate', {+        expression: `(${expr})`,+        returnByValue: true,+        awaitPromise: true,+        userGesture: true,+      });+    } catch (err) {+      const msg = String((err && err.message) || err);+      if (/context|detached|target closed|destroyed/i.test(msg) && attempt < 3) {+        await attach(tabId);                 // re-resolve the context+        await new Promise((r) => setTimeout(r, 250 * (attempt + 1)));+        continue;+      }+      throw err;+    }+    // A torn-down context yields an empty envelope (no result, no exception).+    if (!res || (!res.result && !res.exceptionDetails)) {+      if (attempt < 3) {+        await new Promise((r) => setTimeout(r, 250 * (attempt + 1)));+        continue;+      }+    }+    break;+  }+  bumpIdle(tabId);+  if (res && res.exceptionDetails) {+    const e = res.exceptionDetails;+    return { __error: (e.exception && (e.exception.description || e.exception.value)) || e.text };+  }+  return res && res.result ? res.result.value : undefined;+}++// ---- input dispatch (CDP Input domain → isTrusted events) ------------------+const KEYMAP = {+  Enter: { key: 'Enter', code: 'Enter', vk: 13 },+  Tab: { key: 'Tab', code: 'Tab', vk: 9 },+  Escape: { key: 'Escape', code: 'Escape', vk: 27 },+  Backspace: { key: 'Backspace', code: 'Backspace', vk: 8 },+  Delete: { key: 'Delete', code: 'Delete', vk: 46 },+  ArrowUp: { key: 'ArrowUp', code: 'ArrowUp', vk: 38 },+  ArrowDown: { key: 'ArrowDown', code: 'ArrowDown', vk: 40 },+  ArrowLeft: { key: 'ArrowLeft', code: 'ArrowLeft', vk: 37 },+  ArrowRight: { key: 'ArrowRight', code: 'ArrowRight', vk: 39 },+  Home: { key: 'Home', code: 'Home', vk: 36 },+  End: { key: 'End', code: 'End', vk: 35 },+};++async function pressKey(tabId, name) {+  const k = KEYMAP[name] || { key: name, code: name, vk: name.length === 1 ? name.toUpperCase().charCodeAt(0) : 0 };+  const base = { key: k.key, code: k.code, windowsVirtualKeyCode: k.vk, nativeVirtualKeyCode: k.vk };+  await send(tabId, 'Input.dispatchKeyEvent', { type: 'keyDown', ...base });+  await send(tabId, 'Input.dispatchKeyEvent', { type: 'keyUp', ...base });+}++async function mouseClick(tabId, x, y, button = 'left', clickCount = 1) {+  await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });+  await send(tabId, 'Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button, clickCount, buttons: button === 'right' ? 2 : 1 });+  await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button, clickCount, buttons: 0 });+}++// Port of pup's modal-aware smart-pick: resolve a selector to the best visible element's center.+function scoreExpr(selector, firstMatch) {+  const sel = JSON.stringify(selector);+  return `(function(){+    var els=[].slice.call(document.querySelectorAll(${sel}));+    if(!els.length)return{found:false,count:0};+    function vis(el){var r=el.getBoundingClientRect(),s=getComputedStyle(el);+      return r.width>0&&r.height>0&&s.visibility!=='hidden'&&s.display!=='none'&&parseFloat(s.opacity||'1')>0.01;}+    var c=els.filter(vis); if(!c.length)c=els;+    var modal=document.querySelector('dialog[open],[aria-modal="true"],[role="dialog"]');+    if(modal){var m=c.filter(function(e){return modal.contains(e);});if(m.length)c=m;}+    var chosen=${firstMatch ? 'c[0]' : 'c.reduce(function(a,b){var ra=a.getBoundingClientRect(),rb=b.getBoundingClientRect();return (rb.width*rb.height)>(ra.width*ra.height)?b:a;})'};+    if(chosen.scrollIntoView)chosen.scrollIntoView({block:'center',inline:'center'});+    var r=chosen.getBoundingClientRect();+    return{found:true,count:c.length,x:Math.round(r.left+r.width/2),y:Math.round(r.top+r.height/2),+      rect:{x:Math.round(r.left),y:Math.round(r.top),w:Math.round(r.width),h:Math.round(r.height)},+      text:((chosen.innerText||chosen.value||'')+'').slice(0,60),modal:!!modal};+  })()`;+}+function focusExpr(selector) {+  const sel = JSON.stringify(selector);+  return `(function(){var e=document.querySelector(${sel});if(!e)return{found:false};if(e.focus)e.focus();if(e.scrollIntoView)e.scrollIntoView({block:'center'});return{found:true};})()`;+}++const sleep = (ms) => new Promise((r) => setTimeout(r, ms));++// ---- visible Adom cursor — EXACT match to Hydrogen's AI cursor (hd-control AI_CURSOR_JS) --------------+// Teal Adom arrow (#00b8b0) + dark-teal outline + teal glow, a pulsing teal ring, and a monospace+// "Adom" label so the user always knows it's an Adom-driven cursor (trust). Kept byte-faithful to Hydrogen+// so the cursor looks identical across the whole product.+function cursorScript(action, x, y, label) {+  var id = '__adom_cursor__';+  var c = document.getElementById(id);+  if (action === 'hide') { if (c) c.style.display = 'none'; return; }+  if (!c) {+    c = document.createElement('div');+    c.id = id;+    c.style.cssText = 'position:fixed;z-index:2147483647;pointer-events:none;transition:left 0.15s,top 0.15s;display:none;';+    var g = document.createElement('div'); // pulsing teal glow ring+    g.id = '__adom_cursor_ring__';+    g.style.cssText = 'position:absolute;top:-16px;left:-16px;width:40px;height:40px;border-radius:50%;background:rgba(0,184,176,0.15);border:2px solid rgba(0,184,176,0.4);animation:adomCurP 1.5s ease-in-out infinite;';+    c.appendChild(g);+    var a = document.createElement('div'); // the teal Adom arrow (Hydrogen's exact SVG)+    a.innerHTML = '<svg width="20" height="28" viewBox="0 0 20 28" xmlns="http://www.w3.org/2000/svg"><path d="M1 1L1 22L6.5 16.5L10.5 26L14 24.5L10 15L17 15Z" fill="#00b8b0" stroke="#004d49" stroke-width="1.2" stroke-linejoin="round"/></svg>';+    a.style.cssText = 'position:absolute;top:0;left:0;filter:drop-shadow(0 0 6px rgba(0,184,176,0.7));';+    c.appendChild(a);+    var l = document.createElement('div'); // the "Adom" trust label+    l.id = '__adom_cursor_label__';+    l.style.cssText = 'position:absolute;top:32px;left:8px;white-space:nowrap;font-size:11px;color:#00b8b0;background:rgba(13,17,23,0.92);padding:2px 10px;border-radius:4px;border:1px solid rgba(0,184,176,0.6);font-family:monospace;';+    c.appendChild(l);+    (document.body || document.documentElement).appendChild(c);+    if (!document.getElementById('__adom_cur_kf__')) {+      var s = document.createElement('style'); s.id = '__adom_cur_kf__';+      s.textContent = '@keyframes adomCurP{0%{transform:scale(1);opacity:0.7}50%{transform:scale(1.5);opacity:0.2}100%{transform:scale(1);opacity:0.7}}@keyframes adomCurClick{0%{transform:scale(1);opacity:0.85}45%{transform:scale(2.2);opacity:0.05}100%{transform:scale(1);opacity:0.7}}';+      document.head.appendChild(s);+    }+  }+  var lab = c.querySelector('#__adom_cursor_label__');+  if (lab) {+    lab.textContent = (label != null ? label : 'Adom');+    // flip the label to the LEFT of the cursor when near the right edge, so it never clips offscreen+    var nearRight = (x != null) && (x > (window.innerWidth - 250));+    if (nearRight) { lab.style.left = 'auto'; lab.style.right = '0px'; lab.style.textAlign = 'right'; }+    else { lab.style.left = '8px'; lab.style.right = 'auto'; lab.style.textAlign = 'left'; }+  }+  if (x != null && y != null) { c.style.left = x + 'px'; c.style.top = y + 'px'; }+  c.style.display = 'block';+  if (action === 'click') {+    var ring = c.querySelector('#__adom_cursor_ring__');+    if (ring) { ring.style.animation = 'none'; void ring.offsetWidth; ring.style.animation = 'adomCurClick 0.45s ease-out, adomCurP 1.5s ease-in-out infinite 0.45s'; }+  }+}+export async function cursor(tabId, action, x, y, label) {+  try { await chrome.scripting.executeScript({ target: { tabId }, func: cursorScript, args: [action, x == null ? null : x, y == null ? null : y, label == null ? null : String(label)] }); } catch (e) {}+}++// Hydrogen-style intention narration for the cursor label. phase 'find' = while gliding there; 'act' = doing it.+function phaseLabel(type, tgt, phase) {+  const name = tgt ? `"${tgt}"` : 'this';+  if (type === 'hover') return phase === 'act' ? `Hovering ${name}` : `Moving to ${name}`;+  if (type === 'dblclick' || type === 'doubleclick') return phase === 'act' ? `Double-clicking ${name}` : `Finding ${name}`;+  if (type === 'rightclick' || type === 'contextmenu') return phase === 'act' ? `Right-clicking ${name}` : `Finding ${name}`;+  return phase === 'act' ? `Clicking ${name}` : `Finding ${name}`;+}++// ---- smart finder: locate visible interactive elements (for the screenshot->find->click loop) -----+// Injected via chrome.scripting (no debugger banner). Matches by visible text / aria-label.+// `rich`: when true, attach per-candidate debug data (score/scoreBreakdown, occlusion, visibility,+// inViewport, a best-effort CSS selector) WITHOUT changing the selection order — chosen stays index 0,+// so {debug:true} never regresses a click. The numeric `score` is for human/AI debugging only.+function findFn(query, limit, rich) {+  var q = (query || '').toLowerCase();+  var sel = 'a,button,[role=button],[role=link],[role=menuitem],[role=menuitemradio],[role=menuitemcheckbox],[role=tab],[role=checkbox],[role=radio],[role=switch],[role=option],[role=combobox],[role=treeitem],[role=gridcell],input,select,textarea,summary,[onclick],[tabindex],[contenteditable]';+  // Deep collector: light DOM + every OPEN shadow root (recursively). Custom-element finance/SPA+  // widgets (Schwab account picker, QBO report search) put their real options INSIDE shadow roots that+  // document.querySelectorAll can't see - so we descend into each element's .shadowRoot. (Closed shadow+  // roots are invisible to any script; only open ones are reachable, which covers the vast majority.)+  function deepQ(root, s) {+    var acc = [];+    (function walk(node) {+      try { acc.push.apply(acc, node.querySelectorAll(s)); } catch (e) {}+      var kids; try { kids = node.querySelectorAll('*'); } catch (e) { kids = []; }+      for (var i = 0; i < kids.length; i++) { var sr = kids[i].shadowRoot; if (sr) walk(sr); }+    })(root || document);+    return acc;+  }+  // Scroll the winner to centre and re-read its geometry: the coordinates we hand back are viewport+  // coordinates, so a candidate that was off-screen when matched must be brought on-screen BEFORE its+  // x/y are computed. Without this the dispatch fires at stale/offscreen coordinates and silently+  // misses (nb-bridge #20: right element resolved, changed:false, DOM untouched).+  function centre(list) {+    if (!list.length) return list;+    var top = list[0];+    if (top && top._el && top._el.scrollIntoView) {+      try { top._el.scrollIntoView({ block: 'center', inline: 'center' }); } catch (e) {}+      var r = top._el.getBoundingClientRect();+      top.rect = { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) };+      top.x = Math.round(r.left + r.width / 2); top.y = Math.round(r.top + r.height / 2);+    }+    for (var i = 0; i < list.length; i++) delete list[i]._el;+    return list;+  }+  var els = deepQ(document, sel);+  // RENDERED, not necessarily ON-SCREEN. Requiring the element to be inside the viewport made every+  // target the user had scrolled past invisible to click-by-text (nb-bridge #20): the interactive pass+  // found nothing and the fallback returned <body>/<html>. resolveCoords scrolls the chosen element to+  // centre before dispatching, so off-viewport-but-rendered is perfectly clickable.+  function vis(el) { var r = el.getBoundingClientRect(), s = getComputedStyle(el); return r.width > 1 && r.height > 1 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01; }+  // NEVER a click target: the document/root containers match almost any text and clicking them does+  // nothing (or hits whatever is underneath). Excluding them also removes the phantom second+  // "candidate" that produced false ambiguous_target refusals.+  function clickable(el) { var t = (el.tagName || '').toUpperCase(); return t !== 'HTML' && t !== 'BODY' && t !== 'HEAD' && t !== 'SCRIPT' && t !== 'STYLE' && t !== 'NOSCRIPT'; }+  function txt(el) { return ((el.innerText || el.value || el.getAttribute('aria-label') || el.getAttribute('placeholder') || el.getAttribute('title') || '') + '').replace(/\s+/g, ' ').trim(); }+  function cssPath(el) { try { if (!el || el.nodeType !== 1) return ''; if (el.id) return '#' + el.id; var p = el.tagName.toLowerCase(); var cn = el.className; cn = (cn && cn.baseVal !== undefined ? cn.baseVal : cn) || ''; var cls = ('' + cn).trim().split(/\s+/).filter(Boolean).slice(0, 2); if (cls.length) p += '.' + cls.join('.'); var par = el.parentElement; if (par) { var same = [].slice.call(par.children).filter(function (x) { return x.tagName === el.tagName; }); if (same.length > 1) p += ':nth-of-type(' + (same.indexOf(el) + 1) + ')'; } return p; } catch (e) { return ''; } }+  function richOf(el, t, al) {+    var r = el.getBoundingClientRect(); var tl = (t || '').toLowerCase(); var tag = el.tagName.toLowerCase();+    var textMatch = !q ? 0 : tl === q ? 100 : al === q ? 95 : tl.indexOf(q) === 0 ? 70 : tl.indexOf(q) >= 0 ? 50 : al.indexOf(q) >= 0 ? 40 : 0;+    var clickableTag = (/^(a|button|input|select|textarea|summary)$/.test(tag) || el.getAttribute('role')) ? 20 : 0;+    var visible = vis(el); var visibility = visible ? 10 : 0;+    var inViewport = r.top >= 0 && r.left >= 0 && r.bottom <= (innerHeight || 0) && r.right <= (innerWidth || 0);+    var cx = Math.round(r.left + r.width / 2), cy = Math.round(r.top + r.height / 2);+    var occluded = false, occludedBy = '';+    try { var top = document.elementFromPoint(cx, cy); if (top && top !== el && !el.contains(top) && !top.contains(el)) { occluded = true; occludedBy = cssPath(top); } } catch (e) {}+    var occlusionPenalty = occluded ? -30 : 0;+    return { score: textMatch + clickableTag + visibility + occlusionPenalty, scoreBreakdown: { textMatch: textMatch, clickableTag: clickableTag, visibility: visibility, occlusionPenalty: occlusionPenalty, area: Math.round(r.width * r.height) }, visible: visible, occluded: occluded, occludedBy: occludedBy, inViewport: inViewport, selector: cssPath(el) };+  }+  function mk(el, t, r) { var o = { _el: el, text: (t || '').slice(0, 80), tag: el.tagName.toLowerCase(), role: el.getAttribute('role') || '', type: el.type || '', x: Math.round(r.left + r.width / 2), y: Math.round(r.top + r.height / 2), rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height), centerX: Math.round(r.left + r.width / 2), centerY: Math.round(r.top + r.height / 2) } }; if (rich) { var rf = richOf(el, t, (el.getAttribute('aria-label') || '').toLowerCase()); for (var k in rf) o[k] = rf[k]; } return o; }+  var out = [];+  for (var i = 0; i < els.length; i++) {+    var el = els[i]; if (!vis(el) || !clickable(el)) continue; var t = txt(el); var al = (el.getAttribute('aria-label') || '').toLowerCase();+    if (q && t.toLowerCase().indexOf(q) < 0 && al.indexOf(q) < 0) continue;+    out.push(mk(el, t, el.getBoundingClientRect()));+  }+  // Fallback: hover/move targets are often NON-interactive (info icons, cards, tooltip+  // triggers, plain spans). If nothing interactive matched the text, scan all elements and+  // take the smallest (leaf-most) visible element whose text contains the query — that's the+  // specific thing the user named, not a giant wrapping container.+  if (q && out.length === 0) {+    var all = deepQ(document, '*');+    var fb = [];+    for (var j = 0; j < all.length; j++) {+      var e2 = all[j]; if (!vis(e2) || !clickable(e2)) continue;+      var t2 = ((e2.innerText || e2.textContent || '') + '').replace(/\s+/g, ' ').trim();+      if (!t2 || t2.toLowerCase().indexOf(q) < 0) continue;+      var r2 = e2.getBoundingClientRect();+      var o2 = mk(e2, t2, r2); o2.area = r2.width * r2.height; fb.push(o2);+    }+    // exact text match wins, else smallest area (most specific leaf) — return directly,+    // skipping the interactive-pass sort below (which prefers LARGEST, wrong for leaves).+    fb.sort(function (a, b) { var ae = a.text.toLowerCase() === q ? 0 : 1, be = b.text.toLowerCase() === q ? 0 : 1; if (ae !== be) return ae - be; return a.area - b.area; });+    return centre(fb.map(function (o) { delete o.area; return o; }).slice(0, limit || 40));+  }+  out.sort(function (a, b) { var ae = a.text.toLowerCase() === q ? 0 : 1, be = b.text.toLowerCase() === q ? 0 : 1; if (ae !== be) return ae - be; return (b.rect.w * b.rect.h) - (a.rect.w * a.rect.h); });+  return centre(out.slice(0, limit || 40));+}+export async function find(tabId, query, limit, rich) {+  try {+    const r = await chrome.scripting.executeScript({ target: { tabId }, func: findFn, args: [query || '', limit || 40, !!rich] });+    const els = (r && r[0] && r[0].result) || [];+    return { ok: true, query: query || '', count: els.length, elements: els };+  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }+}++// All visible matches of a CSS selector, with debug data — for {debug}/{resolveOnly} on selector targets.+function selectorCandidatesFn(selector) {+  // Light-DOM first (fast, honors combinators). If it finds nothing, deep-walk every open shadow root and+  // match each element with .matches(selector) - so a stable attribute (e.g. [data-testid=x]) or class/tag+  // selector pierces custom-element shadow DOM. (Cross-shadow combinators like ".a > .b" only match within+  // one root; simple attribute/class/tag/role selectors are what this recovers, which is the common case.)+  var els = [].slice.call(document.querySelectorAll(selector));+  if (!els.length) {+    var deep = [];+    (function walk(node) {+      var kids; try { kids = node.querySelectorAll('*'); } catch (e) { kids = []; }+      for (var i = 0; i < kids.length; i++) {+        var el = kids[i];+        try { if (el.matches && el.matches(selector)) deep.push(el); } catch (e) {}+        if (el.shadowRoot) walk(el.shadowRoot);+      }+    })(document);+    els = deep;+  }+  function vis(el) { var r = el.getBoundingClientRect(), s = getComputedStyle(el); return r.width > 0 && r.height > 0 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01; }+  function cssPath(el) { try { if (el.id) return '#' + el.id; var p = el.tagName.toLowerCase(); var par = el.parentElement; if (par) { var same = [].slice.call(par.children).filter(function (x) { return x.tagName === el.tagName; }); if (same.length > 1) p += ':nth-of-type(' + (same.indexOf(el) + 1) + ')'; } return p; } catch (e) { return ''; } }+  var c = els.filter(vis); if (!c.length) c = els;+  var modal = document.querySelector('dialog[open],[aria-modal="true"],[role="dialog"]');+  if (modal) { var m = c.filter(function (e) { return modal.contains(e); }); if (m.length) c = m; }+  if (!c.length) return [];+  var chosenEl = c.reduce(function (a, b) { var ra = a.getBoundingClientRect(), rb = b.getBoundingClientRect(); return (rb.width * rb.height) > (ra.width * ra.height) ? b : a; });+  return c.slice(0, 40).map(function (el) {+    var r = el.getBoundingClientRect(); var cx = Math.round(r.left + r.width / 2), cy = Math.round(r.top + r.height / 2);+    var occ = false, occBy = ''; try { var top = document.elementFromPoint(cx, cy); if (top && top !== el && !el.contains(top) && !top.contains(el)) { occ = true; occBy = cssPath(top); } } catch (e) {}+    return { text: ((el.innerText || el.value || '') + '').replace(/\s+/g, ' ').trim().slice(0, 80), tag: el.tagName.toLowerCase(), role: el.getAttribute('role') || '', selector: cssPath(el), x: cx, y: cy, rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height), centerX: cx, centerY: cy }, score: el === chosenEl ? 100 : 50, scoreBreakdown: { rule: 'largest-visible-match', area: Math.round(r.width * r.height) }, visible: vis(el), occluded: occ, occludedBy: occBy, inViewport: r.top >= 0 && r.left >= 0 && r.bottom <= innerHeight && r.right <= innerWidth, chosen: el === chosenEl };+  });+}++// ---- nbrowser_select: open a custom dropdown and pick an option by its VISIBLE TEXT ----------------+// Solves: coordinate clicks on virtualized/custom option lists land on the WRONG row (mis-selecting a+// bank account by one row). This locates the trigger (by accessible `label` or the `near` text beside+// it), opens it with an isTrusted CDP click, WAITS for the options to render, clicks the EXACT text+// match (shadow-piercing), and returns the newly-displayed value so the caller can verify.+function selectTriggerFn(label, near) {+  function deepQ(root, s) { var a = []; (function w(n) { try { a.push.apply(a, n.querySelectorAll(s)); } catch (e) {} var k; try { k = n.querySelectorAll('*'); } catch (e) { k = []; } for (var i = 0; i < k.length; i++) { var sr = k[i].shadowRoot; if (sr) w(sr); } })(root || document); return a; }+  function vis(el) { var r = el.getBoundingClientRect(), s = getComputedStyle(el); return r.width > 1 && r.height > 1 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01 && r.top < innerHeight && r.bottom > 0; }+  function txt(el) { return (((el.getAttribute && (el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('placeholder'))) || el.innerText || el.textContent || '') + '').replace(/\s+/g, ' ').trim(); }+  var cand = null;+  if (label) {+    var lab = (label + '').toLowerCase();+    var trigs = deepQ(document, 'select,[role=combobox],[role=listbox],[aria-haspopup],button,[role=button],input').filter(vis);+    trigs.sort(function (a, b) { function sc(e) { var t = txt(e).toLowerCase(); return t === lab ? 3 : t.indexOf(lab) === 0 ? 2 : t.indexOf(lab) >= 0 ? 1 : 0; } return sc(b) - sc(a); });+    if (trigs.length && txt(trigs[0]).toLowerCase().indexOf(lab) >= 0) cand = trigs[0];+  }+  if (!cand && near) {+    var nl = (near + '').toLowerCase();+    var texts = deepQ(document, 'label,span,div,legend,th,td,p').filter(function (e) { return vis(e) && txt(e).toLowerCase().indexOf(nl) >= 0; });+    texts.sort(function (a, b) { return txt(a).length - txt(b).length; });+    if (texts.length) {+      var L = texts[0], forId = L.getAttribute && L.getAttribute('for');+      if (forId) { var t = document.getElementById(forId); if (t && vis(t)) cand = t; }+      if (!cand) {+        var lr = L.getBoundingClientRect(), lx = lr.left + lr.width / 2, ly = lr.top + lr.height / 2;+        var ctrls = deepQ(document, 'select,[role=combobox],[aria-haspopup],button,[role=button],input,[role=listbox]').filter(vis);+        ctrls.sort(function (a, b) { var ra = a.getBoundingClientRect(), rb = b.getBoundingClientRect(); return Math.hypot(ra.left + ra.width / 2 - lx, ra.top + ra.height / 2 - ly) - Math.hypot(rb.left + rb.width / 2 - lx, rb.top + rb.height / 2 - ly); });+        if (ctrls.length) cand = ctrls[0];+      }+    }+  }+  if (!cand) return { found: false };+  var r = cand.getBoundingClientRect();+  // `display` = the trigger's now-VISIBLE text (what a human sees selected), preferred for the readback.+  // `current` = its accessible name (aria-label/title/placeholder, used for finding) - kept as fallback.+  var disp = ((cand.innerText || cand.textContent || '') + '').replace(/\s+/g, ' ').trim();+  return { found: true, x: Math.round(r.left + r.width / 2), y: Math.round(r.top + r.height / 2), tag: cand.tagName.toLowerCase(), isNativeSelect: cand.tagName.toLowerCase() === 'select', current: txt(cand).slice(0, 120), display: disp.slice(0, 120) };+}+function nativeSetFn(x, y, optionText) {+  var el = document.elementFromPoint(x, y); while (el && el.tagName !== 'SELECT') el = el.parentElement;+  if (!el) return { ok: false, error: 'native select not found at point' };+  var ot = (optionText + '').toLowerCase(), opts = [].slice.call(el.options), m = null;+  for (var i = 0; i < opts.length; i++) { if ((opts[i].text || '').replace(/\s+/g, ' ').trim().toLowerCase() === ot) { m = opts[i]; break; } }+  if (!m) for (var j = 0; j < opts.length; j++) { if ((opts[j].text || '').toLowerCase().indexOf(ot) >= 0) { m = opts[j]; break; } }+  if (!m) return { ok: false, error: 'option not found in select: ' + optionText };+  el.value = m.value; el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true }));+  return { ok: true, selected: (m.text || '').replace(/\s+/g, ' ').trim() };+}+function findOptionFn(optionText) {+  function deepQ(root, s) { var a = []; (function w(n) { try { a.push.apply(a, n.querySelectorAll(s)); } catch (e) {} var k; try { k = n.querySelectorAll('*'); } catch (e) { k = []; } for (var i = 0; i < k.length; i++) { var sr = k[i].shadowRoot; if (sr) w(sr); } })(root || document); return a; }+  function txt(e) { return ((e.innerText || e.textContent || '') + '').replace(/\s+/g, ' ').trim(); }+  var ot = (optionText + '').toLowerCase();+  var opts = deepQ(document, '[role=option],[role=menuitem],[role=menuitemradio],[role=treeitem],[role=row],li,option,a,button').filter(function (e) { var r = e.getBoundingClientRect(), s = getComputedStyle(e); return r.width > 1 && r.height > 1 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01; });+  var exact = opts.filter(function (e) { return txt(e).toLowerCase() === ot; });+  var cont = exact.length ? exact : opts.filter(function (e) { return txt(e).toLowerCase().indexOf(ot) >= 0; });+  if (!cont.length) return { found: false, optionCount: opts.length };+  cont.sort(function (a, b) { var ra = a.getBoundingClientRect(), rb = b.getBoundingClientRect(); return (ra.width * ra.height) - (rb.width * rb.height); }); // smallest = leaf-most option row+  var el = cont[0], r = el.getBoundingClientRect();+  return { found: true, x: Math.round(r.left + r.width / 2), y: Math.round(r.top + r.height / 2), text: txt(el).slice(0, 120), exact: exact.length > 0, optionCount: opts.length };+}+export async function selectOption(tabId, args) {+  await attach(tabId);+  const timeoutMs = Math.min(Math.max(Number(args.timeoutMs) || 4000, 500), 20000);+  const inj = (func, a) => chrome.scripting.executeScript({ target: { tabId }, func, args: a }).then((r) => r && r[0] && r[0].result);+  const t = await inj(selectTriggerFn, [args.label || '', args.near || '']);+  if (!t || !t.found) return { ok: false, error: 'dropdown trigger not found' + (args.label ? ` for label "${args.label}"` : '') + (args.near ? ` near "${args.near}"` : ''), _hint: 'pass label (the control\'s accessible name / visible text) or near (a visible text label beside it)' };+  if (t.isNativeSelect) {+    const r = await inj(nativeSetFn, [t.x, t.y, args.optionText || '']);+    return r && r.ok ? { ok: true, selected: r.selected, via: 'native-select', matchedExact: true, _hint: 'set a native <select> by option text and dispatched change.' } : { ok: false, error: (r && r.error) || 'native select failed' };+  }+  await mouseClick(tabId, t.x, t.y);   // open (isTrusted)+  let opt = null; const deadline = Date.now() + timeoutMs; let lastCount = 0;+  while (Date.now() < deadline) {+    await new Promise((r) => setTimeout(r, 150));+    const o = await inj(findOptionFn, [args.optionText || '']);+    if (o) { lastCount = o.optionCount || lastCount; if (o.found) { opt = o; break; } }+  }+  if (!opt) return { ok: false, error: `option "${args.optionText}" did not appear after opening the dropdown (${lastCount} option(s) seen)`, _hint: 'the trigger opened but no option matched that EXACT visible text; check spelling/case, or raise timeoutMs for a slow/virtualized list' };+  await mouseClick(tabId, opt.x, opt.y);   // pick (isTrusted)+  await new Promise((r) => setTimeout(r, 220));+  const after = await inj(selectTriggerFn, [args.label || '', args.near || '']);+  // Prefer the trigger's now-visible display text; fall back to the option we clicked.+  const selected = (after && after.found && (after.display || after.current)) || opt.text;+  return { ok: true, selected, matchedExact: opt.exact, clickedText: opt.text, via: 'custom-dropdown', _hint: `selected "${selected}". Verify it matches what you intended before continuing.` };+}++// ---- annotated overlay shot: draw every candidate's rect (numbered), chosen highlighted, click crosshair.+// Injected into the page, CDP-screenshotted, then removed — so the overlay never lingers. Rects are+// viewport-relative (getBoundingClientRect), and we capture the viewport, so fixed-positioned boxes align.+function overlayDrawFn(boxes, chosenIndex, clickX, clickY) {+  var id = '__adom_finder_overlay__'; var prev = document.getElementById(id); if (prev) prev.remove();+  var o = document.createElement('div'); o.id = id; o.style.cssText = 'position:fixed;inset:0;z-index:2147483646;pointer-events:none;margin:0;padding:0;';+  for (var i = 0; i < boxes.length; i++) {+    var c = boxes[i], r = c.rect, chosen = (i === chosenIndex);+    var col = chosen ? '#00e676' : (c.occluded ? '#ff5252' : '#ffb300');+    var b = document.createElement('div');+    b.style.cssText = 'position:fixed;left:' + r.x + 'px;top:' + r.y + 'px;width:' + r.w + 'px;height:' + r.h + 'px;border:' + (chosen ? '3px' : '2px') + ' solid ' + col + ';box-sizing:border-box;background:' + (chosen ? 'rgba(0,230,118,0.14)' : 'transparent') + ';';+    var lab = document.createElement('div'); lab.textContent = i + (chosen ? ' ★' : '') + (c.occluded ? ' ⛔' : '');+    lab.style.cssText = 'position:absolute;top:-15px;left:0;font:bold 12px/14px monospace;color:#000;background:' + col + ';padding:0 4px;border-radius:3px;white-space:nowrap;';+    b.appendChild(lab); o.appendChild(b);+  }+  if (clickX != null && clickY != null) {+    var ch = document.createElement('div'); ch.style.cssText = 'position:fixed;left:' + (clickX - 11) + 'px;top:' + (clickY - 11) + 'px;width:22px;height:22px;pointer-events:none;';+    ch.innerHTML = '<svg width="22" height="22"><line x1="11" y1="0" x2="11" y2="22" stroke="#2979ff" stroke-width="2"/><line x1="0" y1="11" x2="22" y2="11" stroke="#2979ff" stroke-width="2"/><circle cx="11" cy="11" r="7" fill="none" stroke="#2979ff" stroke-width="2"/></svg>';+    o.appendChild(ch);+  }+  (document.body || document.documentElement).appendChild(o);+}+function overlayClearFn() { var o = document.getElementById('__adom_finder_overlay__'); if (o) o.remove(); }++async function annotateShot(tabId, candidates, chosenIndex, x, y) {+  try {+    const boxes = candidates.map((c) => ({ rect: c.rect, occluded: !!c.occluded }));+    await chrome.scripting.executeScript({ target: { tabId }, func: overlayDrawFn, args: [boxes, chosenIndex == null ? -1 : chosenIndex, x == null ? null : x, y == null ? null : y] });+    const shot = await screenshot(tabId, { fullPage: false, maxWidth: 1568, resize: true });+    await chrome.scripting.executeScript({ target: { tabId }, func: overlayClearFn }).catch(() => {});+    return { base64: shot.base64, width: shot.width, height: shot.height };+  } catch (e) {+    try { await chrome.scripting.executeScript({ target: { tabId }, func: overlayClearFn }); } catch (_) {}+    return { __error: String((e && e.message) || e) };+  }+}++// Build the debug `finder` object (incl. shots + annotatedShot as base64; the bridge spills them to files).+async function buildFinder(tabId, query, candidates, chosenIndex, x, y, withShots) {+  const finder = { query, chosenIndex, candidates };+  if (withShots !== false) {+    try { const raw = await screenshot(tabId, { fullPage: false, maxWidth: 1568, resize: true }); if (raw && raw.base64) finder.shots = [{ label: 'viewport-raw', base64: raw.base64 }]; } catch (e) {}+    const ann = await annotateShot(tabId, candidates, chosenIndex, x, y);+    if (ann && ann.base64) finder.annotatedShot = { base64: ann.base64, width: ann.width, height: ann.height };+    else if (ann && ann.__error) finder.annotatedShotError = ann.__error;+  }+  return finder;+}++// Resolve target xy. When `rich`, also return the full candidate set + chosenIndex + structured query.+async function resolveCoords(tabId, args, rich) {+  if (args.selector) {+    if (rich) {+      const cands = await evaluate(tabId, `(${selectorCandidatesFn.toString()})(${JSON.stringify(args.selector)})`);+      const list = Array.isArray(cands) ? cands : [];+      const ci = Math.max(0, list.findIndex((c) => c.chosen));+      if (!list.length) return { found: false, candidates: [], chosenIndex: -1, query: { selector: args.selector, intent: args.intent } };+      const el = list[ci] || list[0];+      return { found: true, x: el.x, y: el.y, info: { selector: args.selector, matchedCount: list.length, clickedRect: el.rect, clickedText: el.text }, candidates: list, chosenIndex: ci, query: { selector: args.selector, intent: args.intent } };+    }+    const r = await evaluate(tabId, scoreExpr(args.selector, !!args.firstMatch));+    if (!r || !r.found) return { found: false };+    return { found: true, x: r.x, y: r.y, info: { selector: args.selector, matchedCount: r.count, clickedRect: r.rect, clickedText: r.text, modalDetected: r.modal } };+  }+  if (args.text) { // click/hover BY VISIBLE TEXT — the smart-click path+    const f = await find(tabId, args.text, rich ? 16 : 10, rich);+    if (!f.ok || !f.elements.length) return { found: false, candidates: [], chosenIndex: -1, query: { text: args.text, role: args.role, intent: args.intent } };+    const el = f.elements[0];+    const list = rich ? f.elements.map((c, i) => ({ index: i, ...c, chosen: i === 0 })) : null;+    return { found: true, x: el.x, y: el.y, info: { matchedText: el.text, matchedTag: el.tag, via: 'text', candidates: f.count }, candidates: list, chosenIndex: rich ? 0 : undefined, query: { text: args.text, role: args.role, intent: args.intent } };+  }+  return { found: true, x: args.x, y: args.y, info: {}, candidates: rich ? [] : undefined, chosenIndex: rich ? -1 : undefined, query: { intent: args.intent } };+}++// type ∈ move | hover | click | dblclick | rightclick | key | type+// args.cursor:true shows the gliding visual cursor (demos); off by default for fast automation.+export async function inputDispatch(tabId, args) {+  await attach(tabId);+  const _m = modalGuard(tabId); if (_m && !args.resolveOnly) return _m; // a native dialog is blocking the page+  const type = (args.type || 'click').toLowerCase();+  const showCursor = args.cursor === true;+  const resolveOnly = args.resolveOnly === true;          // dry-run: resolve + return finder, dispatch NOTHING+  const wantFinder = resolveOnly || args.debug === true;  // opt-in; default responses stay lean+  try {+    if (type === 'key') {+      if (resolveOnly) return { ok: true, resolveOnly: true, dispatched: false, key: args.key, _hint: 'key press has no finder target to resolve' };+      await pressKey(tabId, args.key); return { ok: true, dispatched: 'key', key: args.key };+    }+    if (type === 'type') {+      let finder = null;+      if (wantFinder) {+        if (args.selector) { const c = await resolveCoords(tabId, args, true); finder = await buildFinder(tabId, c.query || { selector: args.selector }, c.candidates || [], c.chosenIndex == null ? -1 : c.chosenIndex, c.x, c.y); }+        else finder = { query: { intent: args.intent }, chosenIndex: -1, candidates: [], _note: 'typing into the focused field — no selector to resolve' };+      }+      if (resolveOnly) return { ok: true, resolveOnly: true, dispatched: false, ...(finder ? { finder } : {}) };+      if (args.selector) {+        const f = await evaluate(tabId, focusExpr(args.selector));+        if (!f || !f.found) return { ok: false, error: `selector not found: ${args.selector}`, _hint: 'check the selector or wait for the field', ...(finder ? { finder } : {}) };+      }+      await send(tabId, 'Input.insertText', { text: String(args.text || '') });+      return { ok: true, dispatched: 'type', length: String(args.text || '').length, via: args.selector ? 'selector' : 'focused', ...(finder ? { finder } : {}) };+    }+    // pointer types: move | hover | click | dblclick | rightclick | wheel+    // nb-bridge#41 item 2: an UNKNOWN type used to fall through to a click (four "zoom" attempts became four+    // clicks on a canvas editor with a tool armed). Refuse it by name instead.+    const KNOWN = ['click', 'dblclick', 'doubleclick', 'rightclick', 'contextmenu', 'move', 'hover', 'wheel', 'mousewheel', 'scroll'];+    if (!KNOWN.includes(type)) {+      return { ok: false, errorCode: 'unknown_input_type', dispatched: false,+        error: `unknown_input_type: "${args.type}" is not an input type I dispatch - refusing rather than guessing (an unknown type used to become a CLICK).`,+        _hint: 'type must be one of click | dblclick | rightclick | move | hover | wheel | type | key. For a mouse wheel / canvas zoom use type:"wheel" with deltaX/deltaY (or nbrowser_scroll).' };+    }+    const isWheel = (type === 'wheel' || type === 'mousewheel' || type === 'scroll');+    const c = await resolveCoords(tabId, args, wantFinder);+    if (!c.found) {+      const out = { ok: false, error: `target not found: ${args.selector || args.text || '(no selector/text)'}`, _hint: 'element not visible/present; wait or refine the selector/text' };+      if (wantFinder) out.finder = { query: c.query || {}, chosenIndex: -1, candidates: c.candidates || [] };+      return out;+    }+    const { x, y, info } = c;+    // GUARD ambiguous_target — clicking BY TEXT that matches >1 visible element is refused; demand a+    // disambiguating selector (or pass acceptAmbiguous:true / index to override). Stops the AI clicking the+    // wrong one of two "Next"/"Back" buttons or three "Yes" radios.+    if (/click/.test(type) && info.via === 'text' && Number(info.candidates) > 1 && args.acceptAmbiguous !== true && args.index == null && !resolveOnly) {+      return { ok: false, errorCode: 'ambiguous_target',+        error: `ambiguous_target: text "${args.text}" matches ${info.candidates} visible elements — refusing to guess which to click.`,+        _hint: 'Pass a unique selector (nbrowser_click {selector:"…"}), or {debug:true} to see the numbered candidate overlay and pick one, or acceptAmbiguous:true to accept the top-scored match.',+        ...(wantFinder ? { finder: await buildFinder(tabId, c.query || {}, c.candidates || [], c.chosenIndex == null ? 0 : c.chosenIndex, x, y) } : {}) };+    }+    // GUARD stale_coordinates — a raw {x,y} pointer verb is only safe if the page hasn't scrolled since+    // those coords were computed. Require the scroll baseline (atScrollX/atScrollY, from a screenshot's+    // coordMap) and refuse if it drifted — a cached pixel silently becomes a DIFFERENT element after a+    // scroll/re-render (the "Next" that turned into "Back"). Re-resolve by selector/text instead.+    // nb-bridge#41 item 1: the gate applies to CLICKS only. A hover, move or wheel is read-only pointer motion:+    // a stale hover shows the wrong tooltip, it never presses the wrong control. Those accept raw {x,y}.+    if (/click|contextmenu/.test(type) && !args.selector && !args.text && (args.x != null || args.y != null) && !resolveOnly) {+      const live = await evaluate(tabId, '({sx:Math.round(scrollX),sy:Math.round(scrollY)})');+      const bx = args.atScrollX, by = args.atScrollY;+      if (bx == null && by == null) {+        return { ok: false, errorCode: 'stale_coordinates',+          error: `stale_coordinates: a raw {x,y} ${type} carries no freshness proof - the page may have scrolled/re-rendered since those coords were valid.`,+          _hint: 'Prefer nbrowser_click {selector:"…"} or {text:"…"} (re-resolved live). If you must click by pixel, pass atScrollX/atScrollY from your latest screenshot coordMap so I can verify the page has not scrolled.' };+      }+      if ((bx != null && Math.abs(Number(bx) - live.sx) > 2) || (by != null && Math.abs(Number(by) - live.sy) > 2)) {+        return { ok: false, errorCode: 'stale_coordinates',+          error: `stale_coordinates: the page scrolled since these coords were captured (baseline ${bx},${by}; now ${live.sx},${live.sy}) — {x:${args.x},y:${args.y}} now points at different content.`,+          _hint: 'Re-screenshot and re-resolve, or click by selector/text. Never reuse pixel coordinates across a scroll or re-render.' };+      }+    }+    // Build the debug finder (candidates + scores + annotated overlay shot) BEFORE acting, so a+    // resolveOnly dry-run and a debug click see the same pre-action page state.+    const finder = wantFinder ? await buildFinder(tabId, c.query || {}, c.candidates || [], c.chosenIndex == null ? 0 : c.chosenIndex, x, y) : null;+    const fin = finder ? { finder } : {};+    if (resolveOnly) return { ok: true, resolveOnly: true, dispatched: false, x, y, ...info, ...fin };+    // The cursor label narrates intention (Hydrogen-style). args.intent overrides; else auto from element text.+    const intent = args.intent || args.label;+    const tgt = (info.clickedText || info.matchedText || '').trim().slice(0, 40);+    if (showCursor) { await cursor(tabId, 'move', x, y, intent || phaseLabel(type, tgt, 'find')); await sleep(args.cursorGlideMs || 450); }+    if (isWheel) {+      // Real CDP wheel (isTrusted): what a canvas camera (Babylon ArcRotateCamera, three.js OrbitControls) and+      // a scrollable pane both listen for. deltaY < 0 zooms in / scrolls up, > 0 zooms out / scrolls down.+      const deltaX = Number(args.deltaX) || 0, deltaY = Number(args.deltaY) || 0;+      if (!deltaX && !deltaY) return { ok: false, errorCode: 'bad_args', error: 'wheel needs deltaX and/or deltaY (px; deltaY:-300 zooms in / scrolls up)' };+      const steps = Math.max(1, Math.min(20, Number(args.steps) || 1));+      const before = await evaluate(tabId, '({sx:Math.round(scrollX),sy:Math.round(scrollY)})');+      await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });+      for (let i = 0; i < steps; i++) {+        await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseWheel', x, y, deltaX: deltaX / steps, deltaY: deltaY / steps });+        if (steps > 1) await sleep(Number(args.stepDelayMs) || 40);+      }+      await sleep(Number(args.settleMs) || 150);+      const after = await evaluate(tabId, '({sx:Math.round(scrollX),sy:Math.round(scrollY)})');+      return { ok: true, dispatched: 'wheel', x, y, deltaX, deltaY, steps, scrollBefore: before, scrollAfter: after,+        pageScrolled: !!(before && after && (before.sx !== after.sx || before.sy !== after.sy)), ...info, ...fin,+        _hint: 'isTrusted wheel at that point. pageScrolled:false is normal on a canvas (the app consumed the wheel, e.g. a camera zoom); verify the effect with nbrowser_screenshot or an eval of the app state.' };+    }+    if (type === 'move' || type === 'hover') {+      if (showCursor) await cursor(tabId, 'move', x, y, intent || phaseLabel(type, tgt, 'act'));+      // Approach from just outside, then settle on center, then dwell — a single mouseMoved+      // often fails to fire mouseover/mouseenter or let a CSS-transition tooltip paint. Moving+      // INTO the element generates the enter/over events real hover needs, and the dwell lets+      // delayed/animated tooltips appear before the caller screenshots.+      await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x: x - 24, y: y - 24 });+      await sleep(40);+      await send(tabId, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }); // triggers :hover / mouseover / tooltips+      await sleep(args.hoverDwellMs || 600);+      return { ok: true, dispatched: type, x, y, intentLabel: intent || phaseLabel(type, tgt, 'act'), ...info, ...fin };+    }+    if (showCursor) await cursor(tabId, 'click', x, y, intent || phaseLabel(type, tgt, 'act')); // ripple + label+    if (type === 'dblclick' || type === 'doubleclick') {+      await mouseClick(tabId, x, y, 'left', 1); await mouseClick(tabId, x, y, 'left', 2);+      return { ok: true, dispatched: 'dblclick', x, y, ...info, ...fin };+    }+    if (type === 'rightclick' || type === 'contextmenu') {+      await mouseClick(tabId, x, y, 'right', 1);+      return { ok: true, dispatched: 'rightclick', x, y, ...info, ...fin };+    }+    await mouseClick(tabId, x, y, args.button || 'left', args.clickCount || 1);+    return { ok: true, dispatched: 'click', via: args.selector ? 'selector' : 'coords', x, y, ...info, ...fin };+  } finally {+    bumpIdle(tabId);+  }+}++// ---- nbrowser_autologin: inject the bridge-decrypted saved password into the password field ----------+// The bridge decrypts the saved password on the laptop and passes it as args.__secret (laptop-local, over+// native-messaging stdio). This handler injects it via CDP isTrusted keystrokes and submits. SECURITY:+// __secret is NEVER returned, logged, or echoed — only {ok, loggedIn, needs2FA, host, url}.+function probeLoginFn() {+  function vis(el) { var r = el.getBoundingClientRect(), s = getComputedStyle(el); return r.width > 1 && r.height > 1 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01; }+  function info(el) { if (!el) return null; var r = el.getBoundingClientRect(); return { x: Math.round(r.left + r.width / 2), y: Math.round(r.top + r.height / 2), name: el.name || '', id: el.id || '', hasVal: !!(el.value && el.value.length) }; }+  var pw = [].slice.call(document.querySelectorAll('input[type=password]')).filter(vis)[0];+  var user = [].slice.call(document.querySelectorAll('input[type=email],input[autocomplete=username],input[name*="user" i],input[name*="email" i],input[id*="user" i],input[id*="email" i],input[type=text]')).filter(vis)[0];+  return { pw: info(pw), user: info(user), url: location.href };+}+function assessLoginFn() {+  var url = location.href; var body = ((document.body && document.body.innerText) || '').toLowerCase();+  var hasPw = !!document.querySelector('input[type=password]');+  var twofa = /(verification code|two[- ]factor|2[- ]step|enter the code|authenticator app|one[- ]time (code|passcode)|security code|6[- ]digit|passcode we (sent|texted)|verify it's you)/.test(body);+  var failed = /(incorrect|wrong password|invalid (email|password)|try again|password isn't right)/.test(body) && hasPw;+  return { url: url, hasPw: hasPw, twofa: twofa, failed: failed };+}+async function focusType(tabId, fld, text) {+  await mouseClick(tabId, fld.x, fld.y); await sleep(70);+  if (fld.hasVal) { for (let i = 0; i < 60; i++) await pressKey(tabId, 'Backspace'); } // clear pre-fills+  await send(tabId, 'Input.insertText', { text: String(text) });+}+export async function autologin(tabId, args) {+  await attach(tabId);+  const secret = args && args.__secret; // injected by the bridge; do NOT log/return this+  const username = args && args.username;+  try {+    if (!secret) return { ok: false, error: 'no credential available' + (args && args.__secretError ? ': ' + args.__secretError : ''), _hint: 'autologin needs confirm:true + host, and a saved login for that host in this profile. Decryption happens in the in-Chrome native host; if __secretError shows, the saved password could not be decrypted/found.' };+    let probe = await evaluate(tabId, `(${probeLoginFn.toString()})()`);+    // Split form: no password field yet → fill username + advance to the password step.+    if (probe && !probe.pw) {+      if (probe.user && username) {+        await focusType(tabId, probe.user, String(username));+        await pressKey(tabId, 'Enter');+        await sleep(1800);+        probe = await evaluate(tabId, `(${probeLoginFn.toString()})()`);+      }+      if (!probe || !probe.pw) return { ok: false, loggedIn: false, step: 'username', url: (probe && probe.url) || '', _hint: 'Filled username + advanced but no password field appeared yet — wait for the password step (or click Sign in/Continue), then call nbrowser_autologin again.' };+    }+    // Username present + empty on the same page → fill it (not secret).+    if (probe.user && !probe.user.hasVal && username) await focusType(tabId, probe.user, String(username));+    // Inject the secret into the password field via real keystrokes (fires framework onChange).+    await focusType(tabId, probe.pw, secret);+    await sleep(120);+    await pressKey(tabId, 'Enter'); // submit+    await sleep(2800);+    const a = await evaluate(tabId, `(${assessLoginFn.toString()})()`);+    const url = (a && a.url) || '';+    const needs2FA = !!(a && a.twofa);+    const loggedIn = !needs2FA && a && !a.hasPw && !a.failed;+    return { ok: true, loggedIn, needs2FA, host: args.host, url,+      _hint: loggedIn ? 'Logged in (no password form remains).' : needs2FA ? '2FA gate detected — a human verification code (or a TOTP/passkey path) is required; nbrowser_screenshot to see it.' : a && a.failed ? 'Credentials rejected — saved password may be stale.' : 'Submitted but a password form is still present; the submit button may differ — nbrowser_screenshot, then nbrowser_click the explicit Sign in button.' };+  } finally { bumpIdle(tabId); }+}++// ---- nbrowser_login_form: detect a login form's state + recommend the SMARTEST path -----------------+// The #1 rule of login automation: if the browser already AUTOFILLED the form, just SUBMIT it (fully+// background, no autofill popup, no SSO). This inspects the current page and tells the AI which path to take.+function loginFormFn() {+  function vis(el) { var r = el.getBoundingClientRect(), s = getComputedStyle(el); return r.width > 1 && r.height > 1 && s.visibility !== 'hidden' && s.display !== 'none' && parseFloat(s.opacity || '1') > 0.01; }+  function txt(b) { return ((b.innerText || b.value || b.getAttribute('aria-label') || '') + '').replace(/\s+/g, ' ').trim(); }+  function sel(el) { if (!el) return null; if (el.id) return '#' + el.id; if (el.name) return (el.tagName.toLowerCase() + '[name="' + el.name + '"]'); return el.tagName.toLowerCase(); }+  var pw = [].slice.call(document.querySelectorAll('input[type=password]')).filter(vis)[0];+  var user = [].slice.call(document.querySelectorAll('input[type=email],input[autocomplete=username],input[name*="user" i],input[name*="email" i],input[id*="email" i],input[id*="user" i],input[type=text]')).filter(vis)[0];+  var btns = [].slice.call(document.querySelectorAll('button,input[type=submit],[role=button],a[href]')).filter(vis);+  var submit = btns.find(function (b) { return /^(sign in|log ?in|continue|submit|next|verify)$/i.test(txt(b)); })+    || btns.find(function (b) { return /sign in|log ?in|continue|submit/i.test(txt(b)) && !/google|microsoft|apple|sso|with/i.test(txt(b)); })+    || (pw && pw.form && pw.form.querySelector('button[type=submit],input[type=submit],button'));+  var sso = btns.filter(function (b) { return /(sign in|continue|log ?in) with (google|microsoft|apple|github|okta|saml|sso)|use (sso|single sign)/i.test(txt(b)); }).map(txt).slice(0, 5);+  var twofa = /(verification code|two[- ]factor|2[- ]step|authenticator app|enter the (\d|six)[- ]?digit|security code|one[- ]time)/i.test((document.body && document.body.innerText || '').toLowerCase());+  return {+    hasPasswordField: !!pw,+    passwordFilled: !!(pw && pw.value && pw.value.length > 0),+    usernameField: !!user,+    usernameFilled: !!(user && user.value && user.value.length > 0),+    usernameValue: user ? (user.value || '').slice(0, 60) : '', // email/username is NOT a secret — lets the AI confirm the right account+    submitText: submit ? txt(submit) : '',+    submitSelector: sel(submit),+    ssoOptions: sso,+    twoFactorPrompt: twofa,+    url: location.href,+  };+}+export async function detectLoginForm(tabId) {+  await attach(tabId);+  const f = await evaluate(tabId, `(${loginFormFn.toString()})()`);+  bumpIdle(tabId);+  if (!f || f.__error) return { ok: false, error: (f && f.__error) || 'eval failed' };+  let recommendation, action;+  if (f.twoFactorPrompt) { recommendation = '2FA gate — needs a human verification code (authenticator/SMS). Surface it to the user; cannot be automated.'; action = '2fa'; }+  else if (f.hasPasswordField && f.passwordFilled) { recommendation = `✅ FORM IS AUTOFILLED${f.usernameValue ? ' for ' + f.usernameValue : ''} — the browser pre-filled the credentials. JUST SUBMIT IT (fully background, no popup/SSO): nbrowser_click {text:"${f.submitText || 'Sign in'}"}${f.submitSelector ? ' or {selector:"' + f.submitSelector + '"}' : ''}.`; action = 'submit'; }+  else if (f.ssoOptions.length) { recommendation = `Form not autofilled, but SSO is available (${f.ssoOptions.join(', ')}). Prefer SSO — clicking it uses the existing identity-provider session (background, no password): nbrowser_click {text:"${f.ssoOptions[0]}"}.`; action = 'sso'; }+  else if (f.hasPasswordField) { recommendation = 'Password form present but NOT autofilled. Fill the email (background) if split, then summon the browser autofill popup (~1s foreground: click the password field → desktop_screenshot_window owned popup → click the saved-login row). See the driving-the-desktop skill.'; action = 'autofill-popup'; }+  else if (f.usernameField) { recommendation = 'Email/username step (no password field yet). Type the email (background) + click Continue, then re-check nbrowser_login_form on the password step.'; action = 'username-step'; }+  else { recommendation = 'No login form detected on this page.'; action = 'none'; }+  return { ok: true, action, recommendation, ...f, _hint: 'ALWAYS call this before driving a login. If passwordFilled=true, the browser already autofilled it — just submit (background); never reach for the autofill popup or SSO when the form is already filled.' };+}++// ---- native JS dialogs (alert/confirm/prompt/beforeunload) — modal detection ----------------------+// These are NOT OS child windows (no hwnd) - Chrome renders them itself and they BLOCK the page's main+// thread, so an AI that doesn't know one is up will keep firing clicks/eval into a frozen page (real+// incident: an Intuit "questionnaire saved" alert sat over the form while the AI kept trying to fill it).+// We catch Page.javascriptDialogOpening (the debugger is attached during any CDP drive), record it, and+// surface it on the session's NEXT verb (modal_open) with an easy way to dismiss it.+const _openDialogs = new Map(); // tabId -> { type, message, defaultPrompt, ts } (currently OPEN)+const _dialogPolicy = new Map(); // tabId -> 'auto' (default: never wedge) | 'manual' (caller answers)+const _recentDialogs = [];      // ring for nbrowser_events - DRAINED by whoever polls events+// ⚠️ _recentDialogs is drained by ANY events consumer (another AI thread polling nbrowser_events on this+// profile empties it), so it cannot double as the "was a dialog just auto-handled here?" memory - the+// alreadyHandled recovery and the click dialogOpened check lost their evidence to a foreign drain+// (found 2026-08-22: the Fusion thread's event polling raced the verb battery). Per-tab last-dialog+// memory lives here instead, and nothing drains it.+const _lastDialog = new Map();  // tabId -> { dialogType, message, autoHandled, accepted, ts }+export function dialogFor(tabId) { return _openDialogs.get(Number(tabId)) || null; }+export function lastDialogFor(tabId) { return _lastDialog.get(Number(tabId)) || null; }+export function drainDialogs() { const d = _recentDialogs.splice(0); return d; }+// nbrowser_handle_dialog — control native JS dialogs. GROUND TRUTH (measured 2026-08-22, Chrome 139,+// john's laptop): while a chrome.debugger client is attached, CHROME ITSELF cancels page dialogs -+// Page.javascriptDialogOpening never reaches the extension (confirm() returns false instantly, our+// listener sees nothing). So the CDP arming design ("dialog stays open, answer it later") CANNOT work,+// and it silently didn't: policy:'manual' armed a listener Chrome never called. The honest, working+// design is a PAGE-LEVEL PRE-ANSWER: arming overrides window.confirm/alert/prompt in the page to record+// the call and return YOUR preset answer, and disarming restores the originals and reports what was+// seen. The CDP path below stays for the (non-attached / other-browser) case where it does fire.+export async function handleDialog(tabId, accept, promptText, policy) {+  await attach(tabId);+  const id = Number(tabId);+  if (policy === 'manual' || policy === 'auto') {+    _dialogPolicy.set(id, policy);+    if (policy === 'manual') {+      const armed = await evaluate(tabId,+        `(function(){ if (window.__nbDlg && window.__nbDlg.armed) { window.__nbDlg.accept=${accept !== false}; window.__nbDlg.text=${JSON.stringify(promptText != null ? String(promptText) : null)}; return 're-armed'; }+          var w=window; w.__nbDlg={armed:true, accept:${accept !== false}, text:${JSON.stringify(promptText != null ? String(promptText) : null)}, seen:[], orig:{c:w.confirm,a:w.alert,p:w.prompt}};+          w.confirm=function(m){ w.__nbDlg.seen.push({type:'confirm',message:String(m),answered:w.__nbDlg.accept,ts:Date.now()}); return w.__nbDlg.accept; };+          w.alert=function(m){ w.__nbDlg.seen.push({type:'alert',message:String(m),answered:true,ts:Date.now()}); };+          w.prompt=function(m,d){ var ans=w.__nbDlg.accept ? (w.__nbDlg.text!=null?w.__nbDlg.text:(d||'')) : null; w.__nbDlg.seen.push({type:'prompt',message:String(m),answered:ans,ts:Date.now()}); return ans; };+          return 'armed'; })()`);+      return { ok: true, policy: 'manual', armed: true, mode: String(armed), preAnswer: { accept: accept !== false, text: promptText != null ? String(promptText) : null }, tabId: String(id),+        _hint: `Manual mode ARMED as a pre-answer: the NEXT dialog(s) on this tab are answered ${accept !== false ? 'ACCEPT (OK/Yes)' : 'DISMISS (Cancel)'} the instant they fire${promptText != null ? `, prompts answered "${String(promptText).slice(0, 40)}"` : ''}. This is a page-level override (Chrome cancels dialogs itself while a debugger is attached, so a dialog can never be held open for a later answer). Do the action now, then policy:"auto" to disarm and get the list of dialogs seen. The override does NOT survive a page navigation - re-arm after navigating.` };+    }+    // policy:'auto' - restore the page's own dialog functions and report what the arming saw.+    const seen = await evaluate(tabId,+      `(function(){ var w=window, d=w.__nbDlg; if (!d) return []; if (d.orig){ w.confirm=d.orig.c; w.alert=d.orig.a; w.prompt=d.orig.p; } var s=d.seen||[]; delete w.__nbDlg; return s; })()`).catch(() => []);+    return { ok: true, policy: 'auto', disarmed: true, seen: Array.isArray(seen) ? seen : [], tabId: String(id),+      _hint: 'Auto mode restored (page dialog functions un-overridden). While driving, Chrome auto-cancels dialogs the moment they open (confirm/prompt return the dismiss value, alerts just close) so the page can never wedge - to ANSWER one deliberately, arm the pre-answer first: {policy:"manual", accept:true|false, text?}. `seen` lists every dialog the arming answered.' };+  }+  const dlg = _openDialogs.get(id);+  try { await send(tabId, 'Page.handleJavaScriptDialog', { accept: accept !== false, promptText: promptText != null ? String(promptText) : undefined }); }+  catch (e) {+    const auto = ((_lastDialog.get(id) || {}).autoHandled ? _lastDialog.get(id) : null)+      || [..._recentDialogs].reverse().find((x) => x.tabId === String(id) && x.autoHandled);+    if (auto) return { ok: true, handled: false, alreadyHandled: true, was: auto, tabId: String(id),+      _hint: `No dialog was open: a ${auto.dialogType} ("${String(auto.message).slice(0, 80)}") was AUTO-${auto.accepted ? 'ACCEPTED' : 'DISMISSED'} the moment it opened, so the page never blocked. To answer one yourself, arm the PRE-ANSWER first: nbrowser_handle_dialog {sessionId, policy:"manual", accept:true}, then do the action, then policy:"auto" to disarm.` };+    // Pre-answer memory: the page-level arming records every dialog it answered in window.__nbDlg.seen.+    const seen = await evaluate(tabId, '(window.__nbDlg && window.__nbDlg.seen) || []').catch(() => []);+    if (Array.isArray(seen) && seen.length) {+      const last = seen[seen.length - 1];+      return { ok: true, handled: false, alreadyHandled: true, was: last, tabId: String(id),+        _hint: `No dialog is open: your ARMED pre-answer already answered a ${last.type} ("${String(last.message).slice(0, 80)}") with ${JSON.stringify(last.answered)}. Disarm + collect the full list with {policy:"auto"}.` };+    }+    return { ok: false, error: 'no dialog to handle (it may have already closed): ' + ((e && e.message) || e),+      _hint: 'No dialog is open. NOTE: while nbe is driving, Chrome cancels page dialogs the moment they fire (confirm returns false, alerts close) - the page can never wedge, but a dialog also can never be caught open. To ANSWER the next dialog deliberately, arm a pre-answer BEFORE the action: nbrowser_handle_dialog {sessionId, policy:"manual", accept:true|false, text?}, do the action, then {policy:"auto"} to disarm and see what was answered.' };+  }+  _openDialogs.delete(Number(tabId));+  return { ok: true, handled: true, accepted: accept !== false, was: dlg || null, tabId: String(tabId), _hint: 'Dialog dismissed — the page is unblocked. Continue driving; re-screenshot to see the current state.' };+}+// Guard called at the start of page-ACTION verbs: if a native dialog is blocking this tab, refuse the+// action and tell the AI to deal with the modal first (it cannot succeed while the page is frozen).+export function modalGuard(tabId) {+  const dlg = _openDialogs.get(Number(tabId));+  if (!dlg) return null;+  return { ok: false, errorCode: 'modal_open',+    error: `modal_open: a native ${dlg.type} dialog is blocking this tab: "${(dlg.message || '').slice(0, 140)}". The page is FROZEN until it is handled - your clicks/typing/eval will not work.`,+    dialog: { type: dlg.type, message: dlg.message },+    _hint: `Handle it first: nbrowser_handle_dialog {sessionId, accept:true} to press OK/Yes/Leave, or accept:false to Cancel/Stay${dlg.type === 'prompt' ? ', with text:"…" to answer a prompt' : ''}. Then re-screenshot and continue.` };+}++// ---- nbrowser_errors: buffered console/page errors per tab ------------------+const errorBuffers = new Map(); // tabId -> [{type,text,ts}]+chrome.debugger.onEvent.addListener((source, method, params) => {+  const tabId = source.tabId;+  if (tabId == null) return;+  if (method === 'Page.javascriptDialogOpening') {+    const d = { type: params.type || 'alert', message: params.message || '', defaultPrompt: params.defaultPrompt || '', ts: Date.now() };+    _openDialogs.set(tabId, d);+    // AUTO-HANDLE (nb-bridge #21). A native dialog BLOCKS the page's main thread, so if nobody answers+    // it every later eval/click/screenshot on that tab hangs until the window is closed - a driven+    // click on any confirm() used to kill the whole drive. The docs always promised auto-dismissal+    // while driving; this is it. Policy per dialog TYPE, biased to the SAFE answer:+    //   alert  -> accept (only has OK)         confirm -> DISMISS (do not perform the guarded action)+    //   prompt -> dismiss (never invent input) beforeunload -> accept (we asked to navigate)+    // A caller that genuinely wants OK sets policy:'manual' (nbrowser_handle_dialog) and answers itself.+    const policy = _dialogPolicy.get(tabId) || 'auto';+    const accept = d.type === 'alert' || d.type === 'beforeunload';+    if (policy === 'auto') {+      send(tabId, 'Page.handleJavaScriptDialog', { accept }).then(() => {+        _openDialogs.delete(tabId);+        _lastDialog.set(tabId, { dialogType: d.type, message: d.message, autoHandled: true, accepted: accept, ts: d.ts });+        _recentDialogs.push({ event: 'dialog', tabId: String(tabId), dialogType: d.type, message: d.message, autoHandled: true, accepted: accept, ts: d.ts,+          note: `auto-${accept ? 'accepted' : 'dismissed'} so the page could not wedge; set policy:"manual" via nbrowser_handle_dialog BEFORE the action if you need to answer it yourself` });+        while (_recentDialogs.length > 20) _recentDialogs.shift();+      }).catch(() => {+        _recentDialogs.push({ event: 'dialog', tabId: String(tabId), dialogType: d.type, message: d.message, autoHandled: false, ts: d.ts });+        while (_recentDialogs.length > 20) _recentDialogs.shift();+      });+      return;+    }+    _recentDialogs.push({ event: 'dialog', tabId: String(tabId), dialogType: d.type, message: d.message, autoHandled: false, ts: d.ts });+    while (_recentDialogs.length > 20) _recentDialogs.shift();+    return;+  }+  if (method === 'Page.javascriptDialogClosed') { const o = _openDialogs.get(tabId); _openDialogs.delete(tabId); if (o) _recentDialogs.push({ event: 'dialog_closed', tabId: String(tabId), dialogType: o.type, result: params.result, ts: Date.now() }); return; }+  if (method === 'Page.fileChooserOpened') {+    // armed by nbrowser_set_file_input {armForNextChooser:true}: satisfy the page's chooser with the+    // staged files - silently, in the background, no OS dialog ever appears.+    const arm = _chooserArm.get(tabId);+    if (arm && params.backendNodeId) {+      send(tabId, 'DOM.setFileInputFiles', { files: arm.files, backendNodeId: params.backendNodeId })+        .then(() => { _chooserServed.set(tabId, { files: arm.files.map((f) => String(f).split(/[\\/]/).pop()), ts: Date.now() }); })+        .catch(() => {})+        .finally(() => { if (arm.timer) clearTimeout(arm.timer); _chooserArm.delete(tabId); send(tabId, 'Page.setInterceptFileChooserDialog', { enabled: false }).catch(() => {}); });+    }+    return;+  }+  let entry = null;+  if (method === 'Runtime.exceptionThrown') {+    const e = params.exceptionDetails || {};+    entry = { type: 'exception', text: (e.exception && (e.exception.description || e.exception.value)) || e.text, ts: Date.now() };+  } else if (method === 'Runtime.consoleAPICalled' && params.type === 'error') {+    entry = { type: 'console.error', text: (params.args || []).map((a) => a.value ?? a.description ?? '').join(' '), ts: Date.now() };+  } else if (method === 'Log.entryAdded' && params.entry && params.entry.level === 'error') {+    entry = { type: 'log', text: params.entry.text, ts: Date.now() };+  }+  if (!entry) return;+  const buf = errorBuffers.get(tabId) || [];+  buf.push(entry);+  errorBuffers.set(tabId, buf.slice(-200));+});++export async function getErrors(tabId, clear = true) {+  const buf = errorBuffers.get(tabId) || [];+  if (clear) errorBuffers.delete(tabId);+  return { ok: true, errors: buf, count: buf.length, tabId: String(tabId) };+}++// ---- PNG helpers (OffscreenCanvas, runs in the service worker) -------------+async function bitmapFromB64(b64) {+  const bytes = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));+  return createImageBitmap(new Blob([bytes], { type: 'image/png' }));+}+async function pngDims(b64) {+  const bmp = await bitmapFromB64(b64);+  const out = { base64: b64, width: bmp.width, height: bmp.height };+  bmp.close && bmp.close();+  return out;+}+async function resizePng(b64, maxWidth) {+  const bmp = await bitmapFromB64(b64);+  const { width, height } = bmp;+  if (width <= maxWidth) { bmp.close && bmp.close(); return { base64: b64, width, height, resized: false }; }+  const w = maxWidth;+  const h = Math.round(height * (maxWidth / width));+  const canvas = new OffscreenCanvas(w, h);+  canvas.getContext('2d').drawImage(bmp, 0, 0, w, h);+  bmp.close && bmp.close();+  const blob = await canvas.convertToBlob({ type: 'image/png' });+  const buf = new Uint8Array(await blob.arrayBuffer());+  let bin = '';+  for (let i = 0; i < buf.length; i++) bin += String.fromCharCode(buf[i]);+  return { base64: btoa(bin), width: w, height: h, origWidth: width, origHeight: height, resized: true };+}++// ── #5 Robust click: click, then report whether the page ACTUALLY changed ──────+// Captures a light page signature (url, readyState, visible-text length) before and after the click,+// so callers can detect "click dispatched but nothing happened" (disabled/covered element, missed+// target) and retry. Also scrolls the target into view (resolveCoords already centers it).+export async function pageSig(tabId) {+  // t = a cheap rolling hash of the visible text, so a SMALL local mutation (a button relabelling+  // itself from "Click Me" to "Clicked") is detected. Length alone missed those and reported a+  // landed click as changed:false (nb-bridge #20).+  try { const r = await evaluate(tabId, "(function(){var s=document.body?document.body.innerText:'';var h=0;for(var i=0;i<s.length;i++){h=(h*31+s.charCodeAt(i))|0;}return {u:location.href, r:document.readyState, n:s.length, t:h};})()"); return r || {}; } catch { return {}; }+}+export async function clickChanged(tabId, args) {+  const before = await pageSig(tabId);+  let r = await inputDispatch(tabId, { ...args, type: 'click' });+  if (r && r.ok === false) return r;+  await sleep(Number(args.settleMs) || 500);+  let after = await pageSig(tabId);+  const didChange = (b, a) => (b.u !== a.u) || (a.t !== undefined && b.t !== undefined && a.t !== b.t) || Math.abs((a.n || 0) - (b.n || 0)) > 3 || (b.r !== a.r && a.r !== 'complete');+  let changed = didChange(before, after), retried = false;+  // SELF-HEAL (nb-bridge #20). A click-by-text that resolves fine and then lands nowhere is the+  // single most confusing failure this bridge had: ok:true, matchedText set, changed:false, DOM+  // untouched - because the coordinates were resolved a beat before the page settled (late layout,+  // font swap, lazy image) so the point no longer hit the element. Re-resolving and dispatching once+  // more costs ~600ms only in the failure case and turns a silent miss into a hit.+  // A click that OPENED A DIALOG froze the page - the DOM cannot change, so changed:false is expected+  // and the dialog IS the effect. Retrying here queued a second click into the frozen page, which fired+  // a SECOND confirm() the moment the first auto-dismissed (found by the verb battery, 2026-08-22).+  const dlgNow = _openDialogs.get(Number(tabId));+  const _ld = _lastDialog.get(Number(tabId));+  const dlgRecent = !changed && ((_ld && (Date.now() - _ld.ts) < 3000) ? _ld+    : [..._recentDialogs].reverse().find((x) => x.tabId === String(tabId) && (Date.now() - x.ts) < 3000));+  if (!changed && (dlgNow || dlgRecent)) {+    const d = dlgNow || dlgRecent;+    return { ...r, changed: true, retried: false, dialogOpened: { type: d.type || d.dialogType, message: d.message },+      urlBefore: before.u, urlAfter: after.u,+      _hint: `The click's effect was a native ${d.type || d.dialogType} dialog ("${String(d.message || '').slice(0, 80)}")${dlgNow ? ' which is OPEN and blocking the page - handle it: nbrowser_handle_dialog {sessionId, accept:true|false}' : ' which was auto-handled (see nbrowser_events)'} - the page DOM did not change and that is expected.` };+  }+  if (!changed && args.retry !== false) {+    await sleep(350);+    const r2 = await inputDispatch(tabId, { ...args, type: 'click' });+    if (!(r2 && r2.ok === false)) {+      await sleep(Number(args.settleMs) || 500);+      const after2 = await pageSig(tabId);+      if (didChange(before, after2)) { r = r2; after = after2; changed = true; }+      retried = true;+    }+  }+  return { ...r, changed, retried, urlBefore: before.u, urlAfter: after.u,+    _hint: changed+      ? (retried ? 'Landed on the SECOND dispatch - the first missed because the page was still settling when the coordinates were resolved. If you see this often on one site, prefer a selector over click-by-text there.' : undefined)+      : 'The click DISPATCHED TWICE and the page still did not visibly change (same URL + DOM). The element is probably disabled, covered, or the handler does nothing visible. Re-resolve the selector, nbrowser_wait_for a follow-up element, or verify with nbrowser_eval.' };+}++// ── #7 set_date: fill a react-aria segmented date field (role=spinbutton MM/DD/YYYY) ──+// Focus the field, then type each digit as a real keydown (react-aria segments advance on digit+// keydown - Input.insertText does NOT trigger them). US MM/DD/YYYY order. date = "YYYY-MM-DD".+export async function setDate(tabId, args) {+  await attach(tabId);+  const selector = args.selector, date = args.date;+  if (!selector || !date) return { ok: false, error: 'set_date needs {selector, date:"YYYY-MM-DD"}' };+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(date));+  if (!m) return { ok: false, error: 'date must be "YYYY-MM-DD"' };+  const [, Y, M, D] = m;+  const c = await resolveCoords(tabId, { selector }, false);+  if (!c.found) return { ok: false, error: `date field not found: ${selector}`, _hint: 'check the selector or wait for the field' };+  await mouseClick(tabId, c.x, c.y, 'left', 1); // focus the first segment+  await sleep(90);+  const order = (String(args.order || 'MDY').toUpperCase() === 'DMY') ? [D, M, Y] : [M, D, Y];+  for (const seg of order) { for (const ch of seg) { await pressKey(tabId, ch); await sleep(35); } await sleep(40); }+  const val = await evaluate(tabId, `(function(){var e=document.querySelector(${JSON.stringify(selector)});if(!e)return null;return e.value||e.getAttribute('aria-valuetext')||(e.textContent||'').trim().slice(0,40);})()`);+  return { ok: true, dispatched: 'set_date', date, order: (String(args.order || 'MDY').toUpperCase() === 'DMY') ? 'DMY' : 'MDY', fieldValue: val, _hint: 'Typed each digit as a real keydown so react-aria segments advance. If fieldValue looks wrong, the field may use DMY order (pass order:"DMY") or a custom widget - screenshot to check.' };+}++// ── #3 TOTP: type the current 6-digit code (computed by the BRIDGE, injected as __code) into the+// focused 2FA field. The agent never sees the code; we only report {typed}. ──+export async function typeTotp(tabId, args) {+  const code = args && args.__code;+  if (!code) return { ok: false, error: 'no code (register a seed first: nbrowser_register_totp {host, seed})' };+  await attach(tabId);+  if (args.selector) { const f = await evaluate(tabId, focusExpr(args.selector)); if (!f || !f.found) return { ok: false, error: `2FA field not found: ${args.selector}` }; }+  await send(tabId, 'Input.insertText', { text: String(code) });+  if (args.submit === true) await pressKey(tabId, 'Enter');+  return { ok: true, typed: true, digits: String(code).length, submitted: args.submit === true };+}++// ---- nbrowser_set_file_input: populate <input type=file> over CDP, NO OS picker ------------------+// The OS file dialog cannot be driven with the debugger attached (and it FOREGROUNDS), so uploads go+// through DOM.setFileInputFiles - the same primitive Puppeteer's uploadFile / Playwright's+// setInputFiles use. Two modes:+//   direct (default): resolve the input (selector/text -> walk Browse-button/label to its input) and+//     inject the files, then dispatch input+change so React/Angular listeners fire.+//   armForNextChooser: for UIs that CREATE the input inside the Browse click handler - we intercept+//     the page's next file chooser (Page.setInterceptFileChooserDialog) and satisfy it with the staged+//     files when Page.fileChooserOpened fires. Auto-disarms after 30s.+// LIMITATION (documented in the bridge hint): the File System Access API (showOpenFilePicker) cannot+// be satisfied over CDP at all - those sites need their drag-drop path.+function findFileInputFn(sel, txt) {+  return `(function(){+    var sel=${JSON.stringify(sel || null)}, txt=${JSON.stringify(txt || null)};+    function fromEl(el){+      if(!el) return null;+      if(el.matches && el.matches('input[type=file]')) return el;+      if(el.tagName==='LABEL' && el.htmlFor){ var t=document.getElementById(el.htmlFor); if(t && t.type==='file') return t; }+      var lbl=el.closest && el.closest('label'); if(lbl){ var i=lbl.querySelector('input[type=file]'); if(i) return i; }+      if(el.querySelector){ var i2=el.querySelector('input[type=file]'); if(i2) return i2; }+      var form=el.closest && el.closest('form'); if(form){ var i3=form.querySelector('input[type=file]'); if(i3) return i3; }+      var p=el.parentElement; for(var d=0; p && d<4; d++,p=p.parentElement){ var i4=p.querySelector('input[type=file]'); if(i4) return i4; }+      return null;+    }+    var el=null;+    if(sel) el=document.querySelector(sel);+    else if(txt){ var t=txt.trim().toLowerCase();+      var nodes=Array.prototype.slice.call(document.querySelectorAll('button,a,label,input,[role=button],div,span'));+      el=nodes.find(function(n){ var s=(n.innerText||n.value||n.getAttribute('aria-label')||'').trim().toLowerCase(); return s && s.indexOf(t)>=0 && s.length < t.length+60; })||null;+    }+    var inp=fromEl(el);+    if(!inp && !sel && !txt) inp=document.querySelector('input[type=file]');+    if(!inp){ var all=document.querySelectorAll('input[type=file]'); if(all.length===1) inp=all[0]; }+    return inp||null;+  })()`;+}+const _chooserArm = new Map();    // tabId -> { files, timer }+const _chooserServed = new Map(); // tabId -> { files, ts }+export async function setFileInput(tabId, args) {+  await attach(tabId);+  const _m = modalGuard(tabId); if (_m) return _m;+  const files = args.filePaths || [];+  if (args.chooserStatus === true) {+    const s = _chooserServed.get(Number(tabId)) || null;+    return { ok: true, armed: _chooserArm.has(Number(tabId)), served: !!s, ...(s ? { files: s.files, servedAgoMs: Date.now() - s.ts } : {}), _hint: s ? 'The intercepted file chooser was satisfied with the staged files.' : (_chooserArm.has(Number(tabId)) ? 'Still armed - click the Browse/Upload control now (nbrowser_click), then re-check.' : 'Not armed and nothing served. Arm with {armForNextChooser:true, filePaths} first.') };+  }+  if (!files.length) return { ok: false, errorCode: 'no_files', error: 'filePaths is empty', _hint: 'Pass filePaths:["C:/abs/path/on/the/laptop", ...]. Push files to the laptop first with adom-bridge send_files (or use files:[{name,contentBase64}] - the bridge stages them for you).' };+  if (args.armForNextChooser === true) {+    await send(tabId, 'Page.setInterceptFileChooserDialog', { enabled: true });+    const prev = _chooserArm.get(Number(tabId)); if (prev && prev.timer) clearTimeout(prev.timer);+    const timer = setTimeout(() => { _chooserArm.delete(Number(tabId)); send(tabId, 'Page.setInterceptFileChooserDialog', { enabled: false }).catch(() => {}); }, 30000);+    _chooserArm.set(Number(tabId), { files, timer });+    _chooserServed.delete(Number(tabId));+    return { ok: true, armed: true, files: files.map((f) => String(f).split(/[\\/]/).pop()), _hint: 'ARMED for 30s: now nbrowser_click the Browse/Upload control - the page\'s file chooser will be satisfied with these files silently (no OS dialog). Then confirm with {chooserStatus:true} or just screenshot the page.' };+  }+  // direct mode: resolve the input element as a RemoteObject+  let obj;+  try { obj = await send(tabId, 'Runtime.evaluate', { expression: findFileInputFn(args.selector, args.text), returnByValue: false }); }+  catch (e) { return { ok: false, error: 'finder evaluate failed: ' + ((e && e.message) || e) }; }+  const ro = obj && obj.result;+  if (!ro || !ro.objectId || ro.subtype === 'null') {+    const diag = await evaluate(tabId, `(function(){ return { fileInputs: document.querySelectorAll('input[type=file]').length, selMatched: ${args.selector ? `!!document.querySelector(${JSON.stringify(args.selector)})` : 'null'} }; })()`).catch(() => ({}));+    return { ok: false, errorCode: 'input_not_found', error: `no <input type=file> resolved from ${args.selector ? 'selector ' + args.selector : args.text ? 'text "' + args.text + '"' : 'the page'}`, diag, _hint: diag && diag.fileInputs === 0 ? 'This page has NO file input right now. If the input is created by the Browse button\'s click handler, use {armForNextChooser:true, filePaths} then click the button. If the site uses showOpenFilePicker (File System Access API), CDP cannot inject files at all - use the site\'s drag-drop zone manually.' : 'A file input exists but your selector/text did not lead to it - target the input directly (selector:"input[type=file]") or the visible Browse control.' };+  }+  try { await send(tabId, 'DOM.enable').catch(() => {}); await send(tabId, 'DOM.setFileInputFiles', { files, objectId: ro.objectId }); }+  catch (e) { return { ok: false, error: 'DOM.setFileInputFiles failed: ' + ((e && e.message) || e), _hint: 'Verify every path exists ON THE LAPTOP (the bridge stats them, but a file may have been moved) and that the resolved element truly is an input[type=file].' }; }+  try { await send(tabId, 'Runtime.callFunctionOn', { objectId: ro.objectId, functionDeclaration: `function(){ this.dispatchEvent(new Event('input',{bubbles:true,composed:true})); this.dispatchEvent(new Event('change',{bubbles:true,composed:true})); }` }); } catch {}+  const names = await send(tabId, 'Runtime.callFunctionOn', { objectId: ro.objectId, functionDeclaration: 'function(){ return Array.prototype.map.call(this.files||[], function(f){return f.name;}); }', returnByValue: true }).then((r) => (r && r.result && r.result.value) || []).catch(() => []);+  return { ok: true, inputFound: true, via: 'direct', files: names, dispatchedEvents: ['input', 'change'], _hint: 'Files injected + input/change dispatched. Screenshot to confirm the page shows the selected file(s); many UIs need a separate Submit/Upload click next.' };+}