@wenathlan/extension 1.1.32 → 1.1.34

package/extension/dist/pagebridge.js

@@ -1,9 +1,9 @@
 "use strict";
 (() => {
   // policy.ts
-  var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile"]);
-  var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset"]);
-  var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot"]);
+  var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor"]);
+  var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
+  var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector"]);
   var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
   function parseoptions(step) {
     if (step.options === void 0) return {};
@@ -16,6 +16,10 @@
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Step options must be a JSON object.");
     return parsed;
   }
+  function resolutionverdict(count) {
+    if (!Number.isFinite(count) || count <= 0) return "absent";
+    return count === 1 ? "resolved" : "ambiguous";
+  }
 
   // extension/pageactions.ts
   function events(target) {
@@ -49,12 +53,12 @@
     })();
     switch (step.kind) {
       case "presskey": {
-        const receiver = target instanceof HTMLElement ? target : document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
+        const receiver2 = target instanceof HTMLElement ? target : document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
         const key = step.value ?? "";
         const mods = modifiers(options);
-        receiver.dispatchEvent(keyevent("keydown", key, mods));
-        receiver.dispatchEvent(keyevent("keypress", key, mods));
-        receiver.dispatchEvent(keyevent("keyup", key, mods));
+        receiver2.dispatchEvent(keyevent("keydown", key, mods));
+        receiver2.dispatchEvent(keyevent("keypress", key, mods));
+        receiver2.dispatchEvent(keyevent("keyup", key, mods));
         return { ok: true, summary: `Key ${key} delivered with ${mods.length} modifier${mods.length === 1 ? "" : "s"}.` };
       }
       case "clickdeep": {
@@ -179,6 +183,361 @@
     }
   }
 
+  // extension/pagexpath.ts
+  function owntext(element) {
+    let combined = "";
+    for (const node of element.childNodes) if (node.nodeType === Node.TEXT_NODE) combined += node.textContent ?? "";
+    return combined.replace(/\s+/g, " ").trim();
+  }
+  function attributesof(element) {
+    const attributes = {};
+    for (const attribute of [...element.attributes]) attributes[attribute.name] = attribute.value;
+    return attributes;
+  }
+  function wrap(element) {
+    return { tag: element.tagName.toLowerCase(), attributes: attributesof(element), text: owntext(element), children: [...element.children].map(wrap), element };
+  }
+  function buildxtree(root) {
+    return { tag: "#document", attributes: {}, text: "", children: root.documentElement ? [wrap(root.documentElement)] : [] };
+  }
+  function parsepredicate(raw) {
+    const body = raw.trim();
+    let match = /^@([\w-]+)$/.exec(body);
+    if (match) return { kind: "attr", name: match[1] };
+    match = /^@([\w-]+)\s*=\s*['"]([^'"]*)['"]$/.exec(body);
+    if (match) return { kind: "attr", name: match[1], value: match[2] };
+    match = /^contains\(\s*@([\w-]+)\s*,\s*['"]([^'"]*)['"]\s*\)$/.exec(body);
+    if (match) return { kind: "attr", name: match[1], value: match[2], contains: true };
+    match = /^text\(\)\s*=\s*['"]([^'"]*)['"]$/.exec(body);
+    if (match) return { kind: "text", value: match[1] };
+    match = /^contains\(\s*text\(\)\s*,\s*['"]([^'"]*)['"]\s*\)$/.exec(body);
+    if (match) return { kind: "text", value: match[1], contains: true };
+    match = /^(\d+)$/.exec(body);
+    if (match) return { kind: "position", index: Number.parseInt(match[1], 10) };
+    return null;
+  }
+  function parsexpath(expression) {
+    const trimmed = expression.trim();
+    if (!trimmed.startsWith("/")) throw new Error("The reviewed xpath expression must start with a slash.");
+    const steps = [];
+    let index = 0;
+    while (index < trimmed.length) {
+      if (trimmed[index] !== "/") throw new Error("The reviewed xpath expression contains an unsupported segment.");
+      let slashes = 0;
+      while (index < trimmed.length && trimmed[index] === "/") {
+        slashes += 1;
+        index += 1;
+      }
+      const start = index;
+      let quote = "";
+      while (index < trimmed.length) {
+        const character = trimmed[index];
+        if (quote) {
+          if (character === quote) quote = "";
+        } else if (character === "'" || character === '"') quote = character;
+        else if (character === "/") break;
+        index += 1;
+      }
+      const body = trimmed.slice(start, index);
+      if (!body) throw new Error("The reviewed xpath expression contains an empty step.");
+      const parsed = /^(\*|[a-zA-Z][\w-]*)((?:\[[^\]]*\])*)$/.exec(body);
+      if (!parsed) throw new Error(`The reviewed xpath step ${body} is not supported.`);
+      const predicates = [];
+      const pattern = /\[([^\]]*)\]/g;
+      let predicate;
+      while ((predicate = pattern.exec(parsed[2] ?? "")) !== null) {
+        const parsedpredicate = parsepredicate(predicate[1]);
+        if (!parsedpredicate) throw new Error(`The reviewed xpath predicate [${predicate[1]}] is not supported.`);
+        predicates.push(parsedpredicate);
+      }
+      steps.push({ descendant: slashes > 1, tag: parsed[1].toLowerCase(), predicates });
+    }
+    return steps;
+  }
+  function descendants(node, includeself) {
+    const result = includeself ? [node] : [];
+    for (const child of node.children) {
+      result.push(child);
+      result.push(...descendants(child, false));
+    }
+    return result;
+  }
+  function applypredicates(nodes, predicates) {
+    let result = nodes;
+    for (const predicate of predicates) {
+      if (predicate.kind === "position") {
+        const entry = result[predicate.index - 1];
+        result = entry ? [entry] : [];
+        continue;
+      }
+      result = result.filter((node) => {
+        if (predicate.kind === "attr") {
+          const value = node.attributes[predicate.name];
+          if (value === void 0) return false;
+          if (predicate.value === void 0) return true;
+          return predicate.contains ? value.includes(predicate.value) : value === predicate.value;
+        }
+        return predicate.contains ? node.text.includes(predicate.value) : node.text === predicate.value;
+      });
+    }
+    return result;
+  }
+  function evaluatexpath(root, expression) {
+    const steps = parsexpath(expression);
+    let current = [root];
+    let first = true;
+    for (const step of steps) {
+      let matched = [];
+      for (const node of current) {
+        const pool = step.descendant ? descendants(node, first) : node.children;
+        matched = matched.concat(pool.filter((candidate) => candidate.tag === step.tag || step.tag === "*"));
+      }
+      current = applypredicates(matched, step.predicates);
+      first = false;
+    }
+    return current;
+  }
+
+  // extension/pageresolve.ts
+  function clean(value) {
+    return value.replace(/\s+/g, " ").trim();
+  }
+  function cssescape(value) {
+    return typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(value) : value.replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+  }
+  function elementlabel(element) {
+    const aria = element.getAttribute("aria-label");
+    let linked = "";
+    const labelledby = element.getAttribute("aria-labelledby");
+    if (labelledby) {
+      try {
+        const owner = element.ownerDocument?.getElementById(labelledby);
+        if (owner) linked = owner.textContent ?? "";
+      } catch {
+      }
+    }
+    let forlabel = "";
+    if (element.id) {
+      try {
+        const label = element.ownerDocument?.querySelector(`label[for="${cssescape(element.id)}"]`);
+        if (label instanceof HTMLElement) forlabel = label.textContent ?? "";
+      } catch {
+      }
+    }
+    return clean(aria || linked || forlabel || element.getAttribute("title") || element.textContent || "");
+  }
+  function implicitrole(element) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "button") return "button";
+    if (tag === "a" && element.getAttribute("href")) return "link";
+    if (tag === "select") return "combobox";
+    if (tag === "textarea") return "textbox";
+    if (tag === "details") return "group";
+    if (tag === "input") {
+      const type = element.getAttribute("type") ?? "text";
+      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";
+    }
+    return "";
+  }
+  function elementselector(element) {
+    if (element.id) return `#${cssescape(element.id)}`;
+    const role = element.getAttribute("role");
+    const name = element.getAttribute("name");
+    if (role && name) return `[role="${cssescape(role)}"][name="${cssescape(name)}"]`;
+    if (name) return `${element.tagName.toLowerCase()}[name="${cssescape(name)}"]`;
+    const tag = element.tagName.toLowerCase();
+    const parent = element.parentElement;
+    if (!parent) return tag;
+    const peers = [...parent.children].filter((node) => node.tagName === element.tagName);
+    return `${tag}:nth-of-type(${peers.indexOf(element) + 1})`;
+  }
+  function owntext2(element) {
+    let combined = "";
+    for (const node of element.childNodes) if (node.nodeType === Node.TEXT_NODE) combined += node.textContent ?? "";
+    return clean(combined);
+  }
+  function summarize(element) {
+    return {
+      tag: element.tagName.toLowerCase(),
+      id: element.id,
+      role: element.getAttribute("role")?.toLowerCase() || implicitrole(element),
+      name: element.getAttribute("name") ?? "",
+      label: elementlabel(element),
+      text: owntext2(element),
+      selector: elementselector(element),
+      element
+    };
+  }
+  var clickableselector = "a[href], button, input, textarea, select, summary, [role=button], [role=link], [role=combobox], [role=option], [role=checkbox], [role=radio], [role=switch], [role=tab]";
+  function collectclickable(root) {
+    return [...root.querySelectorAll(clickableselector)].map(summarize);
+  }
+  function collectcandidates(root) {
+    return [...root.querySelectorAll("*")].map(summarize);
+  }
+  function matchtext(candidates, text) {
+    const wanted = clean(text).toLowerCase();
+    if (!wanted) return [];
+    const exact = candidates.filter((candidate) => candidate.text.toLowerCase() === wanted || candidate.label.toLowerCase() === wanted);
+    if (exact.length > 0) return exact;
+    return candidates.filter((candidate) => candidate.text.toLowerCase().includes(wanted) || candidate.label.toLowerCase().includes(wanted));
+  }
+  function matcharia(candidates, role, name) {
+    const wantedrole = clean(role).toLowerCase();
+    const wantedname = clean(name).toLowerCase();
+    if (!wantedrole || !wantedname) return [];
+    return candidates.filter((candidate) => candidate.role.toLowerCase() === wantedrole && (candidate.label.toLowerCase() === wantedname || candidate.name.toLowerCase() === wantedname));
+  }
+  function matchname(candidates, name, clickable) {
+    const wanted = clean(name).toLowerCase();
+    if (!wanted) return [];
+    const matches = candidates.filter((candidate) => candidate.label.toLowerCase() === wanted || candidate.name.toLowerCase() === wanted);
+    if (matches.length > 1 && clickable) {
+      const interactive = matches.filter(clickable);
+      if (interactive.length === 1) return interactive;
+    }
+    return matches;
+  }
+  function matchindex(candidates, index) {
+    if (!Number.isInteger(index) || index < 1) return [];
+    const entry = candidates[index - 1];
+    return entry ? [entry] : [];
+  }
+  function buildclickablemap(candidates, version, builtat = 0) {
+    const entries = candidates.map((candidate, position) => ({ number: position + 1, selector: candidate.selector, role: candidate.role || candidate.tag, label: candidate.label, mode: "selector" }));
+    return { version, entries, builtat };
+  }
+  function describeframes(root) {
+    const frames = [...root.querySelectorAll("iframe")].map((frame) => {
+      let content = null;
+      try {
+        content = frame.contentDocument;
+      } catch {
+        content = null;
+      }
+      let sameorigin = false;
+      try {
+        sameorigin = content !== null && frame.contentWindow?.location.origin === location.origin;
+      } catch {
+        sameorigin = false;
+      }
+      return sameorigin && content ? { sameorigin: true, document: describeframes(content) } : { sameorigin: false };
+    });
+    return { frames, live: root };
+  }
+  function walkframepath(root, path) {
+    let current = root;
+    for (const index of path) {
+      if (!Number.isInteger(index) || index < 0) return { ok: false, reason: "The reviewed frame path contains an invalid frame index." };
+      const entry = current.frames[index];
+      if (!entry) return { ok: false, reason: `Frame ${index} of the reviewed frame path is absent.` };
+      if (!entry.sameorigin || !entry.document) return { ok: false, reason: `Frame ${index} of the reviewed frame path is cross origin and was refused.` };
+      current = entry.document;
+    }
+    return { ok: true, document: current };
+  }
+  function describescopes(root) {
+    const elements = [...root.querySelectorAll("*")];
+    const shadows = [];
+    for (const element of elements) {
+      const shadow = element.shadowRoot;
+      if (shadow) {
+        const nested = describescopes(shadow);
+        nested.host = summarize(element);
+        shadows.push(nested);
+      }
+    }
+    return { candidates: elements.map(summarize), shadows };
+  }
+  function queryshadowchain(root, selectors) {
+    let scope = root;
+    for (let position = 0; position < selectors.length; position += 1) {
+      const found = scope.querySelector(selectors[position]);
+      if (!found) return null;
+      if (position === selectors.length - 1) return found;
+      const shadow = found.shadowRoot;
+      if (!shadow) return null;
+      scope = shadow;
+    }
+    return null;
+  }
+  function queryscoped(root, selector) {
+    const direct = root.querySelector(selector);
+    if (direct) return direct;
+    for (const element of [...root.querySelectorAll("*")]) {
+      const shadow = element.shadowRoot;
+      if (shadow) {
+        const found = queryscoped(shadow, selector);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  function parseoptionssafe(step) {
+    try {
+      return parseoptions(step);
+    } catch {
+      return {};
+    }
+  }
+  function targetsummary(mode, element) {
+    const rect = element.getBoundingClientRect();
+    return { mode, selector: elementselector(element), tag: element.tagName.toLowerCase(), label: elementlabel(element), geometry: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } };
+  }
+  function singleresolution(mode, matches) {
+    const verdict = resolutionverdict(matches.length);
+    if (verdict === "resolved") {
+      const winner = matches[0];
+      if (winner && winner.element instanceof HTMLElement) return { status: "resolved", element: winner.element, target: targetsummary(mode, winner.element) };
+      return { status: "absent", mode };
+    }
+    if (verdict === "ambiguous") return { status: "ambiguous", mode, candidates: matches.slice(0, 8).map((candidate) => candidate.label || candidate.selector) };
+    return { status: "absent", mode };
+  }
+  function resolvetargetref(reference, root) {
+    const mode = reference.mode;
+    if (mode === "selector") {
+      const selector = typeof reference.selector === "string" ? reference.selector : "";
+      const element = selector ? root.querySelector(selector) : null;
+      return element instanceof HTMLElement ? { status: "resolved", element, target: targetsummary("selector", element) } : { status: "absent", mode: "selector" };
+    }
+    if (mode === "point") {
+      const x = Number(reference.x);
+      const y = Number(reference.y);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) return { status: "absent", mode: "point" };
+      const element = root.elementFromPoint(x, y);
+      return element instanceof HTMLElement ? { status: "resolved", element, target: targetsummary("point", element) } : { status: "absent", mode: "point" };
+    }
+    if (mode === "xpath") {
+      const expression = typeof reference.xpath === "string" ? reference.xpath : "";
+      if (!expression) return { status: "absent", mode: "xpath" };
+      const matches = evaluatexpath(buildxtree(root), expression);
+      const first = matches[0];
+      return first?.element instanceof HTMLElement ? { status: "resolved", element: first.element, target: targetsummary("xpath", first.element) } : { status: "absent", mode: "xpath" };
+    }
+    if (mode === "index") {
+      const matches = matchindex(collectclickable(root), Number(reference.index));
+      return singleresolution("index", matches);
+    }
+    const candidates = collectcandidates(root);
+    if (mode === "text") return singleresolution("text", matchtext(candidates, typeof reference.text === "string" ? reference.text : ""));
+    if (mode === "aria") return singleresolution("aria", matcharia(candidates, typeof reference.role === "string" ? reference.role : "", typeof reference.name === "string" ? reference.name : ""));
+    if (mode === "name") return singleresolution("name", matchname(candidates, typeof reference.name === "string" ? reference.name : ""));
+    return { status: "absent" };
+  }
+  function resolvestep(step, root) {
+    const reference = parseoptionssafe(step).targetref;
+    if (reference && typeof reference === "object" && !Array.isArray(reference)) return resolvetargetref(reference, root);
+    if (!step.target?.trim()) return { status: "none" };
+    const element = root.querySelector(step.target);
+    if (element instanceof HTMLElement) return { status: "resolved", element, target: targetsummary("selector", element) };
+    return { status: "absent", mode: "selector" };
+  }
+
   // extension/pagereads.ts
   var highlightid = "devthinkactionhighlight";
   function clearhighlight() {
@@ -195,7 +554,7 @@
     window.setTimeout(clearhighlight, 5e3);
     return { ok: true, summary: "Target outlined for five seconds." };
   }
-  function poll(predicate, description, timeout) {
+  function poll(root, predicate, description, timeout) {
     return new Promise((resolve) => {
       const started = Date.now();
       const check = () => {
@@ -212,15 +571,15 @@
       check();
     });
   }
-  function formstate() {
-    return [...document.querySelectorAll("input, textarea, select")].map((element) => ({
+  function formstate(root) {
+    return [...root.querySelectorAll("input, textarea, select")].map((element) => ({
       type: element.getAttribute("type") ?? element.tagName.toLowerCase(),
       name: element.getAttribute("name") ?? "",
       value: element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement ? element.value : "",
       ...element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio") ? { checked: element.checked } : {}
     }));
   }
-  function runpageread(step, target) {
+  function runpageread(step, target, root = document) {
     const options = (() => {
       try {
         return parseoptions(step);
@@ -268,7 +627,7 @@
         return { ok: true, summary: "Target markup read.", details: { html: target.outerHTML } };
       }
       case "countelements": {
-        const count = document.querySelectorAll(step.target ?? "").length;
+        const count = root.querySelectorAll(step.target ?? "").length;
         return { ok: true, summary: `Selector matches ${count} element${count === 1 ? "" : "s"}.`, details: { count } };
       }
       case "readtable": {
@@ -279,19 +638,19 @@
         return { ok: true, summary: `Read table with ${headers.length} column${headers.length === 1 ? "" : "s"} and ${body.length} row${body.length === 1 ? "" : "s"}.`, details: { headers, rows: body } };
       }
       case "readlinks": {
-        const links = [...document.querySelectorAll("a[href]")].map((element) => ({ text: element.textContent?.trim() ?? "", href: element.getAttribute("href") ?? "" }));
+        const links = [...root.querySelectorAll("a[href]")].map((element) => ({ text: element.textContent?.trim() ?? "", href: element.getAttribute("href") ?? "" }));
         return { ok: true, summary: `Read ${links.length} link${links.length === 1 ? "" : "s"}.`, details: { links } };
       }
       case "readimages": {
-        const images = [...document.querySelectorAll("img")].map((element) => ({ src: element.getAttribute("src") ?? "", alt: element.getAttribute("alt") ?? "" }));
+        const images = [...root.querySelectorAll("img")].map((element) => ({ src: element.getAttribute("src") ?? "", alt: element.getAttribute("alt") ?? "" }));
         return { ok: true, summary: `Read ${images.length} image${images.length === 1 ? "" : "s"}.`, details: { images } };
       }
       case "readmeta": {
-        const meta = [...document.querySelectorAll("meta")].map((element) => ({ name: element.getAttribute("name") ?? "", property: element.getAttribute("property") ?? "", content: element.getAttribute("content") ?? "" }));
+        const meta = [...root.querySelectorAll("meta")].map((element) => ({ name: element.getAttribute("name") ?? "", property: element.getAttribute("property") ?? "", content: element.getAttribute("content") ?? "" }));
         return { ok: true, summary: `Read ${meta.length} meta entr${meta.length === 1 ? "y" : "ies"}.`, details: { meta } };
       }
       case "readforms": {
-        const forms = formstate();
+        const forms = formstate(root);
         return { ok: true, summary: `Read ${forms.length} form control${forms.length === 1 ? "" : "s"}.`, details: { forms } };
       }
       case "readstorage": {
@@ -311,43 +670,1379 @@
         }
       }
       case "waitfor": {
-        const selector2 = step.target ?? "";
+        const selector = step.target ?? "";
         const timeout = typeof options.timeout === "number" ? options.timeout : 0;
-        return poll(() => Boolean(document.querySelector(selector2)), `Selector ${selector2}`, timeout);
+        return poll(root, () => Boolean(root.querySelector(selector)), `Selector ${selector}`, timeout);
       }
       case "waittext": {
         const text = step.value ?? "";
         const timeout = typeof options.timeout === "number" ? options.timeout : 0;
-        return poll(() => (document.body?.innerText ?? "").includes(text), `Text ${text}`, timeout);
+        return poll(root, () => (root.body?.innerText ?? "").includes(text), `Text ${text}`, timeout);
+      }
+      case "mapclicks": {
+        const candidates = collectclickable(root);
+        const map = buildclickablemap(candidates, 0, 0);
+        return { ok: true, summary: `Mapped ${map.entries.length} clickable element${map.entries.length === 1 ? "" : "s"}.`, details: { entries: map.entries } };
+      }
+      case "verifyvisible": {
+        if (!target) return { ok: false, summary: "Verify target is no longer available." };
+        const rect = target.getBoundingClientRect();
+        const rendered = rect.width > 0 && rect.height > 0;
+        return { ok: rendered, summary: rendered ? `Target is rendered at ${Math.round(rect.x)},${Math.round(rect.y)} with size ${Math.round(rect.width)}x${Math.round(rect.height)}.` : "Target is not rendered.", details: { visible: rendered, geometry: { x: rect.x, y: rect.y, width: rect.width, height: rect.height } } };
+      }
+      case "verifyenabled": {
+        if (!target) return { ok: false, summary: "Verify target is no longer available." };
+        const control = target;
+        const disabled = control.disabled === true || target.hasAttribute("disabled");
+        const readonly = control.readOnly === true || target.hasAttribute("readonly");
+        const enabled = !disabled && !readonly;
+        return { ok: enabled, summary: enabled ? "Target is enabled and writable." : disabled ? "Target is disabled." : "Target is readonly.", details: { enabled, disabled, readonly } };
+      }
+      case "resolvexpath": {
+        const reference = options.targetref;
+        const expression = typeof reference?.xpath === "string" ? reference.xpath : "";
+        if (!expression) return { ok: false, summary: "The reviewed xpath expression is absent." };
+        let matches = [];
+        try {
+          matches = evaluatexpath(buildxtree(root), expression);
+        } catch (error) {
+          return { ok: false, summary: `The reviewed xpath expression failed: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        const summaries = matches.map((node) => ({ tag: node.tag, ...node.element ? { selector: elementselector(node.element), label: elementlabel(node.element) } : {} }));
+        return { ok: matches.length > 0, summary: matches.length > 0 ? `Resolved ${matches.length} element${matches.length === 1 ? "" : "s"} for the reviewed xpath.` : "The reviewed xpath matched no elements.", details: { mode: "xpath", matches: summaries } };
       }
       default:
         return { ok: false, summary: "Unsupported page read." };
     }
   }
 
-  // extension/pagebridge.ts
-  function clean(value) {
-    return value.replace(/\s+/g, " ").trim();
+  // extension/pagecontrols.ts
+  function typetimeschedule(text, delay) {
+    return [...text].map((character, position) => ({ key: character, delay: position === 0 ? 0 : delay }));
   }
-  function label(element) {
-    const aria = element.getAttribute("aria-label");
-    const labelledby = element.getAttribute("aria-labelledby");
-    const linked = labelledby ? document.getElementById(labelledby)?.textContent : "";
-    return clean(aria || linked || element.getAttribute("title") || element.textContent || "");
+  function appendvalue(current, addition) {
+    return current + addition;
   }
-  function selector(element) {
-    if (element.id) return `#${CSS.escape(element.id)}`;
-    const role = element.getAttribute("role");
-    const name = element.getAttribute("name");
-    if (role && name) return `[role="${CSS.escape(role)}"][name="${CSS.escape(name)}"]`;
-    if (name) return `${element.tagName.toLowerCase()}[name="${CSS.escape(name)}"]`;
-    const tag = element.tagName.toLowerCase();
-    const parent = element.parentElement;
-    if (!parent) return tag;
-    const peers = [...parent.children].filter((node) => node.tagName === element.tagName);
-    return `${tag}:nth-of-type(${peers.indexOf(element) + 1})`;
+  function valueevents() {
+    return ["input", "change"];
+  }
+  function multichoices(values, options) {
+    const present = [];
+    const missing = [];
+    for (const value of values) {
+      const option = options.find((candidate) => candidate.value === value || candidate.label === value);
+      if (option) present.push(option.value);
+      else missing.push(value);
+    }
+    return { present, missing };
+  }
+  function radiochoice(inputs, choice) {
+    return inputs.findIndex((candidate) => candidate.value === choice || candidate.label === choice);
+  }
+  function slidervalue(requested, min, max, step) {
+    const lower = Math.min(min, max);
+    const upper = Math.max(min, max);
+    const clamped = Math.min(upper, Math.max(lower, requested));
+    if (!Number.isFinite(step) || step <= 0) return clamped;
+    return Math.round((clamped - lower) / step) * step + lower;
+  }
+  function datevalue(requested) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(requested)) return null;
+    const parts = requested.split("-").map((part) => Number.parseInt(part, 10));
+    const year = parts[0];
+    const month = parts[1];
+    const day = parts[2];
+    if (!year || !month || !day || month < 1 || month > 12 || day < 1 || day > 31) return null;
+    return requested;
+  }
+  function colorvalue(requested) {
+    if (!/^#[0-9a-fA-F]{6}$/.test(requested)) return null;
+    return requested.toLowerCase();
+  }
+  function expandstate(open) {
+    return open ? { open: true, changed: false } : { open: true, changed: true };
+  }
+  function events2(target) {
+    target.dispatchEvent(new Event("input", { bubbles: true }));
+    target.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+  function modifiers2(options) {
+    return Array.isArray(options.modifiers) ? options.modifiers.filter((item) => typeof item === "string") : [];
+  }
+  function keyevent2(type, key, mods) {
+    const code = key.length === 1 ? `Key${key.toUpperCase()}` : key;
+    return new KeyboardEvent(type, { key, code, bubbles: true, cancelable: true, composed: true, ctrlKey: mods.includes("ctrl"), shiftKey: mods.includes("shift"), altKey: mods.includes("alt"), metaKey: mods.includes("meta") });
+  }
+  function fieldlike2(target) {
+    return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement ? target : null;
+  }
+  function receiver(target) {
+    return target instanceof HTMLElement ? target : document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
+  }
+  function wait(delay) {
+    return new Promise((resolve) => window.setTimeout(resolve, delay));
+  }
+  function focuswhenneeded(target, options) {
+    if (!(target instanceof HTMLElement)) return;
+    if (options.focus === false) return;
+    if (options.focus === true || document.activeElement !== target) target.focus();
+  }
+  function pollfor(predicate, description, timeout) {
+    return new Promise((resolve) => {
+      const started = Date.now();
+      const check = () => {
+        if (predicate()) {
+          resolve({ ok: true, summary: `${description} is now present on the page.` });
+          return;
+        }
+        if (timeout > 0 && Date.now() - started >= timeout) {
+          resolve({ ok: false, summary: `${description} did not appear within ${timeout} milliseconds.` });
+          return;
+        }
+        window.setTimeout(check, 100);
+      };
+      check();
+    });
+  }
+  function runpagecontrol(step, target, root = document) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    switch (step.kind) {
+      case "typetime": {
+        const field = fieldlike2(target);
+        if (!field) return { ok: false, summary: "Target cannot receive timed text." };
+        const text = step.value ?? "";
+        const delay = typeof options.delay === "number" && options.delay > 0 ? options.delay : 0;
+        focuswhenneeded(field, options);
+        const schedule = typetimeschedule(text, delay);
+        return (async () => {
+          for (const entry of schedule) {
+            await wait(entry.delay);
+            field.dispatchEvent(keyevent2("keydown", entry.key, []));
+            field.dispatchEvent(new KeyboardEvent("keypress", { key: entry.key, bubbles: true, cancelable: true }));
+            field.value = `${field.value}${entry.key}`;
+            field.dispatchEvent(new Event("input", { bubbles: true }));
+          }
+          field.dispatchEvent(new Event("change", { bubbles: true }));
+          return { ok: true, summary: `Typed ${text.length} character${text.length === 1 ? "" : "s"} with a per keystroke delay of ${delay} milliseconds.` };
+        })();
+      }
+      case "appendtext": {
+        const field = fieldlike2(target);
+        if (!field) return { ok: false, summary: "Target cannot hold a value." };
+        focuswhenneeded(field, options);
+        field.value = appendvalue(field.value, step.value ?? "");
+        events2(field);
+        return { ok: true, summary: "Reviewed text appended to the current field value." };
+      }
+      case "setvalue": {
+        const field = fieldlike2(target);
+        if (!field) return { ok: false, summary: "Target cannot hold a value." };
+        focuswhenneeded(field, options);
+        field.value = step.value ?? "";
+        events2(field);
+        return { ok: true, summary: `Field value set through the dom property with ${valueevents().join(" and ")} events.` };
+      }
+      case "typeedit": {
+        if (!(target instanceof HTMLElement) || !target.isContentEditable) return { ok: false, summary: "Target is not a content editable region." };
+        focuswhenneeded(target, options);
+        const text = step.value ?? "";
+        return (async () => {
+          for (const character of [...text]) {
+            target.dispatchEvent(new InputEvent("beforeinput", { bubbles: true, cancelable: true, data: character, inputType: "insertText" }));
+            target.append(document.createTextNode(character));
+            target.dispatchEvent(new InputEvent("input", { bubbles: true, data: character, inputType: "insertText" }));
+          }
+          return { ok: true, summary: `Typed ${text.length} character${text.length === 1 ? "" : "s"} into the content editable region.` };
+        })();
+      }
+      case "keyhold": {
+        const key = step.value ?? "";
+        const mods = modifiers2(options);
+        receiver(target).dispatchEvent(keyevent2("keydown", key, mods));
+        const holdid = typeof options.holdid === "string" && options.holdid ? options.holdid : "";
+        return { ok: true, summary: `Key ${key} pressed and held${holdid ? ` under hold id ${holdid}` : ""}.`, details: { ...holdid ? { holdid } : {}, modifiers: mods } };
+      }
+      case "keyrelease": {
+        const key = step.value ?? "";
+        const mods = modifiers2(options);
+        receiver(target).dispatchEvent(keyevent2("keyup", key, mods));
+        return { ok: true, summary: `Key ${key} released.`, details: { modifiers: mods } };
+      }
+      case "submitsearch": {
+        const field = fieldlike2(target);
+        if (!field) return { ok: false, summary: "Target is not a search field." };
+        const results = typeof options.results === "string" ? options.results : "";
+        const timeout = typeof options.timeout === "number" ? options.timeout : 0;
+        focuswhenneeded(field, options);
+        field.dispatchEvent(keyevent2("keydown", "Enter", []));
+        field.dispatchEvent(new KeyboardEvent("keypress", { key: "Enter", bubbles: true, cancelable: true }));
+        field.dispatchEvent(keyevent2("keyup", "Enter", []));
+        return pollfor(() => Boolean(document.querySelector(results)), `Results region ${results}`, timeout);
+      }
+      case "selectmulti": {
+        if (!(target instanceof HTMLSelectElement) || !target.multiple) return { ok: false, summary: "Target is not a multi select control." };
+        const choices = [...target.options].map((option) => ({ value: option.value, label: clean(option.textContent || option.value) }));
+        const requested = Array.isArray(options.values) ? options.values.filter((item) => typeof item === "string") : [];
+        const outcome = multichoices(requested, choices);
+        if (outcome.missing.length > 0) return { ok: false, summary: `Reviewed option${outcome.missing.length === 1 ? "" : "s"} ${outcome.missing.join(", ")} ${outcome.missing.length === 1 ? "is" : "are"} not part of the select control.` };
+        for (const option of target.options) option.selected = outcome.present.includes(option.value);
+        events2(target);
+        return { ok: true, summary: `Selected ${outcome.present.length} reviewed option${outcome.present.length === 1 ? "" : "s"} in the multi select control.`, details: { selected: outcome.present } };
+      }
+      case "chooseradio": {
+        const radios = target instanceof HTMLInputElement && target.type === "radio" ? [...root.querySelectorAll(`input[type=radio][name="${CSS.escape(target.name)}"]`)] : target ? [...target.querySelectorAll("input[type=radio]")] : [];
+        if (radios.length === 0) return { ok: false, summary: "No radio group owns the reviewed target." };
+        const inputs = radios.map((radio) => ({ value: radio.value, label: radio.labels && radio.labels.length > 0 ? clean(radio.labels[0]?.textContent || "") || radio.value : radio.value }));
+        const index = radiochoice(inputs, step.value ?? "");
+        const chosen = radios[index];
+        if (!chosen) return { ok: false, summary: "The reviewed radio option is not part of the group." };
+        chosen.checked = true;
+        events2(chosen);
+        return { ok: true, summary: `Picked reviewed radio option ${step.value}.`, details: { value: chosen.value } };
+      }
+      case "setslider": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "range") return { ok: false, summary: "Target is not a range slider." };
+        const requested = Number(step.value);
+        if (!Number.isFinite(requested)) return { ok: false, summary: "The reviewed slider value is not a number." };
+        focuswhenneeded(target, options);
+        const value = slidervalue(requested, Number(target.min), Number(target.max), Number(target.step));
+        target.value = String(value);
+        events2(target);
+        return { ok: true, summary: `Slider dragged to the reviewed value ${value}.`, details: { value } };
+      }
+      case "setdate": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "date") return { ok: false, summary: "Target is not a date input." };
+        const value = datevalue(step.value ?? "");
+        if (value === null) return { ok: false, summary: "The reviewed date is invalid." };
+        focuswhenneeded(target, options);
+        target.value = value;
+        events2(target);
+        return { ok: true, summary: `Date input set to ${value}.`, details: { value } };
+      }
+      case "setcolor": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "color") return { ok: false, summary: "Target is not a color input." };
+        const value = colorvalue(step.value ?? "");
+        if (value === null) return { ok: false, summary: "The reviewed color is invalid." };
+        focuswhenneeded(target, options);
+        target.value = value;
+        events2(target);
+        return { ok: true, summary: `Color input set to ${value}.`, details: { value } };
+      }
+      case "expanddetails": {
+        const details = target instanceof HTMLElement ? target.closest("details") : null;
+        if (!details) return { ok: false, summary: "Target is not inside a details section." };
+        const outcome = expandstate(details.open);
+        details.open = outcome.open;
+        return { ok: true, summary: outcome.changed ? "Collapsed details section opened." : "Details section was already open.", details: { changed: outcome.changed } };
+      }
+      default:
+        return { ok: false, summary: "Unsupported control action." };
+    }
+  }
+
+  // extension/pagepointer.ts
+  var basecadence = 16;
+  function distance(a, b) {
+    return Math.hypot(b.x - a.x, b.y - a.y);
+  }
+  function ease(easing, progress) {
+    if (easing === "easeinout") return progress * progress * (3 - 2 * progress);
+    return progress;
+  }
+  function ispointref(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const point = value;
+    return typeof point.x === "number" && Number.isFinite(point.x) && typeof point.y === "number" && Number.isFinite(point.y);
+  }
+  function pathhops(path, profile, random = Math.random, cadence = basecadence) {
+    const easing = profile?.easing === "easeinout" ? "easeinout" : "linear";
+    const peak = typeof profile?.peak === "number" && profile.peak > 0 ? profile.peak : void 0;
+    const jitter = typeof profile?.jitter === "number" && profile.jitter > 0 ? profile.jitter : 0;
+    const points = [path.start, ...path.waypoints ?? [], path.end];
+    const lengths = [];
+    let total = 0;
+    for (let index = 1; index < points.length; index += 1) {
+      const length = distance(points[index - 1], points[index]);
+      lengths.push(length);
+      total += length;
+    }
+    const reviewedduration = typeof path.duration === "number" && Number.isFinite(path.duration) && path.duration > 0 ? path.duration : void 0;
+    const duration = reviewedduration ?? (peak !== void 0 && total > 0 ? total / peak * 1e3 : 300);
+    const hops = [];
+    let previous = points[0];
+    for (let index = 1; index < points.length; index += 1) {
+      const from = points[index - 1];
+      const to = points[index];
+      const length = lengths[index - 1] ?? 0;
+      if (total <= 0 || length <= 0) {
+        hops.push({ x: to.x, y: to.y, delay: 0 });
+        previous = to;
+        continue;
+      }
+      const segmentduration = duration * length / total;
+      const count = Math.max(1, Math.ceil(segmentduration / Math.max(1, cadence)));
+      for (let hop = 1; hop <= count; hop += 1) {
+        const progress = hop / count;
+        const eased = ease(easing, progress);
+        const position = { x: from.x + (to.x - from.x) * eased, y: from.y + (to.y - from.y) * eased };
+        const step = distance(previous, position);
+        const base = segmentduration / count;
+        const capped = peak !== void 0 ? Math.max(base, step / peak * 1e3) : base;
+        hops.push({ x: position.x, y: position.y, delay: Math.max(0, capped + (jitter > 0 ? random() * jitter : 0)) });
+        previous = position;
+      }
+    }
+    return hops;
+  }
+  function clickplan(x, y, modifiers3) {
+    const shift = modifiers3.includes("shift");
+    const pointer = (type) => ({ type, eventkind: "pointer", x, y, shift });
+    const mouse = (type) => ({ type, eventkind: "mouse", x, y, shift });
+    return [pointer("pointerover"), pointer("pointermove"), pointer("pointerdown"), mouse("mousedown"), pointer("pointerup"), mouse("mouseup"), mouse("click")];
+  }
+  function dispatchplanned(element, event) {
+    const init = { bubbles: true, cancelable: true, composed: true, clientX: event.x, clientY: event.y, shiftKey: event.shift };
+    if (event.eventkind === "pointer") element.dispatchEvent(new PointerEvent(event.type, init));
+    else element.dispatchEvent(new MouseEvent(event.type, init));
+  }
+  function dispatchclick(element, modifiers3 = []) {
+    const rect = element.getBoundingClientRect();
+    const x = rect.left + rect.width / 2;
+    const y = rect.top + rect.height / 2;
+    for (const event of clickplan(x, y, modifiers3)) dispatchplanned(element, event);
+  }
+  function ensurevisible(element) {
+    try {
+      element.scrollIntoView({ block: "center", inline: "nearest", behavior: "auto" });
+    } catch {
+    }
+  }
+  function settle(delay) {
+    return new Promise((resolve) => window.setTimeout(resolve, delay));
+  }
+  function dispatchmove(x, y) {
+    const element = document.elementFromPoint(x, y);
+    const receiver2 = element ?? document.documentElement;
+    receiver2.dispatchEvent(new PointerEvent("pointermove", { bubbles: true, cancelable: true, composed: true, clientX: x, clientY: y }));
+  }
+  async function travel(path, profile) {
+    const hops = pathhops(path, profile);
+    const startelement = document.elementFromPoint(path.start.x, path.start.y) ?? document.documentElement;
+    startelement.dispatchEvent(new PointerEvent("pointerover", { bubbles: true, cancelable: true, composed: true, clientX: path.start.x, clientY: path.start.y }));
+    for (const hop of hops) {
+      await settle(hop.delay);
+      dispatchmove(hop.x, hop.y);
+    }
+    const endelement = document.elementFromPoint(path.end.x, path.end.y) ?? document.documentElement;
+    endelement.dispatchEvent(new PointerEvent("pointerout", { bubbles: true, cancelable: true, composed: true, clientX: path.end.x, clientY: path.end.y }));
+    return { ok: true, summary: `Pointer traveled ${hops.length} hop${hops.length === 1 ? "" : "s"} to the reviewed end point.` };
+  }
+  function runpointerstep(step, resolution) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    if (step.kind === "movepointer") {
+      const path = options.pointpath;
+      if (!path || !ispointref(path.start) || !ispointref(path.end)) return { ok: false, summary: "The reviewed pointer path is absent." };
+      const waypoints = Array.isArray(path.waypoints) && path.waypoints.every((item) => ispointref(item)) ? path.waypoints : void 0;
+      const fullpath = { start: path.start, end: path.end, ...waypoints ? { waypoints } : {}, ...typeof path.duration === "number" && Number.isFinite(path.duration) ? { duration: path.duration } : {} };
+      return travel(fullpath, options.speedprofile);
+    }
+    if (step.kind === "clickpoint") {
+      const reference = options.targetref;
+      const x = Number(reference?.x);
+      const y = Number(reference?.y);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) return { ok: false, summary: "The reviewed click coordinates are absent." };
+      const element = document.elementFromPoint(x, y);
+      if (!(element instanceof HTMLElement)) return { ok: false, summary: "No element is rendered at the reviewed coordinates." };
+      ensurevisible(element);
+      for (const event of clickplan(x, y, [])) dispatchplanned(element, event);
+      return { ok: true, summary: `Clicked the element at the reviewed coordinates ${x},${y}.` };
+    }
+    if (step.kind === "shiftclick") {
+      if (resolution.status === "ambiguous") return { ok: false, summary: `The reviewed reference matched ${resolution.candidates.length} elements; choose one candidate.`, details: { mode: resolution.mode, candidates: resolution.candidates } };
+      if (resolution.status !== "resolved") return { ok: false, summary: "Action target is no longer available." };
+      ensurevisible(resolution.element);
+      dispatchclick(resolution.element, ["shift"]);
+      return { ok: true, summary: `Shift click delivered to ${resolution.target.label || resolution.target.tag}.`, details: { mode: resolution.target.mode, resolvedtarget: resolution.target } };
+    }
+    return { ok: false, summary: "Unsupported pointer action." };
+  }
+
+  // extension/pageinteract.ts
+  function optionsof(step) {
+    try {
+      return parseoptions(step);
+    } catch {
+      return {};
+    }
+  }
+  function innerstep(step) {
+    const options = optionsof(step);
+    const kind = options.kind;
+    if (typeof kind !== "string" || !kind.trim()) return null;
+    const inneroptions = options.options;
+    return {
+      id: `${step.id}inner`,
+      kind,
+      summary: step.summary,
+      risk: step.risk,
+      ...typeof options.target === "string" ? { target: options.target } : {},
+      ...typeof options.value === "string" ? { value: options.value } : {},
+      ...inneroptions && typeof inneroptions === "object" && !Array.isArray(inneroptions) ? { options: JSON.stringify(inneroptions) } : {}
+    };
+  }
+  function clickresolved(stepkind, resolution) {
+    if (resolution.status === "ambiguous") return { ok: false, summary: `The reviewed ${resolution.mode} reference matched ${resolution.candidates.length} elements: ${resolution.candidates.join("; ")}.`, details: { mode: resolution.mode, candidates: resolution.candidates } };
+    if (resolution.status !== "resolved") return { ok: false, summary: "The reviewed target is no longer available." };
+    ensurevisible(resolution.element);
+    dispatchclick(resolution.element);
+    return { ok: true, summary: `Clicked ${resolution.target.label || resolution.target.tag} resolved by ${stepkind} ${resolution.target.mode} mode.`, details: { mode: resolution.target.mode, resolvedtarget: resolution.target } };
+  }
+  function runinteractstep(step, expectedorigin, dispatch) {
+    if (step.kind === "clicktext" || step.kind === "clickaria" || step.kind === "clickname") {
+      return clickresolved(step.kind, resolvestep(step, document));
+    }
+    if (step.kind === "pierceshadow") {
+      const options = optionsof(step);
+      const shadow = Array.isArray(options.shadow) ? options.shadow.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+      const element = shadow.length > 0 ? queryshadowchain(document, shadow) : queryscoped(document, step.target ?? "");
+      if (!(element instanceof HTMLElement)) return { ok: false, summary: "The reviewed shadow target is not available." };
+      ensurevisible(element);
+      dispatchclick(element);
+      const summary = targetsummary("selector", element);
+      return { ok: true, summary: `Clicked ${summary.label || summary.tag} resolved through ${shadow.length > 0 ? "the reviewed shadow path" : "open shadow roots"}.`, details: { mode: "selector", resolvedtarget: summary } };
+    }
+    if (step.kind === "enterframe") {
+      const options = optionsof(step);
+      const path = Array.isArray(options.framepath) ? options.framepath.filter((item) => typeof item === "number" && Number.isInteger(item) && item >= 0) : [];
+      const walk = walkframepath(describeframes(document), path);
+      if (!walk.ok) return { ok: false, summary: walk.reason };
+      const framedocument = walk.document.live;
+      if (!framedocument) return { ok: false, summary: "The reviewed frame document is not available." };
+      const inner = innerstep(step);
+      if (!inner) return { ok: false, summary: "The reviewed inner step is absent." };
+      return dispatch(inner, expectedorigin, framedocument);
+    }
+    return { ok: false, summary: "Unsupported interaction action." };
+  }
+
+  // extension/pagedialogs.ts
+  function harvestdialoglog(root) {
+    const raw = root.documentElement.dataset.devthinkdialoglog;
+    if (!raw) return [];
+    delete root.documentElement.dataset.devthinkdialoglog;
+    try {
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter((item) => Boolean(item) && typeof item === "object" && typeof item.dialog === "string");
+    } catch {
+      return [];
+    }
+  }
+
+  // extension/pageobserve.ts
+  var maxframedepth = 4;
+  function elementstates(element) {
+    const states = [];
+    if (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") states.push("disabled");
+    if (element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio") && element.checked) states.push("checked");
+    const expanded = element.getAttribute("aria-expanded");
+    if (expanded !== null) states.push(`expanded ${expanded}`);
+    if (element.getAttribute("aria-selected") === "true") states.push("selected");
+    if (element.hasAttribute("required") || element.getAttribute("aria-required") === "true") states.push("required");
+    if (element.hasAttribute("readonly") || element.getAttribute("aria-readonly") === "true") states.push("readonly");
+    if (element.getAttribute("aria-hidden") === "true") states.push("hidden");
+    return states;
+  }
+  function elementvalue(element) {
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) return element.value;
+    return "";
+  }
+  function elementhidden(element) {
+    if (element instanceof HTMLInputElement && element.type === "hidden") return true;
+    if (element.hasAttribute("hidden") || element.getAttribute("aria-hidden") === "true") return true;
+    try {
+      const style = element.ownerDocument?.defaultView?.getComputedStyle(element);
+      if (style && (style.display === "none" || style.visibility === "hidden")) return true;
+    } catch {
+    }
+    return false;
+  }
+  function framenode(frame, depth) {
+    let content = null;
+    try {
+      content = frame.contentDocument;
+    } catch {
+      content = null;
+    }
+    let sameorigin = false;
+    try {
+      sameorigin = content !== null && frame.contentWindow?.location.origin === location.origin;
+    } catch {
+      sameorigin = false;
+    }
+    const node = wrap2(frame, depth);
+    if (sameorigin && content && depth < maxframedepth) node.children.push(...wrapchildren(content, depth + 1));
+    return node;
+  }
+  function wrap2(element, depth) {
+    const shadow = element.shadowRoot;
+    const node = {
+      tag: element.tagName.toLowerCase(),
+      selector: elementselector(element),
+      id: element.id,
+      classes: [...element.classList],
+      role: element.getAttribute("role")?.toLowerCase() || implicitrole(element),
+      name: elementlabel(element),
+      text: owntext2(element),
+      value: elementvalue(element),
+      states: elementstates(element),
+      hidden: elementhidden(element),
+      children: [],
+      element
+    };
+    if (shadow) node.children.push(...wrapchildren(shadow, depth));
+    if (element instanceof HTMLIFrameElement) return framenode(element, depth);
+    node.children.push(...wrapchildren(element, depth));
+    return node;
+  }
+  function wrapchildren(scope, depth) {
+    return [...scope.querySelectorAll(":scope > *")].map((child) => wrap2(child, depth));
+  }
+  function buildpagetree(scope) {
+    const root = {
+      tag: "#document",
+      selector: "",
+      id: "",
+      classes: [],
+      role: "document",
+      name: "",
+      text: "",
+      value: "",
+      states: [],
+      hidden: false,
+      children: []
+    };
+    if (scope instanceof Document) {
+      root.children = scope.documentElement ? [wrap2(scope.documentElement, 0)] : [];
+    } else {
+      root.children = [...wrapchildren(scope, 0)];
+    }
+    return root;
+  }
+  function countnodes(node) {
+    return 1 + node.children.reduce((total, child) => total + countnodes(child), 0);
+  }
+  function builda11ytree(node) {
+    const children = node.children.filter((child) => !child.hidden).map(builda11ytree);
+    return {
+      role: node.role || "generic",
+      name: node.name,
+      states: node.states,
+      ...node.value ? { value: node.value } : {},
+      childcount: children.length,
+      children
+    };
+  }
+  function visibleentries(node) {
+    if (node.hidden) return [];
+    const entries = node.text ? [{ selector: node.selector || node.tag, text: node.text }] : [];
+    for (const child of node.children) entries.push(...visibleentries(child));
+    return entries;
+  }
+  function visibletext(node) {
+    return visibleentries(node).map((entry) => entry.text).join(" ");
+  }
+  function nodetextlength(node) {
+    return node.text.length + node.children.reduce((total, child) => total + nodetextlength(child), 0);
+  }
+  function nodelinktext(node) {
+    const own = node.tag === "a" ? node.text.length : 0;
+    return own + node.children.reduce((total, child) => total + nodelinktext(child), 0);
+  }
+  function wordsin(text) {
+    return text.split(/\s+/).filter(Boolean).length;
+  }
+  function findbyline(node) {
+    const markers = ["byline", "author"];
+    const direct = node.classes.some((item) => markers.some((marker) => item.toLowerCase().includes(marker))) || markers.some((marker) => node.id.toLowerCase().includes(marker));
+    if (direct && node.text) return node.text;
+    for (const child of node.children) {
+      const found = findbyline(child);
+      if (found) return found;
+    }
+    return "";
+  }
+  function findheading(node, tags) {
+    if (tags.includes(node.tag) && node.text) return node.text;
+    for (const child of node.children) {
+      const found = findheading(child, tags);
+      if (found) return found;
+    }
+    return "";
+  }
+  function buildreader(root, title) {
+    let best;
+    let bestscore = 0;
+    const walk = (node) => {
+      if (node.tag !== "#document") {
+        const length = nodetextlength(node);
+        const links = nodelinktext(node);
+        const score = length * (1 - (length > 0 ? links / length : 0));
+        if (score > bestscore) {
+          bestscore = score;
+          best = node;
+        }
+      }
+      for (const child of node.children) walk(child);
+    };
+    walk(root);
+    const article = best ?? root;
+    const blocks = article.children.filter((child) => !child.hidden && child.text).map((child) => ({ kind: child.tag, text: child.text, words: wordsin(child.text) }));
+    const ownblock = article.text ? [{ kind: article.tag, text: article.text, words: wordsin(article.text) }] : [];
+    const allblocks = [...ownblock, ...blocks];
+    return {
+      title: findheading(article, ["h1"]) || findheading(root, ["h1"]) || title,
+      byline: findbyline(article) || findbyline(root),
+      blocks: allblocks,
+      words: allblocks.reduce((total, block) => total + block.words, 0),
+      characters: allblocks.reduce((total, block) => total + block.text.length, 0)
+    };
+  }
+  function pageoutline(root, title) {
+    const headings = [];
+    const walk = (node) => {
+      const level = /^h([1-6])$/.exec(node.tag);
+      if (level && node.text) headings.push({ level: Number.parseInt(level[1], 10), text: node.text });
+      for (const child of node.children) walk(child);
+    };
+    walk(root);
+    return { title: findheading(root, ["h1"]) || title, headings };
+  }
+  function captureselection(root) {
+    const selection = root.getSelection?.() ?? null;
+    const text = selection ? clean(selection.toString()) : "";
+    return { text, length: text.length };
+  }
+  function opengraphfields(meta, jsonld) {
+    const graph = {};
+    for (const entry of meta) {
+      if (entry.property.startsWith("og:") && entry.content) graph[entry.property] = entry.content;
+    }
+    const structured = [];
+    let refused = 0;
+    for (const raw of jsonld) {
+      try {
+        structured.push(JSON.parse(raw));
+      } catch {
+        refused += 1;
+      }
+    }
+    return { graph, structured, refused };
+  }
+  var stopwords = {
+    en: ["the", "is", "at", "which", "on", "and", "of", "to", "in", "that", "it", "with"],
+    pt: ["de", "que", "n\xE3o", "uma", "para", "com", "por", "mais", "como", "p\xE1gina", "este", "voc\xEA"],
+    es: ["que", "el", "las", "los", "por", "una", "para", "con", "como", "p\xE1gina", "m\xE1s", "este"],
+    fr: ["le", "les", "des", "que", "pour", "dans", "est", "sur", "avec", "page", "plus", "cette"],
+    de: ["der", "die", "und", "das", "ist", "von", "mit", "f\xFCr", "auf", "den", "nicht", "seite"],
+    it: ["che", "il", "la", "per", "una", "del", "sono", "non", "con", "pagina", "pi\xF9", "questo"],
+    nl: ["het", "een", "en", "van", "is", "dat", "op", "te", "voor", "met", "niet", "pagina"]
+  };
+  function detecttextlanguage(text) {
+    const words = text.toLowerCase().split(/[^a-zà-ÿ]+/).filter(Boolean);
+    if (words.length === 0) return "";
+    let best = "";
+    let bestscore = 0;
+    for (const [language, dictionary] of Object.entries(stopwords)) {
+      const score = words.filter((word) => dictionary.includes(word)).length;
+      if (score > bestscore) {
+        bestscore = score;
+        best = language;
+      }
+    }
+    return best;
+  }
+  function taglanguage(text) {
+    return { text, language: detecttextlanguage(text) };
+  }
+  function documentlanguage(signals) {
+    if (signals.lang.trim()) return { language: signals.lang.trim(), source: "document" };
+    if (signals.meta.trim()) return { language: signals.meta.trim(), source: "meta" };
+    return { language: detecttextlanguage(signals.text), source: "content" };
+  }
+  function shadowpaths(scope) {
+    const paths = [];
+    const walk = (tree, prefix) => {
+      for (const shadow of tree.shadows) {
+        if (!shadow.host) continue;
+        const path = prefix ? `${prefix} > ${shadow.host.selector}` : shadow.host.selector;
+        paths.push(path);
+        walk(shadow, path);
+      }
+    };
+    walk(scope, "");
+    return paths;
+  }
+  function framelist(root) {
+    return [...root.querySelectorAll("iframe")].map((frame, index) => {
+      let origin = "";
+      try {
+        origin = frame.contentWindow?.location.origin ?? "";
+      } catch {
+        origin = "";
+      }
+      const rect = frame.getBoundingClientRect();
+      return { index, origin, sameorigin: origin !== "" && origin === location.origin, width: Math.round(rect.width), height: Math.round(rect.height) };
+    });
   }
   function stepoptions(step) {
+    try {
+      return parseoptions(step);
+    } catch {
+      return {};
+    }
+  }
+  function runpageobservation(step, target, root = document) {
+    switch (step.kind) {
+      case "a11ytree": {
+        const tree = builda11ytree(buildpagetree(root));
+        const count = countnodes(tree);
+        return { ok: true, summary: `Captured the accessibility tree with ${count} node${count === 1 ? "" : "s"}.`, details: { tree, nodecount: count } };
+      }
+      case "readvisible": {
+        const scope = target ?? root;
+        const tree = buildpagetree(scope);
+        const entries = visibleentries(tree);
+        return { ok: true, summary: `Read the rendered text of ${entries.length} visible element${entries.length === 1 ? "" : "s"}.`, details: { entries, text: visibletext(tree) } };
+      }
+      case "readertree": {
+        const article = buildreader(buildpagetree(root), root.title);
+        return { ok: true, summary: `Extracted the reader view with ${article.blocks.length} block${article.blocks.length === 1 ? "" : "s"} and ${article.words} words.`, details: { article } };
+      }
+      case "readoutline": {
+        const outline = pageoutline(buildpagetree(root), root.title);
+        return { ok: true, summary: `Read the outline with ${outline.headings.length} heading${outline.headings.length === 1 ? "" : "s"}.`, details: { title: outline.title, headings: outline.headings } };
+      }
+      case "readselection": {
+        const selection = captureselection(root);
+        return { ok: true, summary: selection.text ? `Read ${selection.length} characters of the current selection.` : "No text is currently selected.", details: { text: selection.text, length: selection.length } };
+      }
+      case "readopengraph": {
+        const meta = [...root.querySelectorAll("meta")].map((element) => ({ property: element.getAttribute("property") ?? "", name: element.getAttribute("name") ?? "", content: element.getAttribute("content") ?? "" }));
+        const jsonld = [...root.querySelectorAll('script[type="application/ld+json"]')].map((element) => element.textContent ?? "");
+        const fields = opengraphfields(meta, jsonld);
+        return { ok: true, summary: `Read ${Object.keys(fields.graph).length} open graph entr${Object.keys(fields.graph).length === 1 ? "y" : "ies"} and ${fields.structured.length} structured payload${fields.structured.length === 1 ? "" : "s"}${fields.refused > 0 ? `; ${fields.refused} malformed payload${fields.refused === 1 ? " was" : "s were"} refused` : ""}.`, details: { graph: fields.graph, structured: fields.structured, refused: fields.refused } };
+      }
+      case "readlang": {
+        const metatag = root.querySelector('meta[http-equiv="content-language"]')?.getAttribute("content") ?? "";
+        const outcome = documentlanguage({ lang: root.documentElement?.getAttribute("lang") ?? "", meta: metatag, text: root.body?.innerText ?? "" });
+        return { ok: true, summary: `Detected page language ${outcome.language || "unknown"} from the ${outcome.source} signal.`, details: { language: outcome.language, source: outcome.source } };
+      }
+      case "detectlanguage": {
+        const options = stepoptions(step);
+        const text = typeof options.text === "string" && options.text ? options.text : target?.textContent ?? root.body?.innerText ?? "";
+        const routed = taglanguage(clean(text));
+        return { ok: routed.language !== "", summary: routed.language ? `Detected language ${routed.language} for the extracted text.` : "The extracted text language is undetermined.", details: { language: routed.language, routed } };
+      }
+      case "listshadow": {
+        const paths = shadowpaths(describescopes(root));
+        return { ok: true, summary: `Listed ${paths.length} open shadow root${paths.length === 1 ? "" : "s"}.`, details: { shadows: paths } };
+      }
+      case "listframes": {
+        const frames = framelist(root);
+        return { ok: true, summary: `Listed ${frames.length} iframe${frames.length === 1 ? "" : "s"}.`, details: { frames } };
+      }
+      default:
+        return { ok: false, summary: "Unsupported page observation." };
+    }
+  }
+
+  // extension/pagedetect.ts
+  function detectlistpatterns(samples) {
+    const patterns = [];
+    for (const sample of samples) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const child of sample.children) {
+        const key = `${child.tag}|${child.classes}`;
+        const group = groups.get(key) ?? [];
+        group.push(child);
+        groups.set(key, group);
+      }
+      for (const [key, group] of groups) {
+        if (group.length < 2) continue;
+        if (!group.some((item) => item.text)) continue;
+        const [tag, classes] = key.split("|");
+        const classpart = (classes ?? "").split(" ").filter(Boolean).map((name) => `.${name}`).join("");
+        patterns.push({ container: sample.container, itemselector: `${tag}${classpart}`, repeat: group.length, samples: group.map((item) => item.text).filter(Boolean) });
+      }
+    }
+    return patterns;
+  }
+  function normalizetable(rows, caption) {
+    const firstheader = rows.find((row) => row.header);
+    const headers = firstheader?.cells ?? [];
+    const body = firstheader ? rows.filter((row) => row !== firstheader) : rows;
+    const width = rows.reduce((largest, row) => Math.max(largest, row.cells.length), 0);
+    const columns = [];
+    for (let index = 0; index < width; index += 1) {
+      const label = headers[index] ?? `column ${index + 1}`;
+      const cells = body.filter((row) => Boolean((row.cells[index] ?? "").trim())).length;
+      columns.push({ label, cells });
+    }
+    return { headers, columns, rows: body.length, caption };
+  }
+  function paginationestimate(entries) {
+    const pages = [];
+    let current = 0;
+    for (const entry of entries) {
+      const parsed = /^\d+$/.exec(entry.text.trim());
+      if (parsed) {
+        const page = Number.parseInt(parsed[0], 10);
+        pages.push(page);
+        if (entry.current) current = page;
+      }
+    }
+    const total = Math.max(0, ...pages, current);
+    return { current, total, links: entries.length, pages };
+  }
+  function infinitescrollranges(ranges) {
+    return ranges.filter((range) => range.scrollheight > range.clientheight && range.triggers.length > 0).map((range) => ({ selector: range.selector, scrollrange: range.scrollheight - range.clientheight, triggers: range.triggers }));
+  }
+  function virtualizedcontainers(containers) {
+    const results = [];
+    for (const container of containers) {
+      const first = container.rows[0];
+      if (!first || container.rows.length < 2 || first.height <= 0) continue;
+      if (!container.rows.every((row) => row.height === first.height)) continue;
+      if (container.scrollheight <= container.rows.length * first.height) continue;
+      results.push({ selector: container.selector, rendered: container.rows.length, estimated: Math.floor(container.scrollheight / first.height) });
+    }
+    return results;
+  }
+  function lazysurvey(images) {
+    const lazy = [];
+    const placeholders = [];
+    for (const image of images) {
+      if (image.loading === "lazy") lazy.push({ selector: image.selector, reason: "loading attribute" });
+      else if (image.datasrc) lazy.push({ selector: image.selector, reason: "deferred source" });
+      if (!image.src) placeholders.push({ selector: image.selector, reason: "empty source" });
+      else if (image.src.startsWith("data:")) placeholders.push({ selector: image.selector, reason: "inline data placeholder" });
+    }
+    return { lazy, placeholders };
+  }
+  function overlaygeometry(elements, viewport) {
+    const area = viewport.width * viewport.height;
+    return elements.filter((element) => (element.position === "sticky" || element.position === "fixed") && element.top <= 0 && element.height > 0).map((element) => {
+      const coverage = area > 0 ? element.height * element.width / area : 0;
+      return { selector: element.selector, position: element.position, coverage: Math.round(coverage * 1e3) / 1e3, hides: coverage >= overlaythreshold };
+    });
+  }
+  function scrolllockstate(signals) {
+    const reasons = [];
+    if (signals.bodyoverflow.includes("hidden") || signals.htmloverflow.includes("hidden")) reasons.push("overflow hidden");
+    if (signals.bodyposition === "fixed") reasons.push("fixed body");
+    if (signals.modal) reasons.push("modal open");
+    return { locked: reasons.length > 0, reasons, scrollable: signals.scrollable };
+  }
+  var consentkeywords = ["cookie", "consent", "gdpr", "lgpd", "privacy", "ccpa"];
+  function bannermatches(candidates, at) {
+    const reports = [];
+    for (const candidate of candidates) {
+      const haystack = `${candidate.id} ${candidate.classes.join(" ")} ${candidate.text}`.toLowerCase();
+      const keyword = consentkeywords.find((word) => haystack.includes(word));
+      if (!keyword) continue;
+      if (!candidate.text && candidate.controls.length === 0) continue;
+      reports.push({ kind: keyword, selector: candidate.selector, text: candidate.text.slice(0, 200), controls: candidate.controls, at });
+    }
+    return reports;
+  }
+  function classifytemplate(signals) {
+    if (signals.password) return "login";
+    if (signals.paragraphs >= 3) return "article";
+    if (signals.tables > 0) return "table";
+    if (signals.forms > 0 && signals.inputs > 0) return "form";
+    if (signals.lists > 0) return "list";
+    return "generic";
+  }
+  function sectionfingerprint(section) {
+    const canonical = [section.tag, String(section.children), String(section.textlength), ...Object.keys(section.attributes).sort().map((key) => `${key}=${section.attributes[key] ?? ""}`)].join("|");
+    let hash = 5381;
+    for (let index = 0; index < canonical.length; index += 1) hash = (hash << 5) + hash + canonical.charCodeAt(index) >>> 0;
+    return `fp${hash.toString(16)}`;
+  }
+  function scrollreport(window2, containers) {
+    const range = Math.max(0, window2.scrollheight - window2.clientheight);
+    return {
+      window: { x: window2.scrollx, y: window2.scrolly, attop: window2.scrolly <= 0, atbottom: window2.scrolly >= range, height: window2.scrollheight },
+      containers: containers.map((container) => {
+        const containerrange = Math.max(0, container.scrollheight - container.clientheight);
+        return { selector: container.selector, scrolltop: container.scrolltop, scrollleft: container.scrollleft, scrollrange: containerrange, atbottom: container.scrolltop >= containerrange };
+      })
+    };
+  }
+  var loadmorepattern = /(load more|show more|see more|ver mais|carregar mais|load older|afficher plus|mehr anzeigen)/i;
+  var paginationtext = /^(next|prev|previous|last|first|next page|previous page|»|«|›|‹|\d+)$/i;
+  var overlaythreshold = 0.25;
+  function signatureof(element) {
+    return `${element.tagName.toLowerCase()}|${[...element.classList].sort().join(" ")}`;
+  }
+  function collectsiblings(root) {
+    const samples = [];
+    for (const element of [...root.querySelectorAll("*")]) {
+      const children = [...element.children];
+      if (children.length < 2) continue;
+      const counts = /* @__PURE__ */ new Map();
+      for (const child of children) {
+        const key = signatureof(child);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+      if (![...counts.values()].some((count) => count >= 2)) continue;
+      samples.push({
+        container: elementselector(element),
+        children: children.map((child) => ({ tag: child.tagName.toLowerCase(), classes: [...child.classList].sort().join(" "), text: clean(child.textContent ?? ""), selector: elementselector(child) }))
+      });
+    }
+    return samples;
+  }
+  function collecttables(root) {
+    return [...root.querySelectorAll("table")].map((table) => ({
+      selector: elementselector(table),
+      rows: [...table.querySelectorAll("tr")].map((row) => ({ cells: [...row.querySelectorAll("th, td")].map((cell) => clean(cell.textContent ?? "")), header: Boolean(row.querySelector("th")) })),
+      caption: clean(table.querySelector("caption")?.textContent ?? "")
+    }));
+  }
+  function collectpagination(root) {
+    const entries = [];
+    for (const element of [...root.querySelectorAll("a[href], button, [role=button], [role=link], li, span")]) {
+      const text = clean(element.textContent ?? "");
+      if (!text || !paginationtext.test(text)) continue;
+      if (!element.closest("nav, footer, [class*=pag i], [id*=pag i]")) continue;
+      const current = element.getAttribute("aria-current") === "page" || [...element.classList].some((name) => /current|active|selecionado/i.test(name));
+      entries.push({ text, selector: elementselector(element), current });
+    }
+    return entries;
+  }
+  function collecttriggers(scope) {
+    const triggers = [];
+    for (const element of [...scope.querySelectorAll("button, a[href], [role=button], [class*=loading i], [class*=sentinel i], [class*=spinner i]")]) {
+      const label = clean(element.getAttribute("aria-label") ?? element.textContent ?? "");
+      if (loadmorepattern.test(label)) triggers.push(elementselector(element));
+    }
+    return triggers;
+  }
+  function collectscrollranges(root) {
+    const ranges = [];
+    const scrolling = root.scrollingElement ?? root.documentElement;
+    const viewheight = root.defaultView?.innerHeight ?? 0;
+    if (scrolling && scrolling.scrollHeight > viewheight) ranges.push({ selector: "window", scrollheight: scrolling.scrollHeight, clientheight: viewheight, triggers: collecttriggers(root) });
+    for (const element of [...root.querySelectorAll("*")]) {
+      if (!(element instanceof HTMLElement)) continue;
+      if (element.scrollHeight <= element.clientHeight) continue;
+      ranges.push({ selector: elementselector(element), scrollheight: element.scrollHeight, clientheight: element.clientHeight, triggers: collecttriggers(element) });
+    }
+    return ranges;
+  }
+  function collectvirtual(root) {
+    const containers = [];
+    for (const element of [...root.querySelectorAll("*")]) {
+      const children = [...element.children];
+      const first = children[0];
+      if (!first || children.length < 2) continue;
+      if (!children.every((child) => signatureof(child) === signatureof(first))) continue;
+      const heights = children.map((child) => child.getBoundingClientRect().height);
+      if (!heights.every((height) => height > 0 && height === heights[0])) continue;
+      containers.push({ selector: elementselector(element), scrollheight: element.scrollHeight, rows: children.map((child) => ({ selector: elementselector(child), height: child.getBoundingClientRect().height, classes: [...child.classList].join(" ") })) });
+    }
+    return containers;
+  }
+  function collectimages(root) {
+    return [...root.querySelectorAll("img")].map((image) => ({
+      selector: elementselector(image),
+      src: image.getAttribute("src") ?? "",
+      datasrc: image.getAttribute("data-src") ?? image.getAttribute("data-original") ?? "",
+      loading: image.getAttribute("loading") ?? "",
+      width: image.naturalWidth,
+      height: image.naturalHeight
+    }));
+  }
+  function collectoverlays(root) {
+    const elements = [];
+    for (const element of [...root.querySelectorAll("*")]) {
+      if (!(element instanceof HTMLElement)) continue;
+      const view = element.ownerDocument.defaultView;
+      const position = view ? view.getComputedStyle(element).position : "";
+      if (position !== "sticky" && position !== "fixed") continue;
+      const rect = element.getBoundingClientRect();
+      elements.push({ selector: elementselector(element), position, top: rect.top, height: rect.height, width: rect.width });
+    }
+    return elements;
+  }
+  function collectlocksignals(root) {
+    const view = root.defaultView;
+    const bodystyle = root.body ? view ? view.getComputedStyle(root.body) : void 0 : void 0;
+    const htmlstyle = view ? view.getComputedStyle(root.documentElement) : void 0;
+    return {
+      bodyoverflow: bodystyle?.overflow ?? "",
+      htmloverflow: htmlstyle?.overflow ?? "",
+      bodyposition: bodystyle?.position ?? "",
+      modal: Boolean(root.querySelector("dialog[open], [aria-modal=true]")),
+      scrollable: root.documentElement.scrollHeight > root.documentElement.clientHeight
+    };
+  }
+  var bannerselector = '[id*="cookie" i], [class*="cookie" i], [id*="consent" i], [class*="consent" i], [id*="gdpr" i], [class*="gdpr" i], [id*="privacy" i], [class*="privacy" i], [id*="banner" i], [class*="banner" i], dialog, [role="dialog"], [aria-modal="true"]';
+  function collectbannercandidates(root) {
+    const found = [...root.querySelectorAll(bannerselector)];
+    return found.filter((element) => !found.some((other) => other !== element && other.contains(element))).map((element) => ({
+      selector: elementselector(element),
+      id: element.id,
+      classes: [...element.classList],
+      text: clean(element.textContent ?? "").slice(0, 200),
+      controls: [...element.querySelectorAll("button, a[href], [role=button]")].map((control) => clean(control.getAttribute("aria-label") ?? control.textContent ?? "")).filter(Boolean)
+    }));
+  }
+  function runpagedetection(step, target, root = document) {
+    switch (step.kind) {
+      case "detectlists": {
+        const patterns = detectlistpatterns(collectsiblings(root));
+        return { ok: true, summary: `Detected ${patterns.length} repeated list${patterns.length === 1 ? "" : "s"}.`, details: { lists: patterns } };
+      }
+      case "detecttables": {
+        const tables = collecttables(root).map((entry) => {
+          const shape = normalizetable(entry.rows, entry.caption);
+          return { selector: entry.selector, headers: shape.headers, columns: shape.columns, rows: shape.rows, caption: shape.caption };
+        });
+        return { ok: true, summary: `Detected ${tables.length} data table${tables.length === 1 ? "" : "s"}.`, details: { tables } };
+      }
+      case "countpages": {
+        const estimate = paginationestimate(collectpagination(root));
+        return { ok: true, summary: `Counted ${estimate.links} pagination entr${estimate.links === 1 ? "y" : "ies"} and estimated ${estimate.total} total page${estimate.total === 1 ? "" : "s"}.`, details: { current: estimate.current, total: estimate.total, links: estimate.links, pages: estimate.pages } };
+      }
+      case "detectinfinitescroll": {
+        const containers = infinitescrollranges(collectscrollranges(root));
+        return { ok: true, summary: `Detected ${containers.length} infinite scroll container${containers.length === 1 ? "" : "s"}.`, details: { containers } };
+      }
+      case "detectvirtual": {
+        const containers = virtualizedcontainers(collectvirtual(root));
+        return { ok: true, summary: `Detected ${containers.length} virtualized list${containers.length === 1 ? "" : "s"}.`, details: { containers } };
+      }
+      case "detectlazy": {
+        const survey = lazysurvey(collectimages(root));
+        return { ok: true, summary: `Detected ${survey.lazy.length} lazy image${survey.lazy.length === 1 ? "" : "s"} and ${survey.placeholders.length} placeholder${survey.placeholders.length === 1 ? "" : "s"}.`, details: { lazy: survey.lazy, placeholders: survey.placeholders } };
+      }
+      case "detectsticky": {
+        const overlays = overlaygeometry(collectoverlays(root), { width: root.defaultView?.innerWidth ?? 0, height: root.defaultView?.innerHeight ?? 0 });
+        return { ok: true, summary: `Detected ${overlays.length} sticky or fixed overlay${overlays.length === 1 ? "" : "s"}.`, details: { overlays } };
+      }
+      case "detectscrolllock": {
+        const lock = scrolllockstate(collectlocksignals(root));
+        return { ok: true, summary: lock.locked ? `Scroll is locked: ${lock.reasons.join(", ")}.` : "Scroll is not locked.", details: { locked: lock.locked, reasons: lock.reasons, scrollable: lock.scrollable } };
+      }
+      case "classifypage": {
+        const signals = {
+          paragraphs: root.querySelectorAll("p").length,
+          headings: root.querySelectorAll("h1, h2, h3, h4, h5, h6").length,
+          lists: root.querySelectorAll("ul, ol").length,
+          tables: root.querySelectorAll("table").length,
+          forms: root.querySelectorAll("form").length,
+          inputs: root.querySelectorAll("input, textarea, select").length,
+          password: Boolean(root.querySelector("input[type=password]"))
+        };
+        const template = classifytemplate(signals);
+        const fingerprint = sectionfingerprint({ tag: "body", attributes: {}, children: root.body?.children.length ?? 0, textlength: (root.body?.innerText ?? "").length });
+        return { ok: true, summary: `Classified the page template as ${template}.`, details: { template, fingerprint } };
+      }
+      case "fingerprintsection": {
+        if (!target) return { ok: false, summary: "Fingerprint target is no longer available." };
+        const attributes = {};
+        for (const attribute of [...target.attributes]) attributes[attribute.name] = attribute.value;
+        const fingerprint = sectionfingerprint({ tag: target.tagName.toLowerCase(), attributes, children: target.children.length, textlength: (target.textContent ?? "").length });
+        return { ok: true, summary: `Computed section fingerprint ${fingerprint}.`, details: { fingerprint, section: elementselector(target) } };
+      }
+      case "readscrollpos": {
+        const report = scrollreport(
+          { scrollx: root.defaultView?.scrollX ?? 0, scrolly: root.defaultView?.scrollY ?? 0, scrollheight: root.documentElement.scrollHeight, clientheight: root.defaultView?.innerHeight ?? 0 },
+          [...root.querySelectorAll("*")].filter((element) => element instanceof HTMLElement && element.scrollHeight > element.clientHeight).map((element) => ({ selector: elementselector(element), scrolltop: element.scrollTop, scrollleft: element.scrollLeft, scrollheight: element.scrollHeight, clientheight: element.clientHeight }))
+        );
+        return { ok: true, summary: `Read the scroll position at ${Math.round(report.window.x)},${Math.round(report.window.y)} with ${report.containers.length} scrollable container${report.containers.length === 1 ? "" : "s"}.`, details: { scroll: report } };
+      }
+      default:
+        return { ok: false, summary: "Unsupported page detection." };
+    }
+  }
+
+  // extension/pagewatch.ts
+  var defaultpoll = 250;
+  function parsewatchoptions(step, fallbackid) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const scopes = Array.isArray(options.scopes) ? options.scopes.filter((item) => typeof item === "string" && item.trim().length > 0) : void 0;
+    const events3 = Array.isArray(options.events) ? options.events.filter((item) => typeof item === "string" && item.trim().length > 0) : void 0;
+    const lifetime = typeof options.lifetime === "number" && Number.isFinite(options.lifetime) && options.lifetime > 0 ? options.lifetime : 0;
+    return {
+      watchid: typeof options.watchid === "string" && options.watchid.trim() ? options.watchid : fallbackid,
+      ...scopes ? { scopes } : {},
+      ...events3 ? { events: events3 } : {},
+      lifetime,
+      poll: typeof options.poll === "number" && Number.isFinite(options.poll) && options.poll >= 0 ? options.poll : defaultpoll
+    };
+  }
+  function batchmutations(records, windowms) {
+    const batches = [];
+    let current = [];
+    let opened = -1;
+    for (const record of records) {
+      if (current.length === 0 || windowms > 0 && record.at - opened >= windowms) {
+        if (current.length > 0) batches.push(current);
+        current = [record];
+        opened = record.at;
+      } else current.push(record);
+    }
+    if (current.length > 0) batches.push(current);
+    return batches;
+  }
+  function quietfor(entries, now) {
+    let last = 0;
+    for (const entry of entries) if (entry.responseend > last) last = entry.responseend;
+    return Math.max(0, now - last);
+  }
+  function quietresolution(samples, idle, timeout) {
+    const start = samples[0]?.at ?? 0;
+    const last = samples[samples.length - 1];
+    const waited = Math.max(0, (last?.at ?? 0) - start);
+    const reached = samples.find((sample) => sample.quietfor >= idle);
+    if (reached) return { ok: true, quietfor: reached.quietfor, waited: reached.at - start, samples: samples.length };
+    return { ok: false, quietfor: last?.quietfor ?? 0, waited, samples: samples.length };
+  }
+  function nodehash(summary) {
+    const canonical = [summary.tag, summary.text, ...Object.keys(summary.attributes).sort().map((key) => `${key}=${summary.attributes[key] ?? ""}`)].join("|");
+    let hash = 5381;
+    for (let index = 0; index < canonical.length; index += 1) hash = (hash << 5) + hash + canonical.charCodeAt(index) >>> 0;
+    return hash.toString(16);
+  }
+  function diffsummaries(base, target) {
+    const basemap = new Map(base.map((node) => [node.selector, node]));
+    const targetmap = new Map(target.map((node) => [node.selector, node]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [selector, node] of targetmap) {
+      const previous = basemap.get(selector);
+      if (!previous) {
+        added.push({ kind: "added", selector, summary: node.text || node.tag });
+        continue;
+      }
+      if (nodehash(previous) !== nodehash(node)) changed.push({ kind: "changed", selector, summary: `${previous.text || previous.tag} became ${node.text || node.tag}` });
+    }
+    for (const [selector, node] of basemap) {
+      if (!targetmap.has(selector)) removed.push({ kind: "removed", selector, summary: node.text || node.tag });
+    }
+    return { added, removed, changed };
+  }
+  function scanjson(scripts) {
+    const states = [];
+    let refused = 0;
+    for (const script of scripts) {
+      if (script.src) continue;
+      const content = script.content.trim();
+      if (!(script.type.includes("json") || content.startsWith("{") || content.startsWith("["))) continue;
+      try {
+        states.push({ scripturl: script.src, rootpath: script.id, payload: JSON.parse(content) });
+      } catch {
+        refused += 1;
+      }
+    }
+    return { states, refused };
+  }
+  function rankselectors(shape) {
+    const candidates = [];
+    if (shape.id) candidates.push({ selector: `#${shape.id}`, strategy: "id", score: 100 });
+    for (const [name, value] of Object.entries(shape.attributes)) {
+      if (!value) continue;
+      if (name === "name" || name.startsWith("data-") || name.startsWith("aria-")) candidates.push({ selector: `${shape.tag}[${name}="${value}"]`, strategy: "attribute", score: 80 });
+    }
+    if (shape.text) candidates.push({ selector: shape.text, strategy: "text", score: 60 });
+    if (shape.index > 0) candidates.push({ selector: `${shape.tag}:nth-of-type(${shape.index})`, strategy: "structural", score: 40 });
+    return candidates.sort((left, right) => right.score - left.score);
+  }
+  function wait2(ms) {
+    return new Promise((resolve) => window.setTimeout(resolve, ms));
+  }
+  function quietruleof(step) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const rule = options.quietrule;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) return { idle: 0 };
+    const quiet = rule;
+    return {
+      idle: typeof quiet.idle === "number" && Number.isFinite(quiet.idle) && quiet.idle > 0 ? quiet.idle : 0,
+      ...typeof quiet.poll === "number" && Number.isFinite(quiet.poll) && quiet.poll >= 0 ? { poll: quiet.poll } : {},
+      ...typeof quiet.timeout === "number" && Number.isFinite(quiet.timeout) && quiet.timeout >= 0 ? { timeout: quiet.timeout } : {}
+    };
+  }
+  async function watchmutations(step, root) {
+    const options = parsewatchoptions(step, step.id);
+    if (options.lifetime <= 0) return { ok: false, summary: "The reviewed mutation watch lifetime is absent." };
+    const roots = options.scopes ? options.scopes.flatMap((selector) => [...root.querySelectorAll(selector)]) : [root];
+    if (roots.length === 0) return { ok: false, summary: "The reviewed watch scopes match no elements." };
+    const allowed = options.events;
+    const collected = [];
+    const observer = new MutationObserver((records) => {
+      for (const record of records) {
+        if (allowed && !allowed.includes(record.type)) continue;
+        const target = record.target instanceof Element ? record.target : null;
+        collected.push({ watchid: options.watchid, event: record.type, targetpath: target ? elementselector(target) : "#text", at: Date.now() });
+      }
+    });
+    for (const scope of roots) observer.observe(scope, { childList: true, attributes: true, characterData: true, subtree: true });
+    await wait2(options.lifetime);
+    observer.disconnect();
+    const batches = batchmutations(collected, options.poll);
+    return { ok: true, summary: `Watched ${collected.length} mutation${collected.length === 1 ? "" : "s"} in ${batches.length} batch${batches.length === 1 ? "" : "es"} for the reviewed lifetime of ${options.lifetime} milliseconds.`, details: { events: collected, batches: batches.length, watchid: options.watchid, lifetime: options.lifetime, scopes: options.scopes ?? [] } };
+  }
+  async function watchfocus(step, root) {
+    const options = parsewatchoptions(step, step.id);
+    if (options.lifetime <= 0) return { ok: false, summary: "The reviewed focus watch lifetime is absent." };
+    const collected = [];
+    const record = (kind) => (event) => {
+      const target = event.target instanceof Element ? event.target : null;
+      collected.push({ watchid: options.watchid, kind, targetpath: target ? elementselector(target) : "#document", at: Date.now() });
+    };
+    const onfocus = record("focus");
+    const onblur = record("blur");
+    root.addEventListener("focusin", onfocus, true);
+    root.addEventListener("focusout", onblur, true);
+    await wait2(options.lifetime);
+    root.removeEventListener("focusin", onfocus, true);
+    root.removeEventListener("focusout", onblur, true);
+    return { ok: true, summary: `Watched ${collected.length} focus change${collected.length === 1 ? "" : "s"} for the reviewed lifetime of ${options.lifetime} milliseconds.`, details: { events: collected, watchid: options.watchid, lifetime: options.lifetime } };
+  }
+  async function watchbanners(step, root) {
+    const options = parsewatchoptions(step, step.id);
+    if (options.lifetime <= 0) return { ok: false, summary: "The reviewed banner watch lifetime is absent." };
+    const started = Date.now();
+    const seen = /* @__PURE__ */ new Map();
+    while (Date.now() - started < options.lifetime) {
+      const at = Date.now();
+      for (const report of bannermatches(collectbannercandidates(root), at)) {
+        if (!seen.has(report.selector)) seen.set(report.selector, report);
+      }
+      await wait2(options.poll);
+    }
+    const reports = [...seen.values()];
+    return { ok: true, summary: `Watched for consent banners for the reviewed lifetime of ${options.lifetime} milliseconds and observed ${reports.length} banner${reports.length === 1 ? "" : "s"}.`, details: { banners: reports, watchid: options.watchid, lifetime: options.lifetime } };
+  }
+  async function waitquiet(step) {
+    const rule = quietruleof(step);
+    if (rule.idle <= 0) return { ok: false, summary: "The reviewed quiet idle threshold is absent." };
+    const poll2 = rule.poll ?? 100;
+    const timeout = rule.timeout ?? 0;
+    const started = performance.now();
+    const samples = [];
+    for (; ; ) {
+      const now = performance.now();
+      const entries = performance.getEntriesByType("resource").map((entry) => ({ responseend: entry.responseEnd }));
+      samples.push({ at: now - started, quietfor: quietfor(entries, now) });
+      const latest = samples[samples.length - 1];
+      if (latest && latest.quietfor >= rule.idle) break;
+      if (timeout > 0 && now - started >= timeout) break;
+      await wait2(poll2);
+    }
+    const outcome = quietresolution(samples, rule.idle, timeout);
+    return {
+      ok: outcome.ok,
+      summary: outcome.ok ? `The network stayed quiet for ${Math.round(outcome.quietfor)} milliseconds, meeting the reviewed idle threshold of ${rule.idle} milliseconds.` : `The network did not stay quiet for ${rule.idle} milliseconds${timeout > 0 ? ` within the reviewed timeout of ${timeout} milliseconds` : ""}.`,
+      details: { samples, idle: rule.idle, timeout, waited: Math.round(outcome.waited) }
+    };
+  }
+  function scriptsurfaces(target, root) {
+    const elements = target ? [target] : [...root.querySelectorAll("script")];
+    return elements.map((element) => ({ src: element.getAttribute("src") ?? "", type: element.getAttribute("type") ?? "", id: element.id, content: element.textContent ?? "" }));
+  }
+  function readjson(step, target, root) {
+    const outcome = scanjson(scriptsurfaces(target, root));
+    if (target && outcome.states.length === 0 && outcome.refused > 0) return { ok: false, summary: "The reviewed json payload is malformed and was refused." };
+    return { ok: true, summary: `Extracted ${outcome.states.length} embedded json state${outcome.states.length === 1 ? "" : "s"}${outcome.refused > 0 ? ` and refused ${outcome.refused} malformed payload${outcome.refused === 1 ? "" : "s"}` : ""}.`, details: { states: outcome.states, refused: outcome.refused } };
+  }
+  function tonodesummaries(value) {
+    if (!Array.isArray(value)) return null;
+    const summaries = [];
+    for (const entry of value) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+      const candidate = entry;
+      if (typeof candidate.selector !== "string") continue;
+      const attributes = {};
+      if (candidate.attributes && typeof candidate.attributes === "object" && !Array.isArray(candidate.attributes)) {
+        for (const [key, item] of Object.entries(candidate.attributes)) if (typeof item === "string") attributes[key] = item;
+      }
+      summaries.push({ selector: candidate.selector, tag: typeof candidate.tag === "string" ? candidate.tag : "", text: typeof candidate.text === "string" ? candidate.text : "", attributes });
+    }
+    return summaries;
+  }
+  function diffsnapshots(step) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const base = tonodesummaries(options.base);
+    const target = tonodesummaries(options.target);
+    if (!base || !target) return { ok: false, summary: "Two stored observation versions must be reviewed before diffing." };
+    const versions = Array.isArray(options.versions) && options.versions.length === 2 ? options.versions : [0, 0];
+    const diff = diffsummaries(base, target);
+    return { ok: true, summary: `Diffed observation versions ${versions[0] ?? 0} and ${versions[1] ?? 0}: ${diff.added.length} added, ${diff.removed.length} removed and ${diff.changed.length} changed node${diff.added.length + diff.removed.length + diff.changed.length === 1 ? "" : "s"}.`, details: { versions, added: diff.added, removed: diff.removed, changed: diff.changed } };
+  }
+  function deriveselector(target) {
+    if (!(target instanceof Element)) return { ok: false, summary: "Derivation target is no longer available." };
+    const attributes = {};
+    for (const attribute of [...target.attributes]) attributes[attribute.name] = attribute.value;
+    const parent = target.parentElement;
+    const siblings = parent ? [...parent.children].filter((node) => node.tagName === target.tagName) : [target];
+    const candidates = rankselectors({ id: target.id, tag: target.tagName.toLowerCase(), attributes, text: clean(target.textContent ?? "").slice(0, 80), index: siblings.indexOf(target) + 1, siblings: siblings.length });
+    const best = candidates[0];
+    return { ok: candidates.length > 0, summary: best ? `Derived ${candidates.length} selector candidate${candidates.length === 1 ? "" : "s"}; the most stable is ${best.selector} through the ${best.strategy} strategy with stability ${best.score}.` : "No selector candidate could be derived.", details: { candidates } };
+  }
+  function runpagewatch(step, target, root = document) {
+    switch (step.kind) {
+      case "watchmutate":
+        return watchmutations(step, root);
+      case "watchfocus":
+        return watchfocus(step, root);
+      case "watchbanner":
+        return watchbanners(step, root);
+      case "waitquiet":
+        return waitquiet(step);
+      case "readjson":
+        return readjson(step, target, root);
+      case "diffsnapshots":
+        return diffsnapshots(step);
+      case "deriveselector":
+        return deriveselector(target);
+      default:
+        return { ok: false, summary: "Unsupported watched observation." };
+    }
+  }
+
+  // extension/pagebridge.ts
+  function stepoptions2(step) {
     if (!step.options) return {};
     try {
       const parsed = JSON.parse(step.options);
@@ -360,11 +2055,13 @@
   function clearpreview() {
     document.getElementById(previewid)?.remove();
   }
-  function previewtarget(targetselector, expectedorigin) {
+  function previewtarget(step, expectedorigin) {
     if (location.origin !== expectedorigin) return { ok: false, summary: "Page origin changed before preview." };
     clearpreview();
-    const target = document.querySelector(targetselector);
-    if (!(target instanceof HTMLElement)) return { ok: false, summary: "Reviewed target is no longer available." };
+    const resolution = resolvestep(step, document);
+    if (resolution.status === "ambiguous") return { ok: false, summary: `The reviewed ${resolution.mode} reference matched ${resolution.candidates.length} elements: ${resolution.candidates.join("; ")}.`, candidates: resolution.candidates };
+    if (resolution.status !== "resolved") return { ok: false, summary: "Reviewed target is no longer available." };
+    const target = resolution.element;
     const rect = target.getBoundingClientRect();
     if (rect.width <= 0 || rect.height <= 0) return { ok: false, summary: "Reviewed target is not currently visible." };
     const overlay = document.createElement("div");
@@ -373,43 +2070,65 @@
     Object.assign(overlay.style, { position: "fixed", left: `${Math.max(0, rect.left - 3)}px`, top: `${Math.max(0, rect.top - 3)}px`, width: `${rect.width + 6}px`, height: `${rect.height + 6}px`, border: "3px solid #2f80ed", borderRadius: "6px", boxShadow: "0 0 0 3px rgba(47,128,237,.28)", pointerEvents: "none", zIndex: "2147483647", boxSizing: "border-box" });
     document.documentElement.append(overlay);
     window.setTimeout(clearpreview, 5e3);
-    return { ok: true, summary: `Previewing ${label(target) || target.tagName.toLowerCase()} for five seconds.` };
+    return { ok: true, summary: `Previewing ${elementlabel(target) || target.tagName.toLowerCase()} for five seconds.`, resolvedtarget: resolution.target };
   }
   function capturesnapshot() {
     const candidates = [...document.querySelectorAll("a[href], button, input, textarea, select, [role=button], [role=link], [role=combobox], [role=option], [role=checkbox], [role=radio], [role=switch], [role=tab], details, summary")];
-    const interactive = candidates.map((element) => ({ selector: selector(element), role: element.getAttribute("role") || element.tagName.toLowerCase(), label: label(element) })).filter((item) => item.label || item.role);
+    const interactive = candidates.map((element) => ({ selector: elementselector(element), role: element.getAttribute("role") || element.tagName.toLowerCase(), label: elementlabel(element) })).filter((item) => item.label || item.role);
     const forms = [...document.querySelectorAll("input, textarea, select")].map((element) => ({
-      label: label(element),
+      label: elementlabel(element),
       type: element.getAttribute("type") || element.tagName.toLowerCase(),
       name: element.getAttribute("name") || "",
       ...element instanceof HTMLSelectElement ? { options: [...element.options].map((option) => clean(option.textContent || option.value)) } : {}
     }));
     const text = clean(document.body?.innerText || "");
-    return { schemaversion: 2, url: location.href, title: clean(document.title), textpreview: text, textlength: document.body?.innerText.length ?? 0, forms, interactive, capturedat: Date.now() };
+    const tree = buildpagetree(document);
+    const tables = collecttables(document).map((entry) => {
+      const shape = normalizetable(entry.rows, entry.caption);
+      return { selector: entry.selector, headers: shape.headers, columns: shape.columns, rows: shape.rows, caption: shape.caption };
+    });
+    return {
+      schemaversion: 3,
+      url: location.href,
+      title: clean(document.title),
+      textpreview: text,
+      textlength: document.body?.innerText.length ?? 0,
+      forms,
+      interactive,
+      capturedat: Date.now(),
+      mode: "passive",
+      a11y: builda11ytree(tree),
+      reader: buildreader(tree, clean(document.title)),
+      listpattern: detectlistpatterns(collectsiblings(document)),
+      tableshape: tables
+    };
+  }
+  function readdialogs() {
+    return harvestdialoglog(document);
   }
-  function extractcontent(targetselector) {
+  function extractcontent(targetselector, root) {
     if (!targetselector) {
-      const links = [...document.querySelectorAll("a[href]")].map((element) => {
+      const links = [...root.querySelectorAll("a[href]")].map((element) => {
         const href = element instanceof HTMLAnchorElement ? element.getAttribute("href") ?? "" : "";
         return { text: element.textContent?.trim() ?? "", href };
       });
       return { ok: true, summary: `Extracted ${links.length} link entries.`, details: { links } };
     }
-    const target = document.querySelector(targetselector);
+    const target = root.querySelector(targetselector);
     if (!target) return { ok: false, summary: "Extraction target is no longer available." };
     const text = target.textContent ?? "";
     return { ok: true, summary: `Extracted ${text.length} characters of content.`, details: { text } };
   }
   function scrolltarget(target) {
     target.scrollIntoView({ block: "center", inline: "nearest", behavior: "auto" });
-    return { ok: true, summary: `Scrolled ${label(target) || target.tagName.toLowerCase()} into view.` };
+    return { ok: true, summary: `Scrolled ${elementlabel(target) || target.tagName.toLowerCase()} into view.` };
   }
   function hovertarget(target) {
     for (const type of ["pointerover", "mouseover", "pointerenter"]) {
       target.dispatchEvent(new PointerEvent(type, { bubbles: type !== "pointerenter", cancelable: true, composed: true }));
     }
     target.dispatchEvent(new MouseEvent("mouseenter", { bubbles: false, cancelable: true }));
-    return { ok: true, summary: `Hover events delivered to ${label(target) || target.tagName.toLowerCase()}.` };
+    return { ok: true, summary: `Hover events delivered to ${elementlabel(target) || target.tagName.toLowerCase()}.` };
   }
   function selectoption(target, value) {
     if (!(target instanceof HTMLSelectElement)) return { ok: false, summary: "Target is not a select element." };
@@ -420,9 +2139,15 @@
     target.dispatchEvent(new Event("change", { bubbles: true }));
     return { ok: true, summary: `Selected ${clean(option.textContent || option.value)}.` };
   }
-  var readkinds = /* @__PURE__ */ new Set(["readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "waitfor", "waittext", "highlight"]);
+  var readkinds = /* @__PURE__ */ new Set(["readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "waitfor", "waittext", "highlight", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath"]);
   var mutatingkinds = /* @__PURE__ */ new Set(["presskey", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "setattribute", "removeattribute", "writestorage", "evaluate", "fullscreen"]);
-  function performstep(step, expectedorigin) {
+  var controlkinds = /* @__PURE__ */ new Set(["typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails"]);
+  var interactkinds = /* @__PURE__ */ new Set(["clicktext", "clickaria", "clickname", "pierceshadow", "enterframe"]);
+  var pointerkinds = /* @__PURE__ */ new Set(["movepointer", "clickpoint", "shiftclick"]);
+  var observationkinds = /* @__PURE__ */ new Set(["a11ytree", "readvisible", "readertree", "readoutline", "readselection", "readopengraph", "readlang", "detectlanguage", "listshadow", "listframes"]);
+  var detectionkinds = /* @__PURE__ */ new Set(["detectlists", "detecttables", "detectinfinitescroll", "detectvirtual", "detectlazy", "detectsticky", "detectscrolllock", "countpages", "classifypage", "fingerprintsection", "readscrollpos"]);
+  var watchstepkinds = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "waitquiet", "readjson", "diffsnapshots", "deriveselector"]);
+  async function performstep(step, expectedorigin, rootdocument = document) {
     if (location.origin !== expectedorigin) return { ok: false, summary: "Page origin changed before action." };
     if (step.kind === "observe") return { ok: true, summary: "Observation completed." };
     if (step.kind === "wait") {
@@ -430,7 +2155,7 @@
       const duration = Number.isFinite(requested) && requested > 0 ? requested : 0;
       return new Promise((resolve) => window.setTimeout(() => resolve({ ok: true, summary: `Reviewed wait of ${duration} milliseconds completed.` }), duration));
     }
-    if (step.kind === "extract") return extractcontent(step.target);
+    if (step.kind === "extract") return extractcontent(step.target, rootdocument);
     if (step.kind === "navigate") {
       if (!step.value || new URL(step.value).origin !== expectedorigin) return { ok: false, summary: "Navigation target is outside the approved origin." };
       location.assign(step.value);
@@ -449,7 +2174,7 @@
       return { ok: true, summary: "History forward requested." };
     }
     if (step.kind === "scrollpage") {
-      const options = stepoptions(step);
+      const options = stepoptions2(step);
       window.scrollBy({ left: typeof options.x === "number" ? options.x : 0, top: typeof options.y === "number" ? options.y : 600, behavior: "auto" });
       return { ok: true, summary: "Window scrolled by the reviewed amounts." };
     }
@@ -461,39 +2186,52 @@
       window.scrollTo(0, 0);
       return { ok: true, summary: "Window scrolled to the page top." };
     }
-    if (readkinds.has(step.kind)) return runpageread(step, step.target ? document.querySelector(step.target) : null);
-    if (mutatingkinds.has(step.kind)) return runpageaction(step, step.target ? document.querySelector(step.target) : null);
-    if (!step.target) return { ok: false, summary: "Action target is absent." };
-    const target = document.querySelector(step.target);
-    if (!(target instanceof HTMLElement)) return { ok: false, summary: "Action target is no longer available." };
-    if (step.kind === "scrollby") {
-      const options = stepoptions(step);
-      target.scrollBy({ left: typeof options.x === "number" ? options.x : 0, top: typeof options.y === "number" ? options.y : 600, behavior: "auto" });
-      return { ok: true, summary: "Container scrolled by the reviewed amounts." };
-    }
-    if (step.kind === "focus") {
-      target.focus();
-      return { ok: true, summary: "Target focused." };
-    }
-    if (step.kind === "inspect") return { ok: true, summary: `Target: ${label(target) || target.tagName.toLowerCase()}.` };
-    if (step.kind === "click") {
-      target.click();
-      return { ok: true, summary: "Reviewed click completed." };
-    }
-    if (step.kind === "scroll") return scrolltarget(target);
-    if (step.kind === "hover") return hovertarget(target);
-    if (step.kind === "select") return selectoption(target, step.value ?? "");
-    if (step.kind === "type") {
-      if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) return { ok: false, summary: "Target cannot receive text." };
-      if (typeof step.value !== "string") return { ok: false, summary: "Approved text is absent." };
-      target.focus();
-      target.value = step.value;
-      target.dispatchEvent(new Event("input", { bubbles: true }));
-      target.dispatchEvent(new Event("change", { bubbles: true }));
-      return { ok: true, summary: "Approved text entered." };
-    }
-    return { ok: false, summary: "Unsupported action." };
-  }
-  Object.assign(globalThis, { devthinkbridge: { capturesnapshot, previewtarget, performstep } });
+    const resolution = resolvestep(step, rootdocument);
+    if (resolution.status === "ambiguous") {
+      return { ok: false, summary: `The reviewed ${resolution.mode} reference matched ${resolution.candidates.length} elements: ${resolution.candidates.join("; ")}.`, details: { mode: resolution.mode, candidates: resolution.candidates } };
+    }
+    const element = resolution.status === "resolved" ? resolution.element : null;
+    let result;
+    if (readkinds.has(step.kind)) result = runpageread(step, element, rootdocument);
+    else if (controlkinds.has(step.kind)) result = runpagecontrol(step, element, rootdocument);
+    else if (interactkinds.has(step.kind)) return await runinteractstep(step, expectedorigin, performstep);
+    else if (pointerkinds.has(step.kind)) result = runpointerstep(step, resolution);
+    else if (observationkinds.has(step.kind)) result = runpageobservation(step, element, rootdocument);
+    else if (detectionkinds.has(step.kind)) result = runpagedetection(step, element, rootdocument);
+    else if (watchstepkinds.has(step.kind)) result = runpagewatch(step, element, rootdocument);
+    else if (mutatingkinds.has(step.kind)) result = runpageaction(step, element);
+    else {
+      if (!element) return { ok: false, summary: "Action target is no longer available." };
+      if (step.kind === "scrollby") {
+        const options = stepoptions2(step);
+        element.scrollBy({ left: typeof options.x === "number" ? options.x : 0, top: typeof options.y === "number" ? options.y : 600, behavior: "auto" });
+        result = { ok: true, summary: "Container scrolled by the reviewed amounts." };
+      } else if (step.kind === "focus") {
+        element.focus();
+        result = { ok: true, summary: "Target focused." };
+      } else if (step.kind === "inspect") result = { ok: true, summary: `Target: ${elementlabel(element) || element.tagName.toLowerCase()}.` };
+      else if (step.kind === "click") {
+        element.click();
+        result = { ok: true, summary: "Reviewed click completed." };
+      } else if (step.kind === "scroll") result = scrolltarget(element);
+      else if (step.kind === "hover") result = hovertarget(element);
+      else if (step.kind === "select") result = selectoption(element, step.value ?? "");
+      else if (step.kind === "type") {
+        if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) return { ok: false, summary: "Target cannot receive text." };
+        if (typeof step.value !== "string") return { ok: false, summary: "Approved text is absent." };
+        element.focus();
+        element.value = step.value;
+        element.dispatchEvent(new Event("input", { bubbles: true }));
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+        result = { ok: true, summary: "Approved text entered." };
+      } else return { ok: false, summary: "Unsupported action." };
+    }
+    const output = await result;
+    if (resolution.status === "resolved") {
+      return { ...output, details: { ...output.details ?? {}, mode: resolution.target.mode, resolvedtarget: resolution.target } };
+    }
+    return output;
+  }
+  Object.assign(globalThis, { devthinkbridge: { capturesnapshot, previewtarget, performstep, readdialogs } });
 })();
 //# sourceMappingURL=pagebridge.js.map