hunter-mate 0.1.17 → 0.1.19

package/dist/assets/extension/content/control-runtime.js

@@ -0,0 +1,1028 @@
+"use strict";
+(() => {
+  // src/shared/control-runtime.ts
+  function getRefStore() {
+    const g2 = globalThis;
+    if (!g2.__cpRefs) {
+      g2.__cpRefs = { counter: 1, refs: /* @__PURE__ */ new Map(), cssPaths: /* @__PURE__ */ new Map() };
+    }
+    return g2.__cpRefs;
+  }
+  function allocRef(el) {
+    const store = getRefStore();
+    for (const [ref2, existing2] of store.refs) {
+      if (existing2 === el) return ref2;
+    }
+    const ref = store.counter++;
+    store.refs.set(ref, el);
+    store.cssPaths.set(ref, uniqueCssPath(el));
+    return ref;
+  }
+  function uniqueCssPath(el) {
+    if (el.id) return `#${CSS.escape(el.id)}`;
+    const parts = [];
+    let cur = el;
+    while (cur && cur !== document.body && cur !== document.documentElement) {
+      let sel = cur.tagName.toLowerCase();
+      if (cur.id) {
+        parts.unshift(`#${CSS.escape(cur.id)}`);
+        break;
+      }
+      const parent = cur.parentElement;
+      if (parent) {
+        const sameTag = Array.from(parent.children).filter((c) => c.tagName === cur.tagName);
+        if (sameTag.length > 1) {
+          const idx = sameTag.indexOf(cur) + 1;
+          sel += `:nth-of-type(${idx})`;
+        }
+      }
+      parts.unshift(sel);
+      cur = parent;
+    }
+    return parts.join(" > ");
+  }
+  function err(code, message, extra) {
+    return { error: { code, message, ...extra || {} } };
+  }
+  var ERROR_CODES = {
+    NOT_FOUND: "not_found",
+    STALE_REF: "stale_ref",
+    INVALID_SELECTOR: "invalid_selector",
+    SELECTOR_NOT_FOUND: "selector_not_found",
+    SELECTOR_AMBIGUOUS: "selector_ambiguous",
+    SELECTOR_NTH_OUT_OF_RANGE: "selector_nth_out_of_range",
+    OPTION_NOT_FOUND: "option_not_found",
+    NOT_A_SELECT: "not_a_select"
+  };
+  var IMPLICIT_ROLE = {
+    a: "link",
+    button: "button",
+    select: "combobox",
+    textarea: "textbox",
+    h1: "heading",
+    h2: "heading",
+    h3: "heading",
+    h4: "heading",
+    h5: "heading",
+    h6: "heading",
+    img: "img",
+    nav: "navigation",
+    ul: "list",
+    ol: "list",
+    li: "listitem",
+    main: "main",
+    article: "article",
+    aside: "complementary",
+    header: "banner",
+    footer: "contentinfo",
+    form: "form",
+    table: "table",
+    summary: "button",
+    option: "option",
+    output: "status"
+  };
+  function roleOf(el) {
+    const explicit = el.getAttribute("role");
+    if (explicit) return explicit.split(/\s+/)[0];
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input") {
+      const type = el.type || "text";
+      if (type === "hidden") return null;
+      if (type === "checkbox") return "checkbox";
+      if (type === "radio") return "radio";
+      if (type === "button" || type === "submit" || type === "reset") return "button";
+      if (type === "range") return "slider";
+      return "textbox";
+    }
+    if (tag === "progress") return "progressbar";
+    if (tag === "meter") return "meter";
+    return IMPLICIT_ROLE[tag] ?? null;
+  }
+  function accessibleName(el) {
+    const aria = el.getAttribute("aria-label");
+    if (aria) return aria.trim();
+    const labelledby = el.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = labelledby.split(/\s+/).map((id2) => document.getElementById(id2)?.textContent?.trim() || "");
+      const joined = parts.filter(Boolean).join(" ");
+      if (joined) return joined.slice(0, 120);
+    }
+    const id = el.getAttribute("id");
+    if (id) {
+      const label = document.querySelector(`label[for="${CSS.escape(id)}"]`);
+      if (label?.textContent?.trim()) return label.textContent.trim().slice(0, 120);
+    }
+    if (el.tagName.toLowerCase() === "input") {
+      const type = el.type;
+      if (type === "button" || type === "submit" || type === "reset") {
+        const v = el.value;
+        if (v) return v;
+      }
+    }
+    const alt = el.getAttribute("alt");
+    if (alt) return alt;
+    const title = el.getAttribute("title");
+    if (title) return title;
+    const placeholder = el.getAttribute("placeholder");
+    if (placeholder) return placeholder;
+    return (el.textContent || "").replace(/\s+/g, " ").trim().slice(0, 120);
+  }
+  function isVisible(el) {
+    if (!(el instanceof HTMLElement) && !(el instanceof SVGElement)) return false;
+    const html = el;
+    if (html.hasAttribute("hidden")) return false;
+    if (html.closest("[hidden]")) return false;
+    const style = window.getComputedStyle(html);
+    if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+    if (el instanceof HTMLElement && el.offsetParent === null) {
+      const pos = style.position;
+      if (pos !== "fixed" && pos !== "sticky") return false;
+    }
+    return true;
+  }
+  var INTERACTIVE_SELECTOR = "a[href], button, input, textarea, select, summary, [role], [contenteditable=''], [contenteditable='true'], [onclick], [tabindex]";
+  function isInteractive(el) {
+    return el.matches(INTERACTIVE_SELECTOR);
+  }
+  function testidSelector(testid) {
+    return `[data-testid="${CSS.escape(testid)}"], [data-test-id="${CSS.escape(testid)}"], [data-test="${CSS.escape(testid)}"], [data-cy="${CSS.escape(testid)}"]`;
+  }
+  function resolveTargetRich(sel) {
+    const targetDesc = sel.ref != null ? String(sel.ref) : sel.css ?? (sel.role || sel.name || sel.label || sel.testid || sel.text ? `${sel.role ? `role=${sel.role} ` : ""}${sel.name ? `name=${sel.name} ` : ""}${sel.label ? `label=${sel.label} ` : ""}${sel.testid ? `testid=${sel.testid} ` : ""}${sel.text ? `text=${sel.text}` : ""}`.trim() : "");
+    if (sel.ref != null) {
+      const store = getRefStore();
+      const el = store.refs.get(sel.ref);
+      if (el && document.contains(el) && isVisible(el)) {
+        return { el, matches_n: 1, match_level: "exact", target: targetDesc };
+      }
+      if (el && !document.contains(el)) {
+        const cssPath = store.cssPaths.get(sel.ref);
+        if (cssPath) {
+          const re = document.querySelector(cssPath);
+          if (re && isVisible(re)) {
+            store.refs.set(sel.ref, re);
+            return { el: re, matches_n: 1, match_level: "reidentified", target: targetDesc };
+          }
+        }
+        return { errorEnvelope: err(ERROR_CODES.STALE_REF, "Numeric ref is no longer in the DOM. Re-run state.") };
+      }
+      return { errorEnvelope: err(ERROR_CODES.NOT_FOUND, "Numeric ref is no longer in the DOM. Re-run state.") };
+    }
+    let candidates = [];
+    if (sel.css) {
+      try {
+        candidates = Array.from(document.querySelectorAll(sel.css));
+      } catch {
+        return { errorEnvelope: err(ERROR_CODES.INVALID_SELECTOR, "CSS was rejected by querySelectorAll.", { selector: sel.css }) };
+      }
+      if (candidates.length === 0) {
+        return { errorEnvelope: err(ERROR_CODES.SELECTOR_NOT_FOUND, "CSS matches 0 elements.", { selector: sel.css, candidates: suggestCandidates() }) };
+      }
+    } else if (sel.testid) {
+      try {
+        candidates = Array.from(document.querySelectorAll(testidSelector(sel.testid)));
+      } catch {
+        return { errorEnvelope: err(ERROR_CODES.INVALID_SELECTOR, "Invalid testid.", { testid: sel.testid }) };
+      }
+    } else if (sel.role || sel.name || sel.label || sel.text) {
+      const wantRole = sel.role ? sel.role.toLowerCase() : null;
+      const wantName = sel.name ? sel.name.toLowerCase() : null;
+      const wantText = sel.text ? sel.text.toLowerCase() : null;
+      let labelTargets = [];
+      if (sel.label) {
+        const lower = sel.label.toLowerCase();
+        labelTargets = Array.from(document.querySelectorAll("label")).filter((l) => (l.textContent || "").trim().toLowerCase().includes(lower)).map((l) => {
+          const forId = l.getAttribute("for");
+          if (forId) return document.getElementById(forId);
+          return l.querySelector("input, select, textarea");
+        }).filter((x) => !!x);
+      }
+      const all = Array.from(document.querySelectorAll("*"));
+      candidates = all.filter((el) => {
+        if (!isVisible(el)) return false;
+        const role = roleOf(el);
+        if (wantRole && (!role || role.toLowerCase() !== wantRole)) return false;
+        if (wantName) {
+          const name = accessibleName(el).toLowerCase();
+          if (!name.includes(wantName)) return false;
+        }
+        if (wantText) {
+          const t = (el.textContent || "").replace(/\s+/g, " ").trim().toLowerCase();
+          if (!t.includes(wantText)) return false;
+        }
+        return true;
+      });
+      if (labelTargets.length) {
+        const set = new Set(labelTargets);
+        candidates = labelTargets.concat(candidates.filter((c) => !set.has(c)));
+      }
+      if (candidates.length === 0) {
+        return {
+          errorEnvelope: err(
+            ERROR_CODES.SELECTOR_NOT_FOUND,
+            "Semantic locator matches 0 elements.",
+            { role: sel.role, name: sel.name, label: sel.label, text: sel.text, candidates: suggestCandidates() }
+          )
+        };
+      }
+    } else {
+      return { errorEnvelope: err("no_target", "Provide a numeric ref, CSS selector, or semantic locator (--role/--name/--label/--text/--testid).") };
+    }
+    const visible = candidates.filter(isVisible);
+    const pool = visible.length ? visible : candidates;
+    if (sel.nth != null) {
+      if (sel.nth < 0 || sel.nth >= pool.length) {
+        return { errorEnvelope: err(ERROR_CODES.SELECTOR_NTH_OUT_OF_RANGE, `--nth ${sel.nth} beyond match count ${pool.length}.`) };
+      }
+      const el = pool[sel.nth];
+      return { el, matches_n: pool.length, match_level: "reidentified", target: targetDesc };
+    }
+    if (pool.length > 1) {
+      return {
+        errorEnvelope: err(ERROR_CODES.SELECTOR_AMBIGUOUS, `CSS matches ${pool.length} elements and no --nth given.`, {
+          matches_n: pool.length,
+          candidates: pool.slice(0, 5).map((el) => uniqueCssPath(el))
+        })
+      };
+    }
+    return { el: pool[0], matches_n: 1, match_level: "reidentified", target: targetDesc };
+  }
+  function suggestCandidates() {
+    const store = getRefStore();
+    const recent = Array.from(store.refs.entries()).slice(-5).map(([, el]) => uniqueCssPath(el));
+    return recent;
+  }
+  function compoundOf(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input") {
+      const input = el;
+      const type = input.type;
+      if (["date", "time", "datetime-local", "month", "week"].includes(type)) {
+        const formatMap = {
+          date: "YYYY-MM-DD",
+          time: "HH:mm",
+          "datetime-local": "YYYY-MM-DDTHH:mm",
+          month: "YYYY-MM",
+          week: "YYYY-Www"
+        };
+        return {
+          control: type,
+          format: formatMap[type] ?? type,
+          current: input.value || "",
+          min: input.min || null,
+          max: input.max || null
+        };
+      }
+      if (type === "file") {
+        const current = Array.from(input.files ?? []).map((f) => f.name);
+        return { control: "file", multiple: input.multiple, current, accept: input.accept || null };
+      }
+      return null;
+    }
+    if (tag === "select") {
+      const select = el;
+      const options = Array.from(select.options).slice(0, 50).map((o) => ({
+        label: (o.textContent || "").trim(),
+        value: o.value,
+        selected: o.selected
+      }));
+      return {
+        control: "select",
+        multiple: select.multiple,
+        current: select.selectedOptions[0] ? (select.selectedOptions[0].textContent || "").trim() : "",
+        options,
+        options_total: select.options.length
+      };
+    }
+    return null;
+  }
+  var SKIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "meta", "link", "head", "base", "template", "path", "circle", "rect", "g", "defs", "polygon", "line"]);
+  function describeElement(el, ref) {
+    const tag = el.tagName.toLowerCase();
+    const role = el.getAttribute("role") ?? null;
+    const name = accessibleName(el);
+    const parts = [];
+    if (ref != null) parts.push(`[${ref}]`);
+    parts.push(tag);
+    if (role && role !== IMPLICIT_ROLE[tag]) parts.push(`role=${role}`);
+    if (tag === "input") {
+      const input = el;
+      if (input.type && input.type !== "text") parts.push(`[${input.type}]`);
+      if (input.disabled) parts.push("(disabled)");
+    }
+    if (name) parts.push(JSON.stringify(name.length > 60 ? name.slice(0, 57) + "\u2026" : name));
+    if (tag === "a") {
+      const href = el.getAttribute("href");
+      if (href) parts.push(`\u2192 ${href.slice(0, 50)}`);
+    }
+    if (el.disabled) parts.push("(disabled)");
+    return parts.join(" ");
+  }
+  function buildStateTree() {
+    const lines = [];
+    const compounds = {};
+    const budget = { nodes: 0, chars: 0, truncated: false };
+    const MAX_NODES = 400;
+    const MAX_CHARS = 9e3;
+    let hiddenInteractive = 0;
+    function emit(depth, text) {
+      const line = "  ".repeat(Math.min(depth, 12)) + text;
+      lines.push(line);
+      budget.chars += line.length;
+    }
+    function walk(el, depth) {
+      if (budget.nodes >= MAX_NODES || budget.chars >= MAX_CHARS) {
+        budget.truncated = true;
+        return;
+      }
+      const tag = el.tagName.toLowerCase();
+      if (SKIP_TAGS.has(tag)) return;
+      budget.nodes++;
+      const visible = isVisible(el);
+      const interactive = isInteractive(el);
+      if (interactive) {
+        if (visible) {
+          const ref = allocRef(el);
+          emit(depth, describeElement(el, ref));
+          const compound = compoundOf(el);
+          if (compound) compounds[String(ref)] = compound;
+        } else {
+          hiddenInteractive++;
+          return;
+        }
+      } else if (visible) {
+        if (/^h[1-6]$/.test(tag)) {
+          const t = accessibleName(el);
+          if (t) emit(depth, `${"#".repeat(Number(tag[1]))} ${t}`);
+        } else if (tag === "p" || tag === "li" || tag === "td" || tag === "th" || tag === "figcaption" || tag === "blockquote") {
+          const ownText = ownTextOf(el);
+          if (ownText) emit(depth, ownText.slice(0, 100));
+        } else if (tag === "img") {
+          const alt = el.getAttribute("alt") || "";
+          if (alt) emit(depth, `img ${JSON.stringify(alt.slice(0, 60))}`);
+        }
+      }
+      if (depth < 14) {
+        for (const child of Array.from(el.children)) {
+          walk(child, depth + 1);
+          if (budget.truncated) return;
+        }
+      }
+    }
+    function ownTextOf(el) {
+      let text = "";
+      for (const node of Array.from(el.childNodes)) {
+        if (node.nodeType === Node.TEXT_NODE) text += node.textContent || "";
+      }
+      return text.replace(/\s+/g, " ").trim();
+    }
+    const root = document.querySelector("main") || document.querySelector("#root") || document.body;
+    emit(0, `# ${document.title}`);
+    walk(root, 0);
+    const scrollable = document.documentElement.scrollHeight > window.innerHeight + 200;
+    if (scrollable) {
+      emit(0, "\u2195 page is scrollable \u2014 run cp.scroll down to reveal more");
+    }
+    if (hiddenInteractive > 0) {
+      emit(0, `\u2139 ${hiddenInteractive} hidden interactive element(s) not tagged`);
+    }
+    if (budget.truncated) {
+      emit(0, "\u2026 (snapshot truncated by budget \u2014 narrow with a selector or scroll)");
+    }
+    return {
+      url: location.href,
+      title: document.title,
+      text: lines.join("\n"),
+      compounds,
+      hints: { scroll: scrollable, hidden_interactive: hiddenInteractive },
+      truncated: budget.truncated
+    };
+  }
+  function runControl(command, args) {
+    const a = args || {};
+    function getVisibleText(el) {
+      return (el.textContent || "").trim().replace(/\s+/g, " ").slice(0, 120);
+    }
+    function getAttrs(el) {
+      const attrs = {};
+      for (const name of ["id", "class", "name", "type", "href", "src", "placeholder", "value", "role", "aria-label", "data-testid"]) {
+        attrs[name] = el.getAttribute(name);
+      }
+      return attrs;
+    }
+    function sel() {
+      return {
+        ref: a.ref,
+        css: a.css,
+        nth: a.nth,
+        role: a.role,
+        name: a.name,
+        label: a.label,
+        text: a.text,
+        testid: a.testid
+      };
+    }
+    function findElements(findArgs) {
+      const limit = findArgs.limit ?? 20;
+      const textMax = findArgs["text-max"] ?? 120;
+      let elements = [];
+      if (findArgs.css) {
+        try {
+          elements = Array.from(document.querySelectorAll(findArgs.css));
+        } catch {
+          return err(ERROR_CODES.INVALID_SELECTOR, "CSS was rejected by querySelectorAll.", { selector: findArgs.css });
+        }
+      } else if (findArgs.testid) {
+        try {
+          elements = Array.from(document.querySelectorAll(testidSelector(findArgs.testid)));
+        } catch {
+          return err(ERROR_CODES.INVALID_SELECTOR, "Invalid testid.");
+        }
+      } else if (findArgs.role || findArgs.name || findArgs.label) {
+        const r = resolveTargetRich({ role: findArgs.role, name: findArgs.name, label: findArgs.label, text: findArgs.text });
+        if ("errorEnvelope" in r) return r.errorEnvelope;
+        elements = document.querySelectorAll("*").length ? semanticCandidates(findArgs) : [];
+      } else if (findArgs.text) {
+        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+        const lower = findArgs.text.toLowerCase();
+        const seen = /* @__PURE__ */ new Set();
+        let node;
+        while (node = walker.nextNode()) {
+          if (node.textContent?.toLowerCase().includes(lower)) {
+            const el = node.parentElement;
+            if (el && !seen.has(el)) {
+              seen.add(el);
+              elements.push(el);
+              if (elements.length >= limit) break;
+            }
+          }
+        }
+      } else {
+        elements = Array.from(document.querySelectorAll(INTERACTIVE_SELECTOR));
+      }
+      const out = elements.slice(0, limit).map((el, i) => {
+        const ref = allocRef(el);
+        return {
+          nth: i,
+          ref,
+          tag: el.tagName.toLowerCase(),
+          role: roleOf(el),
+          text: getVisibleText(el).slice(0, textMax),
+          attrs: getAttrs(el),
+          visible: isVisible(el),
+          compound: compoundOf(el) ?? void 0
+        };
+      });
+      return out;
+    }
+    function semanticCandidates(findArgs) {
+      const wantRole = findArgs.role ? findArgs.role.toLowerCase() : null;
+      const wantName = findArgs.name ? findArgs.name.toLowerCase() : null;
+      const wantText = findArgs.text ? findArgs.text.toLowerCase() : null;
+      const all = Array.from(document.querySelectorAll("*"));
+      return all.filter((el) => {
+        if (!isVisible(el)) return false;
+        if (wantRole) {
+          const role = roleOf(el);
+          if (!role || role.toLowerCase() !== wantRole) return false;
+        }
+        if (wantName && !accessibleName(el).toLowerCase().includes(wantName)) return false;
+        if (wantText && !(el.textContent || "").toLowerCase().includes(wantText)) return false;
+        return true;
+      });
+    }
+    function pageState() {
+      return {
+        url: location.href,
+        title: document.title,
+        width: window.innerWidth,
+        height: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio
+      };
+    }
+    function goto(gotoArgs) {
+      if (!gotoArgs.url) return { error: "url_required" };
+      let sameUrl = false;
+      try {
+        sameUrl = new URL(gotoArgs.url, window.location.href).href === window.location.href;
+      } catch {
+        sameUrl = false;
+      }
+      if (sameUrl) {
+        if (gotoArgs.reload === true) {
+          window.location.reload();
+          return { navigated: true, reloaded: true, url: gotoArgs.url };
+        }
+        return { navigated: false, reused: true, url: gotoArgs.url };
+      }
+      window.location.href = gotoArgs.url;
+      return { navigated: true, url: gotoArgs.url };
+    }
+    function evalScript(evalArgs) {
+      if (!evalArgs.script) return { error: "script_required" };
+      try {
+        const fn = new Function(evalArgs.script);
+        const result = fn();
+        return { result };
+      } catch (e) {
+        return { error: String(e) };
+      }
+    }
+    function fillElement(fArgs) {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      const input = el;
+      if (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.isContentEditable) {
+        const isContentEditable = el.isContentEditable;
+        if (isContentEditable) {
+          el.innerText = fArgs.text ?? "";
+        } else {
+          input.value = fArgs.text ?? "";
+        }
+        input.dispatchEvent(new Event("input", { bubbles: true }));
+        input.dispatchEvent(new Event("change", { bubbles: true }));
+        const actual = isContentEditable ? el.innerText : input.value;
+        return actual === (fArgs.text ?? "") ? { filled: true, verified: true, text: fArgs.text, actual, target, matches_n, match_level } : err("verify_failed", "Input value diverged after fill (controlled component?).", { actual });
+      }
+      return err("invalid_type", "fill only supports input, textarea, and contenteditable.");
+    }
+    function typeElement(tArgs) {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      const input = el;
+      el.focus({ preventScroll: true });
+      input.value = tArgs.text ?? "";
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      input.dispatchEvent(new Event("change", { bubbles: true }));
+      let autocomplete = false;
+      try {
+        autocomplete = !!document.querySelector("[role='listbox'], [role='combobox'] [role='listbox'], datalist, .ant-select-dropdown:not([style*='hidden']), [id^='listbox']");
+      } catch {
+      }
+      return { typed: true, text: tArgs.text, target, matches_n, match_level, autocomplete };
+    }
+    function clickElement() {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      el.scrollIntoView({ block: "center" });
+      if (a.full === true) {
+        const rect = el.getBoundingClientRect();
+        const opts = {
+          bubbles: true,
+          cancelable: true,
+          view: window,
+          clientX: rect.x + rect.width / 2,
+          clientY: rect.y + rect.height / 2,
+          button: 0,
+          buttons: 1,
+          pointerId: 1,
+          pointerType: "mouse",
+          isPrimary: true
+        };
+        el.dispatchEvent(new PointerEvent("pointerdown", opts));
+        el.dispatchEvent(new MouseEvent("mousedown", opts));
+        el.dispatchEvent(new PointerEvent("pointerup", { ...opts, buttons: 0 }));
+        el.dispatchEvent(new MouseEvent("mouseup", { ...opts, buttons: 0 }));
+        el.dispatchEvent(new MouseEvent("click", { ...opts, buttons: 0 }));
+        return { clicked: true, full: true, target, matches_n, match_level, tag: el.tagName.toLowerCase(), text: getVisibleText(el) };
+      }
+      el.click();
+      return { clicked: true, target, matches_n, match_level, tag: el.tagName.toLowerCase(), text: getVisibleText(el) };
+    }
+    function selectElement(sArgs) {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      if (el.tagName !== "SELECT") {
+        return err(ERROR_CODES.NOT_A_SELECT, "select was called on a non-<select> element.", { tag: el.tagName.toLowerCase() });
+      }
+      const select = el;
+      const want = sArgs.label ?? sArgs.value ?? sArgs.option;
+      if (!want) return err("option_required", "Provide label or value.");
+      const byLabel = Array.from(select.options).find((o) => (o.textContent || "").trim() === want);
+      const byValue = Array.from(select.options).find((o) => o.value === want);
+      const opt = byLabel ?? byValue;
+      if (!opt) {
+        const available = Array.from(select.options).slice(0, 50).map((o) => (o.textContent || "").trim());
+        return err(ERROR_CODES.OPTION_NOT_FOUND, "Option not found.", { available });
+      }
+      select.value = opt.value;
+      select.dispatchEvent(new Event("input", { bubbles: true }));
+      select.dispatchEvent(new Event("change", { bubbles: true }));
+      return { selected: true, value: select.value, target, matches_n, match_level };
+    }
+    function pressKeys(kArgs) {
+      const keyCombo = kArgs.keys ?? kArgs.key ?? "";
+      if (!keyCombo) return { error: "keys_required" };
+      const comboParts = keyCombo.split("+").map((s) => s.trim());
+      const main = comboParts[comboParts.length - 1];
+      const ctrl = comboParts.includes("Control") || comboParts.includes("Ctrl") || comboParts.includes("Meta") || comboParts.includes("Cmd");
+      const alt = comboParts.includes("Alt");
+      const shift = comboParts.includes("Shift");
+      const target = document.activeElement ?? document.body;
+      const opts = { key: main, bubbles: true, cancelable: true, ctrlKey: ctrl, altKey: alt, shiftKey: shift, metaKey: comboParts.includes("Meta") || comboParts.includes("Cmd") };
+      target.dispatchEvent(new KeyboardEvent("keydown", opts));
+      target.dispatchEvent(new KeyboardEvent("keypress", opts));
+      target.dispatchEvent(new KeyboardEvent("keyup", opts));
+      return { pressed: true, key: keyCombo };
+    }
+    function hoverElement() {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      const rect = el.getBoundingClientRect();
+      const opts = { bubbles: true, cancelable: true, clientX: rect.x + rect.width / 2, clientY: rect.y + rect.height / 2 };
+      el.dispatchEvent(new MouseEvent("mouseover", opts));
+      el.dispatchEvent(new MouseEvent("mousemove", opts));
+      return { hovered: true, target, matches_n, match_level };
+    }
+    function focusElement() {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      el.focus({ preventScroll: true });
+      return { focused: true, target, matches_n, match_level };
+    }
+    function dblclickElement() {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      el.dispatchEvent(new MouseEvent("dblclick", { bubbles: true, cancelable: true }));
+      return { dblclicked: true, target, matches_n, match_level };
+    }
+    function setChecked(want) {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      const input = el;
+      const isAria = input.type !== "checkbox" && input.type !== "radio" && el.getAttribute("aria-checked") != null;
+      if (!isAria && input.type !== "checkbox" && input.type !== "radio") {
+        return err("invalid_type", "Target is not a checkbox/radio/aria-checked control.", { tag: el.tagName.toLowerCase() });
+      }
+      if (isAria) {
+        el.setAttribute("aria-checked", String(want));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return { [want ? "checked" : "unchecked"]: true, changed: true, target, matches_n, match_level, kind: "aria" };
+      }
+      if (input.type === "radio" && !want) {
+        return err("invalid_type", "Radio buttons cannot be unchecked directly; select another radio in the group.");
+      }
+      const changed = input.checked !== want;
+      input.checked = want;
+      input.dispatchEvent(new Event("input", { bubbles: true }));
+      input.dispatchEvent(new Event("change", { bubbles: true }));
+      return { [want ? "checked" : "unchecked"]: true, changed, target, matches_n, match_level, kind: input.type };
+    }
+    function scrollElement(sArgs) {
+      const dir = sArgs.direction ?? "down";
+      const amount = sArgs.amount ?? 500;
+      if (dir !== "up" && dir !== "down") return { error: "invalid_direction" };
+      const dy = dir === "down" ? amount : -amount;
+      window.scrollBy({ top: dy, behavior: "instant" });
+      return {
+        scrolled: true,
+        direction: dir,
+        amount,
+        scrollY: Math.round(window.scrollY),
+        scrollHeight: document.documentElement.scrollHeight
+      };
+    }
+    function backNav() {
+      history.back();
+      return { back: true };
+    }
+    function htmlJsonTree(el, depth, maxDepth, childrenMax, textMax, truncated) {
+      const children = Array.from(el.children);
+      const ownText = (el.textContent || "").replace(/\s+/g, " ").trim();
+      const node = {
+        tag: el.tagName.toLowerCase(),
+        attrs: getAttrs(el),
+        text: ownText.length > textMax ? (ownText.slice(0, textMax), truncated.text_truncated = (truncated.text_truncated || 0) + 1, ownText.slice(0, textMax)) : ownText,
+        children: [],
+        compound: compoundOf(el) ?? void 0
+      };
+      if (depth < maxDepth) {
+        let kids = children;
+        if (children.length > childrenMax) {
+          truncated.children_dropped = (truncated.children_dropped || 0) + (children.length - childrenMax);
+          kids = children.slice(0, childrenMax);
+        }
+        node.children = kids.map((c) => htmlJsonTree(c, depth + 1, maxDepth, childrenMax, textMax, truncated));
+      } else if (children.length) {
+        truncated.depth = (truncated.depth || 0) + 1;
+      }
+      return node;
+    }
+    function getElement(gArgs) {
+      const what = gArgs.what ?? "text";
+      if (what === "title") return { value: document.title, matches_n: 1, match_level: "exact" };
+      if (what === "url") return { value: location.href, matches_n: 1, match_level: "exact" };
+      if (what === "html") {
+        if (gArgs["as"] === "json") {
+          const root2 = gArgs.css ? document.querySelector(gArgs.css) : document.body;
+          if (!root2) return err(ERROR_CODES.SELECTOR_NOT_FOUND, "CSS matches 0 elements.", { selector: gArgs.css });
+          const truncated = {};
+          const tree = htmlJsonTree(root2, 0, gArgs.depth ?? 6, gArgs["children-max"] ?? 20, gArgs["text-max"] ?? 200, truncated);
+          return {
+            value: tree,
+            truncated: Object.keys(truncated).length ? truncated : void 0
+          };
+        }
+        const root = gArgs.css ? document.querySelector(gArgs.css) : document.body;
+        if (!root) return err(ERROR_CODES.SELECTOR_NOT_FOUND, "CSS matches 0 elements.", { selector: gArgs.css });
+        let html = root.outerHTML;
+        if (gArgs.max && html.length > gArgs.max) html = html.slice(0, gArgs.max) + "\u2026";
+        return { value: html };
+      }
+      const r = resolveTargetRich(gArgs);
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level } = r;
+      switch (what) {
+        case "text": {
+          const t = getVisibleText(el);
+          return { value: t.length > 2e3 ? t.slice(0, 2e3) : t, matches_n, match_level };
+        }
+        case "value":
+          return { value: el.value ?? el.innerText ?? null, matches_n, match_level };
+        case "attributes":
+          return { value: getAttrs(el), matches_n, match_level };
+        default:
+          return { error: `unknown_what: ${what}` };
+      }
+    }
+    function extractMarkdown(eArgs) {
+      const chunkSize = eArgs["chunk-size"] ?? 0;
+      const start = eArgs.start ?? 0;
+      const scope = eArgs.selector ? document.querySelector(eArgs.selector) : document.querySelector("main") || document.querySelector("article") || document.body;
+      if (!scope) return { error: "scope_not_found" };
+      const parts = [];
+      const walker = document.createTreeWalker(scope, NodeFilter.SHOW_ELEMENT);
+      let node;
+      while (node = walker.nextNode()) {
+        const el = node;
+        const tag = el.tagName.toLowerCase();
+        const text = getVisibleText(el);
+        if (!text) continue;
+        if (tag === "h1") parts.push(`# ${text}`);
+        else if (tag === "h2") parts.push(`## ${text}`);
+        else if (tag === "h3") parts.push(`### ${text}`);
+        else if (tag === "p" || tag === "li") parts.push(text);
+        else if (tag === "a") parts.push(`[${text}](${el.getAttribute("href") ?? ""})`);
+      }
+      const full = parts.join("\n\n");
+      const sliced = chunkSize > 0 ? full.slice(start, start + chunkSize) : full.slice(start);
+      return {
+        url: location.href,
+        title: document.title,
+        selector: eArgs.selector ?? "auto",
+        total_chars: full.length,
+        chunk_size: chunkSize,
+        start,
+        end: start + sliced.length,
+        next_start_char: start + sliced.length < full.length ? start + sliced.length : null,
+        content: sliced
+      };
+    }
+    function listFrames() {
+      const frames = Array.from(document.querySelectorAll("iframe")).map((f, index) => {
+        const src = f.getAttribute("src") ?? "";
+        let crossOrigin = false;
+        try {
+          if (src && /^https?:/.test(src)) crossOrigin = new URL(src, location.href).origin !== location.origin;
+        } catch {
+        }
+        return { index, url: src, name: f.getAttribute("name") ?? "", cross_origin: crossOrigin };
+      });
+      return { frames };
+    }
+    function screenshotMeta() {
+      return {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        url: location.href,
+        title: document.title
+      };
+    }
+    function startTitleMarquee(tArgs) {
+      const g2 = globalThis;
+      if (g2.__cpMarquee) {
+        clearInterval(g2.__cpMarquee.interval);
+      } else {
+        g2.__cpMarquee = { original: document.title, interval: 0 };
+      }
+      const prefix = tArgs.text ?? "\u{1F916}";
+      const base = g2.__cpMarquee.original;
+      const full = `${prefix} ${base}`;
+      const speed = Math.max(100, Math.min(2e3, tArgs.speed ?? 300));
+      let pos = 0;
+      const tick = () => {
+        const display = full.slice(pos) + "  " + full.slice(0, pos);
+        document.title = display.slice(0, 60);
+        pos = (pos + 1) % (full.length + 1 || 1);
+      };
+      tick();
+      g2.__cpMarquee.interval = window.setInterval(tick, speed);
+      return { started: true, original: base, prefix, speed };
+    }
+    function stopTitleMarquee() {
+      const g2 = globalThis;
+      const state = g2.__cpMarquee;
+      if (!state) return { restored: false, reason: "no_active_marquee" };
+      clearInterval(state.interval);
+      document.title = state.original;
+      delete g2.__cpMarquee;
+      return { restored: true, original: state.original };
+    }
+    function networkEntriesLegacy(nArgs) {
+      const all = performance.getEntriesByType("resource").map((e) => ({
+        url: e.name,
+        type: e.initiatorType ?? "unknown",
+        duration: Math.round(e.duration)
+      }));
+      let entries = all;
+      if (nArgs.filter) {
+        const keywords = nArgs.filter.split(",").map((s) => s.trim().toLowerCase());
+        entries = all.filter((e) => keywords.some((kw) => e.url.toLowerCase().includes(kw)));
+      }
+      return { entries, count: entries.length, source: "performance-api" };
+    }
+    async function waitForCondition(wArgs) {
+      const timeout = wArgs.timeout ?? 1e4;
+      if (wArgs.time != null) {
+        await new Promise((res) => setTimeout(res, Math.min(wArgs.time * 1e3, 3e4)));
+        return { waited: true, kind: "time", seconds: wArgs.time };
+      }
+      const deadline = Date.now() + timeout;
+      const pollInterval = 200;
+      if (wArgs.selector) {
+        while (Date.now() < deadline) {
+          if (document.querySelector(wArgs.selector)) return { waited: true, kind: "selector", selector: wArgs.selector, elapsedMs: timeout - (deadline - Date.now()) };
+          await new Promise((res) => setTimeout(res, pollInterval));
+        }
+        return err("wait_timeout", `Selector not found within ${timeout}ms.`, { selector: wArgs.selector });
+      }
+      if (wArgs.text) {
+        const lower = wArgs.text.toLowerCase();
+        while (Date.now() < deadline) {
+          if ((document.body.textContent || "").toLowerCase().includes(lower)) {
+            return { waited: true, kind: "text", text: wArgs.text, elapsedMs: timeout - (deadline - Date.now()) };
+          }
+          await new Promise((res) => setTimeout(res, pollInterval));
+        }
+        return err("wait_timeout", `Text not found within ${timeout}ms.`, { text: wArgs.text });
+      }
+      return { error: "no_condition" };
+    }
+    function uploadFiles(uArgs) {
+      const r = resolveTargetRich(sel());
+      if ("errorEnvelope" in r) return r.errorEnvelope;
+      const { el, matches_n, match_level, target } = r;
+      const input = el;
+      if (input.type !== "file") return err("invalid_type", "Target is not an input[type=file].", { tag: el.tagName.toLowerCase() });
+      try {
+        const dt = new DataTransfer();
+        for (const name of uArgs.files ?? []) {
+          dt.items.add(new File([""], name.split("/").pop() || name));
+        }
+        input.files = dt.files;
+      } catch {
+      }
+      input.dispatchEvent(new Event("change", { bubbles: true }));
+      return {
+        uploaded: true,
+        files: uArgs.files ?? [],
+        file_names: (uArgs.files ?? []).map((f) => f.split("/").pop()),
+        target,
+        matches_n,
+        match_level,
+        multiple: input.multiple,
+        accept: input.accept || null
+      };
+    }
+    function dragElements(dArgs) {
+      const r1 = resolveTargetRich(sel());
+      if ("errorEnvelope" in r1) return r1.errorEnvelope;
+      const r2 = resolveTargetRich({ ref: dArgs.ref2, css: dArgs.css2 });
+      if ("errorEnvelope" in r2) return r2.errorEnvelope;
+      const src = r1.el;
+      const tgt = r2.el;
+      const make = (type) => {
+        const r1rect = src.getBoundingClientRect();
+        return new DragEvent(type, { bubbles: true, cancelable: true, clientX: r1rect.x + r1rect.width / 2, clientY: r1rect.y + r1rect.height / 2 });
+      };
+      src.dispatchEvent(make("dragstart"));
+      tgt.dispatchEvent(new DragEvent("dragenter", { bubbles: true }));
+      tgt.dispatchEvent(new DragEvent("dragover", { bubbles: true, cancelable: true }));
+      tgt.dispatchEvent(new DragEvent("drop", { bubbles: true, cancelable: true }));
+      src.dispatchEvent(new DragEvent("dragend", { bubbles: true }));
+      return { dragged: true, source: String(sel().ref ?? sel().css ?? ""), target: String(dArgs.ref2 ?? dArgs.css2 ?? ""), source_matches_n: r1.matches_n, target_matches_n: r2.matches_n };
+    }
+    switch (command) {
+      case "cp.state":
+        return a.tree === false ? pageState() : buildStateTree();
+      case "cp.snapshot":
+        return buildStateTree();
+      case "cp.find":
+        return findElements({
+          css: a.css,
+          text: a.text,
+          limit: a.limit,
+          role: a.role,
+          name: a.name,
+          label: a.label,
+          testid: a.testid,
+          "text-max": a["text-max"]
+        });
+      case "cp.click":
+        return clickElement();
+      case "cp.type":
+        return typeElement({ text: a.text });
+      case "cp.goto":
+        return goto({ url: a.url });
+      case "cp.eval":
+        return evalScript({ script: a.script });
+      case "cp.fill":
+        return fillElement({ text: a.text });
+      case "cp.select":
+        return selectElement({ label: a.label, value: a.value, option: a.option });
+      case "cp.keys":
+        return pressKeys({ keys: a.keys, key: a.key });
+      case "cp.hover":
+        return hoverElement();
+      case "cp.focus":
+        return focusElement();
+      case "cp.dblclick":
+        return dblclickElement();
+      case "cp.check":
+        return setChecked(true);
+      case "cp.uncheck":
+        return setChecked(false);
+      case "cp.scroll":
+        return scrollElement({ direction: a.direction, amount: a.amount });
+      case "cp.back":
+        return backNav();
+      case "cp.get":
+        return getElement({
+          what: a.what,
+          css: a.css,
+          ref: a.ref,
+          nth: a.nth,
+          "as": a["as"],
+          depth: a.depth,
+          "children-max": a["children-max"],
+          "text-max": a["text-max"],
+          max: a.max,
+          role: a.role,
+          name: a.name,
+          label: a.label,
+          text: a.text,
+          testid: a.testid
+        });
+      case "cp.extract":
+        return extractMarkdown({
+          "chunk-size": a["chunk-size"],
+          start: a.start,
+          selector: a.selector
+        });
+      case "cp.frames":
+        return listFrames();
+      case "cp.screenshot":
+        return screenshotMeta();
+      case "cp.network":
+        return networkEntriesLegacy({ filter: a.filter });
+      case "cp.wait":
+        return waitForCondition({
+          selector: a.selector,
+          text: a.text,
+          time: a.time,
+          timeout: a.timeout
+        });
+      case "cp.upload":
+        return uploadFiles({ files: a.files });
+      case "cp.drag":
+        return dragElements({ ref2: a.ref2, css2: a.css2 });
+      case "cp.title.marquee":
+        return startTitleMarquee({ text: a.text, speed: a.speed });
+      case "cp.title.restore":
+        return stopTitleMarquee();
+      default:
+        return { error: `unknown_command: ${command}` };
+    }
+  }
+  var RUNTIME_VERSION = "0.3.0-opencli-parity";
+  globalThis.__cpRunControl = runControl;
+  globalThis.__cpRuntimeVersion = RUNTIME_VERSION;
+
+  // src/background/control-runtime-bridge.ts
+  var g = globalThis;
+  var existing = g.__hmControlRuntime;
+  if (!existing || existing.version !== RUNTIME_VERSION) {
+    g.__hmControlRuntime = {
+      version: RUNTIME_VERSION,
+      runControl
+    };
+  }
+})();