@wenathlan/extension 1.1.36 → 1.1.38

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", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab"]);
+  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", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract"]);
   var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-  var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta"]);
+  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", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance"]);
   var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
   function parseoptions(step) {
     if (step.options === void 0) return {};
@@ -2107,12 +2107,12 @@
       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 events4 = 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 } : {},
+      ...events4 ? { events: events4 } : {},
       lifetime,
       poll: typeof options.poll === "number" && Number.isFinite(options.poll) && options.poll >= 0 ? options.poll : defaultpoll
     };
@@ -2358,6 +2358,765 @@
     }
   }
 
+  // extension/pageforms.ts
+  function matchfield(fields, match) {
+    const key = match.mode === "label" ? "label" : match.mode === "placeholder" ? "placeholder" : match.mode === "arialabel" ? "arialabel" : "name";
+    const needle = (match[key] ?? "").trim().toLowerCase();
+    if (!needle) return [];
+    return fields.filter((field) => {
+      const primary = field[key].toLowerCase();
+      const secondary = match.mode === "label" || match.mode === "name" ? field.name.toLowerCase() : match.mode === "placeholder" ? field.arialabel.toLowerCase() : field.placeholder.toLowerCase();
+      return primary.includes(needle) || secondary.includes(needle);
+    });
+  }
+  function classifyfield(input) {
+    const type = input.type.toLowerCase();
+    const autocomplete = input.autocomplete.toLowerCase();
+    const label = input.label.toLowerCase();
+    if (type === "password") return "password";
+    if (autocomplete.startsWith("cc-") || label.includes("card number") || label.includes("credit card") || label.includes("cardholder")) return "card";
+    if (autocomplete.includes("one-time-code") || autocomplete.includes("otp") || label.includes("one time code") || label.includes("verification code") || label.includes("otp")) return "code";
+    if (type === "email" || autocomplete.includes("email") || label.includes("email")) return "email";
+    if (type === "tel" || autocomplete.includes("tel") || label.includes("phone") || label.includes("telephone")) return "phone";
+    if (type === "date") return "date";
+    if (type === "number") return "number";
+    if (type === "checkbox") return "check";
+    if (type === "radio") return "radio";
+    if (type === "file") return "file";
+    if (type === "select" || type === "select-one") return "select";
+    return "text";
+  }
+  var firstnames = { en: ["alex", "jordan", "taylor", "morgan", "casey"], pt: ["ana", "bruno", "carla", "diego", "helena"] };
+  var lastnames = { en: ["brooks", "carter", "diaz", "evans", "reyes"], pt: ["alves", "costa", "lima", "souza", "moraes"] };
+  function localekey(locale) {
+    const normalized = locale.toLowerCase();
+    if (normalized.startsWith("pt")) return "pt";
+    return "en";
+  }
+  function generatevalue(kind, rule) {
+    const seed = typeof rule.seed === "number" && Number.isFinite(rule.seed) ? Math.abs(Math.floor(rule.seed)) : 1;
+    const names = firstnames[localekey(rule.locale ?? "en")] ?? firstnames.en ?? ["alex"];
+    const surnames = lastnames[localekey(rule.locale ?? "en")] ?? lastnames.en ?? ["brooks"];
+    let state = seed * 1103515245 + 12345;
+    const next = () => {
+      state = (state * 1103515245 + 12345) % 2147483648;
+      return state / 2147483648;
+    };
+    const pick = (items) => items[Math.floor(next() * items.length) % items.length] ?? items[0];
+    const digits = (count) => Array.from({ length: count }, () => String(Math.floor(next() * 10))).join("");
+    const person = `${pick(names)} ${pick(surnames)}`;
+    switch (kind) {
+      case "email":
+        return `${person.replace(" ", ".")}${digits(2)}@example.com`;
+      case "phone":
+        return localekey(rule.locale ?? "en") === "pt" ? `+55 (11) 9${digits(4)}-${digits(4)}` : `+1 (555) 010-${digits(4)}`;
+      case "date":
+        return `${2024 + Math.floor(next() * 2)}-${String(1 + Math.floor(next() * 12)).padStart(2, "0")}-${String(1 + Math.floor(next() * 28)).padStart(2, "0")}`;
+      case "number":
+        return String(Math.floor(next() * 1e3));
+      case "select":
+        return `option ${1 + Math.floor(next() * 5)}`;
+      case "check":
+        return next() > 0.5 ? "true" : "false";
+      case "radio":
+        return `choice ${1 + Math.floor(next() * 4)}`;
+      case "file":
+        return `sample${digits(2)}.pdf`;
+      case "password":
+        return `pw-${digits(6)}-${pick(names)}`;
+      case "card":
+        return `4111 ${digits(4)} ${digits(4)} ${digits(4)}`;
+      case "code":
+        return digits(6);
+      default:
+        return person;
+    }
+  }
+  function parseformrecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const record = value;
+    if (!Array.isArray(record.entries)) return null;
+    const entries = [];
+    for (const item of record.entries) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+      const entry = item;
+      const match = entry.match;
+      if (!match || typeof match !== "object" || Array.isArray(match)) continue;
+      const shapes = match;
+      if (typeof shapes.mode !== "string") continue;
+      const fieldmatch = {
+        mode: shapes.mode,
+        ...typeof shapes.label === "string" ? { label: shapes.label } : {},
+        ...typeof shapes.placeholder === "string" ? { placeholder: shapes.placeholder } : {},
+        ...typeof shapes.arialabel === "string" ? { arialabel: shapes.arialabel } : {},
+        ...typeof shapes.name === "string" ? { name: shapes.name } : {}
+      };
+      if (typeof entry.kind !== "string" || typeof entry.value !== "string") continue;
+      entries.push({ match: fieldmatch, kind: entry.kind, value: entry.value });
+    }
+    if (entries.length === 0) return null;
+    return { ...typeof record.form === "string" && record.form ? { form: record.form } : {}, entries };
+  }
+  function pairentries(pairs, mode) {
+    return { entries: pairs.map((pair) => ({ match: mode === "label" ? { mode, label: pair.label ?? "" } : { mode, placeholder: pair.placeholder ?? "" }, kind: "text", value: pair.value })) };
+  }
+  function filloperations(record, fields, skippedselectors = []) {
+    return record.entries.map((entry) => {
+      const matches = matchfield(fields, entry.match);
+      if (matches.length === 0) return { entry, reason: "unmatched" };
+      if (matches.length > 1) return { entry, reason: "ambiguous" };
+      const matched = matches[0];
+      if (skippedselectors.includes(matched.selector)) return { entry, matched, skipped: true };
+      return { entry, matched };
+    });
+  }
+  function cardmask(value) {
+    const trimmed = value.trim();
+    if (/^\d[\d\s-]{11,18}$/.test(trimmed)) {
+      const compact = trimmed.replace(/[\s-]/g, "");
+      const last = compact.slice(-4);
+      return `${"\u2022".repeat(Math.max(0, compact.length - 4))}${last}`;
+    }
+    return "\u2022".repeat(trimmed.length);
+  }
+  function detecthoneypots(surveys, loadedat) {
+    const traps = [];
+    for (const field of surveys) {
+      if (field.hidden) traps.push({ selector: field.selector, reason: "hidden" });
+      else if (field.offscreen) traps.push({ selector: field.selector, reason: "offscreen" });
+      else if (field.createdat !== void 0 && loadedat > 0 && field.createdat > loadedat) traps.push({ selector: field.selector, reason: "timetrap" });
+    }
+    return traps;
+  }
+  function detectlogin(fields, links) {
+    const markers = [];
+    const password = fields.find((field) => classifyfield(field) === "password");
+    if (password) markers.push("password field");
+    const identifier = fields.find((field) => {
+      const kind = classifyfield(field);
+      return kind === "email" || kind === "text" && /user|login|account|identifier/i.test(`${field.name} ${field.label}`);
+    });
+    if (identifier) markers.push("identifier field");
+    const sessionlink = links.some((link) => /sign in|log in|log on|forgot|create account|sign up/i.test(link));
+    if (sessionlink) markers.push("session link");
+    return { login: Boolean(password && identifier && sessionlink), markers };
+  }
+  var signupmarkers = ["sign up", "create account", "register", "confirm password", "terms"];
+  var checkoutmarkers = ["checkout", "payment", "billing", "shipping", "card number", "place order", "cart"];
+  function detecttemplate(fields, text) {
+    const corpus = [text, ...fields.map((field) => `${field.label} ${field.name} ${field.placeholder} ${field.arialabel} ${field.autocomplete}`)].join(" ").toLowerCase();
+    const signup = signupmarkers.filter((marker) => corpus.includes(marker));
+    const checkout = checkoutmarkers.filter((marker) => corpus.includes(marker));
+    if (signup.length >= 2 && signup.length >= checkout.length) return { template: "signup", markers: signup };
+    if (checkout.length >= 2) return { template: "checkout", markers: checkout };
+    return { template: "unknown", markers: [...signup, ...checkout] };
+  }
+  function associateerrors(contexts, messages) {
+    const errors = [];
+    for (const field of contexts) {
+      const byref = field.describedby ? messages.find((message) => message.id === field.describedby && message.text.trim()) : void 0;
+      if (byref) {
+        errors.push({ field: field.selector, message: byref.text.trim() });
+        continue;
+      }
+      const sibling = field.siblings.map((text) => text.trim()).find((text) => text.length > 0);
+      if (sibling) errors.push({ field: field.selector, message: sibling });
+    }
+    return errors;
+  }
+  var captchamarkers = ['iframe[src*="recaptcha"]', 'iframe[title*="recaptcha" i]', ".g-recaptcha", "[data-sitekey]", 'iframe[title*="captcha" i]', ".h-captcha"];
+  function captchadetected(matched) {
+    return matched.length > 0;
+  }
+  function events3(target) {
+    target.dispatchEvent(new Event("input", { bubbles: true }));
+    target.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+  function fillcontrol(element, entry) {
+    if (element instanceof HTMLInputElement && (entry.kind === "check" || element.type === "checkbox")) {
+      element.checked = entry.value === "true" || entry.value === "on" || entry.value === "checked";
+      events3(element);
+      return true;
+    }
+    if (element instanceof HTMLInputElement && (entry.kind === "radio" || element.type === "radio")) {
+      element.checked = true;
+      events3(element);
+      return true;
+    }
+    if (element instanceof HTMLSelectElement) {
+      const option = [...element.options].find((candidate) => candidate.value === entry.value || candidate.textContent?.trim() === entry.value);
+      if (!option) return false;
+      element.value = option.value;
+      events3(element);
+      return true;
+    }
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      if (element instanceof HTMLInputElement && element.type === "file") return false;
+      element.focus();
+      const setter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(element), "value")?.set;
+      if (setter) setter.call(element, entry.value);
+      else element.value = entry.value;
+      events3(element);
+      return true;
+    }
+    return false;
+  }
+  function controlshape(element) {
+    return {
+      selector: elementselector(element),
+      tag: element.tagName.toLowerCase(),
+      type: element instanceof HTMLSelectElement ? "select" : element.getAttribute("type") || "text",
+      name: element.getAttribute("name") || "",
+      label: elementlabel(element),
+      placeholder: element.getAttribute("placeholder") || "",
+      arialabel: element.getAttribute("aria-label") || "",
+      autocomplete: element.getAttribute("autocomplete") || "",
+      ...element instanceof HTMLSelectElement ? { options: [...element.options].map((option) => option.value) } : {}
+    };
+  }
+  function collectfields(root, formscope) {
+    const scope = formscope ? root.querySelector(formscope) : root;
+    if (!scope) return [];
+    const controls = [...scope.querySelectorAll("input, select, textarea")];
+    return controls.filter((element) => element.type !== "hidden").map((element) => ({ shape: controlshape(element), element }));
+  }
+  function surveyfields(root, formscope) {
+    const viewport = { left: 0, top: 0, right: window.innerWidth || 0, bottom: window.innerHeight || 0 };
+    return collectfields(root, formscope).map(({ shape, element }) => {
+      const rect = element.getBoundingClientRect();
+      const hidden = element.getAttribute("aria-hidden") === "true" || element.tabIndex < 0 && element.offsetParent === null || element.offsetParent === null && rect.width === 0 && rect.height === 0;
+      const offscreen = rect.width > 0 && rect.height > 0 && (rect.bottom < viewport.top || rect.top > viewport.bottom || rect.right < viewport.left || rect.left > viewport.right);
+      return { survey: { ...shape, hidden, offscreen }, element };
+    });
+  }
+  function collecterrorcontext(root, formscope) {
+    return collectfields(root, formscope).map(({ shape, element }) => {
+      const siblings = [];
+      let neighbor = element.nextElementSibling;
+      for (let index = 0; neighbor && index < 3; index += 1) {
+        const text = clean(neighbor.textContent || "");
+        if (text && text !== shape.label) siblings.push(text);
+        neighbor = neighbor.nextElementSibling;
+      }
+      const describedby = element.getAttribute("aria-describedby");
+      return { context: { ...shape, ...describedby ? { describedby } : {}, siblings }, element };
+    });
+  }
+  function runpageform(step, target, root = document) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    const formscope = typeof options.form === "string" && options.form ? options.form : step.target;
+    switch (step.kind) {
+      case "fillform": {
+        const record = parseformrecord(options.formrecord);
+        if (!record) return { ok: false, summary: "A reviewed form record with entries is required in options." };
+        const surveys = surveyfields(root, record.form);
+        const honeypots = detecthoneypots(surveys.map((entry) => entry.survey), 0);
+        const operations = filloperations(record, surveys.map((entry) => entry.survey), honeypots.map((trap) => trap.selector));
+        let filled = 0;
+        const skipped = [];
+        const failures = [];
+        const values = [];
+        for (const operation of operations) {
+          if (operation.skipped && operation.matched) {
+            skipped.push(operation.matched.selector);
+            continue;
+          }
+          if (!operation.matched) {
+            failures.push(`${operation.reason}: ${operation.entry.match.label ?? operation.entry.match.name ?? operation.entry.match.placeholder ?? "field"}`);
+            continue;
+          }
+          const element = surveys.find((entry) => entry.survey.selector === operation.matched?.selector)?.element;
+          if (!element || !fillcontrol(element, operation.entry)) {
+            failures.push(`unfillable: ${operation.matched.selector}`);
+            continue;
+          }
+          filled += 1;
+          values.push({ label: operation.matched.label || operation.matched.name, value: operation.entry.kind === "password" ? "" : operation.entry.value });
+        }
+        const report = { form: record.form ?? "", fields: operations.map((operation) => ({ selector: operation.matched?.selector ?? "", label: operation.matched?.label ?? operation.entry.match.label ?? "", kind: operation.entry.kind, matched: Boolean(operation.matched) })) };
+        return {
+          ok: failures.length === 0,
+          summary: failures.length === 0 ? `Filled ${filled} reviewed field${filled === 1 ? "" : "s"} from the structured record${skipped.length > 0 ? ` and skipped ${skipped.length} honeypot field${skipped.length === 1 ? "" : "s"}` : ""}.` : `Filled ${filled} of ${record.entries.length} reviewed fields; ${failures.length} refusals: ${failures.join("; ")}.`,
+          details: { filled, skipped, failures, values, report }
+        };
+      }
+      case "filllabel":
+      case "fillplaceholder": {
+        const mode = step.kind === "filllabel" ? "label" : "placeholder";
+        const pairs = Array.isArray(options.fields) ? options.fields.filter((item) => item && typeof item === "object") : [];
+        const record = pairentries(pairs.map((pair) => ({ label: typeof pair.label === "string" ? pair.label : "", placeholder: typeof pair.placeholder === "string" ? pair.placeholder : "", value: typeof pair.value === "string" ? pair.value : "" })), mode);
+        if (record.entries.length === 0) return { ok: false, summary: "A reviewed non-empty list of field pairs is required in options." };
+        const surveys = surveyfields(root, formscope);
+        const honeypots = detecthoneypots(surveys.map((entry) => entry.survey), 0);
+        const operations = filloperations(record, surveys.map((entry) => entry.survey), honeypots.map((trap) => trap.selector));
+        let filled = 0;
+        const failures = [];
+        for (const operation of operations) {
+          if (operation.skipped) continue;
+          if (!operation.matched) {
+            failures.push(`${operation.reason}: ${mode === "label" ? operation.entry.match.label : operation.entry.match.placeholder}`);
+            continue;
+          }
+          const element = surveys.find((entry) => entry.survey.selector === operation.matched?.selector)?.element;
+          const refined = { ...operation.entry, kind: classifyfield(operation.matched) };
+          if (!element || !fillcontrol(element, refined)) {
+            failures.push(`unfillable: ${operation.matched.selector}`);
+            continue;
+          }
+          filled += 1;
+        }
+        return { ok: failures.length === 0, summary: failures.length === 0 ? `Filled ${filled} field${filled === 1 ? "" : "s"} matched by ${mode}.` : `Filled ${filled} of ${record.entries.length} fields matched by ${mode}; ${failures.join("; ")}.`, details: { filled, failures, mode } };
+      }
+      case "detectfields": {
+        const collected = collectfields(root, formscope);
+        const report = { form: formscope ?? "", fields: collected.map((entry) => ({ selector: entry.shape.selector, label: entry.shape.label || entry.shape.name, kind: classifyfield(entry.shape), matched: Boolean(entry.shape.label || entry.shape.name) })) };
+        return { ok: true, summary: `Detected ${collected.length} form field${collected.length === 1 ? "" : "s"} with their kinds.`, details: { report, count: collected.length } };
+      }
+      case "generatevalues": {
+        const rule = options.valuegen && typeof options.valuegen === "object" && !Array.isArray(options.valuegen) ? options.valuegen : {};
+        const locale = typeof rule.locale === "string" ? rule.locale : "en";
+        const seed = typeof rule.seed === "number" && Number.isFinite(rule.seed) ? rule.seed : 1;
+        const surveys = surveyfields(root, formscope);
+        const honeypots = detecthoneypots(surveys.map((entry) => entry.survey), 0);
+        const skippedselectors = new Set(honeypots.map((trap) => trap.selector));
+        const candidates = surveys.filter((entry) => !skippedselectors.has(entry.survey.selector));
+        const values = candidates.map((entry) => ({ label: entry.survey.label || entry.survey.name || entry.survey.selector, kind: classifyfield(entry.survey), value: generatevalue(classifyfield(entry.survey), { locale, seed }) }));
+        const single = values.length === 0 && typeof rule.kind === "string" ? [{ label: rule.kind, kind: rule.kind, value: generatevalue(rule.kind, { locale, seed }) }] : values;
+        return { ok: true, summary: `Generated ${single.length} realistic value${single.length === 1 ? "" : "s"} for the detected field kinds.`, details: { values: single, locale, seed } };
+      }
+      case "readerrors": {
+        const contexts = collecterrorcontext(root, formscope);
+        const messages = [...root.querySelectorAll("[id]")].map((element) => ({ id: element.id, text: clean(element.textContent || "") })).filter((message) => message.text.length > 0);
+        const errors = associateerrors(contexts.map((entry) => entry.context), messages);
+        return { ok: true, summary: errors.length === 0 ? "No validation error was found next to the reviewed fields." : `Collected ${errors.length} inline validation message${errors.length === 1 ? "" : "s"}.`, details: { errors, form: formscope ?? "" } };
+      }
+      case "skiphoneypot": {
+        const surveys = surveyfields(root, formscope);
+        const traps = detecthoneypots(surveys.map((entry) => entry.survey), 0);
+        return { ok: true, summary: traps.length === 0 ? "No honeypot field was detected." : `Skipped ${traps.length} honeypot field${traps.length === 1 ? "" : "s"}: ${traps.map((trap) => `${trap.selector} (${trap.reason})`).join(", ")}.`, details: { skipped: traps } };
+      }
+      case "detectlogin": {
+        const collected = collectfields(root, formscope);
+        const links = [...formscope ? root.querySelectorAll(formscope) : [root]].flatMap((scope) => [...scope.querySelectorAll("a[href], button")]).map((element) => clean(element.textContent || ""));
+        const detection = detectlogin(collected.map((entry) => entry.shape), links);
+        return { ok: true, summary: detection.login ? `Login form detected with ${detection.markers.join(", ")}.` : "No login form was detected.", details: { login: detection.login, markers: detection.markers } };
+      }
+      case "detecttemplate": {
+        const collected = collectfields(root, formscope);
+        const text = clean(root.body?.innerText || "");
+        const detection = detecttemplate(collected.map((entry) => entry.shape), text);
+        return { ok: true, summary: detection.template === "unknown" ? "No signup or checkout template was detected." : `${detection.template} template detected with markers ${detection.markers.join(", ")}.`, details: { template: detection.template, markers: detection.markers } };
+      }
+      case "handoffcaptcha": {
+        const matched = captchamarkers.filter((marker) => root.querySelector(marker) !== null);
+        return { ok: true, summary: captchadetected(matched) ? `Captcha presence detected (${matched.join(", ")}); control hands back to the user.` : "No captcha was detected.", details: { captcha: captchadetected(matched), markers: matched } };
+      }
+      case "asksubmit": {
+        const collected = collectfields(root, step.value || void 0);
+        const values = collected.map((entry) => ({ label: entry.shape.label || entry.shape.name || entry.shape.selector, value: entry.element instanceof HTMLSelectElement ? entry.element.value : entry.element.value }));
+        return { ok: true, summary: `Read ${values.length} field value${values.length === 1 ? "" : "s"} for the submission review.`, details: { values } };
+      }
+      case "submitform": {
+        const form = target instanceof HTMLFormElement ? target : target instanceof HTMLElement ? target.closest("form") : null;
+        if (!form) return { ok: false, summary: "No owning form was found for the reviewed submission." };
+        form.requestSubmit();
+        return { ok: true, summary: "Form submitted programmatically through its owning form." };
+      }
+      case "consentpassword": {
+        if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) return { ok: false, summary: "The reviewed password target cannot receive text." };
+        const entry = { match: { mode: "name", name: target.name || target.getAttribute("id") || "" }, kind: "password", value: step.value ?? "" };
+        if (!fillcontrol(target, entry)) return { ok: false, summary: "The password field refused the native setter fill." };
+        return { ok: true, summary: "Password field filled after the reviewed consent; the value never appears in the audit trail." };
+      }
+      case "attachfile": {
+        if (!(target instanceof HTMLInputElement) || target.type !== "file") return { ok: false, summary: "The reviewed target is not a file input." };
+        const artifactname = typeof options.artifactname === "string" && options.artifactname ? options.artifactname : "artifact";
+        try {
+          const file = new File([new Blob(["devthink artifact"], { type: "application/octet-stream" })], artifactname);
+          const transfer = new DataTransfer();
+          transfer.items.add(file);
+          target.files = transfer.files;
+          events3(target);
+          return { ok: true, summary: `Artifact ${artifactname} attached to the reviewed file input.`, details: { artifact: options.artifact, artifactname } };
+        } catch {
+          return { ok: false, summary: "The reviewed file input refused the artifact attachment." };
+        }
+      }
+      default:
+        return { ok: false, summary: "Unsupported forms and data action." };
+    }
+  }
+
+  // extension/pagewizards.ts
+  function wizardadvance(state, completed, at) {
+    const flags = [...state.completed];
+    while (flags.length < state.index + 1) flags.push(false);
+    flags[state.index] = completed;
+    return { ...state, index: Math.min(state.index + 1, state.steps), completed: flags, at };
+  }
+  function dependentloaded(previouscount, currentcount) {
+    return currentcount !== previouscount;
+  }
+  function typeaheadpick(suggestions, pick) {
+    const needle = pick.trim().toLowerCase();
+    return suggestions.find((suggestion) => suggestion.trim().toLowerCase() === needle);
+  }
+  function parsedateparts(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+    const parts = value.split("-").map((part) => Number.parseInt(part, 10));
+    const year = parts[0] ?? 0;
+    const month = parts[1] ?? 0;
+    const day = parts[2] ?? 0;
+    if (month < 1 || month > 12 || day < 1 || day > 31) return null;
+    return { year, month, day };
+  }
+  function calendarplan(view, date) {
+    return { months: (date.year - view.year) * 12 + (date.month - view.month), day: date.day };
+  }
+  function cardgroups(number) {
+    const groups = number.replace(/[-\s]+/g, " ").trim().split(" ");
+    return groups.filter((group) => group.length > 0);
+  }
+  function codeready(source, value) {
+    if (source === "reviewed") return typeof value === "string" && value.trim().length > 0;
+    return false;
+  }
+  function wait4(delay) {
+    return new Promise((resolve) => window.setTimeout(resolve, delay));
+  }
+  function pollfor2(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 runpagewizard(step, target, root = document) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    switch (step.kind) {
+      case "runwizard": {
+        const scope = target instanceof HTMLElement ? target : root.body ?? root.documentElement;
+        const steps = typeof options.steps === "number" && Number.isInteger(options.steps) && options.steps > 0 ? options.steps : 1;
+        const state = { index: 0, steps, completed: [], at: Date.now() };
+        const next = scope.querySelector("button[type=submit], button[name=next], [data-next]");
+        if (!next) return { ok: false, summary: "No next step control was found inside the wizard scope.", details: { wizard: state } };
+        next.click();
+        const advanced = wizardadvance(state, true, Date.now());
+        return { ok: advanced.index >= steps, summary: `Wizard advanced to step ${advanced.index + 1} of ${steps}${advanced.index >= steps ? " and completed" : ""}.`, details: { wizard: advanced } };
+      }
+      case "selectchain": {
+        if (!(target instanceof HTMLSelectElement)) return { ok: false, summary: "The reviewed parent target is not a select element." };
+        const childselector = typeof options.child === "string" ? options.child : "";
+        const child = root.querySelector(childselector);
+        if (!child) return { ok: false, summary: "The reviewed dependent child control was not found." };
+        const previouscount = child.options.length;
+        const option = [...target.options].find((candidate) => candidate.value === step.value || candidate.textContent?.trim() === step.value);
+        if (!option) return { ok: false, summary: "The reviewed parent option is not part of the select element." };
+        target.value = option.value;
+        target.dispatchEvent(new Event("input", { bubbles: true }));
+        target.dispatchEvent(new Event("change", { bubbles: true }));
+        const waitwindow = typeof options.wait === "number" && options.wait > 0 ? options.wait : 0;
+        return pollfor2(() => dependentloaded(previouscount, child.options.length), "Dependent options of the child control", waitwindow);
+      }
+      case "picktypeahead": {
+        const field = target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement ? target : null;
+        if (!field) return { ok: false, summary: "The reviewed typeahead target cannot receive text." };
+        const pick = typeof options.pick === "string" ? options.pick : "";
+        const timeout = typeof options.timeout === "number" && options.timeout > 0 ? options.timeout : 0;
+        field.focus();
+        field.value = step.value ?? "";
+        field.dispatchEvent(new Event("input", { bubbles: true }));
+        const list = root.querySelector("[role=listbox], .suggestions, ul.autocomplete, [data-typeahead]");
+        const suggestions = list ? [...list.querySelectorAll("[role=option], li, .suggestion")].map((entry2) => clean(entry2.textContent || "")) : [];
+        const chosen = typeaheadpick(suggestions, pick);
+        if (chosen === void 0) return { ok: false, summary: `The reviewed suggestion "${pick}" is not part of the typeahead list.`, details: { suggestions } };
+        const entry = [...list?.querySelectorAll("[role=option], li, .suggestion") ?? []].find((item) => clean(item.textContent || "").trim().toLowerCase() === chosen.trim().toLowerCase());
+        entry?.click();
+        field.dispatchEvent(new Event("change", { bubbles: true }));
+        return { ok: Boolean(entry), summary: `Picked the reviewed typeahead entry "${chosen}".`, details: { pick: chosen, query: step.value ?? "" } };
+      }
+      case "pickdate": {
+        const calendar = target instanceof HTMLElement ? target : root.body ?? root.documentElement;
+        const date = parsedateparts(step.value ?? "");
+        if (!date) return { ok: false, summary: "The reviewed date must use the yyyy-mm-dd form." };
+        const header = clean(calendar.querySelector("[data-calendar-title], .calendar-title, header")?.textContent || "");
+        const match = /(\d{4})/.exec(header);
+        const monthnames = ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
+        const viewyear = match ? Number.parseInt(match[1] ?? "0", 10) : (/* @__PURE__ */ new Date()).getFullYear();
+        const viewmonth = monthnames.findIndex((name) => header.toLowerCase().includes(name)) >= 0 ? monthnames.findIndex((name) => header.toLowerCase().includes(name)) : (/* @__PURE__ */ new Date()).getMonth() + 1;
+        const plan = calendarplan({ year: viewyear, month: viewmonth }, date);
+        const forward = plan.months >= 0;
+        for (let index = 0; index < Math.abs(plan.months); index += 1) {
+          calendar.querySelector(forward ? "[data-next-month], .next-month, [aria-label=next]" : "[data-prev-month], .prev-month, [aria-label=previous]")?.click();
+        }
+        const day = [...calendar.querySelectorAll("[role=gridcell], [data-day], td")].find((cell) => Number.parseInt(clean(cell.textContent || ""), 10) === plan.day);
+        if (!day) return { ok: false, summary: `The reviewed day cell ${plan.day} was not found in the calendar widget.` };
+        day.click();
+        return { ok: true, summary: `Picked ${step.value} from the calendar widget after ${Math.abs(plan.months)} month navigation${Math.abs(plan.months) === 1 ? "" : "s"}.`, details: { months: plan.months, day: plan.day } };
+      }
+      case "fillcard": {
+        const segments = Array.isArray(options.segments) ? options.segments.filter((item) => item && typeof item === "object") : [];
+        if (segments.length === 0) return { ok: false, summary: "A reviewed non-empty list of card segments is required in options." };
+        const pause = typeof options.pause === "number" && options.pause > 0 ? options.pause : 0;
+        const filled = [];
+        const failures = [];
+        const fillsegment = async (segment) => {
+          const match = segment.match;
+          const value = typeof segment.value === "string" ? segment.value : "";
+          if (!match || typeof match !== "object") {
+            failures.push("segment without a reviewed match");
+            return;
+          }
+          const scope = root.body ?? root.documentElement;
+          const candidates = [...scope.querySelectorAll("input, select")];
+          const key = match.mode === "label" ? "label" : match.mode === "placeholder" ? "placeholder" : match.mode === "arialabel" ? "arialabel" : "name";
+          const needle = String(match[key] ?? "").toLowerCase();
+          const element = candidates.find((input) => (key === "label" ? input.name.toLowerCase() || input.getAttribute("aria-label")?.toLowerCase() || "" : (input.getAttribute(key) ?? input.name).toLowerCase()).includes(needle) || (input.getAttribute("aria-label") ?? "").toLowerCase().includes(needle));
+          if (!element) {
+            failures.push(`unmatched: ${needle}`);
+            return;
+          }
+          element.focus();
+          for (const group of cardgroups(value)) {
+            element.value = group;
+            element.dispatchEvent(new Event("input", { bubbles: true }));
+            if (pause > 0) await wait4(pause);
+          }
+          element.dispatchEvent(new Event("change", { bubbles: true }));
+          filled.push({ label: String(match[key] ?? ""), masked: cardmask(value) });
+        };
+        return (async () => {
+          for (const segment of segments) await fillsegment(segment);
+          return {
+            ok: failures.length === 0,
+            summary: failures.length === 0 ? `Filled ${filled.length} card segment${filled.length === 1 ? "" : "s"} with pauses between card number groups.` : `Filled ${filled.length} of ${segments.length} card segments; ${failures.join("; ")}.`,
+            details: { segments: filled, failures, pause }
+          };
+        })();
+      }
+      case "fillcode": {
+        const field = target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement ? target : null;
+        if (!field) return { ok: false, summary: "The reviewed one time code target cannot receive text." };
+        const source = typeof options.source === "string" ? options.source : "";
+        const timeout = typeof options.timeout === "number" && options.timeout > 0 ? options.timeout : 0;
+        const code = step.value ?? "";
+        return pollfor2(() => codeready(source, code), "The reviewed one time code source", timeout).then((result) => {
+          if (!codeready(source, code)) return { ok: false, summary: `The reviewed code source ${source} is not ready to deliver the code yet.` };
+          field.focus();
+          field.value = code;
+          field.dispatchEvent(new Event("input", { bubbles: true }));
+          field.dispatchEvent(new Event("change", { bubbles: true }));
+          return { ok: true, summary: `One time code typed from the reviewed source ${source}.`, details: { source } };
+        });
+      }
+      default:
+        return { ok: false, summary: "Unsupported wizard action." };
+    }
+  }
+
+  // extension/pagedata.ts
+  function normalizeheader(label) {
+    const slug = label.trim().toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+    return slug || "column";
+  }
+  function columnspecof(label, used = /* @__PURE__ */ new Set()) {
+    const base = normalizeheader(label);
+    let key = base;
+    let suffix = 2;
+    while (used.has(key)) {
+      key = `${base}${suffix}`;
+      suffix += 1;
+    }
+    used.add(key);
+    return { key, label: label.trim(), kind: "text", normalized: label.trim().toLowerCase() };
+  }
+  function classifycolumn(values) {
+    const present = values.filter((value) => value.trim().length > 0);
+    if (present.length === 0) return "text";
+    return present.every((value) => Number.isFinite(Number(value.replace(/,/g, ".")))) ? "number" : "text";
+  }
+  function expandspans(rows) {
+    const filled = [];
+    const pending = /* @__PURE__ */ new Map();
+    for (let index = 0; index < rows.length; index += 1) {
+      const row = filled[index] ?? (filled[index] = []);
+      let column = 0;
+      for (const cell of rows[index].cells) {
+        while (row[column] !== void 0 || pending.has(`${index},${column}`)) {
+          if (row[column] === void 0) row[column] = pending.get(`${index},${column}`);
+          column += 1;
+        }
+        row[column] = cell.text;
+        for (let spanrow = 0; spanrow < Math.max(1, cell.rowspan); spanrow += 1) {
+          for (let spancol = 0; spancol < Math.max(1, cell.colspan); spancol += 1) {
+            if (spanrow === 0 && spancol === 0) continue;
+            pending.set(`${index + spanrow},${column + spancol}`, cell.text);
+          }
+        }
+        column += Math.max(1, cell.colspan);
+      }
+    }
+    for (const [key, value] of pending) {
+      const [rowpart, columnpart] = key.split(",");
+      const rowindex = Number.parseInt(rowpart ?? "0", 10);
+      const columnindex = Number.parseInt(columnpart ?? "0", 10);
+      const target = filled[rowindex] ?? (filled[rowindex] = []);
+      if (target[columnindex] === void 0) target[columnindex] = value;
+    }
+    const width = filled.reduce((largest, row) => Math.max(largest, row.length), 0);
+    return filled.map((row) => Array.from({ length: width }, (_, column) => row[column] ?? ""));
+  }
+  function readgrid(rows) {
+    const headerindex = rows.findIndex((row) => row.header || (row.cells[0]?.header ?? false));
+    const useheader = headerindex !== -1 ? headerindex : 0;
+    const hasheader = headerindex !== -1 || rows.length > 0;
+    const grid = expandspans(rows);
+    const headercells = hasheader ? grid[useheader] ?? [] : [];
+    const used = /* @__PURE__ */ new Set();
+    const columns = Array.from({ length: headercells.length || (grid[0]?.length ?? 0) }, (_, index) => columnspecof(headercells[index] ?? `column${index + 1}`, used));
+    const bodyrows = grid.filter((_, index) => hasheader ? index !== useheader : true).filter((line) => line.some((value) => value.trim().length > 0)).map((line) => {
+      const row = {};
+      columns.forEach((column, index) => {
+        row[column.key] = line[index] ?? "";
+      });
+      return row;
+    });
+    for (const column of columns) column.kind = classifycolumn(bodyrows.map((row) => row[column.key] ?? ""));
+    const children = [];
+    rows.forEach((row, rowindex) => {
+      if (hasheader && rowindex === useheader) return;
+      const parentrow = hasheader && rowindex > useheader ? rowindex - 1 : rowindex;
+      row.cells.forEach((cell) => {
+        if (!cell.nested) return;
+        const child = readgrid(cell.nested.rows);
+        children.push({ parentrow, selector: cell.nested.selector, columns: child.columns, rows: child.rows });
+      });
+    });
+    return { columns, rows: bodyrows, children };
+  }
+  function rowsfresh(previous, current) {
+    if (current.length === 0) return false;
+    const known = new Set(previous.map((row) => JSON.stringify(row)));
+    return current.some((row) => !known.has(JSON.stringify(row)));
+  }
+  function mergedatasets(datasets) {
+    const columns = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dataset of datasets) {
+      for (const column of dataset.columns) {
+        if (seen.has(column.key)) continue;
+        seen.add(column.key);
+        columns.push(column);
+      }
+    }
+    const rows = datasets.flatMap((dataset) => dataset.rows.map((row) => {
+      const merged = {};
+      for (const column of columns) merged[column.key] = row[column.key] ?? "";
+      return merged;
+    }));
+    return { columns, rows };
+  }
+  function collectrowshapes(table) {
+    return [...table.rows].map((row) => ({
+      header: [...row.cells].every((cell) => cell.tagName === "TH") && row.cells.length > 0,
+      cells: [...row.cells].map((cell) => {
+        const nested = cell.querySelector("table");
+        return {
+          text: clean(nested ? `${nested.rows.length} rows` : cell.textContent ?? ""),
+          header: cell.tagName === "TH",
+          rowspan: cell.rowSpan,
+          colspan: cell.colSpan,
+          ...nested instanceof HTMLTableElement ? { nested: { selector: elementselector(nested), rows: collectrowshapes(nested) } } : {}
+        };
+      })
+    }));
+  }
+  function readtable(target, root, fallbackselector) {
+    const table = target instanceof HTMLTableElement ? target : fallbackselector ? root.querySelector(fallbackselector) : root.querySelector("table");
+    if (!table) return null;
+    return readgrid(collectrowshapes(table));
+  }
+  async function runpagedata(step, target, root = document) {
+    let options = {};
+    try {
+      options = parseoptions(step);
+    } catch {
+      options = {};
+    }
+    if (step.kind === "scrapetable") {
+      const grid = readtable(target, root, step.target);
+      if (!grid) return { ok: false, summary: "The reviewed table selector matches no table element." };
+      const rowlimit = typeof options.rowlimit === "number" && Number.isInteger(options.rowlimit) && options.rowlimit > 0 ? options.rowlimit : grid.rows.length;
+      const limited = grid.rows.slice(0, rowlimit);
+      return {
+        ok: true,
+        summary: `Scraped ${limited.length} row${limited.length === 1 ? "" : "s"} into ${grid.columns.length} normalized column${grid.columns.length === 1 ? "" : "s"}${grid.children.length > 0 ? ` with ${grid.children.length} nested child table${grid.children.length === 1 ? "" : "s"}` : ""}.`,
+        details: { grid: { columns: grid.columns, rows: limited, children: grid.children }, rows: limited.length, columns: grid.columns.length }
+      };
+    }
+    if (step.kind === "paginateextract") {
+      const nextselector = typeof options.next === "string" ? options.next : "";
+      const pages = typeof options.pages === "number" && Number.isInteger(options.pages) && options.pages > 0 ? options.pages : 1;
+      const wait5 = typeof options.wait === "number" && Number.isFinite(options.wait) && options.wait > 0 ? options.wait : 0;
+      const cursor = typeof options.cursor === "number" && Number.isInteger(options.cursor) && options.cursor > 0 ? options.cursor : 0;
+      const grids = [];
+      let previous = [];
+      for (let page = 0; page < pages + cursor; page += 1) {
+        if (page < cursor) {
+          const control = root.querySelector(nextselector);
+          if (!control) break;
+          control.click();
+          await new Promise((resolve) => window.setTimeout(resolve, 0));
+          continue;
+        }
+        if (page > cursor) {
+          const control = root.querySelector(nextselector);
+          if (!control) break;
+          control.click();
+          const deadline = Date.now() + wait5;
+          let fresh = false;
+          while (!fresh && Date.now() < deadline) {
+            await new Promise((resolve) => window.setTimeout(resolve, Math.min(100, Math.max(16, deadline - Date.now()))));
+            const probe = readtable(target, root, step.target);
+            fresh = probe !== null && rowsfresh(previous, probe.rows);
+          }
+        }
+        const grid = readtable(target, root, step.target);
+        if (!grid) return { ok: false, summary: "The reviewed table selector matches no table element." };
+        grids.push(grid);
+        previous = grid.rows;
+      }
+      const merged = mergedatasets(grids);
+      const hasnext = Boolean(root.querySelector(nextselector));
+      return {
+        ok: grids.length > 0,
+        summary: grids.length > 0 ? `Followed ${grids.length} page${grids.length === 1 ? "" : "s"} of the reviewed table into ${merged.rows.length} row${merged.rows.length === 1 ? "" : "s"}${hasnext ? "; a next control remains" : ""}.` : "No page of the reviewed table was extracted.",
+        details: { grid: { columns: merged.columns, rows: merged.rows, children: grids.flatMap((grid) => grid.children) }, pages: grids.length, rows: merged.rows.length, next: hasnext }
+      };
+    }
+    return { ok: false, summary: "Unsupported data step." };
+  }
+
   // extension/pagebridge.ts
   function stepoptions3(step) {
     if (!step.options) return {};
@@ -2465,6 +3224,9 @@
   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"]);
+  var formkinds = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "asksubmit", "submitform", "consentpassword", "attachfile"]);
+  var wizardkinds = /* @__PURE__ */ new Set(["runwizard", "selectchain", "picktypeahead", "pickdate", "fillcard", "fillcode"]);
+  var datastepkinds = /* @__PURE__ */ new Set(["scrapetable", "paginateextract"]);
   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." };
@@ -2511,7 +3273,10 @@
     }
     const element = resolution.status === "resolved" ? resolution.element : null;
     let result;
-    if (readkinds.has(step.kind)) result = runpageread(step, element, rootdocument);
+    if (formkinds.has(step.kind)) result = runpageform(step, element, rootdocument);
+    else if (wizardkinds.has(step.kind)) result = runpagewizard(step, element, rootdocument);
+    else if (datastepkinds.has(step.kind)) result = runpagedata(step, element, rootdocument);
+    else 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);