@unotest/web 0.5.0

package/dist/inspection/page-inject.js

@@ -0,0 +1,3533 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/semantic-dom/algorithm.ts
+function semanticDomAlgorithm(options) {
+  const disambiguateEnabled = options?.disambiguate !== false;
+  const INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
+    "a",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "details",
+    "summary"
+  ]);
+  const INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+    "button",
+    "link",
+    "menuitem",
+    "tab",
+    "checkbox",
+    "radio",
+    "combobox",
+    "searchbox",
+    "textbox",
+    "switch",
+    "treeitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option"
+  ]);
+  const LANDMARK_TAGS = /* @__PURE__ */ new Set([
+    "header",
+    "nav",
+    "main",
+    "aside",
+    "footer",
+    "form",
+    "section",
+    "article",
+    "dialog"
+  ]);
+  const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+    "banner",
+    "navigation",
+    "main",
+    "contentinfo",
+    "search",
+    "region",
+    "complementary",
+    "dialog",
+    "alertdialog"
+  ]);
+  const CMP_SELECTORS = [
+    "#onetrust-banner-sdk",
+    "#onetrust-consent-sdk",
+    "#CybotCookiebotDialog",
+    "#didomi-notice",
+    "#didomi-host",
+    "#usercentrics-root",
+    '[id^="usercentrics"]',
+    "#truste-consent-track",
+    "#truste-consent-content",
+    ".qc-cmp2-container",
+    "#cmpbox",
+    '[data-testid="cookie-banner"]',
+    '[data-testid="consent-banner"]'
+  ];
+  const nodes = [];
+  const elementToIndex = /* @__PURE__ */ new Map();
+  let shadowHostCount = 0;
+  let shadowElementCount = 0;
+  let visibleCount = 0;
+  let interestingCount = 0;
+  let customElementCount = 0;
+  let walkVisits = 0;
+  function isDynamicId(id) {
+    if (/\d{4,}/.test(id)) return true;
+    if (id.includes(":")) return true;
+    return false;
+  }
+  __name(isDynamicId, "isDynamicId");
+  function stripRandomTail(s) {
+    if (!s) return s || "";
+    let out = s;
+    out = out.replace(/([-_])([A-Za-z0-9]{8,})(?=["\]\s]|$)/g, (_m, sep, tail) => {
+      if (/^[a-z]+$/.test(tail) || /^[A-Z]+$/.test(tail)) return `${sep}${tail}`;
+      const transitions = (tail.match(/[a-z][A-Z]|[A-Z][a-z]/g) || []).length;
+      if (transitions <= 2 && !/\d/.test(tail)) return `${sep}${tail}`;
+      return `${sep}*`;
+    });
+    out = out.replace(/\/\d{5,}(?:[_-]\d+)*(?=\/|"|\]|$)/g, "/*");
+    return out;
+  }
+  __name(stripRandomTail, "stripRandomTail");
+  function isNoiseSample(sample, tag) {
+    if (!sample) return true;
+    const s = sample.trim();
+    if (!s) return true;
+    if (s === tag) return true;
+    if (s.toLowerCase() === tag.toLowerCase()) return true;
+    return false;
+  }
+  __name(isNoiseSample, "isNoiseSample");
+  function dedupStrings(arr) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const s of arr) {
+      if (s && !seen.has(s)) {
+        seen.add(s);
+        out.push(s);
+      }
+    }
+    return out;
+  }
+  __name(dedupStrings, "dedupStrings");
+  function pickPatternSamples(nodes2, count) {
+    const cap = count >= 20 ? 6 : count >= 5 ? 4 : count >= 3 ? 3 : 2;
+    const raw = nodes2.map((n) => (n.text || "").slice(0, 50) || n.tag);
+    const unique = dedupStrings(raw);
+    if (unique.length <= cap) return unique;
+    const indexed = unique.map((s, i) => ({ s, i }));
+    indexed.sort((a, b) => a.s.length - b.s.length || a.i - b.i);
+    return indexed.slice(0, cap).map((x) => x.s);
+  }
+  __name(pickPatternSamples, "pickPatternSamples");
+  let cursorCheckBudget = 2e3;
+  const CURSOR_CHECK_TAGS = /* @__PURE__ */ new Set(["span", "div", "li"]);
+  function isCursorPointerInteractive(el) {
+    if (cursorCheckBudget <= 0) return false;
+    const tag = el.tagName.toLowerCase();
+    if (!CURSOR_CHECK_TAGS.has(tag)) return false;
+    for (let i = 0; i < el.children.length; i++) {
+      const childTag = el.children[i].tagName.toLowerCase();
+      if (INTERACTIVE_TAGS.has(childTag)) return false;
+    }
+    let ancestor = el.parentElement;
+    while (ancestor) {
+      const aTag = ancestor.tagName.toLowerCase();
+      if (INTERACTIVE_TAGS.has(aTag)) return false;
+      if (LANDMARK_TAGS.has(aTag) || aTag === "body" || aTag === "ul" || aTag === "ol") break;
+      ancestor = ancestor.parentElement;
+    }
+    cursorCheckBudget--;
+    const cursor = window.getComputedStyle(el).cursor;
+    if (cursor !== "pointer") return false;
+    ancestor = el.parentElement;
+    while (ancestor) {
+      const aTag = ancestor.tagName.toLowerCase();
+      if (!CURSOR_CHECK_TAGS.has(aTag)) break;
+      cursorCheckBudget--;
+      if (cursorCheckBudget <= 0) break;
+      if (window.getComputedStyle(ancestor).cursor === "pointer") return false;
+      ancestor = ancestor.parentElement;
+    }
+    return true;
+  }
+  __name(isCursorPointerInteractive, "isCursorPointerInteractive");
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (INTERACTIVE_TAGS.has(tag)) return true;
+    const role = el.getAttribute("role");
+    if (role && INTERACTIVE_ROLES.has(role)) return true;
+    if (el.hasAttribute("aria-expanded")) return true;
+    if (el.hasAttribute("aria-haspopup") && el.getAttribute("aria-haspopup") !== "false") return true;
+    if (isCursorPointerInteractive(el)) return true;
+    return false;
+  }
+  __name(isInteractive, "isInteractive");
+  function isActionableHost(el) {
+    const tag = el.tagName.toLowerCase();
+    if (!tag.includes("-")) return false;
+    if (el.getAttribute("data-qa")) return true;
+    if (el.getAttribute("data-testid")) return true;
+    if (el.hasAttribute("tabindex") && el.getAttribute("tabindex") !== "-1") return true;
+    if (el.getAttribute("aria-label")) return true;
+    if (el.hasAttribute("onclick")) return true;
+    return false;
+  }
+  __name(isActionableHost, "isActionableHost");
+  function isInteresting(el) {
+    if (isInteractive(el)) return true;
+    const tag = el.tagName.toLowerCase();
+    if (LANDMARK_TAGS.has(tag)) return true;
+    const role = el.getAttribute("role");
+    if (role && LANDMARK_ROLES.has(role)) return true;
+    if (tag.includes("-")) return true;
+    if (el.children.length >= 3) {
+      let interactiveDescCount = 0;
+      for (let i = 0; i < el.children.length && interactiveDescCount < 2; i++) {
+        if (hasInteractiveDescendant(el.children[i])) {
+          interactiveDescCount++;
+        }
+      }
+      if (interactiveDescCount >= 2) return true;
+    }
+    return false;
+  }
+  __name(isInteresting, "isInteresting");
+  function hasInteractiveDescendant(el) {
+    if (isInteractive(el)) return true;
+    for (let i = 0; i < el.children.length; i++) {
+      if (hasInteractiveDescendant(el.children[i])) return true;
+    }
+    return false;
+  }
+  __name(hasInteractiveDescendant, "hasInteractiveDescendant");
+  function isVisible(el) {
+    const rect = el.getBoundingClientRect();
+    if (rect.height > 0 && rect.width > 0) return true;
+    for (let i = 0; i < el.children.length; i++) {
+      const c = el.children[i].getBoundingClientRect();
+      if (c.width > 0 && c.height > 0) return true;
+    }
+    return false;
+  }
+  __name(isVisible, "isVisible");
+  function buildSelectorWithStability(el, shadowHostSelector) {
+    const tag = el.tagName.toLowerCase();
+    let sel;
+    let stability = "low";
+    const id = el.id;
+    if (id && !isDynamicId(id)) {
+      sel = `#${id}`;
+      stability = "high";
+    } else {
+      const qa = el.getAttribute("data-qa");
+      if (qa) {
+        sel = `[data-qa="${qa}"]`;
+        stability = "high";
+      } else {
+        const testId = el.getAttribute("data-testid");
+        if (testId) {
+          sel = `[data-testid="${testId}"]`;
+          stability = "high";
+        } else {
+          const ariaLabel = el.getAttribute("aria-label");
+          if (ariaLabel) {
+            sel = `${tag}[aria-label="${ariaLabel.slice(0, 60)}"]`;
+            stability = "medium";
+          } else {
+            const name = el.getAttribute("name");
+            if (name) {
+              sel = `${tag}[name="${name}"]`;
+              stability = "medium";
+            } else {
+              const placeholder = el.placeholder;
+              if (placeholder) {
+                sel = `${tag}[placeholder="${placeholder.slice(0, 40)}"]`;
+                stability = "medium";
+              } else {
+                const type = el.type;
+                if (tag === "input" && type) {
+                  sel = `input[type="${type}"]`;
+                  stability = "medium";
+                } else {
+                  const rawHref = tag === "a" ? el.getAttribute("href") : null;
+                  const hrefStart = rawHref == null ? -1 : rawHref.search(/[?#]/);
+                  const cleanHref = rawHref == null ? "" : hrefStart >= 0 ? rawHref.slice(0, hrefStart) : rawHref;
+                  const hrefUsable = rawHref && rawHref !== "#" && rawHref !== "/" && cleanHref !== "" && cleanHref !== "/";
+                  if (hrefUsable) {
+                    const stripped = hrefStart >= 0;
+                    if (cleanHref.length <= 120) {
+                      sel = stripped ? `a[href^="${cleanHref}"]` : `a[href="${cleanHref}"]`;
+                      stability = "high";
+                    } else {
+                      sel = `a[href^="${cleanHref.slice(0, 120)}"]`;
+                      stability = "medium";
+                    }
+                  } else {
+                    sel = textLocatorFallback(el, tag);
+                    stability = "low";
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (shadowHostSelector) {
+      return { selector: `${shadowHostSelector} >> ${sel}`, stability };
+    }
+    return { selector: sel, stability };
+  }
+  __name(buildSelectorWithStability, "buildSelectorWithStability");
+  function shortTextChunk(rawText2) {
+    let normalized = rawText2.replace(/\s+/g, " ").trim();
+    if (!normalized) return "";
+    if (normalized.length >= 6) {
+      const half = Math.floor(normalized.length / 2);
+      if (normalized.slice(0, half) === normalized.slice(half)) {
+        normalized = normalized.slice(0, half);
+      }
+    }
+    if (normalized.length <= 30) return normalized;
+    const leadingWordy = normalized.match(/^[\p{L}\p{N} &'.()\-/]+/u);
+    const wordsPart = leadingWordy ? leadingWordy[0].trim() : "";
+    if (!wordsPart) return normalized.slice(0, 15);
+    const words = wordsPart.split(" ").filter(Boolean);
+    if (words.length === 0) return "";
+    let chunk = words[0];
+    for (let i = 1; i < words.length && chunk.length < 10; i++) {
+      chunk = `${chunk} ${words[i]}`;
+    }
+    return chunk.slice(0, 25);
+  }
+  __name(shortTextChunk, "shortTextChunk");
+  function textLocatorFallback(el, tag) {
+    const rawText2 = el.textContent || "";
+    const chunk = shortTextChunk(rawText2);
+    if (chunk) {
+      const escaped = chunk.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      return `${tag}:has-text("${escaped}")`;
+    }
+    return tag;
+  }
+  __name(textLocatorFallback, "textLocatorFallback");
+  function buildSelector(el, shadowHostSelector) {
+    return buildSelectorWithStability(el, shadowHostSelector).selector;
+  }
+  __name(buildSelector, "buildSelector");
+  function buildLightNode(el, parentIdx, shadowHostSelector) {
+    const tag = el.tagName.toLowerCase();
+    const interactive = isInteractive(el);
+    let text2 = el.textContent?.trim().slice(0, 80) || "";
+    if (text2.length >= 6) {
+      const half = Math.floor(text2.length / 2);
+      if (text2.slice(0, half) === text2.slice(half)) text2 = text2.slice(0, half);
+    }
+    let interactiveChildCount = 0;
+    for (let i = 0; i < el.children.length; i++) {
+      if (isInteractive(el.children[i])) interactiveChildCount++;
+    }
+    const childTags = [];
+    for (let i = 0; i < el.children.length; i++) {
+      childTags.push(el.children[i].tagName.toLowerCase());
+    }
+    const node = {
+      tag,
+      interactive,
+      exportAsActionableHost: isActionableHost(el),
+      childSignature: childTags.join(","),
+      childCount: el.children.length,
+      interactiveChildCount,
+      element: el,
+      parentIndex: parentIdx,
+      children: []
+    };
+    if (el.id && !isDynamicId(el.id)) node.id = el.id;
+    const qa = el.getAttribute("data-qa");
+    if (qa) node.qa = qa;
+    const testId = el.getAttribute("data-testid");
+    if (testId) node.testId = testId;
+    const role = el.getAttribute("role");
+    if (role) node.role = role;
+    if (text2) node.text = text2;
+    const ariaLabel = el.getAttribute("aria-label");
+    if (ariaLabel) node.ariaLabel = ariaLabel.slice(0, 80);
+    if (tag === "a") {
+      try {
+        const href = el.href;
+        if (href) node.href = new URL(href).pathname.slice(0, 80);
+      } catch {
+      }
+    }
+    if (tag === "input") {
+      node.type = el.type || "text";
+    }
+    if (shadowHostSelector) {
+      node.shadowHost = shadowHostSelector;
+      shadowElementCount++;
+    }
+    const nodeIndex = nodes.length;
+    nodes.push(node);
+    elementToIndex.set(el, nodeIndex);
+    if (parentIdx >= 0 && nodes[parentIdx]) {
+      nodes[parentIdx].children.push(nodeIndex);
+    }
+    return nodeIndex;
+  }
+  __name(buildLightNode, "buildLightNode");
+  function walkDOM(root, parentIdx, shadowHostSelector) {
+    const children = root.children;
+    for (let i = 0; i < children.length; i++) {
+      const el = children[i];
+      if (!isVisible(el)) continue;
+      walkVisits++;
+      visibleCount++;
+      const tag = el.tagName.toLowerCase();
+      if (tag.includes("-")) customElementCount++;
+      const interesting = isInteresting(el);
+      let currentIdx = parentIdx;
+      if (interesting) {
+        interestingCount++;
+        currentIdx = buildLightNode(el, parentIdx, shadowHostSelector);
+      }
+      const sr = el.shadowRoot;
+      if (sr) {
+        shadowHostCount++;
+        const hostSel = buildSelector(el, shadowHostSelector);
+        walkDOM(sr, currentIdx, hostSel);
+      }
+      walkDOM(el, currentIdx, shadowHostSelector);
+    }
+  }
+  __name(walkDOM, "walkDOM");
+  const walkRoot = document.body || document.documentElement;
+  if (walkRoot) walkDOM(walkRoot, -1);
+  function collectShadowExportable(nodeIdx, out) {
+    const n = nodes[nodeIdx];
+    if (n.tag.includes("-")) return;
+    const isShadowDesc = n.shadowHost !== void 0;
+    if (isShadowDesc && !n.suppressedByHost && (n.interactive || n.exportAsActionableHost)) {
+      out.push(nodeIdx);
+    }
+    for (const ci of n.children) collectShadowExportable(ci, out);
+  }
+  __name(collectShadowExportable, "collectShadowExportable");
+  for (let i = 0; i < nodes.length; i++) {
+    const host = nodes[i];
+    if (!host.tag.includes("-")) continue;
+    if (host.interactive) continue;
+    const hostOwnShadowSel = buildSelector(host.element, host.shadowHost);
+    const shadowLeaves = [];
+    for (const ci of host.children) {
+      if (nodes[ci].shadowHost === hostOwnShadowSel) {
+        collectShadowExportable(ci, shadowLeaves);
+      }
+    }
+    if (shadowLeaves.length === 1) {
+      if (!host.exportAsActionableHost) host.exportAsActionableHost = true;
+      nodes[shadowLeaves[0]].suppressedByHost = true;
+    }
+  }
+  const totalInteractive = nodes.filter(
+    (n) => !n.suppressedByHost && (n.interactive || n.exportAsActionableHost)
+  ).length;
+  let actionableHostCount = 0;
+  let suppressedByHostCount = 0;
+  for (const n of nodes) {
+    if (n.exportAsActionableHost) actionableHostCount++;
+    if (n.suppressedByHost) suppressedByHostCount++;
+  }
+  function computeDepth2Signature(nodeIdx) {
+    const node = nodes[nodeIdx];
+    if (node.children.length === 0) {
+      return node.tag + (node.interactive ? "!" : "");
+    }
+    const childSigs = node.children.map((ci) => {
+      const child = nodes[ci];
+      const childInteractive = child.interactive ? "!" : "";
+      if (child.children.length === 0) {
+        return child.tag + childInteractive;
+      }
+      const grandchildSigs = child.children.map((gi) => {
+        const gc = nodes[gi];
+        return gc.tag + (gc.interactive ? "!" : "");
+      }).join(",");
+      return child.tag + childInteractive + "(" + grandchildSigs + ")";
+    }).join(",");
+    return node.tag + ":[" + childSigs + "]";
+  }
+  __name(computeDepth2Signature, "computeDepth2Signature");
+  for (let i = 0; i < nodes.length; i++) {
+    nodes[i].depth2Signature = computeDepth2Signature(i);
+  }
+  const detectedCollections = [];
+  let totalFuzzyMatched = 0;
+  function jaccardMultiset(a, b) {
+    const countA = /* @__PURE__ */ new Map();
+    const countB = /* @__PURE__ */ new Map();
+    for (const x of a) countA.set(x, (countA.get(x) || 0) + 1);
+    for (const x of b) countB.set(x, (countB.get(x) || 0) + 1);
+    const allKeys = /* @__PURE__ */ new Set([...countA.keys(), ...countB.keys()]);
+    let intersection = 0;
+    let union = 0;
+    for (const k of allKeys) {
+      const ca = countA.get(k) || 0;
+      const cb = countB.get(k) || 0;
+      intersection += Math.min(ca, cb);
+      union += Math.max(ca, cb);
+    }
+    return union === 0 ? 0 : intersection / union;
+  }
+  __name(jaccardMultiset, "jaccardMultiset");
+  function interactiveOverlap(dominantChildren, candidateChildren) {
+    const dominantInteractive = dominantChildren.filter((ci) => nodes[ci].interactive).map((ci) => nodes[ci].tag);
+    const candidateInteractive = candidateChildren.filter((ci) => nodes[ci].interactive).map((ci) => nodes[ci].tag);
+    if (dominantInteractive.length === 0) return 1;
+    let matched = 0;
+    const used = /* @__PURE__ */ new Set();
+    for (const dt of dominantInteractive) {
+      for (let i = 0; i < candidateInteractive.length; i++) {
+        if (!used.has(i) && candidateInteractive[i] === dt) {
+          matched++;
+          used.add(i);
+          break;
+        }
+      }
+    }
+    return matched / dominantInteractive.length;
+  }
+  __name(interactiveOverlap, "interactiveOverlap");
+  const collectionMemberSet = /* @__PURE__ */ new Set();
+  function addDescendantsToSet(nodeIdx, set) {
+    for (const ci of nodes[nodeIdx].children) {
+      set.add(ci);
+      addDescendantsToSet(ci, set);
+    }
+  }
+  __name(addDescendantsToSet, "addDescendantsToSet");
+  function countInteractiveInSubtree(nodeIdx) {
+    let count = 0;
+    const n = nodes[nodeIdx];
+    if (n.interactive) count++;
+    for (const ci of n.children) {
+      count += countInteractiveInSubtree(ci);
+    }
+    return count;
+  }
+  __name(countInteractiveInSubtree, "countInteractiveInSubtree");
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.children.length < 3) continue;
+    if (collectionMemberSet.has(i)) continue;
+    const sigGroups = /* @__PURE__ */ new Map();
+    for (const ci of node.children) {
+      const sig = nodes[ci].depth2Signature || "";
+      if (!sigGroups.has(sig)) sigGroups.set(sig, []);
+      sigGroups.get(sig).push(ci);
+    }
+    let dominantSig = "";
+    let dominantGroup = [];
+    for (const [sig, group] of sigGroups) {
+      if (group.length > dominantGroup.length) {
+        dominantSig = sig;
+        dominantGroup = group;
+      }
+    }
+    if (dominantGroup.length < 3) continue;
+    const dominantTag = nodes[dominantGroup[0]].tag;
+    const dominantChildTags = nodes[dominantGroup[0]].children.map((ci) => nodes[ci].tag);
+    let fuzzyCount = 0;
+    const allItems = [...dominantGroup];
+    for (const [sig, group] of sigGroups) {
+      if (sig === dominantSig) continue;
+      for (const ci of group) {
+        const candidate = nodes[ci];
+        if (candidate.tag !== dominantTag) continue;
+        const candidateChildTags = candidate.children.map((gi) => nodes[gi].tag);
+        const jaccard = jaccardMultiset(dominantChildTags, candidateChildTags);
+        if (jaccard < 0.7) continue;
+        const iOverlap = interactiveOverlap(nodes[dominantGroup[0]].children, candidate.children);
+        if (iOverlap < 0.5) continue;
+        allItems.push(ci);
+        fuzzyCount++;
+      }
+    }
+    if (allItems.length < 3) continue;
+    const avgInteractive = allItems.reduce((sum, ci) => sum + countInteractiveInSubtree(ci), 0) / allItems.length;
+    if (avgInteractive < 3) continue;
+    detectedCollections.push({
+      parentIdx: i,
+      itemIndices: allItems,
+      dominantSignature: dominantSig,
+      fuzzyCount
+    });
+    totalFuzzyMatched += fuzzyCount;
+    for (const ci of allItems) {
+      collectionMemberSet.add(ci);
+      addDescendantsToSet(ci, collectionMemberSet);
+    }
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.children.length < 3) continue;
+    if (node.children.some((ci) => collectionMemberSet.has(ci))) continue;
+    const grandchildIndices = [];
+    let valid = true;
+    for (const ci of node.children) {
+      const child = nodes[ci];
+      if (child.children.length !== 1) {
+        valid = false;
+        break;
+      }
+      grandchildIndices.push(child.children[0]);
+    }
+    if (!valid || grandchildIndices.length < 3) continue;
+    const sigGroups = /* @__PURE__ */ new Map();
+    for (const gi of grandchildIndices) {
+      const sig = nodes[gi].depth2Signature || "";
+      if (!sigGroups.has(sig)) sigGroups.set(sig, []);
+      sigGroups.get(sig).push(gi);
+    }
+    let dominantSig = "";
+    let dominantGroup = [];
+    for (const [sig, group] of sigGroups) {
+      if (group.length > dominantGroup.length) {
+        dominantSig = sig;
+        dominantGroup = group;
+      }
+    }
+    if (dominantGroup.length < 3) continue;
+    const dominantTag = nodes[dominantGroup[0]].tag;
+    const dominantChildTags = nodes[dominantGroup[0]].children.map((ci) => nodes[ci].tag);
+    let fuzzyCount = 0;
+    const allItems = [...dominantGroup];
+    for (const [sig, group] of sigGroups) {
+      if (sig === dominantSig) continue;
+      for (const gi of group) {
+        const candidate = nodes[gi];
+        if (candidate.tag !== dominantTag) continue;
+        const candidateChildTags = candidate.children.map((ci) => nodes[ci].tag);
+        const jaccard = jaccardMultiset(dominantChildTags, candidateChildTags);
+        if (jaccard < 0.7) continue;
+        const iOverlap = interactiveOverlap(nodes[dominantGroup[0]].children, candidate.children);
+        if (iOverlap < 0.5) continue;
+        allItems.push(gi);
+        fuzzyCount++;
+      }
+    }
+    if (allItems.length < 3) continue;
+    const avgInteractive = allItems.reduce((sum, ci) => sum + countInteractiveInSubtree(ci), 0) / allItems.length;
+    if (avgInteractive < 3) continue;
+    detectedCollections.push({
+      parentIdx: i,
+      itemIndices: allItems,
+      dominantSignature: dominantSig,
+      fuzzyCount
+    });
+    totalFuzzyMatched += fuzzyCount;
+    for (const ci of allItems) {
+      collectionMemberSet.add(ci);
+      addDescendantsToSet(ci, collectionMemberSet);
+    }
+  }
+  const LANDMARK_SELECTOR = 'header, nav, main, aside, footer, form, section[aria-label], section[aria-labelledby], article, dialog, [role="banner"], [role="navigation"], [role="main"], [role="contentinfo"], [role="search"], [role="region"], [role="complementary"], [role="dialog"], [role="alertdialog"]';
+  function landmarkKind(landmark) {
+    const tag = landmark.tagName.toLowerCase();
+    const role = (landmark.getAttribute("role") || "").toLowerCase();
+    if (tag === "nav" || role === "navigation") return "navigation";
+    if (tag === "form") return "form";
+    if (role === "search") return "search";
+    if (tag === "header" || role === "banner") return "header";
+    if (tag === "footer" || role === "contentinfo") return "footer";
+    if (tag === "main" || role === "main") return "main";
+    if (tag === "aside" || role === "complementary") return "aside";
+    if (tag === "dialog" || role === "dialog" || role === "alertdialog") return "dialog";
+    return "unknown";
+  }
+  __name(landmarkKind, "landmarkKind");
+  function landmarkLabel(landmark, kind) {
+    const tag = landmark.tagName.toLowerCase();
+    const role = landmark.getAttribute("role");
+    const ariaLabel = landmark.getAttribute("aria-label");
+    const heading = landmark.querySelector("h1, h2, h3, h4, h5, h6");
+    const headingText = heading?.textContent?.trim().slice(0, 40) || "";
+    const label = ariaLabel?.slice(0, 40) || headingText || "";
+    const baseName = role || tag;
+    const zoneKey = label ? `${baseName}: ${label}` : `${kind}:${baseName}`;
+    return { label, zoneKey };
+  }
+  __name(landmarkLabel, "landmarkLabel");
+  const syntheticRoots = /* @__PURE__ */ new Map();
+  for (const sel of CMP_SELECTORS) {
+    let matches = [];
+    try {
+      matches = Array.from(document.querySelectorAll(sel));
+    } catch {
+    }
+    for (const el of matches) {
+      if (!isVisible(el)) continue;
+      if (!syntheticRoots.has(el)) {
+        syntheticRoots.set(el, { element: el, kind: "cmp", label: "consent" });
+      }
+    }
+  }
+  const overlayCandidates = Array.from(document.querySelectorAll("*"));
+  let overlayInspectBudget = 200;
+  for (const el of overlayCandidates) {
+    if (overlayInspectBudget-- <= 0) break;
+    if (!(el instanceof Element)) continue;
+    if (!isVisible(el)) continue;
+    if (syntheticRoots.has(el)) continue;
+    const style = el.style;
+    const pos = style && style.position;
+    if (pos !== "fixed" && pos !== "absolute") {
+      const computed = window.getComputedStyle(el);
+      if (computed.position !== "fixed" && computed.position !== "absolute") continue;
+      const zi = parseInt(computed.zIndex, 10);
+      if (!Number.isFinite(zi) || zi < 1e3) continue;
+    } else {
+      const computed = window.getComputedStyle(el);
+      const zi = parseInt(computed.zIndex, 10);
+      if (!Number.isFinite(zi) || zi < 1e3) continue;
+    }
+    if (!hasInteractiveDescendant(el)) continue;
+    if (el.closest(LANDMARK_SELECTOR) && el.closest(LANDMARK_SELECTOR) !== el) continue;
+    syntheticRoots.set(el, { element: el, kind: "overlay" });
+  }
+  function detectSyntheticByCollection() {
+    for (let ci = 0; ci < detectedCollections.length; ci++) {
+      const coll = detectedCollections[ci];
+      const parent = nodes[coll.parentIdx]?.element;
+      if (!parent) continue;
+      if (syntheticRoots.has(parent)) continue;
+      let productLinkCount = 0;
+      let promoCtaCount = 0;
+      let chipCount = 0;
+      for (const itemIdx of coll.itemIndices) {
+        const itemEl = nodes[itemIdx]?.element;
+        if (!itemEl) continue;
+        if (itemEl.querySelector('a[href*="/p/"], a[href*="/product/"], a[href*="/item/"]')) productLinkCount++;
+        if (itemEl.querySelector('[aria-label*="ktivierung" i], [aria-label*="Activate" i]')) promoCtaCount++;
+        const text2 = (itemEl.textContent || "").trim();
+        if (text2.length > 0 && text2.length <= 30) chipCount++;
+      }
+      if (productLinkCount >= 5) {
+        syntheticRoots.set(parent, { element: parent, kind: "recommendations" });
+      } else if (promoCtaCount >= 2) {
+        syntheticRoots.set(parent, { element: parent, kind: "promo" });
+      } else if (chipCount >= 5 && coll.itemIndices.length >= 5) {
+        syntheticRoots.set(parent, { element: parent, kind: "categoryChips" });
+      }
+    }
+  }
+  __name(detectSyntheticByCollection, "detectSyntheticByCollection");
+  detectSyntheticByCollection();
+  function getZoneAssignment(el) {
+    let cursor = el;
+    while (cursor) {
+      const synth = syntheticRoots.get(cursor);
+      if (synth) {
+        const label = synth.label || "";
+        const zoneKey = label ? `${synth.kind}: ${label}` : synth.kind;
+        return { kind: synth.kind, zoneKey, label };
+      }
+      cursor = cursor.parentElement;
+    }
+    const landmark = el.closest(LANDMARK_SELECTOR);
+    if (landmark) {
+      const kind = landmarkKind(landmark);
+      const { label, zoneKey } = landmarkLabel(landmark, kind);
+      return { kind, zoneKey, label };
+    }
+    return { kind: "unknown", zoneKey: "unknown", label: "" };
+  }
+  __name(getZoneAssignment, "getZoneAssignment");
+  const standaloneInteractive = [];
+  const collectionItemInteractive = /* @__PURE__ */ new Map();
+  function isExportable(n) {
+    if (n.suppressedByHost) return false;
+    return n.interactive || n.exportAsActionableHost;
+  }
+  __name(isExportable, "isExportable");
+  function collectInteractiveFromSubtree(nodeIdx) {
+    const result = [];
+    const node = nodes[nodeIdx];
+    if (isExportable(node)) result.push(node);
+    for (const ci of node.children) {
+      result.push(...collectInteractiveFromSubtree(ci));
+    }
+    return result;
+  }
+  __name(collectInteractiveFromSubtree, "collectInteractiveFromSubtree");
+  const interactiveInCollection = /* @__PURE__ */ new Set();
+  for (let ci = 0; ci < detectedCollections.length; ci++) {
+    const coll = detectedCollections[ci];
+    const collInteractive = [];
+    for (const itemIdx of coll.itemIndices) {
+      const interactives = collectInteractiveFromSubtree(itemIdx);
+      collInteractive.push(...interactives);
+      for (const n of interactives) {
+        const idx = elementToIndex.get(n.element);
+        if (idx !== void 0) interactiveInCollection.add(idx);
+      }
+    }
+    collectionItemInteractive.set(ci, collInteractive);
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    if (isExportable(nodes[i]) && !interactiveInCollection.has(i)) {
+      standaloneInteractive.push(nodes[i]);
+    }
+  }
+  const zoneMeta = /* @__PURE__ */ new Map();
+  const zoneElements = /* @__PURE__ */ new Map();
+  const zoneCollections = /* @__PURE__ */ new Map();
+  function registerZone(zoneKey, kind, label) {
+    if (zoneMeta.has(zoneKey)) return;
+    zoneMeta.set(zoneKey, label ? { kind, label } : { kind });
+  }
+  __name(registerZone, "registerZone");
+  for (const node of standaloneInteractive) {
+    const { kind, zoneKey, label } = getZoneAssignment(node.element);
+    registerZone(zoneKey, kind, label);
+    if (!zoneElements.has(zoneKey)) zoneElements.set(zoneKey, []);
+    zoneElements.get(zoneKey).push(node);
+  }
+  for (let ci = 0; ci < detectedCollections.length; ci++) {
+    const coll = detectedCollections[ci];
+    const parentNode = nodes[coll.parentIdx];
+    const { kind, zoneKey, label } = getZoneAssignment(parentNode.element);
+    registerZone(zoneKey, kind, label);
+    if (!zoneCollections.has(zoneKey)) zoneCollections.set(zoneKey, []);
+    zoneCollections.get(zoneKey).push(ci);
+  }
+  const tablesByZone = /* @__PURE__ */ new Map();
+  const tableEls = Array.from(document.querySelectorAll('table, [role="grid"], [role="table"], [role="treegrid"]'));
+  for (const tbl of tableEls) {
+    const rect = tbl.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) continue;
+    const { kind, zoneKey, label } = getZoneAssignment(tbl);
+    registerZone(zoneKey, kind, label);
+    let headers = Array.from(tbl.querySelectorAll("thead th, thead td")).map((h) => (h.textContent || "").trim().slice(0, 40)).filter((t) => t);
+    if (headers.length === 0) {
+      const firstRow2 = tbl.querySelector("tr");
+      if (firstRow2) {
+        headers = Array.from(firstRow2.querySelectorAll("th")).map((h) => (h.textContent || "").trim().slice(0, 40)).filter((t) => t);
+      }
+    }
+    const bodyRows = tbl.querySelectorAll("tbody tr").length;
+    const totalRows = tbl.querySelectorAll("tr").length;
+    const rowCount = bodyRows || Math.max(0, totalRows - (headers.length > 0 ? 1 : 0));
+    const firstRow = tbl.querySelector("tr");
+    const columnCount = firstRow ? firstRow.children.length : headers.length;
+    const summary = {
+      selector: buildSelector(tbl),
+      columnCount,
+      rowCount,
+      headers: headers.slice(0, 20)
+    };
+    if (!tablesByZone.has(zoneKey)) tablesByZone.set(zoneKey, []);
+    tablesByZone.get(zoneKey).push(summary);
+  }
+  const allZoneNames = /* @__PURE__ */ new Set([...zoneElements.keys(), ...zoneCollections.keys(), ...tablesByZone.keys()]);
+  function extractTemplate(collIdx) {
+    const coll = detectedCollections[collIdx];
+    const items = coll.itemIndices;
+    const itemFields = [];
+    for (const itemIdx of items) {
+      const fields = [];
+      const stack = [itemIdx];
+      while (stack.length > 0) {
+        const ni = stack.pop();
+        const n = nodes[ni];
+        if (n.suppressedByHost) {
+          for (const ci of n.children) stack.push(ci);
+          continue;
+        }
+        const effectiveInteractive = n.interactive || n.exportAsActionableHost;
+        if (effectiveInteractive || n.testId || n.qa || n.ariaLabel || n.role) {
+          fields.push({
+            tag: n.tag,
+            selector: buildSelector(n.element, n.shadowHost),
+            text: n.text,
+            ariaLabel: n.ariaLabel,
+            role: n.role,
+            type: n.type,
+            interactive: effectiveInteractive
+          });
+        }
+        for (const ci of n.children) {
+          stack.push(ci);
+        }
+      }
+      itemFields.push(fields);
+    }
+    const templateMap = /* @__PURE__ */ new Map();
+    function normalizeSelectorForGrouping(sel) {
+      if (sel.startsWith("[data-testid=")) return sel;
+      if (sel.startsWith("[data-qa=")) return sel;
+      if (sel.startsWith("#")) return sel;
+      const hrefMatch = sel.match(/^a\[href[*=]?="(\/[^/]*\/)/);
+      if (hrefMatch) return `a[href*="${hrefMatch[1]}"]`;
+      const attrMatch = sel.match(/^(\w+)\[(\w+[-\w]*)=/);
+      if (attrMatch) return `${attrMatch[1]}[${attrMatch[2]}]`;
+      return sel.match(/^(\w+)/)?.[1] || sel;
+    }
+    __name(normalizeSelectorForGrouping, "normalizeSelectorForGrouping");
+    for (let itemI = 0; itemI < itemFields.length; itemI++) {
+      const seenInItem = /* @__PURE__ */ new Set();
+      for (const field of itemFields[itemI]) {
+        const key = `${field.tag}:${normalizeSelectorForGrouping(field.selector)}`;
+        if (seenInItem.has(key)) continue;
+        seenInItem.add(key);
+        if (!templateMap.has(key)) {
+          templateMap.set(key, {
+            tag: field.tag,
+            selectorPattern: field.selector,
+            texts: [],
+            ariaLabels: [],
+            roles: /* @__PURE__ */ new Set(),
+            types: /* @__PURE__ */ new Set(),
+            interactive: field.interactive,
+            count: 0
+          });
+        }
+        const tc = templateMap.get(key);
+        tc.count++;
+        if (field.text && tc.texts.length < 2 && !tc.texts.includes(field.text)) {
+          tc.texts.push(field.text);
+        }
+        if (field.ariaLabel && tc.ariaLabels.length < 2 && !tc.ariaLabels.includes(field.ariaLabel)) {
+          tc.ariaLabels.push(field.ariaLabel);
+        }
+        if (field.role) tc.roles.add(field.role);
+        if (field.type) tc.types.add(field.type);
+        if (field.selector.length > tc.selectorPattern.length) {
+          tc.selectorPattern = field.selector;
+        }
+      }
+    }
+    const template = [];
+    for (const [, tc] of templateMap) {
+      const optional = tc.count < items.length;
+      const consistentText = tc.texts.length === 1 && tc.count > 1 ? tc.texts[0] : void 0;
+      const sampleValues = tc.texts.length >= 1 && !consistentText ? tc.texts.slice(0, 2).map((t) => t.slice(0, 50)) : void 0;
+      const field = {
+        tag: tc.tag,
+        interactive: tc.interactive,
+        optional
+      };
+      if (tc.selectorPattern && tc.selectorPattern !== tc.tag) {
+        field.selector = tc.selectorPattern;
+      }
+      if (consistentText) field.text = consistentText.slice(0, 50);
+      if (tc.ariaLabels.length > 0) field.ariaLabel = tc.ariaLabels[0].slice(0, 50);
+      if (tc.roles.size === 1) field.role = [...tc.roles][0];
+      if (tc.types.size === 1) field.type = [...tc.types][0];
+      if (sampleValues && sampleValues.length > 0) field.sampleValues = sampleValues;
+      template.push(field);
+    }
+    template.sort((a, b) => {
+      if (a.interactive !== b.interactive) return a.interactive ? -1 : 1;
+      return a.tag.localeCompare(b.tag);
+    });
+    const MAX_ITEM_SAMPLES = 5;
+    const itemTexts = [];
+    const sampleItems = items.slice(0, MAX_ITEM_SAMPLES);
+    for (const itemIdx of sampleItems) {
+      let bestText = "";
+      const stack = [itemIdx];
+      while (stack.length > 0) {
+        const ni = stack.pop();
+        const n = nodes[ni];
+        if (n.interactive || n.exportAsActionableHost) {
+          const el = n.element;
+          const t = (el.getAttribute("title") || el.textContent || "").trim();
+          if (t.length > bestText.length) {
+            bestText = t.slice(0, 80);
+            if (el.getAttribute("title")) break;
+          }
+        }
+        for (const ci of n.children) stack.push(ci);
+      }
+      if (!bestText) {
+        bestText = (nodes[itemIdx].element.textContent || "").trim().slice(0, 80);
+      }
+      itemTexts.push(bestText);
+    }
+    const result = { count: items.length, template };
+    if (itemTexts.some((t) => t.length > 0)) {
+      result.itemTexts = itemTexts;
+    }
+    return result;
+  }
+  __name(extractTemplate, "extractTemplate");
+  const collections = [];
+  for (let ci = 0; ci < detectedCollections.length; ci++) {
+    collections.push(extractTemplate(ci));
+  }
+  const textCounts = /* @__PURE__ */ new Map();
+  const selectorCounts = /* @__PURE__ */ new Map();
+  const inputTypeCounts = /* @__PURE__ */ new Map();
+  for (const node of standaloneInteractive) {
+    const tag = node.tag;
+    if (node.text) {
+      const key = `${tag}:${node.text.slice(0, 40)}`;
+      textCounts.set(key, (textCounts.get(key) || 0) + 1);
+    }
+    if (node.testId) {
+      const key = `testid:${node.testId}`;
+      selectorCounts.set(key, (selectorCounts.get(key) || 0) + 1);
+    }
+    if (node.qa) {
+      const key = `qa:${node.qa}`;
+      selectorCounts.set(key, (selectorCounts.get(key) || 0) + 1);
+    }
+    if (tag === "input") {
+      const key = `input:${node.type || "text"}`;
+      inputTypeCounts.set(key, (inputTypeCounts.get(key) || 0) + 1);
+    } else if (tag === "select" || tag === "textarea") {
+      const key = `input:${tag}`;
+      inputTypeCounts.set(key, (inputTypeCounts.get(key) || 0) + 1);
+    }
+  }
+  function getImportanceTier(node) {
+    const tag = node.tag;
+    if (tag === "input" || tag === "select" || tag === "textarea") {
+      const type = tag === "input" ? node.type || "text" : tag;
+      const typeCount = inputTypeCounts.get(`input:${type}`) || 1;
+      if (typeCount >= 10) return 3;
+      if (typeCount >= 4) return 2;
+      return 1;
+    }
+    if (node.testId) {
+      const count2 = selectorCounts.get(`testid:${node.testId}`) || 1;
+      if (count2 >= 5) return 3;
+      if (count2 >= 2) return 2;
+      return 1;
+    }
+    if (node.qa) {
+      const count2 = selectorCounts.get(`qa:${node.qa}`) || 1;
+      if (count2 >= 5) return 3;
+      if (count2 >= 2) return 2;
+      return 1;
+    }
+    if (node.id) return 1;
+    const text2 = node.text?.slice(0, 40) || "";
+    const key = `${tag}:${text2}`;
+    const count = textCounts.get(key) || 1;
+    if (count === 1 && text2 && (tag === "button" || node.role === "button")) return 1;
+    if (count >= 5) return 3;
+    if (count >= 2) return 2;
+    return 2;
+  }
+  __name(getImportanceTier, "getImportanceTier");
+  const ANCHOR_LANDMARK_TAGS = /* @__PURE__ */ new Set(["nav", "header", "footer", "main", "aside", "dialog", "form"]);
+  const PW_PSEUDO_RE = /:has-text\(|\s>>\s|\brole=|\btext=/;
+  function domUniquenessCheck(selector) {
+    if (!selector || PW_PSEUDO_RE.test(selector)) return -1;
+    try {
+      return document.querySelectorAll(selector).length;
+    } catch {
+      return -1;
+    }
+  }
+  __name(domUniquenessCheck, "domUniquenessCheck");
+  function buildAnchorSelector(el) {
+    const id = el.id;
+    if (id && !isDynamicId(id)) return `#${id}`;
+    const testId = el.getAttribute("data-testid");
+    if (testId) return `[data-testid="${testId}"]`;
+    const qa = el.getAttribute("data-qa");
+    if (qa) return `[data-qa="${qa}"]`;
+    const tag = el.tagName.toLowerCase();
+    const ariaLabel = el.getAttribute("aria-label");
+    if (ariaLabel) return `${tag}[aria-label="${ariaLabel.slice(0, 60)}"]`;
+    if (ANCHOR_LANDMARK_TAGS.has(tag)) return tag;
+    const explicitRole = el.getAttribute("role");
+    if (explicitRole && (explicitRole === "navigation" || explicitRole === "banner" || explicitRole === "contentinfo" || explicitRole === "main" || explicitRole === "complementary" || explicitRole === "dialog" || explicitRole === "form" || explicitRole === "region")) {
+      return `${tag}[role="${explicitRole}"]`;
+    }
+    return null;
+  }
+  __name(buildAnchorSelector, "buildAnchorSelector");
+  function ancestorAnchorRefine(el, initialSelector) {
+    const isPwPseudo = PW_PSEUDO_RE.test(initialSelector);
+    let cursor = el.parentElement;
+    const body2 = document.body;
+    while (cursor && cursor !== body2) {
+      const anchorSel = buildAnchorSelector(cursor);
+      if (anchorSel) {
+        if (isPwPseudo) {
+          const anchorCount = domUniquenessCheck(anchorSel);
+          if (anchorCount !== 1) continue;
+          const htMatch = initialSelector.match(/:has-text\("([^"]+)"\)/);
+          if (htMatch) {
+            const searchText = htMatch[1];
+            const tagMatch = initialSelector.match(/^(\w+)/);
+            const tag = tagMatch ? tagMatch[1] : "*";
+            const descendants = cursor.querySelectorAll(tag);
+            let textMatches = 0;
+            for (let di = 0; di < descendants.length; di++) {
+              if ((descendants[di].textContent || "").includes(searchText)) textMatches++;
+            }
+            if (textMatches === 1) {
+              const candidate = `${anchorSel} ${initialSelector}`;
+              return { selector: candidate, uniqueCount: 1, strategyApplied: "ancestor-anchor", ambiguous: false };
+            }
+          }
+        } else {
+          const candidate = `${anchorSel} ${initialSelector}`;
+          const count = domUniquenessCheck(candidate);
+          if (count === 1) {
+            return { selector: candidate, uniqueCount: 1, strategyApplied: "ancestor-anchor", ambiguous: false };
+          }
+        }
+      }
+      cursor = cursor.parentElement;
+    }
+    return null;
+  }
+  __name(ancestorAnchorRefine, "ancestorAnchorRefine");
+  function hasTextRefine(el, initialSelector) {
+    if (/:has-text\(/.test(initialSelector)) return null;
+    const chunk = shortTextChunk(el.textContent || "");
+    if (!chunk) return null;
+    let nodes2;
+    try {
+      nodes2 = Array.from(document.querySelectorAll(initialSelector));
+    } catch {
+      return null;
+    }
+    const matches = nodes2.filter((n) => (n.textContent || "").includes(chunk));
+    if (matches.length !== 1) return null;
+    const escapedChunk = chunk.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const refined = `${initialSelector}:has-text("${escapedChunk}")`;
+    return { selector: refined, uniqueCount: 1, strategyApplied: "has-text", ambiguous: false };
+  }
+  __name(hasTextRefine, "hasTextRefine");
+  function isDeepVisible(n) {
+    if (!isVisible(n)) return false;
+    try {
+      const cs = window.getComputedStyle(n);
+      if (cs.visibility === "hidden" || cs.visibility === "collapse") return false;
+      if (parseFloat(cs.opacity) === 0) return false;
+    } catch {
+    }
+    if (n.getAttribute("aria-hidden") === "true") return false;
+    let parent = n.parentElement;
+    let depth = 0;
+    while (parent && depth < 10) {
+      try {
+        const ps = window.getComputedStyle(parent);
+        if (ps.visibility === "hidden" || ps.visibility === "collapse") return false;
+        if (parseFloat(ps.opacity) === 0) return false;
+      } catch {
+        break;
+      }
+      if (parent.getAttribute("aria-hidden") === "true") return false;
+      parent = parent.parentElement;
+      depth++;
+    }
+    return true;
+  }
+  __name(isDeepVisible, "isDeepVisible");
+  function visibilityRefine(el, initialSelector, initialCount) {
+    if (initialCount <= 1) return null;
+    let nodes2;
+    try {
+      nodes2 = Array.from(document.querySelectorAll(initialSelector));
+    } catch {
+      return null;
+    }
+    const visible = nodes2.filter((n) => isDeepVisible(n));
+    if (visible.length === 1 && visible[0] === el) {
+      return { selector: initialSelector, uniqueCount: 1, ambiguous: false };
+    }
+    return null;
+  }
+  __name(visibilityRefine, "visibilityRefine");
+  function slotRefine(el, initialSelector, initialCount) {
+    if (initialCount <= 1) return null;
+    if (PW_PSEUDO_RE.test(initialSelector)) return null;
+    let nodes2;
+    try {
+      nodes2 = Array.from(document.querySelectorAll(initialSelector));
+    } catch {
+      return null;
+    }
+    const elHasSlot = el.hasAttribute("slot");
+    const others = nodes2.filter((n) => n !== el);
+    const othersAllDifferent = others.every((n) => n.hasAttribute("slot") !== elHasSlot);
+    if (!othersAllDifferent) return null;
+    const suffix = elHasSlot ? "[slot]" : ":not([slot])";
+    const refined = `${initialSelector}${suffix}`;
+    const count = domUniquenessCheck(refined);
+    if (count === 1) {
+      return { selector: refined, uniqueCount: 1, strategyApplied: "slot-filter", ambiguous: false };
+    }
+    return null;
+  }
+  __name(slotRefine, "slotRefine");
+  function disambiguateSelector(el, initialSelector) {
+    const initialCount = domUniquenessCheck(initialSelector);
+    if (initialCount === 1) {
+      return { selector: initialSelector, uniqueCount: 1, ambiguous: false };
+    }
+    if (initialCount <= 0) {
+      return { selector: initialSelector, uniqueCount: initialCount, ambiguous: initialCount !== 1 };
+    }
+    const s1 = ancestorAnchorRefine(el, initialSelector);
+    if (s1) return s1;
+    const s2 = hasTextRefine(el, initialSelector);
+    if (s2) return s2;
+    const s4 = slotRefine(el, initialSelector, initialCount);
+    if (s4) return s4;
+    const s3 = visibilityRefine(el, initialSelector, initialCount);
+    if (s3) return s3;
+    return { selector: initialSelector, uniqueCount: initialCount, ambiguous: true };
+  }
+  __name(disambiguateSelector, "disambiguateSelector");
+  function nodeToAction(node) {
+    const action = {};
+    action.tag = node.tag;
+    const { selector, stability } = buildSelectorWithStability(node.element, node.shadowHost);
+    action.selector = selector;
+    action.stability = stability;
+    if (node.text) action.text = node.text;
+    if (node.qa) action.qa = node.qa;
+    if (node.testId) action.testId = node.testId;
+    if (node.role) action.role = node.role;
+    if (node.tag === "a" && node.href) action.href = node.href;
+    if (node.tag === "input") action.type = node.type || "text";
+    try {
+      const rect = node.element.getBoundingClientRect();
+      const x = Math.round(rect.x);
+      const y = Math.round(rect.y);
+      const w = Math.round(rect.width);
+      const h = Math.round(rect.height);
+      if (w > 0 || h > 0) {
+        action.bounds = { x, y, w, h };
+        const vw = window.innerWidth;
+        const vh = window.innerHeight;
+        if (x < 0 && x + w > 0 || y < 0 && y + h > 0 || x < vw && x + w > vw || y < vh && y + h > vh) {
+          action.clipped = true;
+        }
+      }
+    } catch {
+    }
+    if (disambiguateEnabled && action.selector) {
+      const result = disambiguateSelector(node.element, action.selector);
+      action.selector = result.selector;
+      if (result.strategyApplied) action.disambiguatedBy = result.strategyApplied;
+      if (result.ambiguous) action.ambiguous = true;
+    }
+    return action;
+  }
+  __name(nodeToAction, "nodeToAction");
+  function groupLinksByHrefPattern(linkNodes) {
+    const pathGroups = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const node of linkNodes) {
+      if (!node.href) {
+        ungrouped.push(node);
+        continue;
+      }
+      const segments = node.href.split("/").filter(Boolean);
+      const patternKey = segments.length >= 1 ? `/${segments[0]}/` : null;
+      if (patternKey) {
+        if (!pathGroups.has(patternKey)) pathGroups.set(patternKey, []);
+        pathGroups.get(patternKey).push(node);
+      } else {
+        ungrouped.push(node);
+      }
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [key, ns] of pathGroups) {
+      if (ns.length >= 3) {
+        grouped.set(key, ns);
+      } else {
+        ungrouped.push(...ns);
+      }
+    }
+    return { grouped, ungrouped };
+  }
+  __name(groupLinksByHrefPattern, "groupLinksByHrefPattern");
+  function groupByTestId(nodeList) {
+    const groups = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const node of nodeList) {
+      const key = node.testId ? `testid:${node.testId}` : node.qa ? `qa:${node.qa}` : null;
+      if (key) {
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(node);
+      } else {
+        ungrouped.push(node);
+      }
+    }
+    const validGroups = /* @__PURE__ */ new Map();
+    for (const [key, ns] of groups) {
+      if (ns.length >= 3) {
+        validGroups.set(key, ns);
+      } else {
+        ungrouped.push(...ns);
+      }
+    }
+    return { groups: validGroups, ungrouped };
+  }
+  __name(groupByTestId, "groupByTestId");
+  function groupByTagWithType(nodeList) {
+    const groups = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const node of nodeList) {
+      if (node.tag === "input") {
+        const key = `input:${node.type || "text"}`;
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(node);
+      } else if (node.tag.includes("-")) {
+        if (!groups.has(node.tag)) groups.set(node.tag, []);
+        groups.get(node.tag).push(node);
+      } else {
+        ungrouped.push(node);
+      }
+    }
+    const validGroups = /* @__PURE__ */ new Map();
+    for (const [key, ns] of groups) {
+      if (ns.length >= 5) {
+        validGroups.set(key, ns);
+      } else {
+        ungrouped.push(...ns);
+      }
+    }
+    return { groups: validGroups, ungrouped };
+  }
+  __name(groupByTagWithType, "groupByTagWithType");
+  const TIER2_CAP_PER_ZONE = 15;
+  const regions = {};
+  const textLines = [];
+  for (const zoneName of allZoneNames) {
+    const zoneNodes = zoneElements.get(zoneName) || [];
+    const zoneCollIndices = zoneCollections.get(zoneName) || [];
+    const meta = zoneMeta.get(zoneName) || { kind: "unknown" };
+    const kind = meta.kind;
+    let totalInZone = zoneNodes.length;
+    for (const ci of zoneCollIndices) {
+      totalInZone += (collectionItemInteractive.get(ci) || []).length;
+    }
+    const isNavigation = kind === "navigation" || kind === "header";
+    const bulkTestIdNodes = /* @__PURE__ */ new Set();
+    const bulkTestIdPatterns = [];
+    const commonHrefPrefix = /* @__PURE__ */ __name((ns) => {
+      const hrefs = ns.map((n) => n.href || "").filter((h) => h);
+      if (hrefs.length / ns.length < 0.8) return null;
+      const paths = hrefs.map((h) => h.split(/[?#]/)[0].split("/").filter(Boolean));
+      if (!paths.length) return null;
+      let k = 0;
+      const first = paths[0];
+      for (let i = 0; i < first.length; i++) {
+        if (paths.every((p) => p[i] === first[i])) k = i + 1;
+        else break;
+      }
+      if (k === 0) return null;
+      return "/" + first.slice(0, k).join("/") + "/";
+    }, "commonHrefPrefix");
+    const buildTestIdSelector = /* @__PURE__ */ __name((ns, tidPart) => {
+      const hrefPrefix = commonHrefPrefix(ns);
+      return hrefPrefix ? `a[href*="${hrefPrefix}"]${tidPart}` : tidPart;
+    }, "buildTestIdSelector");
+    if (!isNavigation) {
+      const byExact = /* @__PURE__ */ new Map();
+      for (const n of zoneNodes) {
+        const tid = n.testId || n.qa;
+        if (tid) {
+          if (!byExact.has(tid)) byExact.set(tid, []);
+          byExact.get(tid).push(n);
+        }
+      }
+      const remainingForPrefix = [];
+      for (const [tid, ns] of byExact) {
+        if (ns.length >= 3) {
+          const attr = ns[0].qa ? "data-qa" : "data-testid";
+          const selector = buildTestIdSelector(ns, `[${attr}="${tid}"]`);
+          bulkTestIdPatterns.push({
+            pattern: selector,
+            selectorPattern: selector,
+            count: ns.length,
+            samples: pickPatternSamples(ns, ns.length)
+          });
+          for (const n of ns) bulkTestIdNodes.add(n);
+        } else {
+          for (const n of ns) remainingForPrefix.push(n);
+        }
+      }
+      const segOf = /* @__PURE__ */ __name((id) => id.split(/[-_/]/).filter((s) => s.length > 0), "segOf");
+      const usedByPrefix = /* @__PURE__ */ new Set();
+      for (let k = 3; k >= 1; k--) {
+        const byPrefix = /* @__PURE__ */ new Map();
+        for (const n of remainingForPrefix) {
+          if (usedByPrefix.has(n)) continue;
+          const tid = n.testId || n.qa || "";
+          const segs = segOf(tid);
+          if (segs.length < k + 1) continue;
+          const prefix = segs.slice(0, k).join("-");
+          if (!byPrefix.has(prefix)) byPrefix.set(prefix, []);
+          byPrefix.get(prefix).push(n);
+        }
+        for (const [prefix, ns] of byPrefix) {
+          if (ns.length >= 3) {
+            const attr = ns[0].qa ? "data-qa" : "data-testid";
+            const selector = buildTestIdSelector(ns, `[${attr}^="${prefix}"]`);
+            bulkTestIdPatterns.push({
+              pattern: selector,
+              selectorPattern: selector,
+              count: ns.length,
+              samples: pickPatternSamples(ns, ns.length)
+            });
+            for (const n of ns) {
+              bulkTestIdNodes.add(n);
+              usedByPrefix.add(n);
+            }
+          }
+        }
+      }
+    }
+    const tier1 = [];
+    const tier2Nodes = [];
+    const tier3 = [];
+    const links = [];
+    for (const node of zoneNodes) {
+      if (bulkTestIdNodes.has(node)) continue;
+      if (isNavigation) {
+        tier1.push(nodeToAction(node));
+        continue;
+      }
+      const tier = getImportanceTier(node);
+      if (tier === 1) {
+        tier1.push(nodeToAction(node));
+      } else if (node.tag === "a") {
+        links.push(node);
+      } else if (tier === 2) {
+        tier2Nodes.push(node);
+      } else {
+        tier3.push(node);
+      }
+    }
+    const patterns = [...bulkTestIdPatterns];
+    const { grouped: hrefGroups, ungrouped: ungroupedLinks } = groupLinksByHrefPattern(links);
+    for (const node of ungroupedLinks) {
+      const tier = getImportanceTier(node);
+      if (tier === 1) tier1.push(nodeToAction(node));
+      else if (tier === 2) tier2Nodes.push(node);
+      else tier3.push(node);
+    }
+    for (const [pathPrefix, ns] of hrefGroups) {
+      patterns.push({
+        pattern: `a${pathPrefix}*`,
+        selectorPattern: `a[href*="${pathPrefix}"]`,
+        count: ns.length,
+        samples: pickPatternSamples(ns, ns.length)
+      });
+    }
+    const { groups: t2TagGroups, ungrouped: t2Ungrouped } = groupByTagWithType(tier2Nodes);
+    for (const [tagKey, ns] of t2TagGroups) {
+      const displayName = tagKey.includes(":") ? `${tagKey.split(":")[0]}[type=${tagKey.split(":")[1]}]` : tagKey;
+      patterns.push({
+        pattern: displayName,
+        selectorPattern: tagKey.includes("-") ? tagKey : void 0,
+        count: ns.length,
+        samples: pickPatternSamples(ns, ns.length)
+      });
+    }
+    const cappedTier2 = t2Ungrouped.slice(0, TIER2_CAP_PER_ZONE).map(nodeToAction);
+    const tier2Overflow = Math.max(0, t2Ungrouped.length - TIER2_CAP_PER_ZONE);
+    const { groups: testidGroups, ungrouped: noTestidTier3 } = groupByTestId(tier3);
+    for (const [key, ns] of testidGroups) {
+      const isTestid = key.startsWith("testid:");
+      const value = key.split(":").slice(1).join(":");
+      const selectorStr = isTestid ? `[data-testid="${value}"]` : `[data-qa="${value}"]`;
+      patterns.push({
+        pattern: selectorStr,
+        selectorPattern: selectorStr,
+        count: ns.length,
+        samples: pickPatternSamples(ns, ns.length)
+      });
+    }
+    const { groups: tier3TagGroups, ungrouped: ungroupedTier3 } = groupByTagWithType(noTestidTier3);
+    for (const [tagKey, ns] of tier3TagGroups) {
+      const displayName = tagKey.includes(":") ? `${tagKey.split(":")[0]}[type=${tagKey.split(":")[1]}]` : tagKey;
+      patterns.push({
+        pattern: displayName,
+        selectorPattern: tagKey.includes("-") ? tagKey : void 0,
+        count: ns.length,
+        samples: pickPatternSamples(ns, ns.length)
+      });
+    }
+    const otherCount = ungroupedTier3.length + tier2Overflow;
+    const actions = [...tier1, ...cappedTier2];
+    const region = { kind, total: totalInZone };
+    if (meta.label) region.label = meta.label;
+    if (actions.length > 0) region.actions = actions;
+    if (zoneCollIndices.length > 0) {
+      region.collections = zoneCollIndices.map((ci) => collections[ci]);
+    }
+    if (patterns.length > 0) region.patterns = patterns;
+    const zoneTables = tablesByZone.get(zoneName);
+    if (zoneTables && zoneTables.length > 0) region.tables = zoneTables;
+    if (otherCount > 0) region.other = otherCount;
+    regions[zoneName] = region;
+    textLines.push(`=== ${zoneName} [${kind}] (${totalInZone} els) ===`);
+    for (const a of tier1) {
+      const parts = [];
+      const sel = stripRandomTail(a.selector);
+      if (sel) parts.push(sel);
+      if (a.text) parts.push(`"${a.text.slice(0, 40)}"`);
+      if (a.qa && !(sel && sel.includes(`data-qa="${a.qa}"`))) parts.push(`[data-qa=${a.qa}]`);
+      else if (a.testId && !(sel && sel.includes(`data-testid="${a.testId}"`))) parts.push(`[data-testid=${a.testId}]`);
+      if (a.role) parts.push(`[${a.role}]`);
+      if (a.type) parts.push(`type=${a.type}`);
+      textLines.push(`* ${parts.join(" ")}`);
+    }
+    for (const a of cappedTier2) {
+      const parts = [];
+      const tag = a.tag || "";
+      parts.push(tag);
+      if (a.text) parts.push(`"${a.text.slice(0, 30)}"`);
+      const sel = stripRandomTail(a.selector);
+      if (sel && sel !== tag) parts.push(sel);
+      textLines.push(`- ${parts.join(" ")}`);
+    }
+    for (const ci of zoneCollIndices) {
+      const coll = collections[ci];
+      textLines.push("");
+      textLines.push(`collection(${coll.count} items, ${coll.template.length} fields):`);
+      if (coll.itemTexts && coll.itemTexts.length > 0) {
+        for (let ii = 0; ii < coll.itemTexts.length; ii++) {
+          const t = coll.itemTexts[ii].length > 60 ? coll.itemTexts[ii].slice(0, 60) + "..." : coll.itemTexts[ii];
+          textLines.push(`  [${ii}] "${t}"`);
+        }
+        const remaining = coll.count - coll.itemTexts.length;
+        if (remaining > 0) {
+          textLines.push(`  ...${remaining} more`);
+        }
+      }
+      const fieldLines = [];
+      for (const f of coll.template) {
+        const parts = [];
+        parts.push(f.tag);
+        const sel = stripRandomTail(f.selector);
+        if (sel) parts.push(sel);
+        if (f.text) {
+          parts.push(`"${f.text}"`);
+        } else if (f.sampleValues && f.sampleValues.length > 0) {
+          const samples = dedupStrings(f.sampleValues);
+          parts.push(`\u2014 "${samples.join('", "')}"`);
+        }
+        if (f.ariaLabel) parts.push(`[aria-label="${f.ariaLabel}"]`);
+        if (f.role) parts.push(`[${f.role}]`);
+        if (f.type) parts.push(`type=${f.type}`);
+        fieldLines.push(parts.join(" "));
+      }
+      const groups = /* @__PURE__ */ new Map();
+      const order = [];
+      for (const line of fieldLines) {
+        if (!groups.has(line)) order.push(line);
+        groups.set(line, (groups.get(line) || 0) + 1);
+      }
+      for (const line of order) {
+        const n = groups.get(line);
+        const prefix = n > 1 ? `    - ${n}\xD7 ` : `    - `;
+        textLines.push(prefix + line);
+      }
+    }
+    if (zoneTables && zoneTables.length > 0) {
+      for (const t of zoneTables) {
+        const headersPart = t.headers.length ? ` \u2014 headers: [${t.headers.join(", ")}]` : "";
+        textLines.push(`table(${t.rowCount}\xD7${t.columnCount}) ${t.selector}${headersPart}`);
+      }
+    }
+    for (const p of patterns) {
+      const stripped = p.selectorPattern ? stripRandomTail(p.selectorPattern) : void 0;
+      const head = stripped || p.pattern;
+      const tag = p.pattern;
+      const cleanSamples = p.samples ? dedupStrings(p.samples.filter((s) => !isNoiseSample(s, tag))) : [];
+      if (p.count < 2 && cleanSamples.length === 0) continue;
+      const samplesStr = cleanSamples.length ? ` ("${cleanSamples.join('", "')}")` : "";
+      textLines.push(`~ ${p.count}x ${head}${samplesStr}`);
+    }
+    if (otherCount > 0) {
+      textLines.push(`. ${otherCount} other`);
+    }
+    textLines.push("");
+  }
+  const KEEP_SMALL_KINDS = /* @__PURE__ */ new Set(["form", "search", "cmp", "dialog"]);
+  const regionsToDrop = [];
+  let unknownTotalActions = 0;
+  let unknownRegionKey = null;
+  for (const [zoneKey, region] of Object.entries(regions)) {
+    if (region.kind === "unknown") {
+      unknownRegionKey = zoneKey;
+      unknownTotalActions += region.total;
+    }
+  }
+  for (const [zoneKey, region] of Object.entries(regions)) {
+    if (KEEP_SMALL_KINDS.has(region.kind)) continue;
+    if (region.kind === "unknown") continue;
+    if (region.total >= 3) continue;
+    if (region.collections && region.collections.length > 0 || region.tables && region.tables.length > 0) continue;
+    if (!unknownRegionKey) {
+      unknownRegionKey = "unknown";
+      regions[unknownRegionKey] = { kind: "unknown", total: 0 };
+    }
+    const target = regions[unknownRegionKey];
+    if (region.actions) {
+      target.actions = (target.actions || []).concat(region.actions);
+    }
+    if (region.patterns) {
+      target.patterns = (target.patterns || []).concat(region.patterns);
+    }
+    target.total += region.total;
+    regionsToDrop.push(zoneKey);
+  }
+  for (const k of regionsToDrop) delete regions[k];
+  const warnings = [];
+  const totalActions = Object.values(regions).reduce((s, r) => s + r.total, 0);
+  if (totalActions > 0) {
+    const unknownShare = unknownTotalActions / totalActions;
+    if (unknownShare > 0.1) warnings.push(`unclassified-heavy: unknown region holds ${Math.round(unknownShare * 100)}% of elements`);
+  }
+  const text = textLines.join("\n");
+  const chars = text.length;
+  const tokens = Math.ceil(chars / 4);
+  const rawText = document.body?.innerText?.slice(0, 2e4) || "";
+  const totalDomElements = document.querySelectorAll("*").length;
+  const body = document.body;
+  const bodyVisible = body ? (() => {
+    const r = body.getBoundingClientRect();
+    return r.height > 0 && r.width > 0;
+  })() : false;
+  const bodyChildren = body?.children.length || 0;
+  const pageTitle = document.title || "";
+  return {
+    text,
+    rawText,
+    regions,
+    stats: {
+      totalElements: totalInteractive,
+      filteredElements: standaloneInteractive.length + interactiveInCollection.size,
+      chars,
+      tokens
+    },
+    diagnostics: {
+      collections: detectedCollections.length,
+      shadowHosts: shadowHostCount,
+      shadowElements: shadowElementCount,
+      fuzzyMatched: totalFuzzyMatched,
+      totalDomElements,
+      visibleDomElements: visibleCount,
+      interestingElements: interestingCount,
+      customElements: customElementCount,
+      pageTitle,
+      bodyChildren,
+      bodyVisible,
+      walkVisits,
+      actionableHosts: actionableHostCount,
+      suppressedByHost: suppressedByHostCount,
+      warnings: warnings.length > 0 ? warnings : void 0
+    },
+    viewport: { width: window.innerWidth, height: window.innerHeight }
+  };
+}
+__name(semanticDomAlgorithm, "semanticDomAlgorithm");
+
+// src/util/debug-log.ts
+import {
+  appendFileSync as fsAppend,
+  mkdirSync as fsMkdir,
+  renameSync as fsRename,
+  rmSync as fsRm,
+  symlinkSync as fsSymlink,
+  unlinkSync as fsUnlink,
+  writeFileSync as fsWrite
+} from "fs";
+import { join } from "path";
+import { AsyncLocalStorage } from "async_hooks";
+var DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+var DEFAULT_HTML_MAX_BYTES = 64 * 1024;
+var debugStore = new AsyncLocalStorage();
+
+// src/inspection/outline-capture.ts
+import { outlineAlgorithm as outlineAlgorithmInjectable } from "@unotest/web/internal/page-inject";
+function outlineAlgorithm(assignRefs) {
+  const INTERACTIVE_ARIA_ROLES = /* @__PURE__ */ new Set([
+    "button",
+    "link",
+    "checkbox",
+    "radio",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "tab",
+    "option",
+    "switch",
+    "combobox",
+    "listbox",
+    "slider",
+    "spinbutton",
+    "searchbox",
+    "textbox"
+  ]);
+  const LANDMARK_TAGS = {
+    header: "banner",
+    nav: "navigation",
+    main: "main",
+    aside: "complementary",
+    footer: "contentinfo",
+    form: "form",
+    section: "region",
+    // only when it has aria-label or aria-labelledby
+    article: "article",
+    dialog: "dialog"
+  };
+  const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+    "banner",
+    "navigation",
+    "main",
+    "complementary",
+    "contentinfo",
+    "form",
+    "search",
+    "region",
+    "dialog",
+    "alertdialog",
+    "article"
+  ]);
+  const GENERIC_ROLES = /* @__PURE__ */ new Set(["generic", "none", "presentation"]);
+  function* deepWalk(root) {
+    const children = root.children;
+    for (let i = 0; i < children.length; i++) {
+      const el = children[i];
+      yield el;
+      const sr = el.shadowRoot;
+      if (sr) yield* deepWalk(sr);
+      yield* deepWalk(el);
+    }
+  }
+  __name(deepWalk, "deepWalk");
+  function parentOrHost(node) {
+    const parent = node.parentNode;
+    if (!parent) return null;
+    if (parent instanceof ShadowRoot) return parent.host;
+    return parent instanceof Element ? parent : null;
+  }
+  __name(parentOrHost, "parentOrHost");
+  function rootForScope(el) {
+    const root = el.getRootNode();
+    return root instanceof ShadowRoot ? root : document;
+  }
+  __name(rootForScope, "rootForScope");
+  function getElementByIdInScope(el, id) {
+    return rootForScope(el).getElementById(id);
+  }
+  __name(getElementByIdInScope, "getElementByIdInScope");
+  function isVisible(el) {
+    if (!el.getClientRects || el.getClientRects().length === 0) return false;
+    const cs = window.getComputedStyle(el);
+    if (cs.display === "none" || cs.visibility === "hidden") return false;
+    if (Number.parseFloat(cs.opacity || "1") < 0.01) return false;
+    for (let p = el; p; p = parentOrHost(p)) {
+      if (p.getAttribute && p.getAttribute("aria-hidden") === "true") return false;
+    }
+    const r = el.getBoundingClientRect();
+    if (r.width === 0 && r.height === 0) return false;
+    return true;
+  }
+  __name(isVisible, "isVisible");
+  function implicitRole(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "a" && el.hasAttribute("href")) return "link";
+    if (tag === "button") return "button";
+    if (tag === "textarea") return "textbox";
+    if (tag === "select") {
+      return el.multiple || el.size > 1 ? "listbox" : "combobox";
+    }
+    if (tag === "input") {
+      const t = (el.type || "text").toLowerCase();
+      if (t === "button" || t === "submit" || t === "reset" || t === "image") return "button";
+      if (t === "checkbox") return "checkbox";
+      if (t === "radio") return "radio";
+      if (t === "range") return "slider";
+      if (t === "number") return "spinbutton";
+      if (t === "search") return "searchbox";
+      if (t === "hidden") return null;
+      return "textbox";
+    }
+    if (tag === "h1" || tag === "h2" || tag === "h3" || tag === "h4" || tag === "h5" || tag === "h6") {
+      return "heading";
+    }
+    if (tag === "img" && el.hasAttribute("alt")) return "img";
+    if (tag === "details") return "group";
+    if (tag === "summary") return "button";
+    if (tag === "iframe") return "iframe";
+    return null;
+  }
+  __name(implicitRole, "implicitRole");
+  function computeRole(el) {
+    const explicit = el.getAttribute("role");
+    if (explicit) {
+      return explicit.split(/\s+/)[0].toLowerCase();
+    }
+    return implicitRole(el);
+  }
+  __name(computeRole, "computeRole");
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "iframe") return true;
+    const role = computeRole(el);
+    if (role && INTERACTIVE_ARIA_ROLES.has(role)) return true;
+    if (el.hasAttribute("onclick")) return true;
+    const tiRaw = el.getAttribute("tabindex");
+    const ti = tiRaw === null ? null : Number.parseInt(tiRaw, 10);
+    if (ti !== null && ti >= 0) return true;
+    if (tag === "div" || tag === "span") {
+    }
+    return false;
+  }
+  __name(isInteractive, "isInteractive");
+  const MAX_NAME = 80;
+  function trim(s) {
+    return (s ?? "").replace(/\s+/g, " ").trim();
+  }
+  __name(trim, "trim");
+  function cap(s) {
+    return s.length > MAX_NAME ? s.slice(0, MAX_NAME - 1) + "\u2026" : s;
+  }
+  __name(cap, "cap");
+  function svgIconName(host, seen) {
+    const svg = host.querySelector("svg");
+    if (!svg) return "";
+    const labelledby = svg.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(svg, id);
+        if (ref && !seen.has(ref)) {
+          const n = accname(ref, seen);
+          if (n) parts.push(n);
+        }
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const ariaLabel = trim(svg.getAttribute("aria-label"));
+    if (ariaLabel) return cap(ariaLabel);
+    for (const child of Array.from(svg.children)) {
+      if (child.tagName.toLowerCase() === "title") {
+        const t = trim(child.textContent);
+        if (t) return cap(t);
+        break;
+      }
+    }
+    return "";
+  }
+  __name(svgIconName, "svgIconName");
+  function accname(el, visited) {
+    const seen = visited ?? /* @__PURE__ */ new Set();
+    if (seen.has(el)) return "";
+    seen.add(el);
+    const labelledby = el.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(el, id);
+        if (ref && !seen.has(ref)) {
+          const n = accname(ref, seen);
+          if (n) parts.push(n);
+        }
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const ariaLabel = trim(el.getAttribute("aria-label"));
+    if (ariaLabel) return cap(ariaLabel);
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      const id = el.id;
+      if (id) {
+        const lbl = rootForScope(el).querySelector(
+          `label[for="${cssEscape(id)}"]`
+        );
+        if (lbl) {
+          const n = trim(textContentVisible(lbl));
+          if (n) return cap(n);
+        }
+      }
+      let p = parentOrHost(el);
+      while (p) {
+        if (p.tagName.toLowerCase() === "label") {
+          const n = trim(textContentVisible(p));
+          if (n) return cap(n);
+          break;
+        }
+        p = parentOrHost(p);
+      }
+      if (tag === "input") {
+        const it = el.type?.toLowerCase();
+        if (it === "button" || it === "submit" || it === "reset") {
+          const v = trim(el.value);
+          if (v) return cap(v);
+        }
+        const ph = trim(el.placeholder);
+        if (ph) return cap(ph);
+      }
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      return "";
+    }
+    if (tag === "button" || tag === "a" || tag === "summary") {
+      const txt = trim(textContentVisible(el));
+      if (txt) return cap(txt);
+      const svgName = svgIconName(el, seen);
+      if (svgName) return svgName;
+      const img = el.querySelector("img[alt]");
+      if (img) {
+        const alt = trim(img.getAttribute("alt"));
+        if (alt) return cap(alt);
+      }
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      return "";
+    }
+    if (tag === "iframe") {
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      const src = el.getAttribute("src");
+      if (src) {
+        const base = srcBasename(src);
+        if (base) return cap(base);
+      }
+      return "";
+    }
+    if (tag === "img") {
+      return cap(trim(el.getAttribute("alt")));
+    }
+    const inner = trim(textContentVisible(el));
+    if (inner) return cap(inner);
+    const t = trim(el.getAttribute("title"));
+    return cap(t);
+  }
+  __name(accname, "accname");
+  function srcBasename(src) {
+    const noQuery = src.split(/[?#]/)[0] ?? "";
+    const segments = noQuery.split("/").filter((s) => s.length > 0);
+    return segments[segments.length - 1] ?? "";
+  }
+  __name(srcBasename, "srcBasename");
+  function textContentVisible(el) {
+    const ht = el;
+    if (typeof ht.innerText === "string") return ht.innerText;
+    return el.textContent ?? "";
+  }
+  __name(textContentVisible, "textContentVisible");
+  function cssEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+  __name(cssEscape, "cssEscape");
+  const MAX_HREF = 60;
+  const pageOrigin = (() => {
+    try {
+      return window.location.origin;
+    } catch {
+      return "";
+    }
+  })();
+  function shortenedHref(rawHref) {
+    if (!rawHref) return "";
+    const t = trim(rawHref);
+    if (!t || t === "#") return "";
+    try {
+      const u = new URL(t, window.location.href);
+      if (u.protocol === "javascript:" || u.protocol === "mailto:" || u.protocol === "tel:") {
+        return "";
+      }
+      let display;
+      if (pageOrigin && u.origin === pageOrigin) {
+        display = u.pathname + u.search + u.hash;
+      } else {
+        display = u.host + u.pathname + u.search + u.hash;
+      }
+      if (display.length > MAX_HREF) display = display.slice(0, MAX_HREF - 1) + "\u2026";
+      return display;
+    } catch {
+      return t.length > MAX_HREF ? t.slice(0, MAX_HREF - 1) + "\u2026" : t;
+    }
+  }
+  __name(shortenedHref, "shortenedHref");
+  function collectState(el) {
+    const state = {};
+    const tag = el.tagName.toLowerCase();
+    const formDisabled = (tag === "button" || tag === "input" || tag === "select" || tag === "textarea" || tag === "fieldset" || tag === "optgroup" || tag === "option") && el.disabled === true;
+    if (formDisabled || el.getAttribute("aria-disabled") === "true") {
+      state.disabled = true;
+    }
+    const ariaChecked = el.getAttribute("aria-checked");
+    if (ariaChecked === "true") {
+      state.checked = true;
+    } else if (ariaChecked === "mixed") {
+      state.checked = "mixed";
+    } else if (tag === "input" && (el.type === "checkbox" || el.type === "radio") && el.checked) {
+      state.checked = true;
+    }
+    const ariaPressed = el.getAttribute("aria-pressed");
+    if (ariaPressed === "true") state.pressed = true;
+    else if (ariaPressed === "mixed") state.pressed = "mixed";
+    if (el.getAttribute("aria-expanded") === "true") state.expanded = true;
+    if (el.getAttribute("aria-selected") === "true") {
+      state.selected = true;
+    } else if (tag === "option" && el.selected) {
+      state.selected = true;
+    }
+    if (rootForScope(el).activeElement === el) {
+      state.active = true;
+    }
+    if (tag === "h1") state.level = 1;
+    else if (tag === "h2") state.level = 2;
+    else if (tag === "h3") state.level = 3;
+    else if (tag === "h4") state.level = 4;
+    else if (tag === "h5") state.level = 5;
+    else if (tag === "h6") state.level = 6;
+    const ariaLevel = el.getAttribute("aria-level");
+    if (ariaLevel) {
+      const n = Number.parseInt(ariaLevel, 10);
+      if (Number.isFinite(n) && n > 0) state.level = n;
+    }
+    return Object.keys(state).length > 0 ? state : void 0;
+  }
+  __name(collectState, "collectState");
+  function findLandmark(el) {
+    for (let p = parentOrHost(el); p; p = parentOrHost(p)) {
+      const role = p.getAttribute("role");
+      if (role) {
+        const r = role.split(/\s+/)[0].toLowerCase();
+        if (LANDMARK_ROLES.has(r)) {
+          return { kind: r, label: landmarkLabel(p), element: p };
+        }
+      }
+      const tag = p.tagName.toLowerCase();
+      const tagKind = LANDMARK_TAGS[tag];
+      if (tagKind) {
+        if (tag === "section") {
+          if (!p.getAttribute("aria-label") && !p.getAttribute("aria-labelledby")) continue;
+        }
+        return { kind: tagKind, label: landmarkLabel(p), element: p };
+      }
+    }
+    return null;
+  }
+  __name(findLandmark, "findLandmark");
+  function landmarkLabel(landmark) {
+    const aria = trim(landmark.getAttribute("aria-label"));
+    if (aria) return cap(aria);
+    const labelledby = landmark.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(landmark, id);
+        if (ref) parts.push(trim(textContentVisible(ref)));
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const heading = landmark.querySelector("h1, h2, h3, h4, h5, h6");
+    if (heading) {
+      const txt = trim(textContentVisible(heading));
+      if (txt) return cap(txt);
+    }
+    return "";
+  }
+  __name(landmarkLabel, "landmarkLabel");
+  function testIdOf(el) {
+    const t = el.getAttribute("data-testid");
+    if (t) return t;
+    const qa = el.getAttribute("data-qa");
+    if (qa) return qa;
+    return void 0;
+  }
+  __name(testIdOf, "testIdOf");
+  function idStable(id) {
+    if (!id || id.length > 40) return false;
+    if (id.startsWith(":") || id.startsWith("__")) return false;
+    const digits = id.replace(/\D/g, "").length;
+    return !(id.length > 8 && digits * 2 > id.length);
+  }
+  __name(idStable, "idStable");
+  function stableDataAttr(el) {
+    const skip = /^data-(unotest|v-|react|ng-|svelte|qa|testid|sort|shadow|tooltip|toggle|target|bs-|original-title)/;
+    const idLike = /(^|[-_])(id|guid|uid|key|code|ref|num|no)$/;
+    for (const a of Array.from(el.attributes)) {
+      if (!a.name.startsWith("data-") || skip.test(a.name) || !idLike.test(a.name)) continue;
+      const v = (a.value ?? "").trim();
+      if (!v || v.length > 64) continue;
+      if (/^\d+$/.test(v) || idStable(v)) return { name: a.name, value: v };
+    }
+    return void 0;
+  }
+  __name(stableDataAttr, "stableDataAttr");
+  function tooltipLabel(el) {
+    for (const a of Array.from(el.attributes)) {
+      if (!a.name.startsWith("data-") || a.name.startsWith("data-unotest")) continue;
+      if (!/(^|-)(title|tooltip|label)$/.test(a.name)) continue;
+      const v = trim(a.value);
+      if (v) return v.length > 120 ? v.slice(0, 119) + "\u2026" : v;
+    }
+    return void 0;
+  }
+  __name(tooltipLabel, "tooltipLabel");
+  function tooltipText(el, name) {
+    const t = trim(el.getAttribute("title") ?? el.getAttribute("aria-label")) || tooltipLabel(el);
+    if (!t || t === name) return void 0;
+    return t.length > 120 ? t.slice(0, 119) + "\u2026" : t;
+  }
+  __name(tooltipText, "tooltipText");
+  function clickAffordance(el) {
+    if (el.hasAttribute("onclick")) return true;
+    const cls = el.getAttribute("class") ?? "";
+    if (/(^|\s)hover:/.test(cls) || /\bcursor-pointer\b/.test(cls) || /\bclickable\b/.test(cls)) {
+      return true;
+    }
+    try {
+      return window.getComputedStyle(el).cursor === "pointer";
+    } catch {
+      return false;
+    }
+  }
+  __name(clickAffordance, "clickAffordance");
+  const viewport = { width: window.innerWidth, height: window.innerHeight };
+  function classifyViewport(b) {
+    if (viewport.width <= 0 || viewport.height <= 0) return void 0;
+    const top = b.y;
+    const bottom = b.y + b.h;
+    const left = b.x;
+    const right = b.x + b.w;
+    const vTop = 0;
+    const vBottom = viewport.height;
+    const vLeft = 0;
+    const vRight = viewport.width;
+    if (bottom <= vTop) return "above";
+    if (top >= vBottom) return "below";
+    if (right <= vLeft || left >= vRight) {
+      return "partial";
+    }
+    if (top >= vTop && bottom <= vBottom && left >= vLeft && right <= vRight) {
+      return void 0;
+    }
+    return "partial";
+  }
+  __name(classifyViewport, "classifyViewport");
+  function isClipped(b) {
+    return b.x < 0 && b.x + b.width > 0 || b.y < 0 && b.y + b.height > 0 || b.x < viewport.width && b.x + b.width > viewport.width || b.y < viewport.height && b.y + b.height > viewport.height;
+  }
+  __name(isClipped, "isClipped");
+  function rectToBox(r) {
+    return { x: r.x, y: r.y, w: r.width, h: r.height };
+  }
+  __name(rectToBox, "rectToBox");
+  function unionBox(a, b) {
+    if (!a) return b;
+    const x1 = Math.min(a.x, b.x);
+    const y1 = Math.min(a.y, b.y);
+    const x2 = Math.max(a.x + a.w, b.x + b.w);
+    const y2 = Math.max(a.y + a.h, b.y + b.h);
+    return { x: x1, y: y1, w: x2 - x1, h: y2 - y1 };
+  }
+  __name(unionBox, "unionBox");
+  function findTrAncestor(el) {
+    for (let p = parentOrHost(el); p; p = parentOrHost(p)) {
+      if (p.tagName.toLowerCase() === "tr") return p;
+    }
+    return null;
+  }
+  __name(findTrAncestor, "findTrAncestor");
+  const interactiveElements = [];
+  const clickableEls = /* @__PURE__ */ new Set();
+  for (const el of deepWalk(document)) {
+    if (!isVisible(el)) continue;
+    if (isInteractive(el)) {
+      interactiveElements.push(el);
+      continue;
+    }
+    const da = stableDataAttr(el);
+    if (da && trim(textContentVisible(el)) && clickAffordance(el)) {
+      interactiveElements.push(el);
+      clickableEls.add(el);
+    }
+  }
+  const refRegex = /^e\d+$/;
+  const previouslyRefed = /* @__PURE__ */ new Map();
+  for (const el of deepWalk(document)) {
+    const v = el.getAttribute("data-unotest-ref");
+    if (v && refRegex.test(v)) previouslyRefed.set(el, v);
+  }
+  const html = document.documentElement;
+  let refCounter = Number.parseInt(
+    html.getAttribute("data-unotest-ref-counter") || "0",
+    10
+  );
+  if (!Number.isFinite(refCounter) || refCounter < 0) refCounter = 0;
+  const refByElement = /* @__PURE__ */ new Map();
+  if (!assignRefs) {
+    for (const el of interactiveElements) {
+      const existing = previouslyRefed.get(el);
+      if (existing) refByElement.set(el, existing);
+    }
+  } else {
+    const kept = /* @__PURE__ */ new Set();
+    for (const el of interactiveElements) {
+      const existing = previouslyRefed.get(el);
+      if (existing) {
+        refByElement.set(el, existing);
+        el.setAttribute("data-unotest-ref-kind", "i");
+        kept.add(el);
+      } else {
+        refCounter += 1;
+        const ref = "e" + refCounter;
+        el.setAttribute("data-unotest-ref", ref);
+        el.setAttribute("data-unotest-ref-kind", "i");
+        refByElement.set(el, ref);
+        kept.add(el);
+      }
+    }
+    for (const [el] of previouslyRefed) {
+      if (kept.has(el)) continue;
+      if (el.getAttribute("data-unotest-ref-kind") !== "i") continue;
+      el.removeAttribute("data-unotest-ref");
+      el.removeAttribute("data-unotest-ref-kind");
+    }
+    html.setAttribute("data-unotest-ref-counter", String(refCounter));
+  }
+  const MAX_TEXT = 80;
+  const entries = [];
+  for (const el of interactiveElements) {
+    const tag = el.tagName.toLowerCase();
+    const isClk = clickableEls.has(el);
+    let name = accname(el);
+    if (isClk && !name) {
+      const t = trim(textContentVisible(el));
+      name = t.length > MAX_TEXT ? t.slice(0, MAX_TEXT - 1) + "\u2026" : t;
+    }
+    if (!name) name = tooltipLabel(el) ?? "";
+    let href;
+    if (!name && tag === "a") {
+      const h = shortenedHref(el.getAttribute("href"));
+      if (h) href = h;
+    }
+    entries.push({
+      el,
+      role: computeRole(el) ?? (tag === "tr" ? "row" : tag === "li" ? "listitem" : null),
+      name,
+      testId: testIdOf(el),
+      dataId: stableDataAttr(el),
+      title: tooltipText(el, name),
+      ...isClk ? { clickable: true } : {},
+      href,
+      state: collectState(el),
+      bbox: el.getBoundingClientRect(),
+      landmark: findLandmark(el),
+      // A row element groups as its own row-unit (findTrAncestor looks at
+      // ANCESTORS and would return null for the <tr> itself).
+      trAncestor: tag === "tr" ? el : findTrAncestor(el)
+    });
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  let docOrderCounter = 0;
+  function getBucket(landmark) {
+    const key = landmark ? landmark.element : "body";
+    let b = buckets.get(key);
+    if (!b) {
+      b = {
+        kind: landmark ? landmark.kind : "body",
+        label: landmark ? landmark.label : "",
+        landmarkBox: landmark ? rectToBox(landmark.element.getBoundingClientRect()) : null,
+        actionUnion: null,
+        actions: [],
+        firstDocOrder: docOrderCounter++
+      };
+      buckets.set(key, b);
+    }
+    return b;
+  }
+  __name(getBucket, "getBucket");
+  const ROW_COLLAPSE_MIN = 5;
+  const ROW_KEEP_HEAD = 2;
+  const ROW_KEEP_TAIL = 1;
+  function signatureOfRow(start, end) {
+    const parts = [];
+    for (let k = start; k < end; k++) {
+      parts.push(entries[k].role ?? "");
+    }
+    return parts.join(",");
+  }
+  __name(signatureOfRow, "signatureOfRow");
+  function collapseRowRuns() {
+    const out = [];
+    let i = 0;
+    while (i < entries.length) {
+      const tr = entries[i].trAncestor;
+      if (tr === null) {
+        out.push({ kind: "entry", entry: entries[i] });
+        i++;
+        continue;
+      }
+      let firstEnd = i + 1;
+      while (firstEnd < entries.length && entries[firstEnd].trAncestor === tr) {
+        firstEnd++;
+      }
+      const firstSig = signatureOfRow(i, firstEnd);
+      const runRows = [
+        { tr, start: i, end: firstEnd, sig: firstSig }
+      ];
+      let scan = firstEnd;
+      while (scan < entries.length) {
+        const nextTr = entries[scan].trAncestor;
+        if (nextTr === null || nextTr === tr) {
+          break;
+        }
+        let nextEnd = scan + 1;
+        while (nextEnd < entries.length && entries[nextEnd].trAncestor === nextTr) {
+          nextEnd++;
+        }
+        const nextSig = signatureOfRow(scan, nextEnd);
+        if (nextSig !== firstSig) break;
+        runRows.push({ tr: nextTr, start: scan, end: nextEnd, sig: nextSig });
+        scan = nextEnd;
+      }
+      if (runRows.length >= ROW_COLLAPSE_MIN) {
+        for (let r = 0; r < ROW_KEEP_HEAD; r++) {
+          const g = runRows[r];
+          for (let k = g.start; k < g.end; k++) {
+            out.push({ kind: "entry", entry: entries[k] });
+          }
+        }
+        const omitted = runRows.length - ROW_KEEP_HEAD - ROW_KEEP_TAIL;
+        out.push({
+          kind: "summary",
+          text: `\u2026 ${omitted} similar rows \u2026`,
+          landmark: entries[runRows[0].start].landmark
+        });
+        for (let r = runRows.length - ROW_KEEP_TAIL; r < runRows.length; r++) {
+          const g = runRows[r];
+          for (let k = g.start; k < g.end; k++) {
+            out.push({ kind: "entry", entry: entries[k] });
+          }
+        }
+      } else {
+        for (const g of runRows) {
+          for (let k = g.start; k < g.end; k++) {
+            out.push({ kind: "entry", entry: entries[k] });
+          }
+        }
+      }
+      i = scan;
+    }
+    return out;
+  }
+  __name(collapseRowRuns, "collapseRowRuns");
+  const finalItems = collapseRowRuns();
+  let total = 0;
+  for (const item of finalItems) {
+    total++;
+    if (item.kind === "summary") {
+      const bucket2 = getBucket(item.landmark);
+      bucket2.actions.push({ text: item.text });
+      continue;
+    }
+    const e = item.entry;
+    const action = {};
+    if (e.role) action.role = e.role;
+    if (e.name) action.text = e.name;
+    if (e.testId) action.testId = e.testId;
+    if (e.dataId) action.dataId = e.dataId;
+    if (e.title) action.title = e.title;
+    if (e.clickable) action.clickable = true;
+    if (e.href) action.href = e.href;
+    if (e.state) action.state = e.state;
+    if (isClipped(e.bbox)) action.clipped = true;
+    const ref = refByElement.get(e.el);
+    if (ref) action.ref = ref;
+    const box = rectToBox(e.bbox);
+    action.bounds = {
+      x: Math.round(box.x),
+      y: Math.round(box.y),
+      w: Math.round(box.w),
+      h: Math.round(box.h)
+    };
+    const bucket = getBucket(e.landmark);
+    bucket.actions.push(action);
+    bucket.actionUnion = unionBox(bucket.actionUnion, box);
+  }
+  const regionCounts = { inView: 0, above: 0, below: 0, partial: 0 };
+  const regions = Array.from(buckets.values()).sort((a, b) => a.firstDocOrder - b.firstDocOrder).filter((b) => b.actions.length > 0).map((b) => {
+    const region = { kind: b.kind, actions: b.actions };
+    if (b.label) region.label = b.label;
+    const classifyBox = b.landmarkBox ?? b.actionUnion;
+    const vp = classifyBox ? classifyViewport(classifyBox) : void 0;
+    if (vp) region.viewport = vp;
+    if (vp === "above") regionCounts.above++;
+    else if (vp === "below") regionCounts.below++;
+    else if (vp === "partial") regionCounts.partial++;
+    else regionCounts.inView++;
+    return region;
+  });
+  return {
+    regions,
+    _meta: {
+      totalActions: total,
+      totalRegions: regions.length,
+      regionCounts,
+      viewport,
+      mode: "outline"
+    }
+  };
+}
+__name(outlineAlgorithm, "outlineAlgorithm");
+
+// src/inspection/aria-snapshot-capture.ts
+import { ariaSnapshotAlgorithm as ariaSnapshotAlgorithmInjectable } from "@unotest/web/internal/page-inject";
+function ariaSnapshotAlgorithm() {
+  function* deepWalk(root) {
+    const children = root.children;
+    for (let i = 0; i < children.length; i++) {
+      const el = children[i];
+      yield el;
+      const sr = el.shadowRoot;
+      if (sr) yield* deepWalk(sr);
+      yield* deepWalk(el);
+    }
+  }
+  __name(deepWalk, "deepWalk");
+  function parentOrHost(node) {
+    const parent = node.parentNode;
+    if (!parent) return null;
+    if (parent instanceof ShadowRoot) return parent.host;
+    return parent instanceof Element ? parent : null;
+  }
+  __name(parentOrHost, "parentOrHost");
+  function rootForScope(el) {
+    const root = el.getRootNode();
+    return root instanceof ShadowRoot ? root : document;
+  }
+  __name(rootForScope, "rootForScope");
+  function getElementByIdInScope(el, id) {
+    return rootForScope(el).getElementById(id);
+  }
+  __name(getElementByIdInScope, "getElementByIdInScope");
+  function isVisible(el) {
+    if (!el.getClientRects || el.getClientRects().length === 0) return false;
+    const cs = window.getComputedStyle(el);
+    if (cs.display === "none" || cs.visibility === "hidden") return false;
+    if (Number.parseFloat(cs.opacity || "1") < 0.01) return false;
+    for (let p = el; p; p = parentOrHost(p)) {
+      if (p.getAttribute && p.getAttribute("aria-hidden") === "true") return false;
+    }
+    const r = el.getBoundingClientRect();
+    if (r.width === 0 && r.height === 0) return false;
+    return true;
+  }
+  __name(isVisible, "isVisible");
+  const INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+    "button",
+    "link",
+    "checkbox",
+    "radio",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "tab",
+    "option",
+    "switch",
+    "combobox",
+    "listbox",
+    "slider",
+    "spinbutton",
+    "searchbox",
+    "textbox"
+  ]);
+  const NAMED_STRUCTURAL_ROLES = /* @__PURE__ */ new Set([
+    "heading",
+    "list",
+    "listitem",
+    "table",
+    "row",
+    "cell",
+    "columnheader",
+    "rowheader",
+    "img",
+    "figure",
+    "code",
+    "blockquote",
+    "separator",
+    "group",
+    "paragraph"
+  ]);
+  const LANDMARK_ROLES = /* @__PURE__ */ new Set([
+    "banner",
+    "navigation",
+    "main",
+    "complementary",
+    "contentinfo",
+    "form",
+    "search",
+    "region",
+    "dialog",
+    "alertdialog",
+    "article"
+  ]);
+  function implicitRole(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "a") {
+      return el.hasAttribute("href") ? "link" : null;
+    }
+    if (tag === "button") return "button";
+    if (tag === "summary") return "button";
+    if (tag === "textarea") return "textbox";
+    if (tag === "select") {
+      const s = el;
+      return s.multiple || s.size > 1 ? "listbox" : "combobox";
+    }
+    if (tag === "input") {
+      const t = (el.type || "text").toLowerCase();
+      if (t === "button" || t === "submit" || t === "reset" || t === "image") return "button";
+      if (t === "checkbox") return "checkbox";
+      if (t === "radio") return "radio";
+      if (t === "range") return "slider";
+      if (t === "number") return "spinbutton";
+      if (t === "search") return "searchbox";
+      if (t === "hidden") return null;
+      return "textbox";
+    }
+    if (tag === "h1" || tag === "h2" || tag === "h3" || tag === "h4" || tag === "h5" || tag === "h6") {
+      return "heading";
+    }
+    if (tag === "nav") return "navigation";
+    if (tag === "header") return "banner";
+    if (tag === "main") return "main";
+    if (tag === "aside") return "complementary";
+    if (tag === "footer") return "contentinfo";
+    if (tag === "form") return "form";
+    if (tag === "article") return "article";
+    if (tag === "dialog") return "dialog";
+    if (tag === "section") {
+      if (el.hasAttribute("aria-label") || el.hasAttribute("aria-labelledby")) {
+        return "region";
+      }
+      return null;
+    }
+    if (tag === "ul" || tag === "ol" || tag === "menu") return "list";
+    if (tag === "li") return "listitem";
+    if (tag === "table") return "table";
+    if (tag === "tr") return "row";
+    if (tag === "td") return "cell";
+    if (tag === "th") {
+      const scope = (el.getAttribute("scope") || "").toLowerCase();
+      return scope === "row" ? "rowheader" : "columnheader";
+    }
+    if (tag === "p") return "paragraph";
+    if (tag === "figure") return "figure";
+    if (tag === "figcaption") return "caption";
+    if (tag === "img") {
+      const alt = el.getAttribute("alt");
+      if (alt === "") return null;
+      return "img";
+    }
+    if (tag === "code") return "code";
+    if (tag === "pre") return "code";
+    if (tag === "blockquote") return "blockquote";
+    if (tag === "hr") return "separator";
+    if (tag === "details") return "group";
+    if (tag === "fieldset") return "group";
+    if (tag === "iframe") return "iframe";
+    return null;
+  }
+  __name(implicitRole, "implicitRole");
+  function computeRole(el) {
+    const explicit = el.getAttribute("role");
+    if (explicit) return explicit.split(/\s+/)[0].toLowerCase();
+    return implicitRole(el);
+  }
+  __name(computeRole, "computeRole");
+  const MAX_NAME = 80;
+  function trim(s) {
+    return (s ?? "").replace(/\s+/g, " ").trim();
+  }
+  __name(trim, "trim");
+  function cap(s) {
+    return s.length > MAX_NAME ? s.slice(0, MAX_NAME - 1) + "\u2026" : s;
+  }
+  __name(cap, "cap");
+  function cssEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+  __name(cssEscape, "cssEscape");
+  function textContentVisible(el) {
+    const ht = el;
+    if (typeof ht.innerText === "string") return ht.innerText;
+    return el.textContent ?? "";
+  }
+  __name(textContentVisible, "textContentVisible");
+  function composedAccname(el, seen) {
+    const parts = [];
+    for (const child of Array.from(el.childNodes)) {
+      if (child.nodeType === 3) {
+        const t = trim(child.nodeValue);
+        if (t) parts.push(t);
+        continue;
+      }
+      if (child.nodeType !== 1) continue;
+      const ce = child;
+      if (!isVisible(ce)) continue;
+      if (seen.has(ce)) continue;
+      seen.add(ce);
+      const tag = ce.tagName.toLowerCase();
+      if (tag === "img") {
+        const alt = trim(ce.getAttribute("alt"));
+        if (alt) parts.push(alt);
+        continue;
+      }
+      if (tag === "svg") {
+        const sn = svgAccname(ce, seen);
+        if (sn) parts.push(sn);
+        continue;
+      }
+      const sub = composedAccname(ce, seen);
+      if (sub) parts.push(sub);
+    }
+    return trim(parts.join(" "));
+  }
+  __name(composedAccname, "composedAccname");
+  function svgAccname(svg, seen) {
+    const labelledby = svg.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(svg, id);
+        if (ref && !seen.has(ref)) {
+          const n = accname(ref, seen);
+          if (n) parts.push(n);
+        }
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const ariaLabel = trim(svg.getAttribute("aria-label"));
+    if (ariaLabel) return cap(ariaLabel);
+    for (const child of Array.from(svg.children)) {
+      if (child.tagName.toLowerCase() === "title") {
+        const t = trim(child.textContent);
+        if (t) return cap(t);
+        break;
+      }
+    }
+    return "";
+  }
+  __name(svgAccname, "svgAccname");
+  function accname(el, visited) {
+    const seen = visited ?? /* @__PURE__ */ new Set();
+    if (seen.has(el)) return "";
+    seen.add(el);
+    const labelledby = el.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(el, id);
+        if (ref && !seen.has(ref)) {
+          const n = accname(ref, seen);
+          if (n) parts.push(n);
+        }
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const ariaLabel = trim(el.getAttribute("aria-label"));
+    if (ariaLabel) return cap(ariaLabel);
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      const id = el.id;
+      if (id) {
+        const lbl = rootForScope(el).querySelector(
+          `label[for="${cssEscape(id)}"]`
+        );
+        if (lbl) {
+          const n = trim(textContentVisible(lbl));
+          if (n) return cap(n);
+        }
+      }
+      let p = parentOrHost(el);
+      while (p) {
+        if (p.tagName.toLowerCase() === "label") {
+          const n = trim(textContentVisible(p));
+          if (n) return cap(n);
+          break;
+        }
+        p = parentOrHost(p);
+      }
+      if (tag === "input") {
+        const it = el.type?.toLowerCase();
+        if (it === "button" || it === "submit" || it === "reset") {
+          const v = trim(el.value);
+          if (v) return cap(v);
+        }
+        const ph = trim(el.placeholder);
+        if (ph) return cap(ph);
+      }
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      return "";
+    }
+    if (tag === "button" || tag === "a" || tag === "summary") {
+      const composed = composedAccname(el, seen);
+      if (composed) return cap(composed);
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      return "";
+    }
+    if (tag === "h1" || tag === "h2" || tag === "h3" || tag === "h4" || tag === "h5" || tag === "h6") {
+      return cap(trim(textContentVisible(el)));
+    }
+    if (tag === "img") {
+      return cap(trim(el.getAttribute("alt")));
+    }
+    if (tag === "iframe") {
+      const t2 = trim(el.getAttribute("title"));
+      if (t2) return cap(t2);
+      return "";
+    }
+    if (tag === "figure") {
+      for (const child of Array.from(el.children)) {
+        if (child.tagName.toLowerCase() === "figcaption") {
+          const t2 = trim(textContentVisible(child));
+          if (t2) return cap(t2);
+          break;
+        }
+      }
+      return "";
+    }
+    if (tag === "fieldset") {
+      for (const child of Array.from(el.children)) {
+        if (child.tagName.toLowerCase() === "legend") {
+          const t2 = trim(textContentVisible(child));
+          if (t2) return cap(t2);
+          break;
+        }
+      }
+      return "";
+    }
+    if (tag === "form" || tag === "nav" || tag === "header" || tag === "main" || tag === "aside" || tag === "footer" || tag === "section" || tag === "article" || tag === "dialog") {
+      return "";
+    }
+    if (tag === "ul" || tag === "ol" || tag === "menu" || tag === "li" || tag === "table" || tag === "tr" || tag === "td" || tag === "th" || tag === "p" || tag === "code" || tag === "pre" || tag === "blockquote" || tag === "details") {
+      return "";
+    }
+    const inner = trim(textContentVisible(el));
+    if (inner) return cap(inner);
+    const t = trim(el.getAttribute("title"));
+    return cap(t);
+  }
+  __name(accname, "accname");
+  function collectState(el, role) {
+    const state = {};
+    const tag = el.tagName.toLowerCase();
+    if (el.getAttribute("aria-disabled") === "true" || el.disabled) {
+      state.disabled = true;
+    }
+    const ariaChecked = el.getAttribute("aria-checked");
+    if (ariaChecked === "true") state.checked = true;
+    else if (ariaChecked === "mixed") state.checked = "mixed";
+    else if (tag === "input" && (el.type === "checkbox" || el.type === "radio") && el.checked) {
+      state.checked = true;
+    }
+    const ariaPressed = el.getAttribute("aria-pressed");
+    if (ariaPressed === "true") state.pressed = true;
+    else if (ariaPressed === "mixed") state.pressed = "mixed";
+    if (el.getAttribute("aria-expanded") === "true") state.expanded = true;
+    if (el.getAttribute("aria-selected") === "true") state.selected = true;
+    else if (tag === "option" && el.selected) {
+      state.selected = true;
+    }
+    if (rootForScope(el).activeElement === el) state.active = true;
+    if (role === "heading") {
+      if (tag === "h1") state.level = 1;
+      else if (tag === "h2") state.level = 2;
+      else if (tag === "h3") state.level = 3;
+      else if (tag === "h4") state.level = 4;
+      else if (tag === "h5") state.level = 5;
+      else if (tag === "h6") state.level = 6;
+      const ariaLevel = el.getAttribute("aria-level");
+      if (ariaLevel) {
+        const n = Number.parseInt(ariaLevel, 10);
+        if (Number.isFinite(n) && n > 0) state.level = n;
+      }
+    }
+    return Object.keys(state).length > 0 ? state : void 0;
+  }
+  __name(collectState, "collectState");
+  const pageOrigin = (() => {
+    try {
+      return window.location.origin;
+    } catch {
+      return "";
+    }
+  })();
+  function normaliseHref(raw) {
+    if (!raw) return void 0;
+    let href = raw.trim();
+    if (!href) return void 0;
+    if (pageOrigin && href.startsWith(pageOrigin)) {
+      href = href.slice(pageOrigin.length) || "/";
+    }
+    return href;
+  }
+  __name(normaliseHref, "normaliseHref");
+  const REF_REGEX = /^e\d+$/;
+  const html = document.documentElement;
+  let refCounter = Number.parseInt(
+    html.getAttribute("data-unotest-ref-counter") || "0",
+    10
+  );
+  if (!Number.isFinite(refCounter) || refCounter < 0) refCounter = 0;
+  function ensureRef(el, role) {
+    const existing = el.getAttribute("data-unotest-ref");
+    if (existing && REF_REGEX.test(existing)) return existing;
+    refCounter += 1;
+    const ref = "e" + refCounter;
+    el.setAttribute("data-unotest-ref", ref);
+    const interactive = INTERACTIVE_ROLES.has(role);
+    el.setAttribute("data-unotest-ref-kind", interactive ? "i" : "n");
+    return ref;
+  }
+  __name(ensureRef, "ensureRef");
+  let totalNodes = 0;
+  let totalRefs = 0;
+  let frameCounter = 0;
+  function shouldInclude(role) {
+    if (!role) return false;
+    if (INTERACTIVE_ROLES.has(role)) return true;
+    if (NAMED_STRUCTURAL_ROLES.has(role)) return true;
+    if (LANDMARK_ROLES.has(role)) return true;
+    if (role === "caption") return true;
+    return false;
+  }
+  __name(shouldInclude, "shouldInclude");
+  function makeRef(el, role, refPrefix) {
+    const localRef = ensureRef(el, role);
+    totalRefs += 1;
+    return refPrefix ? `${refPrefix}${localRef}` : localRef;
+  }
+  __name(makeRef, "makeRef");
+  function pushText(text, bucket, parentName) {
+    const t = text;
+    if (parentName && parentName === t) return;
+    for (const existing of bucket) {
+      if (existing.name === t) return;
+    }
+    bucket.push({ role: "text", name: t, children: [] });
+    totalNodes += 1;
+  }
+  __name(pushText, "pushText");
+  function descendInto(parent, bucket, refPrefix, parentName) {
+    const buf = { value: "" };
+    function flush() {
+      const t = trim(buf.value);
+      if (t) pushText(t, bucket, parentName);
+      buf.value = "";
+    }
+    __name(flush, "flush");
+    function consume(node) {
+      if (node.nodeType === 3) {
+        buf.value += node.nodeValue ?? "";
+        return;
+      }
+      if (node.nodeType !== 1) return;
+      const el = node;
+      if (!isVisible(el)) return;
+      const tag = el.tagName.toLowerCase();
+      if (tag === "script" || tag === "style" || tag === "noscript") return;
+      if (tag === "iframe") {
+        flush();
+        visit(el, bucket, refPrefix, parentName);
+        return;
+      }
+      const role = computeRole(el);
+      if (shouldInclude(role)) {
+        flush();
+        visit(el, bucket, refPrefix, parentName);
+        return;
+      }
+      const sr2 = el.shadowRoot;
+      if (sr2) {
+        for (const c of Array.from(sr2.childNodes)) consume(c);
+      }
+      for (const c of Array.from(el.childNodes)) consume(c);
+    }
+    __name(consume, "consume");
+    const sr = parent.shadowRoot;
+    if (sr) {
+      for (const c of Array.from(sr.childNodes)) consume(c);
+    }
+    for (const c of Array.from(parent.childNodes)) consume(c);
+    flush();
+  }
+  __name(descendInto, "descendInto");
+  function visit(el, parentBucket, refPrefix, _parentName) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "iframe") {
+      const name2 = accname(el);
+      const ref = makeRef(el, "iframe", refPrefix);
+      const node2 = { role: "iframe", name: name2, ref, children: [] };
+      let inner = null;
+      try {
+        inner = el.contentDocument;
+      } catch {
+        inner = null;
+      }
+      if (inner && inner.body) {
+        frameCounter += 1;
+        const innerPrefix = `f${frameCounter}`;
+        descendInto(inner.body, node2.children, innerPrefix, name2);
+      }
+      totalNodes += 1;
+      parentBucket.push(node2);
+      return;
+    }
+    const role = computeRole(el);
+    const name = accname(el);
+    const node = { role, name, children: [] };
+    node.ref = makeRef(el, role, refPrefix);
+    if (role === "link") {
+      const url = normaliseHref(
+        el.getAttribute("href")
+      );
+      if (url) node.url = url;
+    }
+    const state = collectState(el, role);
+    if (state) node.state = state;
+    totalNodes += 1;
+    parentBucket.push(node);
+    if (role === "paragraph" || role === "code") {
+      if (!node.name) {
+        const t = trim(textContentVisible(el));
+        if (t) node.name = t;
+      }
+      return;
+    }
+    if (role === "heading") return;
+    if (role === "button" || role === "tab" || role === "menuitem" || role === "option") {
+      return;
+    }
+    descendInto(el, node.children, refPrefix, name);
+  }
+  __name(visit, "visit");
+  const ROW_COLLAPSE_MIN = 5;
+  const ROW_KEEP_HEAD = 2;
+  const ROW_KEEP_TAIL = 1;
+  function signatureOf(node) {
+    const roles = node.children.map((c) => c.role).join(",");
+    return `${node.role}:[${roles}]`;
+  }
+  __name(signatureOf, "signatureOf");
+  function collapseRepetitiveRows(node) {
+    for (const c of node.children) collapseRepetitiveRows(c);
+    if (node.children.length < ROW_COLLAPSE_MIN) return;
+    const out = [];
+    let i = 0;
+    while (i < node.children.length) {
+      const sig = signatureOf(node.children[i]);
+      const isRowRun = node.children[i].role === "row";
+      let j = i + 1;
+      if (isRowRun) {
+        while (j < node.children.length && node.children[j].role === "row" && signatureOf(node.children[j]) === sig) {
+          j++;
+        }
+      }
+      const runLen = j - i;
+      if (isRowRun && runLen >= ROW_COLLAPSE_MIN) {
+        for (let k = 0; k < ROW_KEEP_HEAD; k++) out.push(node.children[i + k]);
+        const omitted = runLen - ROW_KEEP_HEAD - ROW_KEEP_TAIL;
+        out.push({
+          role: "text",
+          name: `\u2026 ${omitted} similar rows \u2026`,
+          children: []
+        });
+        for (let k = ROW_KEEP_TAIL; k > 0; k--) {
+          out.push(node.children[j - k]);
+        }
+      } else {
+        for (let k = i; k < j; k++) out.push(node.children[k]);
+        if (!isRowRun) j = i + 1;
+      }
+      i = j;
+    }
+    node.children = out;
+  }
+  __name(collapseRepetitiveRows, "collapseRepetitiveRows");
+  function recountTree(roots) {
+    let nodes2 = 0;
+    let refs = 0;
+    function walk(n) {
+      nodes2 += 1;
+      if (n.ref) refs += 1;
+      for (const c of n.children) walk(c);
+    }
+    __name(walk, "walk");
+    for (const r of roots) walk(r);
+    return { nodes: nodes2, refs };
+  }
+  __name(recountTree, "recountTree");
+  const rootBucket = [];
+  const body = document.body;
+  if (body) {
+    descendInto(body, rootBucket, "", "");
+  }
+  html.setAttribute("data-unotest-ref-counter", String(refCounter));
+  for (const r of rootBucket) collapseRepetitiveRows(r);
+  const recounted = recountTree(rootBucket);
+  totalNodes = recounted.nodes;
+  totalRefs = recounted.refs;
+  const nodes = rootBucket;
+  return {
+    nodes,
+    _meta: {
+      totalNodes,
+      totalRefs,
+      viewport: { width: window.innerWidth, height: window.innerHeight },
+      mode: "aria"
+    }
+  };
+}
+__name(ariaSnapshotAlgorithm, "ariaSnapshotAlgorithm");
+
+// src/inspection/full-html-capture.ts
+import { serializeRuntimeDom as serializeRuntimeDomInjectable } from "@unotest/web/internal/page-inject";
+function serializeRuntimeDom() {
+  const VOID = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  function escText(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  __name(escText, "escText");
+  function escAttr(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  }
+  __name(escAttr, "escAttr");
+  function isLiveControlledAttr(tag, name) {
+    return tag === "input" && (name === "value" || name === "checked");
+  }
+  __name(isLiveControlledAttr, "isLiveControlledAttr");
+  function runtimeAttrs(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag !== "input") return "";
+    const inp = el;
+    const type = (inp.type || "text").toLowerCase();
+    if (type === "checkbox" || type === "radio") {
+      return inp.checked ? " checked" : "";
+    }
+    return ` value="${escAttr(inp.value)}"`;
+  }
+  __name(runtimeAttrs, "runtimeAttrs");
+  function serialize(node) {
+    if (node.nodeType === 3) return escText(node.nodeValue ?? "");
+    if (node.nodeType === 8) return `<!--${node.nodeValue ?? ""}-->`;
+    if (node.nodeType !== 1) return "";
+    const el = node;
+    const tag = el.tagName.toLowerCase();
+    if (tag === "script" || tag === "style") {
+      let a = "";
+      for (const attr of Array.from(el.attributes)) a += ` ${attr.name}="${escAttr(attr.value)}"`;
+      return `<${tag}${a}>${el.textContent ?? ""}</${tag}>`;
+    }
+    let attrs = "";
+    for (const attr of Array.from(el.attributes)) {
+      if (isLiveControlledAttr(tag, attr.name)) continue;
+      attrs += ` ${attr.name}="${escAttr(attr.value)}"`;
+    }
+    attrs += runtimeAttrs(el);
+    let html = `<${tag}${attrs}>`;
+    if (VOID.has(tag)) return html;
+    const sr = el.shadowRoot;
+    if (sr) {
+      html += `<template shadowrootmode="open">`;
+      for (const c of Array.from(sr.childNodes)) html += serialize(c);
+      html += `</template>`;
+    }
+    if (tag === "textarea") {
+      html += escText(el.value);
+    } else {
+      for (const c of Array.from(el.childNodes)) html += serialize(c);
+    }
+    html += `</${tag}>`;
+    return html;
+  }
+  __name(serialize, "serialize");
+  return "<!DOCTYPE html>\n" + serialize(document.documentElement);
+}
+__name(serializeRuntimeDom, "serializeRuntimeDom");
+
+// src/inspection/find-element.ts
+import { findElementAlgorithm as findElementAlgorithmInjectable } from "@unotest/web/internal/page-inject";
+function findElementAlgorithm(args) {
+  function* deepWalk(root) {
+    const children = root.children;
+    for (let i = 0; i < children.length; i++) {
+      const el = children[i];
+      yield el;
+      const sr = el.shadowRoot;
+      if (sr) yield* deepWalk(sr);
+      yield* deepWalk(el);
+    }
+  }
+  __name(deepWalk, "deepWalk");
+  function parentOrHost(node) {
+    const parent = node.parentNode;
+    if (!parent) return null;
+    if (parent instanceof ShadowRoot) return parent.host;
+    return parent instanceof Element ? parent : null;
+  }
+  __name(parentOrHost, "parentOrHost");
+  function rootForScope(el) {
+    const root = el.getRootNode();
+    return root instanceof ShadowRoot ? root : document;
+  }
+  __name(rootForScope, "rootForScope");
+  function getElementByIdInScope(el, id) {
+    return rootForScope(el).getElementById(id);
+  }
+  __name(getElementByIdInScope, "getElementByIdInScope");
+  function isVisible(el) {
+    if (!el.getClientRects || el.getClientRects().length === 0) return false;
+    const cs = window.getComputedStyle(el);
+    if (cs.display === "none" || cs.visibility === "hidden") return false;
+    if (Number.parseFloat(cs.opacity || "1") < 0.01) return false;
+    for (let p = el; p; p = parentOrHost(p)) {
+      if (p.getAttribute && p.getAttribute("aria-hidden") === "true") return false;
+    }
+    const r = el.getBoundingClientRect();
+    if (r.width === 0 && r.height === 0) return false;
+    return true;
+  }
+  __name(isVisible, "isVisible");
+  function implicitRole(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === "a") return el.hasAttribute("href") ? "link" : null;
+    if (tag === "button") return "button";
+    if (tag === "summary") return "button";
+    if (tag === "textarea") return "textbox";
+    if (tag === "select") {
+      const s = el;
+      return s.multiple || s.size > 1 ? "listbox" : "combobox";
+    }
+    if (tag === "input") {
+      const t = (el.type || "text").toLowerCase();
+      if (t === "button" || t === "submit" || t === "reset" || t === "image") return "button";
+      if (t === "checkbox") return "checkbox";
+      if (t === "radio") return "radio";
+      if (t === "range") return "slider";
+      if (t === "number") return "spinbutton";
+      if (t === "search") return "searchbox";
+      if (t === "hidden") return null;
+      return "textbox";
+    }
+    if (/^h[1-6]$/.test(tag)) return "heading";
+    if (tag === "nav") return "navigation";
+    if (tag === "header") return "banner";
+    if (tag === "main") return "main";
+    if (tag === "aside") return "complementary";
+    if (tag === "footer") return "contentinfo";
+    if (tag === "form") return "form";
+    if (tag === "article") return "article";
+    if (tag === "dialog") return "dialog";
+    if (tag === "section") {
+      return el.hasAttribute("aria-label") || el.hasAttribute("aria-labelledby") ? "region" : null;
+    }
+    if (tag === "ul" || tag === "ol" || tag === "menu") return "list";
+    if (tag === "li") return "listitem";
+    if (tag === "table") return "table";
+    if (tag === "tr") return "row";
+    if (tag === "td") return "cell";
+    if (tag === "th") {
+      const scope = (el.getAttribute("scope") || "").toLowerCase();
+      return scope === "row" ? "rowheader" : "columnheader";
+    }
+    if (tag === "p") return "paragraph";
+    if (tag === "figure") return "figure";
+    if (tag === "img") {
+      const alt = el.getAttribute("alt");
+      if (alt === "") return null;
+      return "img";
+    }
+    if (tag === "details" || tag === "fieldset") return "group";
+    if (tag === "iframe") return "iframe";
+    return null;
+  }
+  __name(implicitRole, "implicitRole");
+  function computeRole(el) {
+    const explicit = el.getAttribute("role");
+    if (explicit) return explicit.split(/\s+/)[0].toLowerCase();
+    return implicitRole(el);
+  }
+  __name(computeRole, "computeRole");
+  function trim(s) {
+    return (s ?? "").replace(/\s+/g, " ").trim();
+  }
+  __name(trim, "trim");
+  function textContentVisible(el) {
+    const ht = el;
+    if (typeof ht.innerText === "string") return ht.innerText;
+    return el.textContent ?? "";
+  }
+  __name(textContentVisible, "textContentVisible");
+  const MAX_NAME = 200;
+  function cap(s) {
+    return s.length > MAX_NAME ? s.slice(0, MAX_NAME - 1) + "\u2026" : s;
+  }
+  __name(cap, "cap");
+  function accname(el, visited) {
+    const seen = visited ?? /* @__PURE__ */ new Set();
+    if (seen.has(el)) return "";
+    seen.add(el);
+    const labelledby = el.getAttribute("aria-labelledby");
+    if (labelledby) {
+      const parts = [];
+      for (const id of labelledby.split(/\s+/)) {
+        if (!id) continue;
+        const ref = getElementByIdInScope(el, id);
+        if (ref && !seen.has(ref)) {
+          const n = accname(ref, seen);
+          if (n) parts.push(n);
+        }
+      }
+      const joined = trim(parts.join(" "));
+      if (joined) return cap(joined);
+    }
+    const ariaLabel = trim(el.getAttribute("aria-label"));
+    if (ariaLabel) return cap(ariaLabel);
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input" || tag === "textarea") {
+      const ph = trim(el.placeholder);
+      if (ph) return cap(ph);
+      const t = trim(el.getAttribute("title"));
+      if (t) return cap(t);
+      return "";
+    }
+    if (tag === "img") return cap(trim(el.getAttribute("alt")));
+    if (tag === "form" || tag === "nav" || tag === "header" || tag === "main" || tag === "aside" || tag === "footer" || tag === "section" || tag === "article" || tag === "dialog" || tag === "ul" || tag === "ol" || tag === "menu" || tag === "li" || tag === "table" || tag === "tr" || tag === "td" || tag === "th" || tag === "p" || tag === "code" || tag === "pre" || tag === "blockquote" || tag === "fieldset" || tag === "details") {
+      return "";
+    }
+    return cap(trim(textContentVisible(el)));
+  }
+  __name(accname, "accname");
+  const REF_REGEX = /^e\d+$/;
+  const html = document.documentElement;
+  let refCounter = Number.parseInt(
+    html.getAttribute("data-unotest-ref-counter") || "0",
+    10
+  );
+  if (!Number.isFinite(refCounter) || refCounter < 0) refCounter = 0;
+  function ensureRef(el) {
+    const existing = el.getAttribute("data-unotest-ref");
+    if (existing && REF_REGEX.test(existing)) return existing;
+    refCounter += 1;
+    const ref = "e" + refCounter;
+    el.setAttribute("data-unotest-ref", ref);
+    el.setAttribute("data-unotest-ref-kind", "n");
+    return ref;
+  }
+  __name(ensureRef, "ensureRef");
+  let scopeRoot = document;
+  if (args.near) {
+    const scoped = document.querySelector(
+      `[data-unotest-ref="${args.near}"]`
+    );
+    if (scoped) scopeRoot = scoped;
+  }
+  const wantName = args.name ? args.name.toLowerCase() : null;
+  const hits = [];
+  function visitOne(el) {
+    if (!isVisible(el)) return;
+    const role = computeRole(el);
+    if (role === args.role) {
+      if (wantName === null) {
+        hits.push(el);
+      } else if (accname(el).toLowerCase().includes(wantName)) {
+        hits.push(el);
+      }
+    }
+  }
+  __name(visitOne, "visitOne");
+  if (scopeRoot !== document) {
+    const sr = scopeRoot.shadowRoot;
+    if (sr) {
+      for (const el of deepWalk(sr)) visitOne(el);
+    }
+  }
+  for (const el of deepWalk(scopeRoot)) visitOne(el);
+  const totalCount = hits.length;
+  let selected = hits;
+  if (args.nth !== void 0) {
+    const i = args.nth;
+    selected = i >= 0 && i < hits.length ? [hits[i]] : [];
+  } else {
+    selected = hits.slice(0, args.limit);
+  }
+  function namedAncestors(el) {
+    const chain = [];
+    let p = parentOrHost(el);
+    while (p) {
+      const role = computeRole(p);
+      if (role) {
+        const name = accname(p);
+        if (role !== "generic" || name) {
+          chain.push({ role, name, ref: ensureRef(p) });
+        }
+      }
+      p = parentOrHost(p);
+    }
+    return chain.reverse().slice(-4);
+  }
+  __name(namedAncestors, "namedAncestors");
+  const matches = selected.map((el, idx) => ({
+    ref: ensureRef(el),
+    role: args.role,
+    name: accname(el),
+    index: args.nth !== void 0 ? args.nth : idx,
+    ancestors: namedAncestors(el)
+  }));
+  html.setAttribute("data-unotest-ref-counter", String(refCounter));
+  const query = { role: args.role };
+  if (args.name !== void 0) query.name = args.name;
+  if (args.near !== void 0) query.near = args.near;
+  if (args.nth !== void 0) query.nth = args.nth;
+  return { matches, totalCount, query };
+}
+__name(findElementAlgorithm, "findElementAlgorithm");
+
+// src/inspection/page-dom.ts
+function pasteValue(el, pasted) {
+  const input = el;
+  const setter = Object.getOwnPropertyDescriptor(
+    input.constructor.prototype,
+    "value"
+  )?.set;
+  if (setter && typeof input.value === "string") {
+    setter.call(input, pasted);
+  } else {
+    input.value = pasted;
+  }
+  input.dispatchEvent(new Event("input", { bubbles: true }));
+  input.dispatchEvent(new Event("change", { bubbles: true }));
+}
+__name(pasteValue, "pasteValue");
+function readOuterHtml(el) {
+  globalThis.__name ??= (fn) => fn;
+  return el.outerHTML;
+}
+__name(readOuterHtml, "readOuterHtml");
+function inspectElementRaw(el) {
+  globalThis.__name ??= (fn) => fn;
+  const e = el;
+  const ds = e.dataset;
+  const testId = ds.testid ?? ds.qa ?? e.getAttribute("data-testid") ?? e.getAttribute("data-qa");
+  const ariaLabel = e.getAttribute("aria-label") ?? void 0;
+  const explicitRole = e.getAttribute("role") ?? void 0;
+  const tag = e.tagName.toLowerCase();
+  const inferredRole = inferRole(tag, e);
+  const role = explicitRole ?? inferredRole;
+  let name = ariaLabel;
+  if (!name) {
+    const labelledBy = e.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      const ids = labelledBy.split(/\s+/);
+      const parts = [];
+      for (const id of ids) {
+        const n = e.ownerDocument?.getElementById(id);
+        if (n) parts.push((n.textContent ?? "").trim());
+      }
+      name = parts.filter(Boolean).join(" ") || void 0;
+    }
+  }
+  const STRUCTURAL_TAGS = /* @__PURE__ */ new Set([
+    "form",
+    "nav",
+    "header",
+    "main",
+    "aside",
+    "footer",
+    "section",
+    "article",
+    "dialog",
+    "ul",
+    "ol",
+    "menu",
+    "li",
+    "table",
+    "tr",
+    "td",
+    "th",
+    "p",
+    "code",
+    "pre",
+    "blockquote",
+    "fieldset",
+    "details",
+    "thead",
+    "tbody",
+    "tfoot",
+    "colgroup",
+    "col"
+  ]);
+  const rawText = STRUCTURAL_TAGS.has(tag) ? "" : (e.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
+  const text = rawText || void 0;
+  if (!name && text) name = text;
+  const href = tag === "a" ? e.getAttribute("href") ?? void 0 : void 0;
+  const placeholder = e.placeholder?.trim() || void 0;
+  const alt = e.getAttribute("alt")?.trim() || void 0;
+  const titleAttr = e.getAttribute("title")?.trim() || void 0;
+  const rawId = e.id;
+  const idLooksStable = /* @__PURE__ */ __name((id) => {
+    if (!id || id.length > 40) return false;
+    if (id.startsWith(":") || id.startsWith("__")) return false;
+    const digits = id.replace(/\D/g, "").length;
+    return !(id.length > 8 && digits * 2 > id.length);
+  }, "idLooksStable");
+  const elementId = rawId && idLooksStable(rawId) ? rawId : void 0;
+  const nameAttr = e.getAttribute("name")?.trim() || void 0;
+  function dataIdOf(el2) {
+    const skip = /^data-(unotest|v-|react|ng-|svelte|qa|testid|sort|shadow|tooltip|toggle|target|bs-|original-title)/;
+    const idLike = /(^|[-_])(id|guid|uid|key|code|ref|num|no)$/;
+    for (const a of Array.from(el2.attributes)) {
+      if (!a.name.startsWith("data-") || skip.test(a.name) || !idLike.test(a.name)) continue;
+      const v = (a.value ?? "").trim();
+      if (!v || v.length > 64) continue;
+      if (/^\d+$/.test(v) || idLooksStable(v)) return { name: a.name, value: v };
+    }
+    return void 0;
+  }
+  __name(dataIdOf, "dataIdOf");
+  const dataAttr = dataIdOf(e);
+  const tooltipAttr = (() => {
+    for (const a of Array.from(e.attributes)) {
+      if (!a.name.startsWith("data-") || a.name.startsWith("data-unotest")) continue;
+      if (!/(^|-)(title|tooltip|label)$/.test(a.name)) continue;
+      const v = (a.value ?? "").trim();
+      if (v && v.length <= 120) return { name: a.name, value: v };
+    }
+    return void 0;
+  })();
+  function stableClassOf(el2) {
+    const cls = (el2.getAttribute("class") ?? "").trim();
+    if (!cls) return void 0;
+    for (const c of cls.split(/\s+/)) {
+      if (c.includes(":") || c.length < 3 || c.length > 30) continue;
+      const digits = c.replace(/\D/g, "").length;
+      if (digits * 2 > c.length) continue;
+      if (/^(active|open|show|hidden|selected|disabled|hover|focus)$/.test(c)) continue;
+      return c;
+    }
+    return void 0;
+  }
+  __name(stableClassOf, "stableClassOf");
+  function parentOrHost(node) {
+    const p = node.parentNode;
+    if (!p) return null;
+    if (p instanceof ShadowRoot) return p.host;
+    return p instanceof Element ? p : null;
+  }
+  __name(parentOrHost, "parentOrHost");
+  const ancestors = [];
+  for (let p = parentOrHost(e); p && ancestors.length < 6; p = parentOrHost(p)) {
+    const tid = p.dataset?.testid ?? p.getAttribute("data-qa") ?? void 0;
+    const did = dataIdOf(p);
+    const pid = p.id && idLooksStable(p.id) ? p.id : void 0;
+    const cls = stableClassOf(p);
+    if (tid || did || pid || cls) {
+      ancestors.push({
+        testId: tid ?? void 0,
+        dataAttr: did,
+        elementId: pid,
+        className: cls
+      });
+    }
+  }
+  return {
+    testId: testId ?? void 0,
+    role,
+    name,
+    ariaLabel,
+    placeholder,
+    alt,
+    titleAttr,
+    text,
+    href,
+    elementId,
+    nameAttr,
+    dataAttr,
+    tooltipAttr,
+    ancestors
+  };
+  function inferRole(tag2, el2) {
+    if (tag2 === "a" && el2.hasAttribute("href")) return "link";
+    if (tag2 === "button") return "button";
+    if (tag2 === "input") {
+      const type = (el2.getAttribute("type") ?? "text").toLowerCase();
+      if (type === "checkbox") return "checkbox";
+      if (type === "radio") return "radio";
+      if (type === "submit" || type === "button" || type === "reset") return "button";
+      if (type === "range") return "slider";
+      return "textbox";
+    }
+    if (tag2 === "textarea") return "textbox";
+    if (tag2 === "select") return "combobox";
+    if (tag2 === "img") return "img";
+    if (/^h[1-6]$/.test(tag2)) return "heading";
+    if (tag2 === "nav") return "navigation";
+    if (tag2 === "main") return "main";
+    if (tag2 === "header") return "banner";
+    if (tag2 === "footer") return "contentinfo";
+    if (tag2 === "aside") return "complementary";
+    if (tag2 === "form") return "form";
+    return void 0;
+  }
+  __name(inferRole, "inferRole");
+}
+__name(inspectElementRaw, "inspectElementRaw");
+export {
+  ariaSnapshotAlgorithm,
+  findElementAlgorithm,
+  inspectElementRaw,
+  outlineAlgorithm,
+  pasteValue,
+  readOuterHtml,
+  semanticDomAlgorithm,
+  serializeRuntimeDom
+};
+//# sourceMappingURL=page-inject.js.map