@wenathlan/extension 1.1.33 → 1.1.35

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", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor"]);
+  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", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen"]);
   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"]);
+  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", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe"]);
   var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
   function parseoptions(step) {
     if (step.options === void 0) return {};
@@ -440,6 +440,19 @@
     }
     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) {
@@ -1122,6 +1135,323 @@
     return { ok: false, summary: "Unsupported interaction action." };
   }
 
+  // extension/pagenav.ts
+  function loadphase(readystate) {
+    if (readystate === "interactive") return "interactive";
+    if (readystate === "complete") return "complete";
+    return "loading";
+  }
+  function parseurlpattern(step, key = "urlpattern") {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const value = options[key];
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const pattern = value;
+    if (typeof pattern.url !== "string" || !pattern.url) return null;
+    const mode = pattern.mode === "exact" || pattern.mode === "host" || pattern.mode === "pattern" ? pattern.mode : "prefix";
+    const query = {};
+    if (pattern.query && typeof pattern.query === "object" && !Array.isArray(pattern.query)) {
+      for (const [name, item] of Object.entries(pattern.query)) if (typeof item === "string") query[name] = item;
+    }
+    return {
+      mode,
+      url: pattern.url,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      ...typeof pattern.fragment === "string" && pattern.fragment ? { fragment: pattern.fragment } : {}
+    };
+  }
+  function segmentmatches(pattern, actual) {
+    if (pattern === "*" || pattern === "**") return true;
+    if (!pattern.includes("*")) return pattern === actual;
+    const parts = pattern.split("*");
+    let index = 0;
+    for (let position = 0; position < parts.length; position += 1) {
+      const part = parts[position];
+      if (part === "") continue;
+      const found = actual.indexOf(part, index);
+      if (found < 0) return false;
+      if (position === 0 && found !== 0) return false;
+      index = found + part.length;
+    }
+    const last = parts[parts.length - 1];
+    return last === "" || actual.endsWith(last);
+  }
+  function urlmatches(url, pattern) {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return false;
+    }
+    let expected;
+    try {
+      expected = new URL(pattern.url);
+    } catch {
+      return false;
+    }
+    if (pattern.mode === "exact" && parsed.toString() !== expected.toString()) return false;
+    if (pattern.mode === "prefix" && !parsed.toString().startsWith(pattern.url)) return false;
+    if (pattern.mode === "host" && parsed.origin !== expected.origin) return false;
+    if (pattern.mode === "pattern") {
+      if (parsed.origin !== expected.origin) return false;
+      const expectedsegments = expected.pathname.split("/").filter((segment) => segment !== "");
+      const actualsegments = parsed.pathname.split("/").filter((segment) => segment !== "");
+      if (expectedsegments.includes("**")) {
+        const cut = expectedsegments.indexOf("**");
+        const head = expectedsegments.slice(0, cut);
+        const tail = expectedsegments.slice(cut + 1);
+        if (actualsegments.length < head.length + tail.length) return false;
+        if (!head.every((segment, position) => segmentmatches(segment, actualsegments[position] ?? ""))) return false;
+        if (!tail.every((segment, position) => segmentmatches(segment, actualsegments[actualsegments.length - tail.length + position] ?? ""))) return false;
+      } else if (expectedsegments.length !== actualsegments.length || !expectedsegments.every((segment, position) => segmentmatches(segment, actualsegments[position] ?? ""))) return false;
+    }
+    const values = parsed.searchParams;
+    for (const [name, value] of Object.entries(pattern.query ?? {})) {
+      if (!values.has(name)) return false;
+      if (value !== "*" && values.get(name) !== value) return false;
+    }
+    if (pattern.fragment !== void 0 && parsed.hash.slice(1) !== pattern.fragment) return false;
+    return true;
+  }
+  function readquery(url) {
+    const values = {};
+    try {
+      for (const [name, value] of new URL(url).searchParams.entries()) values[name] = value;
+    } catch {
+    }
+    return values;
+  }
+  function rewritequeryurl(url, set, remove) {
+    const parsed = new URL(url);
+    const before = readquery(url);
+    for (const name of remove) parsed.searchParams.delete(name);
+    for (const [name, value] of Object.entries(set)) parsed.searchParams.set(name, value);
+    parsed.hash = "";
+    return { url: parsed.toString(), before, after: readquery(parsed.toString()), set: Object.keys(set), removed: [...remove] };
+  }
+  function fragmenturl(url, fragment) {
+    const parsed = new URL(url);
+    parsed.hash = fragment.replace(/^#/, "");
+    return parsed.toString();
+  }
+  function matchlinktext(links, text) {
+    const wanted = text.trim().toLowerCase();
+    return links.filter((link) => link.text.trim().toLowerCase() === wanted);
+  }
+  function matchlinkfragment(links, fragment) {
+    const wanted = fragment.trim().replace(/^#/, "");
+    return links.filter((link) => {
+      try {
+        return new URL(link.href, "https://example.invalid").hash.replace(/^#/, "") === wanted;
+      } catch {
+        return false;
+      }
+    });
+  }
+  function spauroutechanged(previousurl, currenturl) {
+    if (previousurl === currenturl) return false;
+    try {
+      return new URL(previousurl).origin === new URL(currenturl).origin;
+    } catch {
+      return false;
+    }
+  }
+  function wait2(ms) {
+    return new Promise((resolve) => window.setTimeout(resolve, ms));
+  }
+  function stepoptions(step) {
+    try {
+      return parseoptions(step);
+    } catch {
+      return {};
+    }
+  }
+  function collectlinks(root) {
+    return [...root.querySelectorAll("a[href]")].map((element) => ({
+      text: element.textContent?.trim() ?? "",
+      href: element instanceof HTMLAnchorElement ? element.href : element.getAttribute("href") ?? "",
+      selector: element.getAttribute("href") ?? ""
+    }));
+  }
+  function resolvelink(step, root) {
+    const options = stepoptions(step);
+    const allowedorigins = Array.isArray(options.allowedorigins) ? options.allowedorigins.filter((item) => typeof item === "string") : [];
+    const links = collectlinks(root);
+    const matches = options.fragment === true ? matchlinkfragment(links, step.value ?? "") : matchlinktext(links, step.value ?? "");
+    if (matches.length === 0) return { ok: false, summary: `No link matches the reviewed reference "${step.value ?? ""}".` };
+    if (matches.length > 1) return { ok: false, summary: `The reviewed link reference matched ${matches.length} links; review a unique one.` };
+    const element = [...root.querySelectorAll("a[href]")].find((candidate) => (candidate instanceof HTMLAnchorElement ? candidate.href : candidate.getAttribute("href") ?? "") === matches[0]?.href);
+    if (!(element instanceof HTMLAnchorElement)) return { ok: false, summary: "The reviewed link is no longer available." };
+    if (allowedorigins.length > 0) {
+      let origin = "";
+      try {
+        origin = new URL(element.href).origin;
+      } catch {
+        origin = "";
+      }
+      if (!allowedorigins.includes(origin)) return { ok: false, summary: `The reviewed link leaves the session origin grants for ${origin}.` };
+    }
+    return { ok: true, element };
+  }
+  async function runwaitload(step) {
+    const options = stepoptions(step);
+    const timeout = typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0 ? options.timeout : 0;
+    const started = Date.now();
+    for (; ; ) {
+      const phase = loadphase(document.readyState);
+      if (phase === "complete") return { ok: true, summary: `The page load event fired and the document is complete after ${Date.now() - started} milliseconds.`, details: { phase, readystate: document.readyState, waited: Date.now() - started } };
+      if (timeout > 0 && Date.now() - started >= timeout) return { ok: false, summary: `The page did not reach the complete load phase within the reviewed timeout of ${timeout} milliseconds.`, details: { phase, readystate: document.readyState, waited: Date.now() - started } };
+      await wait2(50);
+    }
+  }
+  async function runwaiturl(step) {
+    const options = stepoptions(step);
+    const pattern = parseurlpattern(step);
+    if (!pattern) return { ok: false, summary: "A reviewed urlpattern is required." };
+    const timeout = typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0 ? options.timeout : 0;
+    const poll2 = typeof options.poll === "number" && Number.isFinite(options.poll) && options.poll > 0 ? options.poll : 100;
+    const started = Date.now();
+    for (; ; ) {
+      if (urlmatches(location.href, pattern)) return { ok: true, summary: `The url matched the reviewed ${pattern.mode} pattern after ${Date.now() - started} milliseconds.`, details: { url: location.href, mode: pattern.mode, waited: Date.now() - started } };
+      if (timeout > 0 && Date.now() - started >= timeout) return { ok: false, summary: `The url did not match the reviewed ${pattern.mode} pattern within the reviewed timeout of ${timeout} milliseconds.`, details: { url: location.href, mode: pattern.mode, waited: Date.now() - started } };
+      await wait2(poll2);
+    }
+  }
+  async function runfollowlink(step, root) {
+    const resolution = resolvelink(step, root);
+    if (!resolution.ok) return { ok: false, summary: resolution.summary };
+    const href = resolution.element.href;
+    resolution.element.click();
+    return { ok: true, summary: `Followed the reviewed link to ${href}.`, details: { href } };
+  }
+  async function runspanav(step, root) {
+    const options = stepoptions(step);
+    const resolution = resolvelink(step, root);
+    if (!resolution.ok) return { ok: false, summary: resolution.summary };
+    const timeout = typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0 ? options.timeout : 0;
+    const pattern = parseurlpattern(step, "routepattern");
+    const before = location.href;
+    resolution.element.click();
+    const started = Date.now();
+    for (; ; ) {
+      const changed = spauroutechanged(before, location.href);
+      const matched = pattern ? urlmatches(location.href, pattern) : changed;
+      if (matched) return { ok: true, summary: `The single page app route changed to ${location.href} without a reload.`, details: { from: before, to: location.href, waited: Date.now() - started } };
+      if (timeout > 0 && Date.now() - started >= timeout) return { ok: false, summary: `The single page app route did not change within the reviewed timeout of ${timeout} milliseconds.`, details: { from: before, to: location.href, waited: Date.now() - started } };
+      await wait2(50);
+    }
+  }
+  async function runspawait(step) {
+    const options = stepoptions(step);
+    const timeout = typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0 ? options.timeout : 0;
+    const poll2 = typeof options.poll === "number" && Number.isFinite(options.poll) && options.poll > 0 ? options.poll : 100;
+    const pattern = parseurlpattern(step);
+    const before = location.href;
+    const started = Date.now();
+    let detected = false;
+    const onroute = () => {
+      if (spauroutechanged(before, location.href)) detected = true;
+    };
+    window.addEventListener("popstate", onroute);
+    window.addEventListener("hashchange", onroute);
+    try {
+      for (; ; ) {
+        if (pattern ? urlmatches(location.href, pattern) : detected || spauroutechanged(before, location.href)) {
+          return { ok: true, summary: `The single page app url changed to ${location.href} without a reload.`, details: { from: before, to: location.href, waited: Date.now() - started } };
+        }
+        if (timeout > 0 && Date.now() - started >= timeout) return { ok: false, summary: `The single page app url did not change within the reviewed timeout of ${timeout} milliseconds.`, details: { from: before, to: location.href, waited: Date.now() - started } };
+        await wait2(poll2);
+      }
+    } finally {
+      window.removeEventListener("popstate", onroute);
+      window.removeEventListener("hashchange", onroute);
+    }
+  }
+  function runrewritequery(step) {
+    const options = stepoptions(step);
+    const set = {};
+    if (options.set && typeof options.set === "object" && !Array.isArray(options.set)) {
+      for (const [name, value] of Object.entries(options.set)) if (typeof value === "string") set[name] = value;
+    }
+    const remove = Array.isArray(options.remove) ? options.remove.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+    const outcome = rewritequeryurl(location.href, set, remove);
+    history.pushState(history.state, document.title, outcome.url);
+    return { ok: true, summary: `Rewrote ${outcome.set.length + outcome.removed.length} query parameter${outcome.set.length + outcome.removed.length === 1 ? "" : "s"}; the url is now ${outcome.url}.`, details: { url: outcome.url, before: outcome.before, after: outcome.after, set: outcome.set, removed: outcome.removed } };
+  }
+  async function runsetfragment(step) {
+    const fragment = (step.value ?? "").replace(/^#/, "");
+    if (!fragment) return { ok: false, summary: "A reviewed fragment is required." };
+    const url = fragmenturl(location.href, fragment);
+    history.pushState(history.state, document.title, url);
+    const anchor = document.getElementById(fragment);
+    anchor?.scrollIntoView({ behavior: "smooth", block: "start" });
+    return { ok: true, summary: `Set the url fragment to ${fragment} and scrolled to its anchor.`, details: { url, fragment, anchored: Boolean(anchor) } };
+  }
+  function runstopnav() {
+    window.stop();
+    return { ok: true, summary: "Stopped the pending navigation of the page." };
+  }
+  function runprefetch(step) {
+    const options = stepoptions(step);
+    const urls = Array.isArray(options.urls) ? options.urls.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+    if (urls.length === 0) return { ok: false, summary: "A reviewed list of prefetch urls is required." };
+    for (const url of urls) {
+      const hint = document.createElement("link");
+      hint.rel = "prefetch";
+      hint.href = url;
+      document.head.append(hint);
+    }
+    return { ok: true, summary: `Queued ${urls.length} prefetch hint${urls.length === 1 ? "" : "s"}.`, details: { urls } };
+  }
+  function runpreconnect(step) {
+    const options = stepoptions(step);
+    const origins = Array.isArray(options.origins) ? options.origins.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+    if (origins.length === 0) return { ok: false, summary: "A reviewed list of preconnect origins is required." };
+    for (const origin of origins) {
+      const hint = document.createElement("link");
+      hint.rel = "preconnect";
+      hint.href = origin;
+      document.head.append(hint);
+    }
+    return { ok: true, summary: `Opened ${origins.length} preconnect hint${origins.length === 1 ? "" : "s"}.`, details: { origins } };
+  }
+  function runprintpdf() {
+    window.print();
+    return { ok: true, summary: "Sent the page to the browser print pipeline." };
+  }
+  function runpagenav(step, root = document) {
+    switch (step.kind) {
+      case "waitload":
+        return runwaitload(step);
+      case "waiturl":
+        return runwaiturl(step);
+      case "followlink":
+        return runfollowlink(step, root);
+      case "spanav":
+        return runspanav(step, root);
+      case "spawait":
+        return runspawait(step);
+      case "rewritequery":
+        return runrewritequery(step);
+      case "setfragment":
+        return runsetfragment(step);
+      case "stopnav":
+        return runstopnav();
+      case "prefetch":
+        return runprefetch(step);
+      case "preconnect":
+        return runpreconnect(step);
+      case "printpdf":
+        return runprintpdf();
+      default:
+        return { ok: false, summary: "Unsupported navigation action." };
+    }
+  }
+
   // extension/pagedialogs.ts
   function harvestdialoglog(root) {
     const raw = root.documentElement.dataset.devthinkdialoglog;
@@ -1136,8 +1466,900 @@
     }
   }
 
+  // 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 stepoptions2(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 = stepoptions2(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 wait3(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 wait3(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 wait3(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 wait3(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 wait3(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 stepoptions(step) {
+  function stepoptions3(step) {
     if (!step.options) return {};
     try {
       const parsed = JSON.parse(step.options);
@@ -1177,7 +2399,26 @@
       ...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);
@@ -1220,6 +2461,10 @@
   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"]);
+  var navstepkinds = /* @__PURE__ */ new Set(["waitload", "waiturl", "followlink", "spanav", "spawait", "rewritequery", "setfragment", "stopnav", "prefetch", "preconnect", "printpdf"]);
   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." };
@@ -1246,8 +2491,9 @@
       history.forward();
       return { ok: true, summary: "History forward requested." };
     }
+    if (navstepkinds.has(step.kind)) return await runpagenav(step, rootdocument);
     if (step.kind === "scrollpage") {
-      const options = stepoptions(step);
+      const options = stepoptions3(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." };
     }
@@ -1269,11 +2515,14 @@
     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 = stepoptions(step);
+        const options = stepoptions3(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") {