@wenathlan/extension 1.1.31 → 1.1.33

package/extension/dist/pagebridge.js

@@ -1,36 +1,1162 @@
 "use strict";
 (() => {
-  // extension/pagebridge.ts
-  function bounded(value, length = 180) {
-    return value.replace(/\s+/g, " ").trim().slice(0, length);
+  // 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 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 allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
+  function parseoptions(step) {
+    if (step.options === void 0) return {};
+    let parsed;
+    try {
+      parsed = JSON.parse(step.options);
+    } catch {
+      throw new Error("Step options must be a JSON object.");
+    }
+    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) {
+    target.dispatchEvent(new Event("input", { bubbles: true }));
+    target.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+  function modifiers(options) {
+    return Array.isArray(options.modifiers) ? options.modifiers.filter((item) => typeof item === "string") : [];
+  }
+  function keyevent(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 fieldlike(target) {
+    return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement ? target : null;
+  }
+  function stringify(value) {
+    try {
+      return JSON.parse(JSON.stringify(value)) ?? null;
+    } catch {
+      return String(value);
+    }
+  }
+  function runpageaction(step, target) {
+    const options = (() => {
+      try {
+        return parseoptions(step);
+      } catch {
+        return {};
+      }
+    })();
+    switch (step.kind) {
+      case "presskey": {
+        const receiver2 = target instanceof HTMLElement ? target : document.activeElement instanceof HTMLElement ? document.activeElement : document.body;
+        const key = step.value ?? "";
+        const mods = modifiers(options);
+        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": {
+        if (!(target instanceof HTMLElement)) return { ok: false, summary: "Action target is no longer available." };
+        target.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true, cancelable: true, composed: true }));
+        target.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true }));
+        target.dispatchEvent(new PointerEvent("pointerup", { bubbles: true, cancelable: true, composed: true }));
+        target.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true }));
+        target.click();
+        return { ok: true, summary: "Full pointer click sequence delivered." };
+      }
+      case "rightclick": {
+        if (!(target instanceof HTMLElement)) return { ok: false, summary: "Action target is no longer available." };
+        const init = { bubbles: true, cancelable: true, button: 2, buttons: 2 };
+        target.dispatchEvent(new PointerEvent("pointerdown", { ...init, composed: true }));
+        target.dispatchEvent(new MouseEvent("mousedown", init));
+        target.dispatchEvent(new MouseEvent("contextmenu", init));
+        return { ok: true, summary: "Context menu events delivered." };
+      }
+      case "doubleclick": {
+        if (!(target instanceof HTMLElement)) return { ok: false, summary: "Action target is no longer available." };
+        target.click();
+        target.click();
+        target.dispatchEvent(new MouseEvent("dblclick", { bubbles: true, cancelable: true, detail: 2 }));
+        return { ok: true, summary: "Double click sequence delivered." };
+      }
+      case "drag": {
+        if (!(target instanceof HTMLElement)) return { ok: false, summary: "Drag source is no longer available." };
+        const destination = document.querySelector(step.value ?? "");
+        if (!destination) return { ok: false, summary: "Drag destination is no longer available." };
+        const transfer = new DataTransfer();
+        if (typeof options.data === "string") transfer.setData("text/plain", options.data);
+        target.dispatchEvent(new DragEvent("dragstart", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        destination.dispatchEvent(new DragEvent("dragenter", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        destination.dispatchEvent(new DragEvent("dragover", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        destination.dispatchEvent(new DragEvent("drop", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        target.dispatchEvent(new DragEvent("dragend", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        return { ok: true, summary: "Drag and drop sequence delivered." };
+      }
+      case "drop": {
+        if (!(target instanceof HTMLElement)) return { ok: false, summary: "Drop zone is no longer available." };
+        const transfer = new DataTransfer();
+        transfer.setData("text/plain", step.value ?? "");
+        target.dispatchEvent(new DragEvent("dragenter", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        target.dispatchEvent(new DragEvent("dragover", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        target.dispatchEvent(new DragEvent("drop", { bubbles: true, cancelable: true, dataTransfer: transfer }));
+        return { ok: true, summary: "Drop payload delivered." };
+      }
+      case "upload": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "file") return { ok: false, summary: "Target is not a file input." };
+        const transfer = new DataTransfer();
+        transfer.items.add(new File([typeof options.content === "string" ? options.content : ""], step.value ?? "upload", { type: typeof options.type === "string" ? options.type : "text/plain" }));
+        target.files = transfer.files;
+        events(target);
+        return { ok: true, summary: `Uploaded ${step.value ?? "file"} into the reviewed input.` };
+      }
+      case "clear": {
+        const field = fieldlike(target);
+        if (!field) return { ok: false, summary: "Target cannot hold a value." };
+        field.value = "";
+        events(field);
+        return { ok: true, summary: "Field cleared." };
+      }
+      case "check":
+      case "uncheck":
+      case "toggle": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "checkbox" && target.type !== "radio") return { ok: false, summary: "Target is not a checkbox or radio control." };
+        if (step.kind === "uncheck" && target.type === "radio") return { ok: false, summary: "A radio control cannot be unchecked." };
+        target.checked = step.kind === "toggle" ? !target.checked : step.kind === "check";
+        events(target);
+        return { ok: true, summary: `Control is now ${target.checked ? "checked" : "unchecked"}.` };
+      }
+      case "submit": {
+        const form = target instanceof HTMLFormElement ? target : target instanceof HTMLElement ? target.closest("form") : null;
+        if (!form) return { ok: false, summary: "No form owns the reviewed target." };
+        try {
+          form.requestSubmit(target instanceof HTMLFormElement ? void 0 : target);
+        } catch {
+          form.submit();
+        }
+        return { ok: true, summary: "Form submission requested." };
+      }
+      case "setattribute": {
+        if (!target) return { ok: false, summary: "Action target is no longer available." };
+        const name = typeof options.name === "string" ? options.name : "";
+        target.setAttribute(name, typeof options.value === "string" ? options.value : "");
+        return { ok: true, summary: `Attribute ${name} set.` };
+      }
+      case "removeattribute": {
+        if (!target) return { ok: false, summary: "Action target is no longer available." };
+        const name = step.value ?? "";
+        target.removeAttribute(name);
+        return { ok: true, summary: `Attribute ${name} removed.` };
+      }
+      case "writestorage": {
+        try {
+          localStorage.setItem(typeof options.key === "string" ? options.key : "", typeof options.value === "string" ? options.value : "");
+          return { ok: true, summary: `Local storage entry ${String(options.key)} written.` };
+        } catch (error) {
+          return { ok: false, summary: `Local storage refused the write: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+      case "evaluate": {
+        try {
+          let outcome;
+          try {
+            outcome = new Function(`"use strict"; return (${step.value ?? "undefined"});`)();
+          } catch {
+            outcome = new Function(`"use strict"; ${step.value ?? ""}`)();
+          }
+          return { ok: true, summary: `Reviewed expression returned ${outcome === void 0 ? "no value" : "a value"}.`, details: { result: stringify(outcome) } };
+        } catch (error) {
+          return { ok: false, summary: `Reviewed expression failed: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+      case "fullscreen": {
+        const element = target instanceof HTMLElement ? target : document.documentElement;
+        return document.fullscreenElement === element ? document.exitFullscreen().then(() => ({ ok: true, summary: "Fullscreen state cleared." })) : element.requestFullscreen().then(() => ({ ok: true, summary: "Fullscreen state entered." })).catch((error) => ({ ok: false, summary: `Fullscreen was refused: ${error instanceof Error ? error.message : String(error)}` }));
+      }
+      default:
+        return { ok: false, summary: "Unsupported page action." };
+    }
+  }
+
+  // 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 label(element) {
+  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");
-    const linked = labelledby ? document.getElementById(labelledby)?.textContent : "";
-    return bounded(aria || linked || element.getAttribute("title") || element.textContent || "");
+    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 selector(element) {
-    if (element.id) return `#${CSS.escape(element.id)}`;
+  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="${CSS.escape(role)}"][name="${CSS.escape(name)}"]`;
-    if (name) return `${element.tagName.toLowerCase()}[name="${CSS.escape(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 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() {
+    document.getElementById(highlightid)?.remove();
+  }
+  function highlighttarget(target) {
+    clearhighlight();
+    const rect = target.getBoundingClientRect();
+    const overlay = document.createElement("div");
+    overlay.id = highlightid;
+    overlay.setAttribute("aria-hidden", "true");
+    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 #2f9e44", borderRadius: "6px", pointerEvents: "none", zIndex: "2147483647", boxSizing: "border-box" });
+    document.documentElement.append(overlay);
+    window.setTimeout(clearhighlight, 5e3);
+    return { ok: true, summary: "Target outlined for five seconds." };
+  }
+  function poll(root, 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 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, root = document) {
+    const options = (() => {
+      try {
+        return parseoptions(step);
+      } catch {
+        return {};
+      }
+    })();
+    switch (step.kind) {
+      case "highlight": {
+        if (!target) return { ok: false, summary: "Highlight target is no longer available." };
+        return highlighttarget(target);
+      }
+      case "readattribute": {
+        if (!target) return { ok: false, summary: "Read target is no longer available." };
+        const value = target.getAttribute(step.value ?? "");
+        return value === null ? { ok: false, summary: `Attribute ${step.value} is absent.` } : { ok: true, summary: `Attribute ${step.value} read.`, details: { value } };
+      }
+      case "readstyle": {
+        if (!target) return { ok: false, summary: "Read target is no longer available." };
+        const computed = getComputedStyle(target);
+        const styles = {};
+        for (let index = 0; index < computed.length; index += 1) {
+          const property = computed.item(index);
+          styles[property] = computed.getPropertyValue(property);
+        }
+        return { ok: true, summary: `Read ${computed.length} computed style properties.`, details: { styles } };
+      }
+      case "readgeometry": {
+        if (!target) return { ok: false, summary: "Read target is no longer available." };
+        const rect = target.getBoundingClientRect();
+        const geometry = { x: rect.x, y: rect.y, width: rect.width, height: rect.height, top: rect.top, right: rect.right, bottom: rect.bottom, left: rect.left };
+        return { ok: true, summary: "Target geometry read.", details: { geometry } };
+      }
+      case "readvalue": {
+        if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement)) return { ok: false, summary: "Target does not hold a form value." };
+        return { ok: true, summary: "Form value read.", details: { value: target.value } };
+      }
+      case "readtext": {
+        if (!target) return { ok: false, summary: "Read target is no longer available." };
+        const text = target.textContent ?? "";
+        return { ok: true, summary: `Read ${text.length} characters of text.`, details: { text } };
+      }
+      case "readhtml": {
+        if (!target) return { ok: false, summary: "Read target is no longer available." };
+        return { ok: true, summary: "Target markup read.", details: { html: target.outerHTML } };
+      }
+      case "countelements": {
+        const count = root.querySelectorAll(step.target ?? "").length;
+        return { ok: true, summary: `Selector matches ${count} element${count === 1 ? "" : "s"}.`, details: { count } };
+      }
+      case "readtable": {
+        if (!(target instanceof HTMLTableElement)) return { ok: false, summary: "Read target is not a table element." };
+        const rows = [...target.querySelectorAll("tr")].map((row) => [...row.querySelectorAll("th, td")].map((cell) => cell.textContent?.trim() ?? ""));
+        const headers = rows[0] ?? [];
+        const body = rows.slice(1);
+        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 = [...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 = [...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 = [...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(root);
+        return { ok: true, summary: `Read ${forms.length} form control${forms.length === 1 ? "" : "s"}.`, details: { forms } };
+      }
+      case "readstorage": {
+        try {
+          if (step.value) {
+            const value = localStorage.getItem(step.value);
+            return { ok: true, summary: `Read local storage entry ${step.value}.`, details: { value } };
+          }
+          const entries = {};
+          for (let index = 0; index < localStorage.length; index += 1) {
+            const key = localStorage.key(index);
+            if (key !== null) entries[key] = localStorage.getItem(key);
+          }
+          return { ok: true, summary: `Read ${Object.keys(entries).length} local storage entr${Object.keys(entries).length === 1 ? "y" : "ies"}.`, details: { entries } };
+        } catch (error) {
+          return { ok: false, summary: `Local storage refused the read: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+      case "waitfor": {
+        const selector = step.target ?? "";
+        const timeout = typeof options.timeout === "number" ? options.timeout : 0;
+        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(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/pagecontrols.ts
+  function typetimeschedule(text, delay) {
+    return [...text].map((character, position) => ({ key: character, delay: position === 0 ? 0 : delay }));
+  }
+  function appendvalue(current, addition) {
+    return current + addition;
+  }
+  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/pagebridge.ts
+  function stepoptions(step) {
+    if (!step.options) return {};
+    try {
+      const parsed = JSON.parse(step.options);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
   var previewid = "devthinktargetpreview";
   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");
@@ -39,42 +1165,46 @@
     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], details, summary")].slice(0, 80);
-    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 forms = [...document.querySelectorAll("input, textarea, select")].slice(0, 40).map((element) => ({
-      label: label(element),
+    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: 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: elementlabel(element),
       type: element.getAttribute("type") || element.tagName.toLowerCase(),
       name: element.getAttribute("name") || "",
-      ...element instanceof HTMLSelectElement ? { options: [...element.options].slice(0, 12).map((option) => bounded(option.textContent || option.value, 60)) } : {}
+      ...element instanceof HTMLSelectElement ? { options: [...element.options].map((option) => clean(option.textContent || option.value)) } : {}
     }));
-    const text = bounded(document.body?.innerText || "", 2e3);
-    return { url: location.href, title: bounded(document.title, 180), textpreview: text, textlength: document.body?.innerText.length ?? 0, forms, interactive, capturedat: Date.now() };
+    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() };
+  }
+  function readdialogs() {
+    return harvestdialoglog(document);
   }
-  function extractcontent(targetselector) {
+  function extractcontent(targetselector, root) {
     if (!targetselector) {
-      const links = [...document.querySelectorAll("a[href]")].slice(0, 25).map((element) => {
+      const links = [...root.querySelectorAll("a[href]")].map((element) => {
         const href = element instanceof HTMLAnchorElement ? element.getAttribute("href") ?? "" : "";
-        return `${bounded(element.textContent || "")} (${bounded(href, 120)})`;
+        return { text: element.textContent?.trim() ?? "", href };
       });
-      return { ok: true, summary: `Extracted ${links.length} bounded link entries: ${links.join("; ").slice(0, 180) || "no links present"}.` };
+      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." };
-    return { ok: true, summary: `Extracted: ${bounded(target.textContent || "", 180) || "empty target"}.` };
+    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." };
@@ -83,48 +1213,95 @@
     target.value = option.value;
     target.dispatchEvent(new Event("input", { bubbles: true }));
     target.dispatchEvent(new Event("change", { bubbles: true }));
-    return { ok: true, summary: `Selected ${bounded(option.textContent || option.value, 60)}.` };
+    return { ok: true, summary: `Selected ${clean(option.textContent || option.value)}.` };
   }
-  function performstep(step, expectedorigin) {
+  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"]);
+  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"]);
+  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") {
       const requested = step.value ? Number.parseInt(step.value, 10) : 250;
-      const duration = Number.isFinite(requested) && requested > 0 ? Math.min(requested, 1e4) : 0;
-      return new Promise((resolve) => window.setTimeout(() => resolve({ ok: true, summary: `Bounded wait of ${duration} milliseconds completed.` }), duration));
+      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);
       return { ok: true, summary: "Navigation request sent." };
     }
-    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 === "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 } });
+    if (step.kind === "reload") {
+      location.reload();
+      return { ok: true, summary: "Page reload requested." };
+    }
+    if (step.kind === "back") {
+      history.back();
+      return { ok: true, summary: "History back requested." };
+    }
+    if (step.kind === "forward") {
+      history.forward();
+      return { ok: true, summary: "History forward requested." };
+    }
+    if (step.kind === "scrollpage") {
+      const options = stepoptions(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." };
+    }
+    if (step.kind === "scrollend") {
+      window.scrollTo(0, document.documentElement.scrollHeight);
+      return { ok: true, summary: "Window scrolled to the page end." };
+    }
+    if (step.kind === "scrolltop") {
+      window.scrollTo(0, 0);
+      return { ok: true, summary: "Window scrolled to the page top." };
+    }
+    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 (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);
+        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