@xbrowser/cli 1.0.0 → 1.0.3

package/dist/{chunk-2MFXKN32.js → chunk-ACFE6PKF.js}

@@ -1,14 +1,231 @@
+import {
+  init_site_knowledge,
+  site_knowledge_exports,
+  updateSiteKnowledge
+} from "./chunk-OZKD3W4X.js";
+import {
+  __require,
+  __toCommonJS
+} from "./chunk-KFQGP6VL.js";
+
 // src/recorder/session-recorder.ts
 import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+
+// src/recorder/selector-utils.ts
+function getSelectorGeneratorScript() {
+  return `
+(function() {
+  if (window.__xb_generateSelector) return;
+
+  var IGNORE_CLASS = [
+    /^css-[a-zA-Z0-9]+$/,
+    /^sc-[a-zA-Z0-9]+$/,
+    /^emotion-\\d+$/,
+    /^_[a-f0-9]{4,}$/,
+    /^[a-f0-9]{6,}$/,
+    /^styled-[a-zA-Z0-9]+/,
+    /^__[a-zA-Z0-9]{4,}$/,
+    /^makeStyles-/,
+    /^MuiPrivate/,
+    /^jss\\d+$/,
+    /^ant-[a-z]+$/,
+    /^semi-[a-z]{4,}/
+  ];
+  var STABLE_ATTRS = ['data-testid', 'data-test-id', 'data-cy', 'data-qa', 'data-el'];
+  var MAX_DEPTH = 5;
+
+  function isStableClass(cls) {
+    if (!cls || cls.length <= 1) return false;
+    for (var i = 0; i < IGNORE_CLASS.length; i++) {
+      if (IGNORE_CLASS[i].test(cls)) return false;
+    }
+    return true;
+  }
+
+  function isUnique(root, sel) {
+    try { return root.querySelectorAll(sel).length === 1; } catch(e) { return false; }
+  }
+
+  function esc(s) { return CSS.escape(s); }
+
+  window.__xb_generateSelector = function(el, root) {
+    root = root || document;
+    if (!el || !el.tagName) return null;
+    if (el === root || el === document.documentElement) return { selector: 'html', strategy: 'root', confidence: 'high' };
+
+    var tag = el.tagName.toLowerCase();
+
+    // #id
+    if (el.id) {
+      var s = '#' + esc(el.id);
+      if (isUnique(root, s)) return { selector: s, strategy: 'id', confidence: 'high' };
+      s = tag + s;
+      if (isUnique(root, s)) return { selector: s, strategy: 'id+tag', confidence: 'high' };
+    }
+
+    // [data-testid]
+    for (var si = 0; si < STABLE_ATTRS.length; si++) {
+      var v = el.getAttribute(STABLE_ATTRS[si]);
+      if (v) {
+        var s = '[' + STABLE_ATTRS[si] + '="' + esc(v) + '"]';
+        if (isUnique(root, s)) return { selector: s, strategy: 'testid', confidence: 'high' };
+        s = tag + s;
+        if (isUnique(root, s)) return { selector: s, strategy: 'testid+tag', confidence: 'high' };
+      }
+    }
+
+    // [name]
+    var name = el.getAttribute('name');
+    if (name) {
+      var s = tag + '[name="' + esc(name) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'name', confidence: 'high' };
+    }
+
+    // [aria-label]
+    var aria = el.getAttribute('aria-label');
+    if (aria) {
+      var s = '[aria-label="' + esc(aria.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'aria-label', confidence: 'high' };
+      s = tag + s;
+      if (isUnique(root, s)) return { selector: s, strategy: 'aria-label+tag', confidence: 'high' };
+    }
+
+    // [placeholder]
+    var ph = el.getAttribute('placeholder');
+    if (ph) {
+      var s = tag + '[placeholder="' + esc(ph.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'placeholder', confidence: 'high' };
+    }
+
+    // [alt]
+    var alt = el.getAttribute('alt');
+    if (alt && tag === 'img') {
+      var s = 'img[alt="' + esc(alt.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'alt', confidence: 'high' };
+    }
+
+    // [title]
+    var title = el.getAttribute('title');
+    if (title) {
+      var s = tag + '[title="' + esc(title.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'title', confidence: 'high' };
+    }
+
+    // Unique attribute (skip URL-like, long)
+    var skipAttr = {class:1,style:1,id:1,name:1,'aria-label':1,placeholder:1,alt:1,title:1,role:1,src:1,href:1,action:1,'data-src':1,'data-href':1};
+    for (var ai = 0; ai < el.attributes.length; ai++) {
+      var a = el.attributes[ai];
+      if (skipAttr[a.name] || a.name.startsWith('data-') || a.name.startsWith('aria-')) continue;
+      if (a.value && a.value.length > 2 && a.value.length <= 60) {
+        var s = tag + '[' + a.name + '="' + esc(a.value) + '"]';
+        if (isUnique(root, s)) return { selector: s, strategy: 'attribute', confidence: 'medium' };
+      }
+    }
+
+    // Class combos
+    var rawCls = (typeof el.className === 'string' ? el.className : '').trim().split(/\\s+/);
+    var cls = rawCls.filter(isStableClass);
+    if (cls.length > 0) {
+      cls.sort(function(a, b) {
+        return root.querySelectorAll('.' + esc(a)).length - root.querySelectorAll('.' + esc(b)).length;
+      });
+      // single class
+      for (var i = 0; i < cls.length; i++) {
+        var s = '.' + esc(cls[i]);
+        if (isUnique(root, s)) return { selector: s, strategy: 'class', confidence: 'medium' };
+      }
+      // tag + class
+      for (var i = 0; i < cls.length; i++) {
+        var s = tag + '.' + esc(cls[i]);
+        if (isUnique(root, s)) return { selector: s, strategy: 'tag+class', confidence: 'medium' };
+      }
+      // 2-class combo
+      for (var i = 0; i < cls.length && i < 5; i++) {
+        for (var j = i+1; j < cls.length && j < 5; j++) {
+          var s = '.' + esc(cls[i]) + '.' + esc(cls[j]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'class-combo', confidence: 'medium' };
+        }
+      }
+      // tag + 2-class combo
+      for (var i = 0; i < cls.length && i < 4; i++) {
+        for (var j = i+1; j < cls.length && j < 4; j++) {
+          var s = tag + '.' + esc(cls[i]) + '.' + esc(cls[j]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'tag+class-combo', confidence: 'medium' };
+        }
+      }
+    }
+
+    // Parent scope
+    var parent = el.parentElement;
+    if (parent && parent !== root) {
+      if (parent.id) {
+        var s = '#' + esc(parent.id) + ' > ' + tag;
+        if (isUnique(root, s)) return { selector: s, strategy: 'parent-scope', confidence: 'medium' };
+      }
+      var pCls = (typeof parent.className === 'string' ? parent.className : '').trim().split(/\\s+/).filter(isStableClass);
+      for (var i = 0; i < pCls.length; i++) {
+        var s = '.' + esc(pCls[i]) + ' > ' + tag;
+        if (isUnique(root, s)) return { selector: s, strategy: 'parent-class-scope', confidence: 'medium' };
+      }
+      if (cls.length > 0) {
+        for (var i = 0; i < Math.min(cls.length, 3); i++) {
+          var s = parent.tagName.toLowerCase() + ' > ' + tag + '.' + esc(cls[i]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'parent>tag.class', confidence: 'medium' };
+        }
+      }
+    }
+
+    // :nth-of-type chain \u2014 walk all the way up, then find shortest unique suffix
+    var path = [];
+    var cur = el;
+    while (cur && cur !== root && cur !== document.documentElement) {
+      var p = cur.parentElement;
+      if (!p || p === root) break;
+      var t = cur.tagName.toLowerCase();
+      var same = [];
+      for (var k = 0; k < p.children.length; k++) {
+        if (p.children[k].tagName === cur.tagName) same.push(p.children[k]);
+      }
+      var nth = same.length === 1 ? null : (same.indexOf(cur) + 1);
+      path.unshift({tag: t, nth: nth});
+      if (cur !== el && cur.id) {
+        path.unshift({tag: '#' + esc(cur.id), nth: null});
+        break;
+      }
+      cur = p;
+    }
+    // Try suffixes from shortest to longest
+    for (var d = 1; d <= path.length; d++) {
+      var parts = path.slice(-d).map(function(p) {
+        return p.nth !== null ? p.tag + ':nth-of-type(' + p.nth + ')' : p.tag;
+      });
+      var sel = parts.join(' > ');
+      if (isUnique(root, sel)) return { selector: sel, strategy: 'nth-of-type', confidence: 'low' };
+    }
+    // Fallback
+    if (path.length > 0) {
+      var parts = path.map(function(p) {
+        return p.nth !== null ? p.tag + ':nth-of-type(' + p.nth + ')' : p.tag;
+      });
+      return { selector: parts.join(' > '), strategy: 'nth-of-type', confidence: 'low' };
+    }
+    return { selector: tag, strategy: 'tag-only', confidence: 'low' };
+  };
+})();
+`;
+}
+
+// src/recorder/session-recorder.ts
+init_site_knowledge();
 var ACTION_SIGNAL_SCRIPT = `
 (function() {
   if (window.__xb_action_signal) return;
   window.__xb_action_signal = true;
   window.__xb_pending_actions = [];
 
-  // --- Unique short selector generator ---
+  // --- Unique short selector generator (delegates to 13-strategy selector-utils) ---
   function uniqueSelector(el) {
     if (!el || !el.tagName) return null;
     var doc = el.ownerDocument || document;
@@ -17,6 +234,14 @@ var ACTION_SIGNAL_SCRIPT = `
       try { return doc.querySelectorAll(sel).length === 1; } catch(e) { return false; }
     }
 
+    // Prefer window.__xb_generateSelector from selector-utils (13 strategies)
+    if (typeof window.__xb_generateSelector === 'function') {
+      try {
+        var result = window.__xb_generateSelector(el, doc);
+        if (result && result.selector) return result.selector;
+      } catch(e) { /* fallback to local logic */ }
+    }
+
     // 1. #id (shortest, globally unique)
     if (el.id) {
       var idSel = '#' + CSS.escape(el.id);
@@ -103,10 +328,92 @@ var ACTION_SIGNAL_SCRIPT = `
       ? (el.value || el.getAttribute('placeholder') || '').trim().substring(0, 40)
       : (el.textContent || '').trim().substring(0, 40);
     if (tag === 'a' && el.getAttribute('href')) displayText = el.textContent.trim().substring(0, 40);
+
+    // Prefer window.__xb_generateSelector (13 strategies) \u2014 also extracts strategy + confidence
+    var selector, strategy, confidence;
+    if (typeof window.__xb_generateSelector === 'function') {
+      try {
+        var result = window.__xb_generateSelector(el, el.ownerDocument || document);
+        if (result && result.selector) {
+          selector = result.selector;
+          strategy = result.strategy;
+          confidence = result.confidence;
+        }
+      } catch(e) { /* fall through to local */ }
+    }
+    if (!selector) {
+      selector = uniqueSelector(el);
+    }
+
+    // For low-confidence selectors (nth-of-type), generate a text-based fallback
+    // when the element has short, unique text (e.g. menu items "\u5220\u9664", "\u786E\u8BA4")
+    var textFallback;
+    var popupContext;
+
+    // Check if element is inside a popup/menu first (needed for scoped text uniqueness)
+    var popupEl;
+    try {
+      popupEl = el.closest('[role="menu"], [role="listbox"], [role="dialog"], [role="tooltip"], [role="list"], [class*="popover"], [class*="popup"], [class*="dropdown"], [class*="menu"], [class*="modal"], [id*="menu"], [id*="dropdown"], [id*="popup"], [id*="modal"]');
+    } catch(e) {}
+
+    if (confidence === 'low') {
+      var rawText = (el.textContent || '').trim();
+      if (rawText && rawText.length >= 1 && rawText.length <= 30 && el.children.length === 0) {
+        try {
+          var doc = el.ownerDocument || document;
+          var escapedText = rawText.replace(/'/g, "\\'");
+
+          // If inside popup, check uniqueness WITHIN popup only
+          var count;
+          if (popupEl && popupEl !== el) {
+            var popupCount = doc.evaluate(
+              "count(.//*[normalize-space(text())='" + escapedText + "'])",
+              popupEl, null, XPathResult.NUMBER_TYPE, null
+            );
+            count = popupCount.numberValue;
+          } else {
+            // Check global uniqueness
+            var globalCount = doc.evaluate(
+              "count(//*[normalize-space(text())='" + escapedText + "'])",
+              doc, null, XPathResult.NUMBER_TYPE, null
+            );
+            count = globalCount.numberValue;
+          }
+
+          if (count === 1) {
+            textFallback = {
+              type: popupEl && popupEl !== el ? 'popup-text' : 'text',
+              value: rawText,
+              selector: popupEl && popupEl !== el ? 'popup-text=' + rawText : 'text=' + rawText,
+            };
+          }
+        } catch(e) { /* xpath not available or error */ }
+      }
+    }
+
+    // Generate popup context info
+    if (popupEl && popupEl !== el) {
+      try {
+        var popupResult = window.__xb_generateSelector
+          ? window.__xb_generateSelector(popupEl, el.ownerDocument || document)
+          : null;
+        if (popupResult && popupResult.selector) {
+          popupContext = {
+            containerSelector: popupResult.selector,
+            containerText: (popupEl.textContent || '').trim().substring(0, 50),
+          };
+        }
+      } catch(e) { /* skip */ }
+    }
+
     return {
       tag: tag,
-      selector: uniqueSelector(el),
+      selector: selector,
       text: displayText,
+      strategy: strategy,
+      confidence: confidence,
+      textFallback: textFallback,
+      popup: popupContext,
       role: el.getAttribute('role') || undefined,
       type: el.getAttribute('type') || undefined,
       placeholder: el.getAttribute('placeholder') || undefined,
@@ -115,6 +422,107 @@ var ACTION_SIGNAL_SCRIPT = `
     };
   }
 
+  // \u2500\u2500 Mouse trajectory capture \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Continuously samples mousemove (every ~60ms).
+  // When a meaningful action fires, we snapshot the buffer,
+  // simplify it (Douglas-Peucker), and attach as trajectory.
+  var __xb_traj_buffer = [];        // raw samples: {x, y, t}
+  var __xb_traj_last_action = null; // {x, y, t} of previous action
+
+  document.addEventListener('mousemove', function(e) {
+    var now = Date.now();
+    // Sample at ~60ms intervals
+    if (__xb_traj_buffer.length > 0) {
+      var last = __xb_traj_buffer[__xb_traj_buffer.length - 1];
+      if (now - last.t < 60) return;
+    }
+    __xb_traj_buffer.push({ x: e.clientX, y: e.clientY, t: now });
+    // Cap buffer at 200 points (~12 seconds at 60ms)
+    if (__xb_traj_buffer.length > 200) {
+      __xb_traj_buffer = __xb_traj_buffer.slice(-150);
+    }
+  }, true);
+
+  // Douglas-Peucker simplification: keep only points that define the path shape
+  function dpSimplify(pts, epsilon) {
+    if (pts.length <= 2) return pts;
+    var maxDist = 0, maxIdx = 0;
+    var first = pts[0], last = pts[pts.length - 1];
+    for (var i = 1; i < pts.length - 1; i++) {
+      var d = pointLineDistance(pts[i], first, last);
+      if (d > maxDist) { maxDist = d; maxIdx = i; }
+    }
+    if (maxDist > epsilon) {
+      var left = dpSimplify(pts.slice(0, maxIdx + 1), epsilon);
+      var right = dpSimplify(pts.slice(maxIdx), epsilon);
+      return left.slice(0, -1).concat(right);
+    }
+    return [first, last];
+  }
+
+  function pointLineDistance(p, a, b) {
+    var dx = b.x - a.x, dy = b.y - a.y;
+    var lenSq = dx * dx + dy * dy;
+    if (lenSq === 0) return Math.sqrt((p.x - a.x) * (p.x - a.x) + (p.y - a.y) * (p.y - a.y));
+    var t = Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lenSq));
+    var projX = a.x + t * dx, projY = a.y + t * dy;
+    return Math.sqrt((p.x - projX) * (p.x - projX) + (p.y - projY) * (p.y - projY));
+  }
+
+  // Extract trajectory from buffer ending at (toX, toY, toT).
+  // Returns null if no meaningful path.
+  function extractTrajectory(toX, toY) {
+    var now = Date.now();
+    // Add current position as final point
+    var raw = __xb_traj_buffer.slice();
+    raw.push({ x: toX, y: toY, t: now });
+
+    // Trim to last 5 seconds
+    var cutoff = now - 5000;
+    while (raw.length > 0 && raw[0].t < cutoff) raw.shift();
+    if (raw.length < 2) { __xb_traj_buffer = []; return null; }
+
+    // If we know the previous action position, prepend it as start
+    if (__xb_traj_last_action) {
+      // Trim raw points before the last action
+      while (raw.length > 1 && raw[0].t < __xb_traj_last_action.t) raw.shift();
+      raw.unshift({ x: __xb_traj_last_action.x, y: __xb_traj_last_action.y, t: __xb_traj_last_action.t });
+    }
+
+    // Simplify (epsilon=3px keeps shape but removes jitter)
+    var simplified = dpSimplify(raw, 3);
+    if (simplified.length < 2) { __xb_traj_buffer = []; return null; }
+
+    // Build result with delta times
+    var totalDist = 0;
+    var points = [];
+    for (var i = 0; i < simplified.length; i++) {
+      var dt = i === 0 ? 0 : simplified[i].t - simplified[i - 1].t;
+      if (i > 0) {
+        var ddx = simplified[i].x - simplified[i - 1].x;
+        var ddy = simplified[i].y - simplified[i - 1].y;
+        totalDist += Math.sqrt(ddx * ddx + ddy * ddy);
+      }
+      points.push({ x: simplified[i].x, y: simplified[i].y, dt: dt });
+    }
+
+    var duration = simplified[simplified.length - 1].t - simplified[0].t;
+
+    // Only return if meaningful movement (>5px total distance)
+    if (totalDist < 5) { __xb_traj_buffer = []; return null; }
+
+    // Reset buffer
+    __xb_traj_buffer = [];
+    __xb_traj_last_action = { x: toX, y: toY, t: now };
+
+    return { points: points, distance: Math.round(totalDist), duration: duration };
+  }
+
+  // \u2500\u2500 End trajectory capture \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+  // Expose describe() for CDP command element metadata extraction
+  window.__xb_describe = describe;
+
   function isMeaningful(el) {
     if (!el || !el.tagName) return false;
     var tag = el.tagName.toLowerCase();
@@ -153,6 +561,12 @@ var ACTION_SIGNAL_SCRIPT = `
   }
 
   function pushAction(type, detail) {
+    // Attach mouse trajectory for actions with coordinates
+    if (detail && detail.x != null && detail.y != null) {
+      var traj = extractTrajectory(detail.x, detail.y);
+      if (traj) detail.trajectory = traj;
+    }
+
     if (type === 'input') {
       if (__xb_input_timer) clearTimeout(__xb_input_timer);
       __xb_input_pending = {
@@ -331,12 +745,66 @@ var ACTION_SIGNAL_SCRIPT = `
     var tag = target.tagName && target.tagName.toLowerCase();
     if (tag === 'select') {
       pushAction('change', { element: describe(target), value: (target.value || '').substring(0, 100) });
+    } else if (tag === 'input' && target.type === 'file') {
+      var files = target.files;
+      var fileNames = [];
+      for (var i = 0; i < files.length; i++) {
+        fileNames.push(files[i].name);
+      }
+      // Read file contents asynchronously, then push action
+      var readers = [];
+      for (var i = 0; i < files.length; i++) {
+        readers.push(new Promise(function(resolve) {
+          var reader = new FileReader();
+          reader.onload = function() { resolve(reader.result); };
+          reader.onerror = function() { resolve(null); };
+          reader.readAsDataURL(files[i]);
+        }));
+      }
+      Promise.all(readers).then(function(contents) {
+        var fileData = [];
+        for (var i = 0; i < files.length; i++) {
+          fileData.push({
+            name: files[i].name,
+            type: files[i].type,
+            size: files[i].size,
+            dataUrl: contents[i],
+          });
+        }
+        pushAction('filechooser', {
+          element: describe(target),
+          value: fileNames.join(', '),
+          files: {
+            names: fileNames,
+            count: files.length,
+            isMultiple: target.multiple,
+            fileData: fileData,
+          },
+        });
+      });
     }
   }, true);
 
   document.addEventListener('keydown', function(e) {
+    // Special keys always recorded
     if (e.key === 'Enter' || e.key === 'Tab' || e.key === 'Escape' || e.key.startsWith('Arrow')) {
       pushAction('keydown', { key: e.key, element: describe(actualTarget(e)) });
+      return;
+    }
+    // Editing keys
+    if (e.key === 'Backspace' || e.key === 'Delete') {
+      pushAction('keydown', { key: e.key, element: describe(actualTarget(e)) });
+      return;
+    }
+    // Modifier combinations (Ctrl/Cmd/Alt + key)
+    if (e.ctrlKey || e.metaKey || e.altKey) {
+      var combo = '';
+      if (e.ctrlKey) combo += 'Ctrl+';
+      if (e.metaKey) combo += 'Meta+';
+      if (e.altKey) combo += 'Alt+';
+      if (e.shiftKey) combo += 'Shift+';
+      combo += e.key;
+      pushAction('keydown', { key: combo, element: describe(actualTarget(e)) });
     }
   }, true);
 
@@ -350,6 +818,155 @@ var ACTION_SIGNAL_SCRIPT = `
       pushAction('scroll', { scrollX: window.scrollX, scrollY: window.scrollY });
     }
   }, true);
+
+  // \u2500\u2500 Double click \u2500\u2500
+  document.addEventListener('dblclick', function(e) {
+    pushAction('dblclick', {
+      element: describe(resolveMeaningful(e)),
+      x: e.clientX,
+      y: e.clientY,
+    });
+  }, true);
+
+  // \u2500\u2500 Right click (context menu) \u2500\u2500
+  document.addEventListener('contextmenu', function(e) {
+    pushAction('contextmenu', {
+      element: describe(resolveMeaningful(e)),
+      x: e.clientX,
+      y: e.clientY,
+    });
+  }, true);
+
+  // \u2500\u2500 Hover (throttled to 800ms) \u2500\u2500
+  var __xb_last_hover = 0;
+  document.addEventListener('mouseover', function(e) {
+    if (Date.now() - __xb_last_hover < 800) return;
+    __xb_last_hover = Date.now();
+    var target = resolveMeaningful(e);
+    // Only record hover on interactive elements
+    var tag = target.tagName && target.tagName.toLowerCase();
+    var isInteractive = tag === 'a' || tag === 'button' || tag === 'input'
+      || tag === 'select' || tag === 'textarea' || tag === 'summary'
+      || target.getAttribute('role') === 'button'
+      || target.getAttribute('role') === 'link'
+      || target.getAttribute('role') === 'menuitem'
+      || target.getAttribute('role') === 'tab'
+      || target.getAttribute('role') === 'option'
+      || !!target.closest('[role="menu"], [role="menubar"], [role="tablist"], [role="listbox"], [role="tree"], nav, menu');
+    if (isInteractive) {
+      pushAction('hover', {
+        element: describe(target),
+        x: e.clientX,
+        y: e.clientY,
+      });
+    }
+  }, true);
+
+  // \u2500\u2500 Drag & drop \u2500\u2500
+  var __xb_drag_source = null;
+  var __xb_drag_start_pos = null;
+  document.addEventListener('dragstart', function(e) {
+    __xb_drag_source = e.target;
+    __xb_drag_start_pos = { x: e.clientX, y: e.clientY };
+  }, true);
+  document.addEventListener('drop', function(e) {
+    if (__xb_drag_source && __xb_drag_start_pos) {
+      pushAction('drag', {
+        x: e.clientX,
+        y: e.clientY,
+        drag: {
+          fromX: __xb_drag_start_pos.x,
+          fromY: __xb_drag_start_pos.y,
+          toX: e.clientX,
+          toY: e.clientY,
+          source: describe(__xb_drag_source),
+          target: describe(resolveMeaningful(e)),
+        },
+      });
+    }
+    __xb_drag_source = null;
+    __xb_drag_start_pos = null;
+  }, true);
+  document.addEventListener('dragend', function() {
+    __xb_drag_source = null;
+    __xb_drag_start_pos = null;
+  }, true);
+
+  // \u2500\u2500 Window resize \u2500\u2500
+  var __xb_last_resize = 0;
+  window.addEventListener('resize', function() {
+    if (Date.now() - __xb_last_resize < 1000) return;
+    __xb_last_resize = Date.now();
+    pushAction('resize', {
+      resize: { width: window.innerWidth, height: window.innerHeight },
+    });
+  }, true);
+
+  // \u2500\u2500 Clipboard (copy/paste/cut) \u2500\u2500
+  document.addEventListener('copy', function(e) {
+    pushAction('clipboard', { clipboard: { operation: 'copy' } });
+  }, true);
+  document.addEventListener('paste', function(e) {
+    var preview = '';
+    try {
+      preview = (e.clipboardData || window.clipboardData).getData('text').substring(0, 100);
+    } catch(ex) {}
+    pushAction('clipboard', { clipboard: { operation: 'paste', textPreview: preview } });
+  }, true);
+  document.addEventListener('cut', function(e) {
+    pushAction('clipboard', { clipboard: { operation: 'cut' } });
+  }, true);
+
+  // \u2500\u2500 Touch events \u2500\u2500
+  document.addEventListener('touchstart', function(e) {
+    var touches = [];
+    for (var i = 0; i < e.touches.length; i++) {
+      touches.push({ x: e.touches[i].clientX, y: e.touches[i].clientY });
+    }
+    pushAction('touch', {
+      element: describe(resolveMeaningful(e)),
+      touch: { touchType: 'start', touches: touches },
+    });
+  }, true);
+  document.addEventListener('touchend', function(e) {
+    var touches = [];
+    for (var i = 0; i < e.changedTouches.length; i++) {
+      touches.push({ x: e.changedTouches[i].clientX, y: e.changedTouches[i].clientY });
+    }
+    pushAction('touch', {
+      element: describe(resolveMeaningful(e)),
+      touch: { touchType: 'end', touches: touches },
+    });
+  }, true);
+
+  // \u2500\u2500 Focus / Blur \u2500\u2500
+  document.addEventListener('focusin', function(e) {
+    var target = actualTarget(e);
+    var tag = target.tagName && target.tagName.toLowerCase();
+    if (tag === 'input' || tag === 'textarea' || tag === 'select' || target.isContentEditable) {
+      pushAction('focus', {
+        element: describe(target),
+        focus: { focusType: 'focus' },
+      });
+    }
+  }, true);
+  document.addEventListener('focusout', function(e) {
+    var target = actualTarget(e);
+    var tag = target.tagName && target.tagName.toLowerCase();
+    if (tag === 'input' || tag === 'textarea' || tag === 'select' || target.isContentEditable) {
+      pushAction('focus', {
+        element: describe(target),
+        focus: { focusType: 'blur' },
+      });
+    }
+  }, true);
+
+  // \u2500\u2500 Visibility change (tab switch) \u2500\u2500
+  document.addEventListener('visibilitychange', function() {
+    pushAction('visibility', {
+      visibility: { state: document.hidden ? 'hidden' : 'visible' },
+    });
+  }, true);
 })();
 `;
 var CHECKPOINT_OVERLAY_SCRIPT = `
@@ -605,6 +1222,13 @@ var SessionRecorder = class _SessionRecorder {
   flushTimer = null;
   lastActionTs = 0;
   activePages = /* @__PURE__ */ new Set();
+  lastKnownUrl = "";
+  // Track URL to detect real navigation changes
+  /** Dedup window: after a CDP command action, ignore matching action signals within this window */
+  cdpActionDedup = null;
+  /** Network dedup: last request key for short-window dedup */
+  _lastRequestKey = "";
+  _lastRequestTs = 0;
   _isRecording = false;
   constructor(context, page, sessionName) {
     this.context = context;
@@ -617,6 +1241,43 @@ var SessionRecorder = class _SessionRecorder {
   get actionCount() {
     return this.actions.length;
   }
+  /** Record an action triggered by a CDP command (e.g. xbrowser fill/click/goto) */
+  recordCommandAction(action) {
+    const normalizedType = action.type === "cdp-fill" ? "input" : action.type === "cdp-click" ? "click" : action.type;
+    const recent = this.actions[this.actions.length - 1];
+    if (recent && Date.now() - recent.timestamp < 1500) {
+      const typeMatch = recent.type === action.type || recent.type === normalizedType;
+      const valueMatch = !action.value || recent.value === action.value;
+      const selectorMatch = !action.selector || recent.element?.selector && (recent.element.selector === action.selector || recent.element.selector.endsWith(" " + action.selector) || action.selector.endsWith(" " + recent.element.selector));
+      if (typeMatch && valueMatch && selectorMatch) {
+        return;
+      }
+    }
+    this.actionCounter++;
+    const ts = Date.now();
+    const actionUrl = action.url && action.url !== "about:blank" ? action.url : this.lastKnownUrl || this.page.url();
+    this.actions.push({
+      id: this.actionCounter,
+      type: action.type,
+      timestamp: ts,
+      url: actionUrl,
+      pageTitle: "",
+      element: action.element || (action.selector ? { tag: "", selector: action.selector, text: "" } : void 0),
+      value: action.value
+    });
+    this.lastActionTs = ts;
+    this.cdpActionDedup = {
+      type: normalizedType,
+      value: action.value,
+      selector: action.selector,
+      until: Date.now() + 1500
+    };
+    if (action.url && action.url !== "about:blank") {
+      this.lastKnownUrl = action.url;
+    } else if (action.type === "goto" && action.value && action.value !== "about:blank") {
+      this.lastKnownUrl = action.value;
+    }
+  }
   get networkCount() {
     return this.network.length;
   }
@@ -663,6 +1324,10 @@ var SessionRecorder = class _SessionRecorder {
     this.contextChanges = [];
     this.checkpoints = [];
     this.checkpointCounter = 0;
+    this.lastKnownUrl = this.page.url();
+    await this.page.addInitScript(getSelectorGeneratorScript());
+    await this.page.addInitScript(ACTION_SIGNAL_SCRIPT);
+    await this.page.addInitScript(CHECKPOINT_OVERLAY_SCRIPT);
     if (url) {
       await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
       this.startUrl = url;
@@ -678,13 +1343,17 @@ var SessionRecorder = class _SessionRecorder {
     };
     writeFileSync(this.controlFilePath, JSON.stringify(control, null, 2), "utf-8");
     await this.injectActionScript(this.page);
-    await this.page.addInitScript(ACTION_SIGNAL_SCRIPT);
-    await this.page.addInitScript(CHECKPOINT_OVERLAY_SCRIPT);
     this.context.on("request", this.handleRequest);
     this.context.on("response", this.handleResponse);
     this.context.on("page", this.handleNewPage);
+    for (const p of this.context.pages()) {
+      p.on("request", this.handleRequest);
+      p.on("response", this.handleResponse);
+    }
+    this.context.on("page", this.handleNewPage);
     this.page.on("framenavigated", this.handleFrameNavigated);
     this.page.on("dialog", this.handleDialog);
+    this.page.on("filechooser", this.handleFileChooser);
     this.pollTimer = setInterval(() => void this.pollActions(), 200);
     this.flushTimer = setInterval(() => this.flushToDisk(), 5e3);
   }
@@ -719,6 +1388,21 @@ var SessionRecorder = class _SessionRecorder {
     const data = this.buildData();
     const summary = this.buildSummary(data);
     this.writeFinalOutput(data, summary);
+    try {
+      const knowledge = updateSiteKnowledge(data);
+      const knowledgeDir = join(this.recordingsDir, "site-knowledge.md");
+      const knowledgeJson = join(this.recordingsDir, "site-knowledge.json");
+      const { readFileSync: rf } = __require("fs");
+      const { getKnowledgePath } = (init_site_knowledge(), __toCommonJS(site_knowledge_exports));
+      const mdPath = getKnowledgePath(knowledge.domain, "md");
+      try {
+        const md = rf(mdPath, "utf-8");
+        writeFileSync(knowledgeDir, md, "utf-8");
+      } catch {
+      }
+      writeFileSync(knowledgeJson, JSON.stringify(knowledge, null, 2), "utf-8");
+    } catch {
+    }
     try {
       rmSync(this.controlFilePath);
     } catch {
@@ -811,13 +1495,75 @@ var SessionRecorder = class _SessionRecorder {
   // ==================== Private ====================
   async injectActionScript(page) {
     try {
+      await page.evaluate(getSelectorGeneratorScript());
       await page.evaluate(ACTION_SIGNAL_SCRIPT);
+      await page.evaluate(`window.__xb_action_script_src = ${JSON.stringify(ACTION_SIGNAL_SCRIPT)};`);
     } catch {
     }
     try {
       await page.evaluate(CHECKPOINT_OVERLAY_SCRIPT);
     } catch {
     }
+    try {
+      await page.evaluate(`
+        (function() {
+          var _scriptSrc = ${JSON.stringify(ACTION_SIGNAL_SCRIPT)};
+          function injectIframe(iframe) {
+            try {
+              var w = iframe.contentWindow;
+              if (!w) return;
+              // Force re-injection: clear old flag
+              try { delete w.__xb_action_signal; } catch(e) {}
+              w.eval(_scriptSrc);
+              // Tag iframe so flushIframes knows it's injected
+              iframe.__xb_injected = true;
+            } catch(e) {}
+          }
+          function watchIframe(iframe) {
+            if (iframe.__xb_watched) return;
+            iframe.__xb_watched = true;
+            injectIframe(iframe);
+            iframe.addEventListener('load', function() { injectIframe(iframe); });
+          }
+          // Inject into existing iframes
+          try {
+            var iframes = document.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) watchIframe(iframes[i]);
+          } catch(e) {}
+          // Watch for dynamically inserted iframes
+          if (!window.__xb_iframe_observer) {
+            window.__xb_iframe_observer = new MutationObserver(function(mutations) {
+              for (var m = 0; m < mutations.length; m++) {
+                for (var n = 0; n < mutations[m].addedNodes.length; n++) {
+                  var node = mutations[m].addedNodes[n];
+                  if (node.tagName === 'IFRAME') {
+                    watchIframe(node);
+                  } else if (node.querySelectorAll) {
+                    var sub = node.querySelectorAll('iframe');
+                    for (var k = 0; k < sub.length; k++) watchIframe(sub[k]);
+                  }
+                }
+              }
+            });
+            window.__xb_iframe_observer.observe(document.documentElement, { childList: true, subtree: true });
+          }
+          // Periodic re-injection for iframes that load late or navigate internally
+          if (!window.__xb_iframe_timer) {
+            window.__xb_iframe_timer = setInterval(function() {
+              try {
+                var iframes = document.querySelectorAll('iframe');
+                for (var i = 0; i < iframes.length; i++) {
+                  if (!iframes[i].__xb_injected) {
+                    watchIframe(iframes[i]);
+                  }
+                }
+              } catch(e) {}
+            }, 3000);
+          }
+        })();
+      `);
+    } catch {
+    }
   }
   // ─── Network capture ────────────────────────────────────────────
   handleRequest = (request) => {
@@ -825,6 +1571,11 @@ var SessionRecorder = class _SessionRecorder {
     if (["image", "stylesheet", "font", "manifest", "other"].includes(resourceType)) return;
     const url = request.url();
     if (url.startsWith("data:") || url.startsWith("chrome-extension://") || url.startsWith("blob:")) return;
+    const dedupKey = request.method() + " " + url;
+    const now = Date.now();
+    if (this._lastRequestKey === dedupKey && now - this._lastRequestTs < 100) return;
+    this._lastRequestKey = dedupKey;
+    this._lastRequestTs = now;
     this.networkCounter++;
     const entry = {
       id: this.networkCounter,
@@ -894,22 +1645,68 @@ var SessionRecorder = class _SessionRecorder {
     });
     await page.addInitScript(ACTION_SIGNAL_SCRIPT);
     await page.addInitScript(CHECKPOINT_OVERLAY_SCRIPT);
-    await this.injectActionScript(page).catch(() => {
-    });
+    await page.addInitScript(getSelectorGeneratorScript());
+    const injectAndRetry = async () => {
+      for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+          const url = page.url();
+          if (url && url !== "about:blank" && !url.startsWith("chrome")) {
+            await this.injectActionScript(page);
+            return;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    };
+    injectAndRetry();
     page.on("framenavigated", this.handleFrameNavigated);
+    page.on("request", this.handleRequest);
+    page.on("response", this.handleResponse);
+    page.on("filechooser", this.handleFileChooser);
+    page.on("dialog", this.handleDialog);
     page.on("close", () => {
       this.activePages.delete(page);
     });
+    page.on("framenavigated", async (frame) => {
+      if (frame !== frame.page().mainFrame()) return;
+      const url = frame.url();
+      if (url && url !== "about:blank" && !url.startsWith("chrome")) {
+        try {
+          await this.injectActionScript(page);
+        } catch {
+        }
+      }
+    });
   };
   handleFrameNavigated = (frame) => {
     if (frame !== frame.page().mainFrame()) return;
+    const newUrl = frame.url();
     this.contextCounter++;
     this.contextChanges.push({
       id: this.contextCounter,
       timestamp: Date.now(),
       type: "navigate",
-      url: frame.url()
+      url: newUrl
     });
+    const lastAction = this.actions[this.actions.length - 1];
+    const lastActionUrl = lastAction?.url;
+    if (newUrl && newUrl !== "about:blank" && newUrl !== lastActionUrl) {
+      this.actionCounter++;
+      this.actions.push({
+        id: this.actionCounter,
+        type: "navigation",
+        timestamp: Date.now(),
+        url: newUrl,
+        pageTitle: "",
+        element: void 0
+      });
+    }
+    const page = frame.page();
+    if (newUrl && newUrl !== "about:blank") {
+      this.injectActionScript(page).catch(() => {
+      });
+    }
   };
   handleDialog = async (dialog) => {
     this.checkpointCounter++;
@@ -926,6 +1723,62 @@ var SessionRecorder = class _SessionRecorder {
     await dialog.dismiss().catch(() => {
     });
   };
+  handleFileChooser = async (fileChooser) => {
+    const url = this.page.url();
+    const sel = fileChooser.selector || 'input[type="file"]';
+    let element;
+    try {
+      element = await this.page.evaluate(new Function("selector", `
+        const el = document.querySelector(selector);
+        if (!el) return null;
+        return window.__xb_describe(el);
+      `), sel) ?? void 0;
+    } catch {
+    }
+    let fileData = [];
+    try {
+      fileData = await this.page.evaluate(new Function("selector", `
+        return new Promise(resolve => {
+          const input = document.querySelector(selector);
+          if (!input || !input.files || input.files.length === 0) { resolve([]); return; }
+          const readers = [];
+          for (let i = 0; i < input.files.length; i++) {
+            readers.push(new Promise(r => {
+              const reader = new FileReader();
+              reader.onload = () => r({ name: input.files[i].name, type: input.files[i].type, size: input.files[i].size, dataUrl: reader.result });
+              reader.onerror = () => r({ name: input.files[i].name, type: input.files[i].type, size: input.files[i].size, dataUrl: null });
+              reader.readAsDataURL(input.files[i]);
+            }));
+          }
+          Promise.all(readers).then(resolve);
+        });
+      `), sel);
+    } catch {
+    }
+    const names = fileData.map((f) => f.name);
+    this.actionCounter++;
+    this.actions.push({
+      id: this.actionCounter,
+      type: "filechooser",
+      timestamp: Date.now(),
+      url,
+      pageTitle: "",
+      element: element || {
+        selector: sel,
+        strategy: "css",
+        confidence: "high",
+        tag: "input",
+        text: ""
+      },
+      value: names.join(", ") || void 0,
+      files: {
+        names,
+        count: fileData.length,
+        isMultiple: fileChooser.isMultiple,
+        fileData: fileData.length > 0 ? fileData : void 0
+      }
+    });
+  };
   // ─── Action polling ─────────────────────────────────────────────
   async pollActions() {
     const pages = [this.page, ...this.activePages];
@@ -940,17 +1793,86 @@ var SessionRecorder = class _SessionRecorder {
   async flushPendingActions(page) {
     let pending = [];
     try {
-      pending = await page.evaluate(() => {
-        const w = window;
-        const actions = w.__xb_pending_actions || [];
+      pending = await page.evaluate(`(function() {
+        var w = window;
+        var actions = w.__xb_pending_actions || [];
         w.__xb_pending_actions = [];
+
+        // Recursively flush pending actions from same-origin iframes (including nested)
+        function flushIframes(doc) {
+          try {
+            var iframes = doc.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) {
+              try {
+                var iframeWin = iframes[i].contentWindow;
+                if (!iframeWin) continue;
+                // Ensure action script is injected into iframe
+                if (!iframeWin.__xb_action_script_injected) {
+                  iframeWin.__xb_action_script_injected = true;
+                  try { delete iframeWin.__xb_action_signal; } catch(e) {}
+                  try { iframeWin.eval(w.__xb_action_script_src); } catch(e) {}
+                }
+                var iframeActions = iframeWin.__xb_pending_actions;
+                if (Array.isArray(iframeActions) && iframeActions.length > 0) {
+                  // Get iframe position to offset coordinates
+                  var rect = iframes[i].getBoundingClientRect();
+                  for (var j = 0; j < iframeActions.length; j++) {
+                    var act = iframeActions[j];
+                    // Offset coordinates from iframe-relative to page-relative
+                    if (act.x != null) act.x = act.x + rect.left;
+                    if (act.y != null) act.y = act.y + rect.top;
+                    // Tag the action as originating from an iframe
+                    act.iframeSrc = iframes[i].src || '';
+                    actions.push(act);
+                  }
+                  iframeWin.__xb_pending_actions = [];
+                }
+                // Recurse into nested iframes
+                try { flushIframes(iframeWin.document); } catch(e) {}
+              } catch(e) {}
+            }
+          } catch(e) {}
+        }
+
+        flushIframes(document);
         return actions;
-      });
+      })()`);
     } catch {
       return;
     }
+    try {
+      const currentUrl = page.url();
+      const normalize = (u) => u.replace(/\/+$/, "");
+      if (currentUrl && currentUrl !== "about:blank" && normalize(currentUrl) !== normalize(this.lastKnownUrl)) {
+        const hasNav = this.actions.slice(-3).some(
+          (a) => (a.type === "navigation" || a.type === "goto") && normalize(a.url || "") === normalize(currentUrl)
+        );
+        if (!hasNav) {
+          this.actionCounter++;
+          this.actions.push({
+            id: this.actionCounter,
+            type: "navigation",
+            timestamp: Date.now(),
+            url: currentUrl,
+            pageTitle: "",
+            element: void 0
+          });
+        }
+        this.lastKnownUrl = currentUrl;
+      }
+    } catch {
+    }
     for (const raw of pending) {
       if (raw.ts <= this.lastActionTs) continue;
+      if (this.cdpActionDedup && Date.now() < this.cdpActionDedup.until) {
+        const dedup = this.cdpActionDedup;
+        const typeMatch = raw.type === dedup.type;
+        const valueMatch = !dedup.value || raw.value === dedup.value;
+        const selectorMatch = !dedup.selector || raw.element?.selector && (raw.element.selector === dedup.selector || raw.element.selector.endsWith(" " + dedup.selector) || dedup.selector.endsWith(" " + raw.element.selector));
+        if (typeMatch && valueMatch && selectorMatch) {
+          continue;
+        }
+      }
       this.actionCounter++;
       let clickContext;
       if (raw.type === "click" && raw.x !== void 0 && raw.y !== void 0) {
@@ -969,7 +1891,8 @@ var SessionRecorder = class _SessionRecorder {
         y: raw.y,
         scrollX: raw.scrollX,
         scrollY: raw.scrollY,
-        clickContext
+        clickContext,
+        files: raw.files
       });
       this.lastActionTs = raw.ts;
       if (raw.type === "click" || raw.type === "navigate" || raw.type === "submit") {
@@ -989,116 +1912,87 @@ var SessionRecorder = class _SessionRecorder {
   async captureClickContext(page, cx, cy) {
     await new Promise((r) => setTimeout(r, 300));
     try {
-      const ctx = await page.evaluate(([cx2, cy2]) => {
-        const POPOVER_SELECTORS = [
-          '[role="menu"]',
-          '[role="listbox"]',
-          '[role="dialog"]',
-          '[role="tooltip"]',
-          '[role="popover"]',
-          '[role="combobox"]',
-          '[role="tree"]',
-          '[role="grid"]',
-          ".popover",
-          ".popup",
-          ".dropdown",
-          ".menu",
-          ".modal",
-          ".tooltip",
-          ".panel",
-          '[class*="popover"]',
-          '[class*="popup"]',
-          '[class*="dropdown"]',
-          '[class*="menu"]',
-          '[class*="tooltip"]',
-          '[class*="modal"]',
-          '[class*="panel"]',
-          '[class*="overlay"]',
-          '[class*="sheet"]',
-          "[data-popup]",
-          "[data-dropdown]",
-          "[data-menu]",
-          '[data-popover"]',
-          ".semi-dropdown",
-          ".semi-popover",
-          ".semi-modal",
-          ".ant-dropdown",
-          ".ant-popover",
-          ".ant-modal",
-          ".el-dropdown",
-          ".el-popover",
-          ".el-dialog",
-          ".t-dropdown",
-          ".t-popup",
-          ".t-dialog"
-        ];
-        function isNear(el, x, y, range) {
-          try {
-            const r = el.getBoundingClientRect();
-            if (!r || r.width === 0 || r.height === 0) return false;
-            return !(r.left > x + range || r.right < x - range || r.top > y + range || r.bottom < y - range);
-          } catch {
-            return false;
+      const ctx = await page.evaluate(`
+        (function() {
+          var cx = ${cx}, cy = ${cy};
+          var POPOVER_SELECTORS = [
+            '[role="menu"]','[role="listbox"]','[role="dialog"]','[role="tooltip"]','[role="popover"]',
+            '[role="combobox"]','[role="tree"]','[role="grid"]',
+            '.popover','.popup','.dropdown','.menu','.modal','.tooltip','.panel',
+            '[class*="popover"]','[class*="popup"]','[class*="dropdown"]','[class*="menu"]',
+            '[class*="tooltip"]','[class*="modal"]','[class*="panel"]','[class*="overlay"]','[class*="sheet"]',
+            '[data-popup]','[data-dropdown]','[data-menu]','[data-popover"]',
+            '.semi-dropdown','.semi-popover','.semi-modal',
+            '.ant-dropdown','.ant-popover','.ant-modal',
+            '.el-dropdown','.el-popover','.el-dialog',
+            '.t-dropdown','.t-popup','.t-dialog'
+          ];
+
+          function isNear(el, x, y, range) {
+            try {
+              var r = el.getBoundingClientRect();
+              if (!r || r.width === 0 || r.height === 0) return false;
+              return !(r.left > x + range || r.right < x - range || r.top > y + range || r.bottom < y - range);
+            } catch(e) { return false; }
           }
-        }
-        const result = {
-          appeared: [],
-          disappeared: [],
-          stateChanges: []
-        };
-        const seenSelectors = /* @__PURE__ */ new Set();
-        for (const sel of POPOVER_SELECTORS) {
-          try {
-            const els = document.querySelectorAll(sel);
-            for (let j = 0; j < els.length; j++) {
-              const el = els[j];
-              if (!isNear(el, cx2, cy2, 500)) continue;
-              const rect = el.getBoundingClientRect();
-              if (rect.width === 0 || rect.height === 0) continue;
-              const elSel = el.id ? "#" + el.id : sel;
-              if (seenSelectors.has(elSel + rect.x + rect.y)) continue;
-              seenSelectors.add(elSel + rect.x + rect.y);
-              const items = [];
-              const children = el.querySelectorAll('a,button,[role="menuitem"],[role="option"],[role="treeitem"],li,div[class*="item"]');
-              for (let k = 0; k < Math.min(children.length, 20); k++) {
-                const child = children[k];
-                const childText = (child.textContent || "").trim().substring(0, 60);
-                if (!childText) continue;
-                const ci = { text: childText };
-                if (child.disabled || child.getAttribute("aria-disabled") === "true") ci.disabled = true;
-                if (child.tagName) ci.tag = child.tagName.toLowerCase();
-                if (child.href) ci.href = child.href.substring(0, 80);
-                items.push(ci);
+
+          var result = { appeared: [], disappeared: [], stateChanges: [] };
+          var seenElements = new Set();
+
+          for (var si = 0; si < POPOVER_SELECTORS.length; si++) {
+            try {
+              var els = document.querySelectorAll(POPOVER_SELECTORS[si]);
+              for (var j = 0; j < els.length; j++) {
+                var el = els[j];
+                if (seenElements.has(el)) continue;
+                if (!isNear(el, cx, cy, 300)) continue;
+                var rect = el.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0) continue;
+                seenElements.add(el);
+
+                var items = [];
+                var children = el.querySelectorAll('a,button,[role="menuitem"],[role="option"],[role="treeitem"],li,div[class*="item"]');
+                var seenItemTexts = new Set();
+                for (var k = 0; k < Math.min(children.length, 30); k++) {
+                  var child = children[k];
+                  var childText = (child.textContent || '').trim().substring(0, 60);
+                  if (!childText || seenItemTexts.has(childText)) continue;
+                  seenItemTexts.add(childText);
+                  var ci = { text: childText };
+                  try { if (child.disabled || child.getAttribute('aria-disabled') === 'true') ci.disabled = true; } catch(e) {}
+                  try { if (child.tagName) ci.tag = child.tagName.toLowerCase(); } catch(e) {}
+                  try { if (child.href) ci.href = child.href.substring(0, 80); } catch(e) {}
+                  items.push(ci);
+                }
+
+                result.appeared.push({
+                  tag: el.tagName.toLowerCase(),
+                  selector: el.id ? '#' + el.id : undefined,
+                  role: el.getAttribute('role'),
+                  text: (el.textContent || '').trim().substring(0, 100),
+                  rect: { x: Math.round(rect.x), y: Math.round(rect.y), w: Math.round(rect.width), h: Math.round(rect.height) },
+                  items: items
+                });
               }
-              result.appeared.push({
-                tag: el.tagName.toLowerCase(),
-                selector: el.id ? "#" + el.id : void 0,
-                role: el.getAttribute("role"),
-                text: (el.textContent || "").trim().substring(0, 100),
-                rect: { x: Math.round(rect.x), y: Math.round(rect.y), w: Math.round(rect.width), h: Math.round(rect.height) },
-                items
-              });
-            }
-          } catch {
+            } catch(e) { /* skip invalid selectors */ }
           }
-        }
-        const allInteractive = document.querySelectorAll("[aria-expanded],[disabled],[aria-disabled],[aria-selected],[data-state]");
-        for (let i = 0; i < allInteractive.length; i++) {
-          const el = allInteractive[i];
-          if (!isNear(el, cx2, cy2, 400)) continue;
-          const info = {
-            tag: el.tagName.toLowerCase(),
-            text: (el.textContent || "").trim().substring(0, 60)
-          };
-          if (el.id) info.id = el.id;
-          if (el.getAttribute("aria-expanded")) info.ariaExpanded = el.getAttribute("aria-expanded");
-          if (el.disabled || el.getAttribute("aria-disabled") === "true") info.disabled = true;
-          if (el.getAttribute("aria-selected")) info.ariaSelected = el.getAttribute("aria-selected");
-          if (el.getAttribute("data-state")) info.dataState = el.getAttribute("data-state");
-          result.stateChanges.push(info);
-        }
-        return result;
-      }, [cx, cy]);
+
+          var allInteractive = document.querySelectorAll('[aria-expanded],[disabled],[aria-disabled],[aria-selected],[data-state]');
+          for (var i = 0; i < allInteractive.length; i++) {
+            var el2 = allInteractive[i];
+            if (!isNear(el2, cx, cy, 200)) continue;
+            var info = { tag: el2.tagName.toLowerCase(), text: (el2.textContent || '').trim().substring(0, 60) };
+            try { if (el2.id) info.id = el2.id; } catch(e) {}
+            try { if (el2.getAttribute('aria-expanded')) info.ariaExpanded = el2.getAttribute('aria-expanded'); } catch(e) {}
+            try { if (el2.disabled || el2.getAttribute('aria-disabled') === 'true') info.disabled = true; } catch(e) {}
+            try { if (el2.getAttribute('aria-selected')) info.ariaSelected = el2.getAttribute('aria-selected'); } catch(e) {}
+            try { if (el2.getAttribute('data-state')) info.dataState = el2.getAttribute('data-state'); } catch(e) {}
+            result.stateChanges.push(info);
+          }
+
+          return result;
+        })()
+      `);
       if (ctx.appeared.length > 0 || ctx.stateChanges.length > 0) {
         return ctx;
       }