#!/usr/bin/env node
import path from "node:path";
import {
  DEFAULT_VIEWPORTS,
  classifyUrl,
  docsDir,
  ensureDir,
  extractLinks,
  fetchText,
  normalizeUrl,
  parseArgs,
  resolveOutputDir,
  slugForUrl,
  writeJson,
} from "./lib/common.mjs";
import { loadPlaywrightFromContext, resolveBrowserToolingContext } from "./lib/browser-tooling.mjs";
import { extractSeo, extractSectionsFromHtml, inferTokensFromHtml } from "./lib/html-extract.mjs";

async function main() {
  const args = parseArgs();
  const url = normalizeUrl(args._[0] || args.url).toString();
  const outputDir = resolveOutputDir(url, args.out);
  const page = await extractPage(url, { outputDir, screenshots: args.screenshots !== "false" });
  const pageDir = path.join(docsDir(outputDir), "pages");
  await writeJson(path.join(pageDir, `${slugForUrl(url)}.json`), page);
  if (args.json) process.stdout.write(`${JSON.stringify(page, null, 2)}\n`);
}

export async function extractPage(url, options = {}) {
  try {
    return await extractWithPlaywright(url, options);
  } catch (error) {
    throw new Error(
      `Browser extraction failed for ${url}. The site clone skill now requires Playwright-based extraction instead of HTML fallback because shared chrome, first-viewport evidence, and repeater detection depend on a real browser. Details: ${error.message}`,
    );
  }
}

async function extractWithPlaywright(url, { outputDir, screenshots = true, browserTooling, screenshotDir: suppliedScreenshotDir, screenshotPrefix = "source" } = {}) {
  const toolingContext = browserTooling || await resolveBrowserToolingContext({ startDir: process.cwd() });
  const playwright = await loadPlaywrightFromContext(toolingContext);
  const browser = await playwright.chromium.launch({ headless: true });
  const page = await browser.newPage();
  const screenshotMap = {};
  try {
    const htmlByViewport = {};
    const navigationProfiles = [];
    const responsiveTextGeometry = {};
    for (const viewport of DEFAULT_VIEWPORTS) {
      await page.setViewportSize({ width: viewport.width, height: viewport.height });
      const navigation = await navigateWithAdaptiveProfile(page, url);
      navigationProfiles.push({ viewport: viewport.name, ...navigation });
      responsiveTextGeometry[viewport.name] = await captureImportantTextGeometry(page);
      if (screenshots && outputDir) {
        const screenshotDir = suppliedScreenshotDir || path.join(docsDir(outputDir), "screenshots");
        await ensureDir(screenshotDir);
        const screenshotPath = path.join(screenshotDir, `${screenshotPrefix}-${slugForUrl(url)}-${viewport.name}.png`);
        await page.screenshot({ path: screenshotPath, fullPage: true });
        screenshotMap[viewport.name] = screenshotPath;
      }
      htmlByViewport[viewport.name] = await page.content();
    }
    const html = htmlByViewport.desktop || Object.values(htmlByViewport)[0];
    const seo = extractSeo(html, url);
    const desktopViewport = DEFAULT_VIEWPORTS.find((viewport) => viewport.name === "desktop") || DEFAULT_VIEWPORTS[0];
    await page.setViewportSize({ width: desktopViewport.width, height: desktopViewport.height });
    const desktopNavigation = await navigateWithAdaptiveProfile(page, url);
    const repeaterPlan = await detectRepeaterSignals(page);
    const browserData = await page.evaluate(async (repeaterPlan) => {
      const cleanText = (value) => String(value || "").replace(/\s+/g, " ").trim();
      const nonContentSelector = "script,style,noscript,template";
      const semanticText = (node) => {
        if (!node || node.nodeType !== Node.ELEMENT_NODE || node.matches(nonContentSelector)) return "";
        const clone = node.cloneNode(true);
        clone.querySelectorAll(nonContentSelector).forEach((child) => child.remove());
        return cleanText(clone.textContent);
      };
      const renderedText = (node) => {
        if (!node || node.nodeType !== Node.ELEMENT_NODE || node.matches(nonContentSelector)) return "";
        const excludedSelector = `${nonContentSelector},[hidden],[inert],[aria-hidden='true' i]`;
        const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
        const values = [];
        for (let textNode = walker.nextNode(); textNode; textNode = walker.nextNode()) {
          if (!cleanText(textNode.nodeValue)) continue;
          const parent = textNode.parentElement;
          if (!parent || parent.closest(excludedSelector)) continue;
          let current = parent;
          let excluded = false;
          while (current) {
            const styles = getComputedStyle(current);
            if (styles.display === "none" || styles.visibility === "hidden" || Number(styles.opacity || 1) <= 0) {
              excluded = true;
              break;
            }
            if (current === node) break;
            current = current.parentElement;
          }
          if (!excluded) values.push(textNode.nodeValue);
        }
        return cleanText(values.join(" "));
      };
      const rectFor = (node) => {
        const rect = node.getBoundingClientRect();
        return { x: rect.x, y: rect.y, width: rect.width, height: rect.height, top: rect.top, bottom: rect.bottom };
      };
      const isRawVisible = (node) => {
        const rect = node.getBoundingClientRect();
        const styles = getComputedStyle(node);
        return rect.width > 0 && rect.height > 0 && styles.display !== "none" && styles.visibility !== "hidden" && Number(styles.opacity || 1) > 0;
      };
      const visibleCodeTexts = (node) => Array.from(node?.querySelectorAll?.("pre,code") || [])
        .filter((candidate) => isRawVisible(candidate))
        .map((candidate) => renderedText(candidate))
        .filter(Boolean)
        .filter((value, index, values) => values.indexOf(value) === index)
        .slice(0, 12);
      const consentSelectors = [
        "#onetrust-banner-sdk",
        "#onetrust-consent-sdk",
        "[class*='onetrust' i]",
        "[id*='cookie-banner' i]",
        "[class*='cookie-banner' i]",
        "[id*='consent-banner' i]",
        "[class*='consent-banner' i]",
        "[role='dialog']",
      ].join(",");
      const consentCandidates = Array.from(document.querySelectorAll(consentSelectors)).filter(isRawVisible).filter((node) => {
        const text = renderedText(node).toLowerCase();
        const identity = `${node.id || ""} ${node.className || ""} ${node.getAttribute("aria-label") || ""}`.toLowerCase();
        const controls = Array.from(node.querySelectorAll("button,a,[role='button']")).map((control) => renderedText(control)).join(" ").toLowerCase();
        const style = getComputedStyle(node);
        const rect = node.getBoundingClientRect();
        const consentSignal = /cookie|consent|privacy preferences|tracking preferences/.test(`${identity} ${text}`);
        const actionSignal = /accept|reject|decline|customi[sz]e|preferences|allow all/.test(controls);
        const overlaySignal = style.position === "fixed" || style.position === "sticky" || node.getAttribute("role") === "dialog" || rect.width >= window.innerWidth * 0.55;
        return /onetrust|cookiebot|quantcast/.test(identity) || consentSignal && actionSignal && overlaySignal;
      });
      const consentRoots = consentCandidates.filter((node, index, all) => !all.some((candidate, candidateIndex) => candidateIndex !== index && candidate.contains(node)));
      const ignoredSurfaces = consentRoots.map((node, index) => {
        node.setAttribute("data-rp-ignored-surface", "consent-management");
        const rect = node.getBoundingClientRect();
        const identity = `${node.id || ""} ${node.className || ""}`.toLowerCase();
        return {
          id: `ignored-surface-${String(index + 1).padStart(3, "0")}`,
          kind: "consent-management",
          provider: /onetrust|ot-sdk/.test(identity) ? "onetrust" : /cookiebot/.test(identity) ? "cookiebot" : /quantcast/.test(identity) ? "quantcast" : "unknown",
          creationPolicy: "ignore",
          reason: "Destination consent must be implemented as functional infrastructure, not cloned page content.",
          textFingerprint: renderedText(node).slice(0, 240),
          rect: { top: Math.round(rect.top), left: Math.round(rect.left), width: Math.round(rect.width), height: Math.round(rect.height) },
          domRef: {
            tag: node.tagName.toLowerCase(),
            id: node.id || "",
            classTokens: String(node.className || "").split(/\s+/).filter(Boolean).slice(0, 10),
          },
        };
      });
      const isVisible = (node) => {
        if (!(node instanceof Element) || node.closest("[data-rp-ignored-surface]")) return false;
        return isRawVisible(node);
      };
      const headerSelectors = "header,[role='banner'],#header,.header,.site-header,.main-header,.masthead,.sticky-header";
      const navSelectors = "nav,[role='navigation'],.menu,.nav,.navbar,.navigation";
      const visualAssetSelectors = "img,svg";

      function pickHeader() {
        const candidates = Array.from(document.querySelectorAll(headerSelectors))
          .filter(isVisible)
          .map((node) => ({ node, rect: node.getBoundingClientRect(), styles: getComputedStyle(node) }))
          .filter(({ rect }) => rect.bottom > -8 && rect.top < Math.max(window.innerHeight * 0.55, 260));
        candidates.sort((a, b) => {
          const aTop = Math.abs(a.rect.top);
          const bTop = Math.abs(b.rect.top);
          if (aTop !== bTop) return aTop - bTop;
          return b.rect.height - a.rect.height;
        });
        return candidates[0] || null;
      }

      function visualAssetRecord(node, context = "page") {
        if (!(node instanceof Element)) return null;
        const rect = node.getBoundingClientRect();
        const styles = getComputedStyle(node);
        const tag = node.tagName.toLowerCase();
        const use = tag === "svg" ? node.querySelector("use") : null;
        const useHref = use?.getAttribute("href") || use?.getAttribute("xlink:href") || "";
        const sourceUrl = tag === "img" ? (node.currentSrc || node.src || "") : useHref;
        const accessibleName = cleanText(node.getAttribute("aria-label") || node.getAttribute("title") || node.getAttribute("alt") || node.closest("a,button")?.getAttribute("aria-label") || "");
        const identity = `${node.id || ""} ${node.className?.baseVal || node.className || ""} ${sourceUrl} ${accessibleName}`.toLowerCase();
        if (/cookielaw|onetrust|ot-sdk|cookiebot|quantcast/.test(identity)) return null;
        const owner = node.closest("header,footer,button,a,[role='button']");
        const ownerIdentity = `${owner?.className || ""} ${owner?.id || ""} ${owner?.getAttribute?.("aria-label") || ""} ${owner ? semanticText(owner) : ""}`.toLowerCase();
        const homeLink = node.closest("a")?.href && new URL(node.closest("a").href, location.href).pathname.replace(/\/+$/, "") === "";
        const social = /linkedin|instagram|facebook|twitter|youtube|tiktok|x\.com|social/.test(`${identity} ${ownerIdentity}`);
        const looksLikeLogo = /logo|wordmark|brandmark|brand-mark/.test(identity)
          || (!social && homeLink && (rect.width >= 72 || Number(node.getAttribute("width")) >= 72))
          || (!social && rect.width >= 120 && rect.width >= rect.height * 1.8 && /header|footer/.test(context));
        const kind = looksLikeLogo ? "logo" : "icon";
        const fragmentId = useHref.startsWith("#") ? useHref.slice(1) : "";
        const symbol = fragmentId ? document.getElementById(fragmentId) : null;
        const variantText = `${identity} ${context}`;
        const variant = /footer/.test(variantText) ? "footer"
          : /solid/.test(variantText) ? "solid"
            : /dark|black/.test(variantText) ? "dark"
              : /light|white/.test(variantText) ? "light"
                : /mobile|menu|drawer/.test(variantText) ? "menu"
                  : "default";
        return {
          kind,
          context,
          variant,
          sourceType: tag === "img" ? (/\.svg(?:$|[?#])/i.test(sourceUrl) ? "external-svg" : "image") : useHref ? "svg-sprite-use" : "inline-svg",
          sourceUrl,
          useHref,
          accessibleName,
          visible: isRawVisible(node),
          renderedSize: { width: Math.round(rect.width * 100) / 100, height: Math.round(rect.height * 100) / 100 },
          intrinsicSize: {
            width: node.getAttribute("width") || "",
            height: node.getAttribute("height") || "",
            viewBox: node.getAttribute("viewBox") || symbol?.getAttribute?.("viewBox") || "",
          },
          presentation: {
            color: styles.color,
            fill: styles.fill,
            stroke: styles.stroke,
          },
          svgMarkup: tag === "svg" ? node.outerHTML.slice(0, 24000) : "",
          symbolMarkup: symbol?.outerHTML?.slice(0, 24000) || "",
          domRef: {
            tag,
            id: node.id || "",
            classTokens: String(node.className?.baseVal || node.className || "").split(/\s+/).filter(Boolean).slice(0, 10),
          },
        };
      }

      function collectVisualAssets() {
        const records = [];
        const seen = new Set();
        const scopes = [
          ...Array.from(document.querySelectorAll("header,[role='banner']")).map((scope) => ({ scope, context: "header" })),
          ...Array.from(document.querySelectorAll("footer,[role='contentinfo']")).map((scope) => ({ scope, context: "footer" })),
          ...Array.from(document.querySelectorAll("button,[role='button'],a[href]")).map((scope) => ({ scope, context: scope.closest("footer") ? "footer-control" : scope.closest("header") ? "header-control" : "control" })),
        ];
        for (const { scope, context } of scopes) {
          const nodes = scope.matches?.(visualAssetSelectors) ? [scope] : Array.from(scope.querySelectorAll(visualAssetSelectors));
          for (const node of nodes) {
            if (node.closest("[data-rp-ignored-surface]")) continue;
            const record = visualAssetRecord(node, context);
            if (!record) continue;
            if (record.kind === "icon" && !record.visible && !record.useHref && !record.sourceUrl) continue;
            const key = `${record.kind}\u0000${record.sourceType}\u0000${record.sourceUrl}\u0000${record.domRef.id}\u0000${record.domRef.classTokens.join(".")}\u0000${context}`;
            if (seen.has(key)) continue;
            seen.add(key);
            records.push(record);
            if (records.length >= 120) return records;
          }
        }
        return records;
      }

      function headerVariant(name) {
        const candidate = pickHeader();
        if (!candidate) return { name, position: "unknown", height: 0, visibleAtScrollY: window.scrollY, visible: false };
        const { node, rect, styles } = candidate;
        const logo = Array.from(node.querySelectorAll(visualAssetSelectors))
          .map((asset) => ({ asset, record: visualAssetRecord(asset, `header-${name}`) }))
          .find(({ record }) => record?.kind === "logo") || null;
        const logoNode = logo?.asset || null;
        const logoRect = logoNode?.getBoundingClientRect();
        return {
          name,
          position: styles.position || "static",
          height: Math.round(rect.height),
          visibleAtScrollY: Math.round(window.scrollY),
          visible: true,
          rect: rectFor(node),
          logo: logoNode && logoRect ? {
            ...logo.record,
            sourceUrl: logo.record.sourceUrl,
            alt: logoNode.getAttribute("alt") || logo.record.accessibleName || "",
            renderedWidth: Math.round(logoRect.width),
            renderedHeight: Math.round(logoRect.height),
          } : null,
        };
      }

      function linkRecord(anchor) {
        return {
          label: semanticText(anchor).slice(0, 120),
          href: anchor.href || anchor.getAttribute("href") || "",
        };
      }

      function isSameOriginHref(href) {
        try {
          return new URL(href, window.location.href).origin === window.location.origin;
        } catch {
          return false;
        }
      }

      function navScore(scope, headerNode) {
        const anchors = Array.from(scope.querySelectorAll("a[href]")).filter(isVisible);
        if (!anchors.length) return Number.NEGATIVE_INFINITY;
        const records = anchors.map(linkRecord);
        const sameOriginCount = records.filter((item) => isSameOriginHref(item.href)).length;
        const nonEmptyLabelCount = records.filter((item) => item.label).length;
        const longLabelCount = records.filter((item) => item.label.length >= 2).length;
        const externalCount = records.length - sameOriginCount;
        const socialCount = anchors.filter((anchor) => {
          const text = semanticText(anchor).toLowerCase();
          const classText = `${anchor.className || ""} ${anchor.parentElement?.className || ""}`.toLowerCase();
          const href = String(anchor.href || "").toLowerCase();
          return /facebook|instagram|pinterest|youtube|tiktok|whatsapp|social|icon-/.test(`${text} ${classText} ${href}`);
        }).length;
        const topLevelListItems = Array.from(scope.querySelectorAll(":scope > ul > li, :scope > ol > li, :scope > li"))
          .filter(isVisible);
        const nestedListItems = Array.from(scope.querySelectorAll("li li")).filter(isVisible);
        const uniqueHrefs = new Set(records.map((item) => item.href)).size;
        const inHeader = Boolean(headerNode && headerNode.contains(scope));
        const ariaLabel = cleanText(scope.getAttribute("aria-label") || "").toLowerCase();
        const classText = `${scope.className || ""} ${scope.id || ""}`.toLowerCase();
        const textSample = semanticText(scope).toLowerCase();

        let score = 0;
        score += sameOriginCount * 10;
        score += nonEmptyLabelCount * 6;
        score += longLabelCount * 3;
        score += Math.min(topLevelListItems.length, 12) * 8;
        score += Math.min(nestedListItems.length, 24) * 3;
        score += Math.min(uniqueHrefs, 20) * 2;
        if (inHeader) score += 30;
        if (/main|primary|menu|navigation/.test(`${ariaLabel} ${classText}`)) score += 20;
        if (/social/.test(`${ariaLabel} ${classText}`)) score -= 40;
        if (sameOriginCount <= 1 && externalCount > 0) score -= 35;
        score -= externalCount * 6;
        score -= socialCount * 25;
        if (records.length <= 2 && sameOriginCount === 0) score -= 50;
        if (!topLevelListItems.length && records.length <= 3) score -= 15;
        if (/facebook|instagram/.test(textSample) && sameOriginCount === 0) score -= 50;
        return score;
      }

      function navigationItems() {
        const scopes = Array.from(document.querySelectorAll(`header ${navSelectors}, ${navSelectors}`)).filter(isVisible);
        const headerNode = pickHeader()?.node || null;
        const scoredScopes = scopes
          .map((scope) => ({ scope, score: navScore(scope, headerNode) }))
          .sort((a, b) => b.score - a.score);
        const scope = scoredScopes[0]?.scope;
        if (!scope) return [];
        const listItems = Array.from(scope.querySelectorAll("li")).filter((item) => {
          const parentLi = item.parentElement?.closest("li");
          return !parentLi || !scope.contains(parentLi);
        });
        const items = listItems.length ? listItems.map((item) => {
          const anchor = Array.from(item.children).find((child) => child.matches?.("a[href]")) || item.querySelector("a[href]");
          if (!anchor) return null;
          const children = Array.from(item.querySelectorAll("li a[href]"))
            .filter((childAnchor) => childAnchor !== anchor)
            .map(linkRecord)
            .filter((child) => child.label || child.href);
          return { ...linkRecord(anchor), children: dedupeNav(children).slice(0, 24) };
        }) : Array.from(scope.querySelectorAll("a[href]")).map((anchor) => ({ ...linkRecord(anchor), children: [] }));
        return dedupeNav(items.filter((item) => item && (item.label || item.href))).slice(0, 40);
      }

      function dedupeNav(items) {
        const seen = new Set();
        return items.filter((item) => {
          const key = `${item.label}\u0000${item.href}`;
          if (seen.has(key)) return false;
          seen.add(key);
          return true;
        });
      }

      function firstViewportText() {
        const nodes = Array.from(document.querySelectorAll("main *:not(script):not(style), body > *:not(header):not(nav):not(footer):not(script):not(style)"));
        const texts = [];
        const seen = new Set();
        for (const node of nodes) {
          if (!isVisible(node)) continue;
          if (node.closest("header,nav,footer")) continue;
          const rect = node.getBoundingClientRect();
          if (rect.bottom < 0 || rect.top > window.innerHeight) continue;
          if (Array.from(node.children).some((child) => renderedText(child) === renderedText(node))) continue;
          const text = renderedText(node);
          if (!text || text.length < 2 || seen.has(text)) continue;
          seen.add(text);
          texts.push(text.slice(0, 180));
          if (texts.length >= 80) break;
        }
        return texts;
      }

      const initialHeader = headerVariant("initial");
      const navigation = navigationItems();
      const visibleText = firstViewportText();
      const scrollTarget = Math.max(260, Math.min(document.documentElement.scrollHeight - window.innerHeight, window.innerHeight * 0.75));
      window.scrollTo(0, scrollTarget);
      await new Promise((resolve) => setTimeout(resolve, 250));
      const scrolledHeader = headerVariant("scrolled");
      window.scrollTo(0, 0);

      function domPath(node, stopNode) {
        if (!node) return "";
        const parts = [];
        let current = node;
        while (current && current.nodeType === Node.ELEMENT_NODE && current !== stopNode && parts.length < 8) {
          const tag = current.tagName.toLowerCase();
          const id = current.id ? `#${current.id}` : "";
          const classTokens = String(current.className || "")
            .split(/\s+/)
            .filter(Boolean)
            .slice(0, 2)
            .map((token) => `.${token}`)
            .join("");
          const siblings = current.parentElement
            ? Array.from(current.parentElement.children).filter((sibling) => sibling.tagName === current.tagName)
            : [];
          const nthOfType = siblings.length > 1 ? `:nth-of-type(${siblings.indexOf(current) + 1})` : "";
          parts.unshift(`${tag}${id}${classTokens}${id ? "" : nthOfType}`);
          current = current.parentElement;
        }
        return parts.join(" > ");
      }

      function visibleChildren(node) {
        return Array.from(node?.children || []).filter((child) => isVisible(child));
      }

      function visibleHeadingText(node) {
        return Array.from(node.querySelectorAll("h1,h2,h3,h4"))
          .filter(isVisible)
          .map((heading) => renderedText(heading))
          .find(Boolean) || "";
      }

      function visibleHeadings(node) {
        return Array.from(node.querySelectorAll("h1,h2,h3,h4"))
          .filter(isVisible)
          .map((heading) => ({
            level: Number(heading.tagName.replace(/^H/i, "")) || null,
            text: renderedText(heading),
          }))
          .filter((heading) => heading.text);
      }

      function isTransparentColor(value) {
        const normalized = String(value || "").replace(/\s+/g, "").toLowerCase();
        return !normalized || normalized === "transparent" || normalized === "rgba(0,0,0,0)";
      }

      function backgroundInfo(node) {
        const styles = getComputedStyle(node);
        return {
          color: styles.backgroundColor,
          image: styles.backgroundImage && styles.backgroundImage !== "none" ? styles.backgroundImage : "",
        };
      }

      function roundedBox(rect) {
        return {
          top: Math.round(rect.top + window.scrollY),
          left: Math.round(rect.left),
          width: Math.round(rect.width),
          height: Math.round(rect.height),
        };
      }

      function normalizedBox(rect, sectionRect) {
        return {
          x: Number(((rect.left - sectionRect.left) / Math.max(sectionRect.width, 1)).toFixed(3)),
          y: Number(((rect.top - sectionRect.top) / Math.max(sectionRect.height, 1)).toFixed(3)),
          width: Number((rect.width / Math.max(sectionRect.width, 1)).toFixed(3)),
          height: Number((rect.height / Math.max(sectionRect.height, 1)).toFixed(3)),
        };
      }

      function textGeometry(node, rect) {
        const styles = getComputedStyle(node);
        const lineTops = [];
        const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT, {
          acceptNode(textNode) {
            return cleanText(textNode.nodeValue).length ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
          },
        });
        for (let textNode = walker.nextNode(); textNode; textNode = walker.nextNode()) {
          const range = document.createRange();
          range.selectNodeContents(textNode);
          for (const lineRect of range.getClientRects()) {
            if (lineRect.width > 0 && lineRect.height > 0 && !lineTops.some((top) => Math.abs(top - lineRect.top) <= 2)) lineTops.push(lineRect.top);
          }
        }
        const lineCount = Math.max(1, lineTops.length);
        const maxWidth = styles.maxWidth;
        return {
          inlineSize: Math.round(rect.width * 100) / 100,
          blockSize: Math.round(rect.height * 100) / 100,
          lineCount,
          wrapPolicy: lineCount === 1 ? "single-line" : styles.whiteSpace === "nowrap" ? "clipped-or-overflowing" : "wrapped",
          whiteSpace: styles.whiteSpace,
          maxWidth,
          minWidth: styles.minWidth,
          fontSize: styles.fontSize,
          lineHeight: styles.lineHeight,
          letterSpacing: styles.letterSpacing,
        };
      }

      function layoutRole(node) {
        const tag = node.tagName.toLowerCase();
        const role = node.getAttribute("role") || "";
        const classText = `${node.className || ""} ${node.id || ""}`.toLowerCase();
        const peerControls = Array.from(node.parentElement?.children || []).filter((candidate) => {
          const candidateTag = candidate.tagName?.toLowerCase?.();
          return candidateTag === "button" || candidate.getAttribute?.("role") === "tab";
        });
        const childControls = Array.from(node.children || []).filter((candidate) => {
          const candidateTag = candidate.tagName?.toLowerCase?.();
          return candidateTag === "button" || candidate.getAttribute?.("role") === "tab";
        });
        if (role === "tablist" || /\btabs?\b|tab-list|tablist/.test(classText) || childControls.length >= 3) return "tabs";
        if (role === "tab" || /tab__btn|tab-button/.test(classText) || (tag === "button" && peerControls.length >= 3)) return "tab";
        if (/^h[1-6]$/.test(tag)) return "heading";
        if (tag === "p" || tag === "blockquote") return "body-copy";
        if (tag === "video" || tag === "iframe" || tag === "picture" || tag === "img") return "media";
        if (tag === "button" || role === "button" || (tag === "a" && /button|cta|contact|learn|read|discover|explore/.test(classText))) return "action";
        if (tag === "nav" || role === "navigation") return "navigation";
        return "content";
      }

      const STYLEABLE_CATEGORY_PROPERTIES = {
        text: ["color", "font-family", "font-size", "font-style", "font-weight", "letter-spacing", "line-height", "text-align", "text-decoration", "text-transform", "white-space"],
        action: ["color", "background-color", "border-color", "border-radius", "border-style", "border-width", "box-shadow", "cursor", "min-height", "padding", "transition"],
        media: ["aspect-ratio", "border-radius", "height", "object-fit", "object-position", "opacity", "width"],
        container: ["align-items", "background-color", "background-image", "border-color", "border-radius", "box-shadow", "display", "gap", "grid-template-columns", "justify-content", "overflow", "padding", "position", "z-index"],
      };

      function styleableCategories(role) {
        if (["heading", "body-copy", "tab"].includes(role)) return role === "tab" ? ["text", "action"] : ["text"];
        if (role === "action") return ["text", "action"];
        if (["media", "background-media"].includes(role)) return ["media"];
        return ["container"];
      }

      function computedPropertyUnion(styles, categories) {
        const properties = [...new Set(categories.flatMap((category) => STYLEABLE_CATEGORY_PROPERTIES[category] || []))].sort();
        return Object.fromEntries(properties.map((property) => [property, styles.getPropertyValue(property)]));
      }

      function authoredCssContext(node, categories) {
        const allowed = new Set(categories.flatMap((category) => STYLEABLE_CATEGORY_PROPERTIES[category] || []));
        const matches = [];
        for (const sheet of Array.from(document.styleSheets).slice(0, 80)) {
          let rules;
          try { rules = Array.from(sheet.cssRules || []); } catch { continue; }
          for (const rule of rules.slice(0, 800)) {
            if (!rule.selectorText || !rule.style) continue;
            let matched = false;
            try { matched = node.matches(rule.selectorText); } catch { continue; }
            if (!matched) continue;
            const declarations = {};
            for (const property of Array.from(rule.style)) if (allowed.has(property)) declarations[property] = rule.style.getPropertyValue(property);
            if (Object.keys(declarations).length) matches.push({ selector: rule.selectorText, href: sheet.href || "inline", declarations });
            if (matches.length >= 20) return matches;
          }
        }
        return matches;
      }

      function collectLayoutEvidence(sectionRoot) {
        const sectionRect = sectionRoot.getBoundingClientRect();
        const sectionStyles = getComputedStyle(sectionRoot);
        const selector = [
          "h1", "h2", "h3", "h4", "h5", "h6", "p", "blockquote",
          "a[href]", "button", "[role='button']", "[role='tablist']", "[role='tab']",
          "nav", "[class*='tabs' i]", "[class*='tab-list' i]",
          "video", "iframe", "picture", "img",
        ].join(",");
        const semanticCandidates = Array.from(sectionRoot.querySelectorAll(selector));
        const repeatedControlGroups = [...new Set(Array.from(sectionRoot.querySelectorAll("button, [role='tab']"))
          .map((control) => control.parentElement)
          .filter(Boolean)
          .filter((parent) => Array.from(parent.children).filter((child) => child.tagName?.toLowerCase?.() === "button" || child.getAttribute?.("role") === "tab").length >= 3))];
        const regionCandidates = [...new Set([...semanticCandidates, ...repeatedControlGroups])]
          .filter(isVisible)
          .filter((node) => {
            const rect = node.getBoundingClientRect();
            if (rect.width < 20 || rect.height < 12) return false;
            if (["p", "blockquote"].includes(node.tagName.toLowerCase()) && renderedText(node).length < 16) return false;
            return true;
          });
        const regions = [];
        for (const node of regionCandidates) {
          const role = layoutRole(node);
          if (role === "tab" && regionCandidates.some((candidate) => candidate !== node && layoutRole(candidate) === "tabs" && candidate.contains(node))) continue;
          let rect = node.getBoundingClientRect();
          if (role === "tabs") {
            const tabRects = Array.from(node.querySelectorAll("[role='tab'], button, a"))
              .filter(isVisible)
              .filter((candidate) => layoutRole(candidate) === "tab")
              .map((candidate) => candidate.getBoundingClientRect());
            if (tabRects.length >= 2) {
              const left = Math.min(...tabRects.map((candidate) => candidate.left));
              const top = Math.min(...tabRects.map((candidate) => candidate.top));
              const right = Math.max(...tabRects.map((candidate) => candidate.right));
              const bottom = Math.max(...tabRects.map((candidate) => candidate.bottom));
              rect = { left, top, right, bottom, width: right - left, height: bottom - top };
            }
          }
          const styles = getComputedStyle(node);
          const categories = styleableCategories(role);
          regions.push({
            role,
            text: ["heading", "body-copy", "action", "tab", "tabs"].includes(role) ? renderedText(node).slice(0, 180) : "",
            rect: roundedBox(rect),
            normalizedRect: normalizedBox(rect, sectionRect),
            position: styles.position,
            display: styles.display,
            textAlign: styles.textAlign,
            zIndex: styles.zIndex,
            styleableCategories: categories,
            computedStyle: computedPropertyUnion(styles, categories),
            authoredCss: authoredCssContext(node, categories),
            ...(["heading", "body-copy", "action", "tab", "tabs"].includes(role) ? { textGeometry: textGeometry(node, rect) } : {}),
            domRef: {
              tag: node.tagName.toLowerCase(),
              id: node.id || "",
              classTokens: String(node.className || "").split(/\s+/).filter(Boolean).slice(0, 6),
            },
          });
          if (regions.length >= 36) break;
        }

        const layerCandidates = Array.from(sectionRoot.querySelectorAll("video, iframe, picture, img, [class*='background' i], [class*='overlay' i], [class*='curtain' i], [class*='mask' i], [class*='panel' i], [class*='frame' i], [class*='border' i]"))
          .filter(isVisible)
          .map((node) => ({ node, rect: node.getBoundingClientRect(), styles: getComputedStyle(node) }))
          .filter(({ rect, styles }) => {
            const areaRatio = (rect.width * rect.height) / Math.max(sectionRect.width * Math.min(sectionRect.height, window.innerHeight), 1);
            return areaRatio >= 0.18 || ["absolute", "fixed", "sticky"].includes(styles.position);
          })
          .slice(0, 20)
          .map(({ node, rect, styles }) => {
            const classText = String(node.className || "").toLowerCase();
            const kind = ["video", "iframe"].includes(node.tagName.toLowerCase()) ? "video" : ["picture", "img"].includes(node.tagName.toLowerCase()) ? "image" : "decorative-layer";
            const role = /partial.*border|border.*frame|\bframe\b/.test(classText) ? "partial-border-frame"
              : /copy.*panel|content.*panel/.test(classText) ? "copy-panel"
                : /overlay|curtain|mask|scrim/.test(classText) ? "overlay"
                  : /background|\bbg\b/.test(classText) ? "background"
                    : kind === "image" || kind === "video" ? "media" : "decoration";
            return {
            kind,
            role,
            rect: roundedBox(rect),
            normalizedRect: normalizedBox(rect, sectionRect),
            position: styles.position,
            zIndex: styles.zIndex,
            opacity: styles.opacity,
            objectFit: styles.objectFit,
            overflow: styles.overflow,
            background: backgroundInfo(node),
            src: node.currentSrc || node.src || "",
            classTokens: String(node.className || "").split(/\s+/).filter(Boolean).slice(0, 8),
          };
          });

        const pseudoLayers = ["::before", "::after"].map((pseudo) => {
          const styles = getComputedStyle(sectionRoot, pseudo);
          if (!styles || styles.content === "none" || (isTransparentColor(styles.backgroundColor) && (!styles.backgroundImage || styles.backgroundImage === "none"))) return null;
          return {
            kind: "pseudo-layer",
            pseudo,
            position: styles.position,
            zIndex: styles.zIndex,
            opacity: styles.opacity,
            background: {
              color: styles.backgroundColor,
              image: styles.backgroundImage && styles.backgroundImage !== "none" ? styles.backgroundImage : "",
            },
          };
        }).filter(Boolean);

        return {
          vocabularyVersion: 1,
          viewport: { width: window.innerWidth, height: window.innerHeight },
          canvas: {
            display: sectionStyles.display,
            position: sectionStyles.position,
            overflowX: sectionStyles.overflowX,
            overflowY: sectionStyles.overflowY,
            minHeight: sectionStyles.minHeight,
            background: backgroundInfo(sectionRoot),
          },
          regions,
          layers: [...layerCandidates, ...pseudoLayers],
        };
      }

      function nodeFingerprint(node) {
        const heading = visibleHeadingText(node);
        const textPrefix = renderedText(node).slice(0, 160);
        return {
          heading,
          textPrefix,
          imageCount: node.querySelectorAll("img").length,
          linkCount: node.querySelectorAll("a[href]").length,
        };
      }

      function findContentRoot() {
        const candidateDefs = [
          { selector: "main", label: "main" },
          { selector: "[role='main']", label: "role-main" },
          { selector: "article", label: "article" },
          { selector: "#primary", label: "primary-id" },
          { selector: ".content-area", label: "content-area" },
          { selector: ".site-main", label: "site-main" },
          { selector: "body", label: "body" },
        ];
        const candidates = [];
        for (const def of candidateDefs) {
          for (const node of Array.from(document.querySelectorAll(def.selector)).filter(isVisible).slice(0, 3)) {
            const rect = node.getBoundingClientRect();
            const headingCount = node.querySelectorAll("h1,h2,h3,h4").length;
            const imageCount = node.querySelectorAll("img").length;
            const linkCount = node.querySelectorAll("a[href]").length;
            let score = 0;
            score += 40;
            score += Math.min(rect.width / Math.max(window.innerWidth, 1), 1.2) * 35;
            score += Math.min(rect.height / Math.max(window.innerHeight, 1), 4) * 10;
            score += Math.min(headingCount, 8) * 4;
            score += Math.min(imageCount, 20) * 1.5;
            if (linkCount > 3) score += 5;
            if (def.label === "main") score += 20;
            else if (def.label === "role-main") score += 18;
            else if (def.label === "article") score += 10;
            else if (def.label === "body") score -= 30;
            if (rect.height > document.documentElement.scrollHeight * 0.9) score -= 25;
            candidates.push({ node, label: def.label, score });
          }
        }
        candidates.sort((a, b) => b.score - a.score);
        return candidates[0] || { node: document.body, label: "body", score: 0 };
      }

      function collectModuleStats(node, root) {
        const rect = node.getBoundingClientRect();
        const children = visibleChildren(node);
        const headings = visibleHeadings(node);
        const images = Array.from(node.querySelectorAll("img")).filter((img) => isVisible(img));
        const links = Array.from(node.querySelectorAll("a[href]")).filter((link) => isVisible(link));
        const buttons = Array.from(node.querySelectorAll("button")).filter((button) => isVisible(button));
        const paragraphs = Array.from(node.querySelectorAll("p, li, blockquote, figcaption")).filter((item) => isVisible(item));
        const childRects = children.map((child) => child.getBoundingClientRect());
        const rowCountEstimate = new Set(childRects.map((item) => Math.round(item.top / 24))).size;
        const background = backgroundInfo(node);
        const role = node.getAttribute("role") || "";
        const classText = `${node.className || ""} ${node.id || ""}`.toLowerCase();
        const ancestorText = [];
        let ancestor = node.parentElement;
        for (let depth = 0; ancestor && depth < 4; depth += 1) {
          ancestorText.push(`${ancestor.className || ""} ${ancestor.id || ""}`.toLowerCase());
          if (ancestor === root) break;
          ancestor = ancestor.parentElement;
        }
        const ancestryText = ancestorText.join(" ");
        const reviewPattern = /review|testimonial|verified customer|productreview|based on [\d,.\s]+ reviews|what our customers/i;
        const reviewLike = reviewPattern.test(classText)
          || headings.some((heading) => reviewPattern.test(heading.text))
          || reviewPattern.test(renderedText(node))
          || reviewPattern.test(ancestryText);
        const pricePattern = /\$\s?\d|\bprice\b|original price|current price|sale\b/i;
        const addToCartPattern = /add to cart|quantity|buy now|shop now/i;
        const productLike = pricePattern.test(renderedText(node))
          || addToCartPattern.test(renderedText(node))
          || /product|products|woocommerce|add-to-cart|price|shopify-buy/.test(`${classText} ${ancestryText}`);
        const reviewWidgetLike = /reviewsio|judge\.me|stamped|loox|yotpo|trustpilot|productreview/.test(`${classText} ${ancestryText}`);
        const galleryLike = /gallery|slider|embla|swiper|carousel|featured/.test(classText);
        const logoLikeChildren = images.filter((image) => {
          const imageRect = image.getBoundingClientRect();
          return imageRect.width <= 240 && imageRect.height <= 140;
        }).length;
        return {
          node,
          tag: node.tagName.toLowerCase(),
          role,
          rect,
          heading: headings[0]?.text || "",
          headings,
          text: renderedText(node).slice(0, 1800) || "",
          textLength: renderedText(node).length,
          visibleCodeTexts: visibleCodeTexts(node),
          imageCount: images.length,
          linkCount: links.length,
          buttonCount: buttons.length,
          paragraphCount: paragraphs.length,
          childCount: children.length,
          cardLikeChildren: children.filter((child) => {
            const childRect = child.getBoundingClientRect();
            return childRect.width >= 140 && childRect.height >= 90;
          }).length,
          rowCountEstimate,
          background,
          hasBackgroundChange: !isTransparentColor(background.color) || Boolean(background.image),
          reviewLike,
          reviewWidgetLike,
          productLike,
          galleryLike,
          logoLikeChildren,
          path: domPath(node, root?.parentElement || document.body.parentElement),
          parentPath: domPath(node.parentElement, root?.parentElement || document.body.parentElement),
          nthOfType: node.parentElement
            ? Array.from(node.parentElement.children).filter((sibling) => sibling.tagName === node.tagName).indexOf(node) + 1
            : 1,
          fingerprint: nodeFingerprint(node),
        };
      }

      function statsClassText(stats) {
        return `${stats.node?.className || ""} ${stats.node?.id || ""} ${stats.path || ""}`.toLowerCase();
      }

      function sectionCapabilities({ hasCta, hasMedia, repeatingItems = false, isCarouselLike = false }) {
        return { hasCta, hasMedia, repeatingItems, isCarouselLike };
      }

      const SECTION_DETECTORS = [
        {
          kind: "header",
          match: ({ stats, classText, hasCta }) => (stats.tag === "header" || /\bheader\b|masthead|top-bar|site-header/.test(classText))
            ? {
                kind: "header",
                variant: /top-bar/.test(classText) ? "top-bar" : "generic",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1 }),
              }
            : null,
        },
        {
          kind: "footer",
          match: ({ stats, classText, hasCta }) => (stats.tag === "footer" || /\bfooter\b|site-info|copyright|privacy|terms|site-map/.test(classText))
            ? {
                kind: "footer",
                variant: "site-footer",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1 }),
              }
            : null,
        },
        {
          kind: "hero",
          match: ({ stats, classText, hasCta, atTopOfPage, hasStrongHeroMedia }) => (
            hasStrongHeroMedia
            && hasCta
            && stats.rect.height >= Math.max(window.innerHeight * 0.22, 220)
            && (atTopOfPage || /\bhero\b|banner|masthead|billboard|home-section/.test(classText) || stats.headings.some((heading) => heading.level === 1))
          )
            ? {
                kind: "hero",
                variant: stats.galleryLike || stats.cardLikeChildren >= 2 ? "carousel-hero" : "generic-hero",
                capabilities: sectionCapabilities({ hasCta: true, hasMedia: true, repeatingItems: stats.cardLikeChildren >= 2, isCarouselLike: stats.galleryLike }),
              }
            : null,
        },
        {
          kind: "reviews",
          match: ({ stats, hasCta }) => (
            (stats.reviewWidgetLike || stats.reviewLike)
            && !(stats.productLike && !stats.reviewWidgetLike)
            && (stats.cardLikeChildren >= 1 || stats.imageCount >= 2 || stats.textLength >= 80)
          )
            ? {
                kind: "reviews",
                variant: stats.galleryLike || stats.cardLikeChildren >= 2 ? "review-carousel" : "review-list",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1, repeatingItems: true, isCarouselLike: stats.galleryLike }),
              }
            : null,
        },
        {
          kind: "category-strip",
          match: ({ stats }) => (
            stats.imageCount === 0
            && stats.linkCount === 0
            && stats.buttonCount === 0
            && stats.paragraphCount >= 4
            && stats.textLength >= 40
            && stats.textLength <= 280
          )
            ? {
                kind: "category-strip",
                variant: "text-category-grid",
                capabilities: sectionCapabilities({ hasCta: false, hasMedia: false, repeatingItems: true }),
              }
            : null,
        },
        {
          kind: "card-collection",
          match: ({ stats, hasCta }) => (
            (stats.logoLikeChildren >= 4 && stats.imageCount >= 4 && stats.textLength < 420)
            || (stats.galleryLike && stats.imageCount >= 5 && stats.textLength < 180)
          )
            ? {
                kind: "card-collection",
                variant: "logo-gallery",
                capabilities: sectionCapabilities({ hasCta, hasMedia: true, repeatingItems: true, isCarouselLike: stats.galleryLike }),
              }
            : null,
        },
        {
          kind: "card-collection",
          match: ({ stats }) => (stats.productLike && (stats.cardLikeChildren >= 3 || stats.imageCount >= 4) && (stats.buttonCount >= 2 || stats.linkCount >= 6))
            ? {
                kind: "card-collection",
                variant: stats.galleryLike ? "product-carousel" : "product-grid",
                capabilities: sectionCapabilities({ hasCta: true, hasMedia: true, repeatingItems: true, isCarouselLike: stats.galleryLike }),
              }
            : null,
        },
        {
          kind: "card-collection",
          match: ({ stats, hasCta }) => (stats.cardLikeChildren >= 3 && (stats.imageCount >= 3 || stats.linkCount >= 3))
            ? {
                kind: "card-collection",
                variant: stats.galleryLike ? "card-carousel" : "card-grid",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1, repeatingItems: true, isCarouselLike: stats.galleryLike }),
              }
            : null,
        },
        {
          kind: "text-media",
          match: ({ stats, classText, hasCta }) => (stats.imageCount >= 1 && stats.headings.length >= 1 && stats.paragraphCount >= 1)
            ? {
                kind: "text-media",
                variant: /has-media-on-the-right|media-right/.test(classText) ? "media-right" : "media-left",
                capabilities: sectionCapabilities({ hasCta, hasMedia: true }),
              }
            : null,
        },
        {
          kind: "stat-group",
          match: ({ stats }) => (stats.headings.length >= 3 && stats.imageCount === 0 && stats.linkCount === 0 && stats.buttonCount === 0)
            ? {
                kind: "stat-group",
                variant: "step-strip",
                capabilities: sectionCapabilities({ hasCta: false, hasMedia: false, repeatingItems: true }),
              }
            : null,
        },
        {
          kind: "promo-band",
          match: ({ stats, hasCta }) => (
            stats.imageCount <= 1
            && stats.textLength >= 40
            && stats.textLength <= 220
            && stats.paragraphCount <= 2
            && stats.headings.length <= 1
            && (stats.hasBackgroundChange || stats.imageCount >= 1)
          )
            ? {
                kind: "promo-band",
                variant: hasCta ? "value-prop-cta" : "value-prop-band",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1 }),
              }
            : null,
        },
        {
          kind: "cta-strip",
          match: ({ stats, hasCta }) => (
            stats.imageCount === 0
            && hasCta
            && stats.textLength <= 220
            && stats.paragraphCount <= 1
            && stats.headings.length <= 2
          )
            ? {
                kind: "cta-strip",
                variant: "inline-cta-strip",
                capabilities: sectionCapabilities({ hasCta: true, hasMedia: false }),
              }
            : null,
        },
        {
          kind: "cta-strip",
          match: ({ stats, hasCta, atTopOfPage }) => ((stats.buttonCount + stats.linkCount) >= 2 && stats.imageCount >= 1 && stats.rect.height >= 120)
            ? {
                kind: "cta-strip",
                variant: atTopOfPage ? "promo-hero-strip" : "promo-strip",
                capabilities: sectionCapabilities({ hasCta: true, hasMedia: true }),
              }
            : null,
        },
        {
          kind: "cta-strip",
          match: ({ stats, hasCta }) => (stats.headings.length === 1 && stats.imageCount === 0 && stats.paragraphCount === 0)
            ? {
                kind: "cta-strip",
                variant: "centered-heading-strip",
                capabilities: sectionCapabilities({ hasCta, hasMedia: false }),
              }
            : null,
        },
        {
          kind: "rich-text",
          match: ({ stats, hasCta }) => (stats.textLength >= 60 || stats.headings.length || stats.imageCount)
            ? {
                kind: "rich-text",
                variant: "generic",
                capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1 }),
              }
            : null,
        },
      ];

      function classifySection(stats) {
        const classText = statsClassText(stats);
        const atTopOfPage = (stats.rect.top + window.scrollY) < Math.max(window.innerHeight * 0.35, 320);
        const hasCta = (stats.buttonCount + stats.linkCount) >= 1;
        const hasStrongHeroMedia = stats.imageCount >= 1 || stats.hasBackgroundChange;
        for (const detector of SECTION_DETECTORS) {
          const matched = detector.match({ stats, classText, atTopOfPage, hasCta, hasStrongHeroMedia });
          if (matched) return matched;
        }
        return { kind: "unknown", variant: "generic", capabilities: sectionCapabilities({ hasCta, hasMedia: stats.imageCount >= 1 }) };
      }

      function sectionScore(stats, root) {
        let score = 0;
        score += 30;
        score += Math.min(stats.rect.width / Math.max(root.getBoundingClientRect().width, 1), 1.2) * 30;
        score += Math.min(stats.rect.height / Math.max(window.innerHeight, 1), 1.5) * 20;
        score += Math.min(stats.headings.length, 4) * 10;
        score += Math.min(stats.imageCount, 6) * 4;
        score += Math.min(stats.cardLikeChildren, 6) * 5;
        if (stats.hasBackgroundChange) score += 10;
        if (stats.rect.width < root.getBoundingClientRect().width * 0.55) score -= 20;
        if (stats.rect.height < 80) score -= 40;
        if (stats.textLength < 15 && stats.imageCount === 0) score -= 60;
        if (/nav|menu|breadcrumb|popup|modal|drawer|cookie/.test(`${stats.role} ${stats.path}`.toLowerCase())) score -= 35;
        if (stats.tag === "main" || stats.tag === "article") score -= 20;
        if (stats.rect.height > root.getBoundingClientRect().height * 0.8) score -= 50;
        if (stats.childCount === 1 && stats.cardLikeChildren <= 1 && stats.headings.length <= 1 && !stats.hasBackgroundChange) score -= 40;
        if (stats.textLength > 3200 && stats.rect.height > root.getBoundingClientRect().height * 0.55 && !stats.hasBackgroundChange) score -= 45;
        return score;
      }

      function isWrapperLike(stats, root) {
        return (
          stats.childCount <= 2
          && stats.cardLikeChildren <= 1
          && stats.headings.length <= 1
          && !stats.hasBackgroundChange
          && stats.rect.height > Math.max(window.innerHeight * 1.25, root.getBoundingClientRect().height * 0.45)
        );
      }

      function findSegmentationRoot(contentRoot) {
        const warnings = [];
        let current = contentRoot;
        for (let depth = 0; depth < 10; depth += 1) {
          const scopedContentChild = Array.from(current.children || []).find((child) => {
            if (!isVisible(child)) return false;
            const classText = `${child.className || ""} ${child.id || ""}`.toLowerCase();
            return /single-content|entry-content|post-content|article-content|main-content/.test(classText);
          });
          if (scopedContentChild) {
            const childStats = collectModuleStats(scopedContentChild, contentRoot);
            current = scopedContentChild;
            warnings.push(`segmentation-root-descended:${childStats.path}`);
            continue;
          }
          const children = visibleChildren(current).filter((child) => {
            const rect = child.getBoundingClientRect();
            return rect.height >= 24 && (renderedText(child).length >= 20 || child.querySelector("img,svg,a[href],button") || rect.height >= 120);
          });
          if (!children.length) break;
          if (children.length === 1) {
            const childStats = collectModuleStats(children[0], contentRoot);
            if (childStats.rect.width >= current.getBoundingClientRect().width * 0.72) {
              current = children[0];
              warnings.push(`segmentation-root-descended:${childStats.path}`);
              continue;
            }
          }
          const dominant = children.find((child) => {
            const rect = child.getBoundingClientRect();
            return rect.width >= current.getBoundingClientRect().width * 0.72 && rect.height >= current.getBoundingClientRect().height * 0.72;
          });
          if (children.length <= 3 && dominant) {
            const dominantStats = collectModuleStats(dominant, contentRoot);
            if (!dominantStats.hasBackgroundChange && dominantStats.cardLikeChildren <= 1) {
              current = dominant;
              warnings.push(`segmentation-root-descended:${dominantStats.path}`);
              continue;
            }
          }
          const dominantCandidate = children
            .map((child) => ({ child, rect: child.getBoundingClientRect() }))
            .sort((a, b) => b.rect.height - a.rect.height)[0];
          if (dominantCandidate && children.length <= 5) {
            const otherHeight = children
              .filter((child) => child !== dominantCandidate.child)
              .reduce((sum, child) => sum + child.getBoundingClientRect().height, 0);
            const dominantClassText = `${dominantCandidate.child.className || ""} ${dominantCandidate.child.id || ""}`.toLowerCase();
            if (dominantCandidate.rect.height >= current.getBoundingClientRect().height * 0.6 && otherHeight <= dominantCandidate.rect.height * 0.35) {
              const dominantStats = collectModuleStats(dominantCandidate.child, contentRoot);
              if (!dominantStats.hasBackgroundChange) {
                current = dominantCandidate.child;
                warnings.push(`segmentation-root-descended:${dominantStats.path}`);
                continue;
              }
            }
            if (
              dominantCandidate.rect.width >= current.getBoundingClientRect().width * 0.68
              && dominantCandidate.rect.height >= current.getBoundingClientRect().height * 0.45
              && otherHeight <= dominantCandidate.rect.height * 0.8
              && /content|entry|article|post|main/.test(dominantClassText)
            ) {
              const dominantStats = collectModuleStats(dominantCandidate.child, contentRoot);
              current = dominantCandidate.child;
              warnings.push(`segmentation-root-descended:${dominantStats.path}`);
              continue;
            }
          }
          break;
        }
        return { node: current, warnings };
      }

      function isStructuralBand(stats, segmentationRoot) {
        const lowerTag = stats.tag.toLowerCase();
        if (/^h[1-6]$/.test(lowerTag) || lowerTag === "p") return false;
        if (lowerTag === "div" && stats.rect.height < 100 && !stats.hasBackgroundChange && stats.imageCount === 0 && stats.cardLikeChildren === 0) return false;
        if (stats.rect.width < segmentationRoot.getBoundingClientRect().width * 0.55 && stats.imageCount === 0 && stats.headings.length === 0) return false;
        return true;
      }

      function overlaps(a, b) {
        const top = Math.max(a.rect.top, b.rect.top);
        const bottom = Math.min(a.rect.top + a.rect.height, b.rect.top + b.rect.height);
        const overlapHeight = Math.max(0, bottom - top);
        return overlapHeight >= Math.min(a.rect.height, b.rect.height) * 0.6;
      }

      function classifyModule(stats, sectionType = null) {
        const classText = statsClassText(stats);
        const text = String(stats.text || "").toLowerCase();
        const hasCta = stats.linkCount + stats.buttonCount >= 1;
        const sectionKey = sectionType ? `${sectionType.kind}:${sectionType.variant || "*"}` : "";
        const moduleDetectors = {
          "reviews:*": () => ({ kind: "review-card", variant: "customer-review", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } }),
          "stat-group:*": () => ({ kind: "stat-item", variant: "step-or-stat", capabilities: { hasCta: false, hasMedia: false } }),
          "category-strip:*": () => ({ kind: "text-block", variant: "category-item", capabilities: { hasCta, hasMedia: false } }),
          "promo-band:*": () => (stats.imageCount >= 1 && stats.headings.length === 0 && stats.paragraphCount === 0
            ? { kind: "media-item", variant: "promo-media", capabilities: { hasCta, hasMedia: true } }
            : { kind: "text-block", variant: "promo-copy", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } }),
          "cta-strip:*": () => ({ kind: "text-block", variant: hasCta ? "cta-copy" : "strip-copy", capabilities: { hasCta, hasMedia: false } }),
          "text-media:*": () => {
            if (stats.imageCount >= 1 && stats.paragraphCount === 0 && stats.headings.length === 0) return { kind: "media-item", variant: "image-tile", capabilities: { hasCta, hasMedia: true } };
            if (stats.headings.length >= 1 || stats.paragraphCount >= 1) return { kind: "text-block", variant: "copy-block", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
            return null;
          },
          "card-collection:logo-gallery": () => ({ kind: "logo-item", variant: "brand-mark", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } }),
          "card-collection:*": () => ({ kind: "card", variant: /product|price|add to cart|book rental|rent/.test(text) ? "product-card" : "content-card", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } }),
          "footer:*": () => ({ kind: "link-group", variant: "footer-links", capabilities: { hasCta: stats.linkCount >= 1, hasMedia: false } }),
          "hero:*": () => {
            if (stats.headings.length >= 1 || stats.paragraphCount >= 1) return { kind: "text-block", variant: "hero-copy", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
            if (stats.imageCount >= 1) return { kind: "media-item", variant: "hero-media", capabilities: { hasCta, hasMedia: true } };
            return null;
          },
        };
        const specialized = (moduleDetectors[sectionKey] || moduleDetectors[`${sectionType?.kind}:*`])?.();
        if (specialized) return specialized;
        if (stats.reviewLike || /review|testimonial|verified customer/.test(`${classText} ${text}`)) return { kind: "review-card", variant: "customer-review", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
        if (stats.productLike) return { kind: "card", variant: "product-card", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
        if (stats.logoLikeChildren >= 1 || (stats.imageCount >= 1 && stats.textLength < 40 && stats.rect.width <= 260)) return { kind: "logo-item", variant: "brand-mark", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
        if (stats.imageCount >= 1 && stats.headings.length === 0 && stats.paragraphCount === 0) return { kind: "media-item", variant: "image-tile", capabilities: { hasCta, hasMedia: true } };
        if (stats.headings.length >= 1 || stats.paragraphCount >= 1) return { kind: "text-block", variant: "copy-block", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
        return { kind: "unknown", variant: "generic", capabilities: { hasCta, hasMedia: stats.imageCount >= 1 } };
      }

      function moduleSummary(stats, sectionRoot, sectionType = null) {
        const moduleType = classifyModule(stats, sectionType);
        return {
          id: "",
          kind: moduleType.kind,
          variant: moduleType.variant,
          capabilities: moduleType.capabilities,
          heading: stats.heading,
          visibleCodeTexts: stats.visibleCodeTexts,
          order: 0,
          confidence: Number(Math.max(0.2, Math.min(0.95, 0.45 + ((stats.imageCount + stats.headings.length + stats.cardLikeChildren) * 0.04))).toFixed(2)),
          rect: {
            top: Math.round(stats.rect.top + window.scrollY),
            left: Math.round(stats.rect.left),
            width: Math.round(stats.rect.width),
            height: Math.round(stats.rect.height),
          },
          counts: {
            headings: stats.headings.length,
            paragraphs: stats.paragraphCount,
            images: stats.imageCount,
            links: stats.linkCount,
            buttons: stats.buttonCount,
          },
          domRef: {
            tag: stats.tag,
            id: stats.node.id || "",
            classTokens: String(stats.node.className || "").split(/\s+/).filter(Boolean).slice(0, 6),
            path: domPath(stats.node, sectionRoot.parentElement || document.body.parentElement),
            parentPath: domPath(stats.node.parentElement, sectionRoot.parentElement || document.body.parentElement),
            nthOfType: stats.nthOfType,
            fingerprint: stats.fingerprint,
          },
          warnings: [],
        };
      }

      function moduleCandidatesFrom(containerRoot, sectionRoot, filters = {}) {
        const minHeight = filters.minHeight || 60;
        const minWidth = filters.minWidth || Math.min(sectionRoot.getBoundingClientRect().width * 0.22, 220);
        return visibleChildren(containerRoot)
          .map((child) => collectModuleStats(child, sectionRoot))
          .filter((stats) => stats.rect.height >= minHeight)
          .filter((stats) => stats.rect.width >= minWidth || stats.imageCount >= 1 || stats.headings.length >= 1)
          .filter((stats) => stats.textLength >= 10 || stats.imageCount >= 1)
          .slice(0, 36);
      }

      function resolveRepeatingContainer(sectionRoot) {
        let current = sectionRoot;
        for (let depth = 0; depth < 3; depth += 1) {
          const children = visibleChildren(current);
          if (!children.length) return current;
          const repeatedChild = children.find((child) => {
            const classText = `${child.className || ""} ${child.id || ""}`.toLowerCase();
            return /slider|carousel|embla|swiper|viewport|container|grid|gallery|reviews|products|list/.test(classText);
          });
          if (repeatedChild) {
            current = repeatedChild;
            continue;
          }
          if (children.length === 1) {
            current = children[0];
            continue;
          }
          return current;
        }
        return current;
      }

      function extractRepeatingItemModules(sectionRoot, sectionType) {
        const container = resolveRepeatingContainer(sectionRoot);
        const children = moduleCandidatesFrom(container, sectionRoot, { minHeight: 80, minWidth: 120 });
        const accepted = [];
        for (const stats of children) {
          if (stats.rect.height > sectionRoot.getBoundingClientRect().height * 0.95 && stats.cardLikeChildren <= 1) continue;
          if (accepted.some((existing) => overlaps(existing, stats))) continue;
          accepted.push(stats);
        }
        return accepted.slice(0, 12).map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        }).filter((module) => module.kind !== "unknown");
      }

      function dedupeModuleStats(statsList) {
        const accepted = [];
        for (const stats of statsList) {
          if (accepted.some((existing) => overlaps(existing, stats))) continue;
          accepted.push(stats);
        }
        return accepted;
      }

      function extractLogoModules(sectionRoot, sectionType) {
        const imageNodes = uniqueElements(
          Array.from(sectionRoot.querySelectorAll("img"))
            .filter(isVisible)
            .map((image) => image.closest("a, figure, li, div") || image),
        );
        const statsList = imageNodes
          .map((node) => collectModuleStats(node, sectionRoot))
          .filter((stats) => stats.imageCount >= 1)
          .filter((stats) => stats.rect.width >= 40 && stats.rect.height >= 24)
          .sort((a, b) => (a.rect.width * a.rect.height) - (b.rect.width * b.rect.height));
        return dedupeModuleStats(statsList).slice(0, 16).map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        }).filter((module) => module.kind !== "unknown");
      }

      function extractReviewModules(sectionRoot, sectionType) {
        const reviewNodes = uniqueElements(
          Array.from(sectionRoot.querySelectorAll("[class*='review'], [id*='review'], [class*='testimonial'], [class*='customer']"))
            .filter(isVisible),
        );
        const statsList = reviewNodes
          .map((node) => collectModuleStats(node, sectionRoot))
          .filter((stats) => stats.textLength >= 30 || stats.imageCount >= 1)
          .filter((stats) => stats.rect.height >= 60)
          .sort((a, b) => (a.rect.width * a.rect.height) - (b.rect.width * b.rect.height));
        const accepted = dedupeModuleStats(statsList)
          .filter((stats) => !stats.node.contains(sectionRoot))
          .slice(0, 12);
        return accepted.map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        }).filter((module) => module.kind !== "unknown");
      }

      function resolveTextMediaScope(sectionRoot) {
        let current = sectionRoot;
        for (let depth = 0; depth < 3; depth += 1) {
          const children = visibleChildren(current).filter((child) => child.getBoundingClientRect().height >= 24);
          if (children.length !== 1) return current;
          const onlyChild = children[0];
          const onlyRect = onlyChild.getBoundingClientRect();
          if (onlyRect.width < current.getBoundingClientRect().width * 0.72) return current;
          current = onlyChild;
        }
        return current;
      }

      function extractTextMediaModules(sectionRoot, sectionType) {
        const scope = resolveTextMediaScope(sectionRoot);
        const children = moduleCandidatesFrom(scope, sectionRoot, { minHeight: 90, minWidth: 120 })
          .sort((a, b) => (a.rect.width * a.rect.height) - (b.rect.width * b.rect.height));
        const accepted = [];
        for (const stats of children) {
          const moduleType = classifyModule(stats, sectionType);
          if (moduleType.kind === "unknown") continue;
          if (accepted.some((existing) => existing.node.contains(stats.node) && classifyModule(existing, sectionType).kind === moduleType.kind)) continue;
          if (accepted.some((existing) => overlaps(existing, stats))) continue;
          accepted.push(stats);
        }
        return accepted.slice(0, 6).map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        });
      }

      function extractStatModules(sectionRoot, sectionType) {
        const children = visibleChildren(sectionRoot)
          .map((child) => collectModuleStats(child, sectionRoot))
          .filter((stats) => stats.headings.length >= 1 || stats.textLength >= 20)
          .filter((stats) => stats.rect.height >= 40)
          .slice(0, 12);
        return children.map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        }).filter((module) => module.kind !== "unknown");
      }

      function extractGenericModules(sectionRoot, sectionType) {
        const children = visibleChildren(sectionRoot)
          .map((child) => collectModuleStats(child, sectionRoot))
          .filter((stats) => stats.rect.width >= Math.min(sectionRoot.getBoundingClientRect().width * 0.22, 220) || stats.imageCount >= 1)
          .filter((stats) => stats.rect.height >= 90)
          .filter((stats) => stats.textLength >= 10 || stats.imageCount >= 1)
          .slice(0, 16);
        const accepted = [];
        for (const stats of children) {
          if (stats.rect.height > sectionRoot.getBoundingClientRect().height * 0.92 && stats.cardLikeChildren <= 1) continue;
          if (accepted.some((existing) => overlaps(existing, stats))) continue;
          accepted.push(stats);
        }
        return accepted.slice(0, 8).map((stats, index) => {
          const module = moduleSummary(stats, sectionRoot, sectionType);
          module.id = `module-${index + 1}`;
          module.order = index + 1;
          return module;
        }).filter((module) => module.kind !== "unknown");
      }

      const MODULE_EXTRACTORS = {
        "reviews:*": extractReviewModules,
        "card-collection:logo-gallery": extractLogoModules,
        "card-collection:*": extractRepeatingItemModules,
        "text-media:*": extractTextMediaModules,
        "hero:*": extractTextMediaModules,
        "stat-group:*": extractStatModules,
        "footer:*": extractStatModules,
        "category-strip:*": extractStatModules,
        "cta-strip:*": extractStatModules,
        "promo-band:*": extractStatModules,
      };

      function extractSectionModules(sectionRoot, sectionType) {
        const exact = MODULE_EXTRACTORS[`${sectionType.kind}:${sectionType.variant}`];
        const family = MODULE_EXTRACTORS[`${sectionType.kind}:*`];
        const extractor = exact || family || extractGenericModules;
        return extractor(sectionRoot, sectionType);
      }

      function extractSections() {
        const contentRootChoice = findContentRoot();
        const contentRoot = contentRootChoice.node || document.body;
        const segmentationRootChoice = findSegmentationRoot(contentRoot);
        const segmentationRoot = segmentationRootChoice.node || contentRoot;
        const diagnostics = {
          source: "dom-layout+a11y",
          contentRoot: contentRootChoice.label || "body",
          segmentationRootPath: domPath(segmentationRoot, contentRoot.parentElement || document.body.parentElement),
          accessibilitySnapshotAvailable: Boolean(repeaterPlan?.accessibilitySnapshotAvailable),
          accessibilityRoot: repeaterPlan?.accessibilityRoot || null,
          candidateCount: 0,
          acceptedSectionCount: 0,
          acceptedModuleCount: 0,
          warnings: [],
        };
        if (contentRootChoice.label !== "main" && contentRootChoice.label !== "role-main") {
          diagnostics.warnings.push(`content-root-fallback-used:${contentRootChoice.label}`);
        }
        diagnostics.warnings.push(...segmentationRootChoice.warnings);
        const primaryChildren = visibleChildren(segmentationRoot)
          .map((node) => collectModuleStats(node, segmentationRoot))
          .filter((stats) => stats.rect.height >= 24)
          .filter((stats) => stats.textLength >= 10 || stats.imageCount >= 1 || stats.buttonCount >= 1 || stats.linkCount >= 1);
        const primaryBandStats = primaryChildren
          .filter((stats) => isStructuralBand(stats, segmentationRoot))
          .map((stats) => ({
            ...stats,
            score: sectionScore(stats, segmentationRoot) + 22,
            isDirectChild: true,
          }))
          .filter((stats) => stats.score >= 30)
          .filter((stats) => stats.rect.height >= 40)
          .sort((a, b) => a.rect.top - b.rect.top);
        const candidateNodes = uniqueElements([
          ...primaryBandStats.map((stats) => stats.node),
          ...Array.from(segmentationRoot.querySelectorAll("section, article, aside, [role='region'], [data-testid], div"))
            .filter(isVisible)
            .slice(0, 260),
        ]).filter((node) => node !== contentRoot && node !== segmentationRoot);
        const candidateStats = candidateNodes
          .map((node) => collectModuleStats(node, segmentationRoot))
          .filter((stats) => stats.rect.width >= Math.min(segmentationRoot.getBoundingClientRect().width * 0.45, 520))
          .filter((stats) => stats.rect.height >= 80)
          .filter((stats) => stats.textLength >= 20 || stats.imageCount >= 1)
          .map((stats) => {
            let score = sectionScore(stats, segmentationRoot);
            if (stats.node.parentElement === segmentationRoot) score += 18;
            if (isStructuralBand(stats, segmentationRoot)) score += 8;
            return { ...stats, score, isDirectChild: stats.node.parentElement === segmentationRoot };
          })
          .sort((a, b) => a.rect.top - b.rect.top || b.score - a.score);
        diagnostics.candidateCount = candidateStats.length;
        const accepted = [...primaryBandStats];
        for (const stats of candidateStats) {
          if (stats.score < 35) continue;
          if (isWrapperLike(stats, segmentationRoot)) continue;
          const duplicate = accepted.find((existing) => overlaps(existing, stats));
          if (!duplicate) {
            accepted.push(stats);
            continue;
          }
          if (duplicate.isDirectChild && !stats.isDirectChild && duplicate.score >= stats.score - 15) continue;
          if (stats.isDirectChild && !duplicate.isDirectChild && stats.score >= duplicate.score - 15) {
            accepted.splice(accepted.indexOf(duplicate), 1, stats);
            continue;
          }
          const statsContainsDuplicate = stats.node.contains(duplicate.node);
          const duplicateContainsStats = duplicate.node.contains(stats.node);
          if (isWrapperLike(duplicate, segmentationRoot) && duplicateContainsStats) {
            accepted.splice(accepted.indexOf(duplicate), 1, stats);
          } else if (isWrapperLike(stats, segmentationRoot) && statsContainsDuplicate) {
            diagnostics.warnings.push(`nested-candidates-collapsed:${stats.path}`);
            continue;
          } else if (duplicateContainsStats && duplicate.rect.height > stats.rect.height * 1.5 && stats.score >= duplicate.score - 8) {
            accepted.splice(accepted.indexOf(duplicate), 1, stats);
          } else if (statsContainsDuplicate && stats.rect.height > duplicate.rect.height * 1.5) {
            diagnostics.warnings.push(`nested-candidates-collapsed:${stats.path}`);
            continue;
          } else if (stats.score > duplicate.score) {
            accepted.splice(accepted.indexOf(duplicate), 1, stats);
          }
        }
        if (!accepted.length) {
          diagnostics.warnings.push("no-strong-section-boundaries");
        }
        const sections = accepted.slice(0, 18).map((stats, index) => {
          const sectionRoot = stats.node;
          const sectionType = classifySection(stats);
          const modules = extractSectionModules(sectionRoot, sectionType).map((module, moduleIndex) => ({
            ...module,
            id: `section-${String(index + 1).padStart(3, "0")}-module-${String(moduleIndex + 1).padStart(3, "0")}`,
            order: moduleIndex + 1,
          }));
          diagnostics.acceptedModuleCount += modules.length;
          return {
            id: `section-${String(index + 1).padStart(3, "0")}`,
            kind: sectionType.kind,
            variant: sectionType.variant,
            capabilities: sectionType.capabilities,
            source: "dom-layout+a11y",
            tag: stats.tag,
            idAttr: sectionRoot.id || "",
            className: sectionRoot.className?.toString?.() || "",
            heading: stats.heading,
            text: stats.text,
            visibleCodeTexts: stats.visibleCodeTexts,
            order: index + 1,
            confidence: Number(Math.max(0.3, Math.min(0.98, stats.score / 100)).toFixed(2)),
            rect: {
              x: Math.round(stats.rect.x),
              y: Math.round(stats.rect.y),
              width: Math.round(stats.rect.width),
              height: Math.round(stats.rect.height),
              top: Math.round(stats.rect.top + window.scrollY),
              left: Math.round(stats.rect.left),
            },
            layoutHints: {
              fullWidth: stats.rect.width >= segmentationRoot.getBoundingClientRect().width * 0.85,
              columnCount: Math.max(1, Math.min(stats.rowCountEstimate > 1 ? Math.ceil(stats.cardLikeChildren / stats.rowCountEstimate) : stats.cardLikeChildren, 4)) || 1,
              hasGrid: stats.cardLikeChildren >= 3 && stats.rowCountEstimate >= 1,
              hasRepeatingChildren: stats.cardLikeChildren >= 3,
            },
            counts: {
              headings: stats.headings.length,
              paragraphs: stats.paragraphCount,
              images: stats.imageCount,
              links: stats.linkCount,
              buttons: stats.buttonCount,
            },
            background: stats.background,
            layoutEvidence: collectLayoutEvidence(sectionRoot),
            domRef: {
              tag: stats.tag,
              id: sectionRoot.id || "",
              classTokens: String(sectionRoot.className || "").split(/\s+/).filter(Boolean).slice(0, 6),
              path: stats.path,
              parentPath: stats.parentPath,
              nthOfType: stats.nthOfType,
              fingerprint: stats.fingerprint,
            },
            a11y: {
              role: stats.role || null,
              headingLevels: stats.headings.map((heading) => heading.level).filter(Boolean),
              containsList: sectionRoot.querySelectorAll("ul,ol,[role='list']").length > 0,
            },
            modules,
            warnings: [],
          };
        });
        diagnostics.acceptedSectionCount = sections.length;
        return { sections, diagnostics };
      }

      const sectionResult = extractSections();
      const footer = (() => {
        const node = Array.from(document.querySelectorAll("footer, .site-footer, [role='contentinfo']")).find(isVisible);
        if (!node) return null;
        const links = Array.from(node.querySelectorAll("a[href]")).filter(isVisible).map(linkRecord);
        const cleanNodeText = (source) => renderedText(source);
        const text = cleanNodeText(node).slice(0, 6000);
        const legalText = Array.from(node.querySelectorAll("p, small, [class*='legal' i], [class*='disclaimer' i]"))
          .filter(isVisible)
          .map(cleanNodeText)
          .filter((value) => value.length >= 120 || /disclaimer|portfolio companies|copyright|©/i.test(value))
          .filter((value, index, values) => values.indexOf(value) === index)
          .join("\n\n") || text;
        return {
          text,
          legalText: legalText.slice(0, 6000),
          links: dedupeNav(links).slice(0, 80),
          domRef: {
            tag: node.tagName.toLowerCase(),
            id: node.id || "",
            classTokens: String(node.className || "").split(/\s+/).filter(Boolean).slice(0, 8),
            path: domPath(node, document.body.parentElement),
          },
        };
      })();
      const computedTokens = Array.from(document.querySelectorAll("body, h1, h2, h3, p, a, button")).slice(0, 80).map((node) => {
        const styles = getComputedStyle(node);
        return {
          tag: node.tagName.toLowerCase(),
          text: renderedText(node).slice(0, 120) || "",
          color: styles.color,
          backgroundColor: styles.backgroundColor,
          fontFamily: styles.fontFamily,
          fontSize: styles.fontSize,
          fontWeight: styles.fontWeight,
          borderRadius: styles.borderRadius,
          boxShadow: styles.boxShadow,
        };
      });
      const direction = document.documentElement.dir || document.body.dir || getComputedStyle(document.body).direction || "ltr";
      function nextVisibleNonHeadingSibling(node) {
        let current = node?.nextElementSibling || null;
        while (current) {
          if (isVisible(current) && !/^H[1-6]$/.test(current.tagName)) return current;
          current = current.nextElementSibling;
        }
        return null;
      }

      function findContentContainerForHeading(heading) {
        const direct = nextVisibleNonHeadingSibling(heading);
        if (direct) return direct;
        const parentDirect = nextVisibleNonHeadingSibling(heading.parentElement);
        if (parentDirect) return parentDirect;
        return null;
      }

      function nearestCommonAncestor(a, b, limit) {
        let current = a || null;
        while (current) {
          if (current.contains(b)) return current;
          if (limit && current === limit) break;
          current = current.parentElement;
        }
        return null;
      }

      function uniqueElements(nodes) {
        const seen = new Set();
        const result = [];
        for (const node of nodes || []) {
          if (!node || seen.has(node)) continue;
          seen.add(node);
          result.push(node);
        }
        return result;
      }

      function queryScopeNodes(scopeNodes, selector) {
        const seen = new Set();
        const matches = [];
        for (const node of scopeNodes || []) {
          if (node?.matches?.(selector) && !seen.has(node)) {
            seen.add(node);
            matches.push(node);
          }
          for (const child of node?.querySelectorAll?.(selector) || []) {
            if (seen.has(child)) continue;
            seen.add(child);
            matches.push(child);
          }
        }
        return matches;
      }

      function collectContentNodes(content, nextHeadingNode) {
        if (!content) return [];
        const nodes = [];
        if (nextHeadingNode && content.parentElement && nextHeadingNode.parentElement === content.parentElement) {
          let current = content;
          while (current && current !== nextHeadingNode) {
            if (isVisible(current)) nodes.push(current);
            current = current.nextElementSibling;
          }
        }
        if (!nodes.length) nodes.push(content);
        return uniqueElements(nodes);
      }

      function nodeSignature(node) {
        if (!node) return "";
        const tag = node.tagName.toLowerCase();
        const classTokens = String(node.className || "")
          .split(/\s+/)
          .filter(Boolean)
          .slice(0, 4)
          .sort()
          .join(".");
        const childTags = Array.from(node.children).slice(0, 8).map((child) => child.tagName.toLowerCase()).join(",");
        return `${tag}:${classTokens}:${childTags}`;
      }

      function normalized(value) {
        return cleanText(value).toLowerCase();
      }

      function extractParagraphs(scopeNodes, heading) {
        const seen = new Set();
        const paragraphs = [];
        const candidates = queryScopeNodes(scopeNodes, "p, li, blockquote, figcaption").filter(isVisible);
        for (const node of candidates) {
          const text = renderedText(node);
          if (!text || text.length < 20) continue;
          const key = normalized(text);
          if (seen.has(key)) continue;
          seen.add(key);
          paragraphs.push(text);
        }
        if (!paragraphs.length) {
          const fallbackBlocks = queryScopeNodes(scopeNodes, "div, span").filter((node) => {
            if (!isVisible(node) || node === heading || heading?.contains(node)) return false;
            if (node.querySelector("p, li, blockquote, figcaption")) return false;
            if (node.querySelector("img")) return false;
            const text = renderedText(node);
            if (!text || text.length < 30) return false;
            if (Array.from(node.children).some((child) => renderedText(child) === text)) return false;
            const display = getComputedStyle(node).display;
            return /block|flex|grid|inline-block|table/.test(display);
          });
          for (const node of fallbackBlocks) {
            const text = renderedText(node);
            const key = normalized(text);
            if (seen.has(key)) continue;
            seen.add(key);
            paragraphs.push(text);
          }
        }
        if (paragraphs.length) return paragraphs;
        const fallback = cleanText(scopeNodes.map((node) => renderedText(node)).join(" "));
        return fallback ? [fallback] : [];
      }

      function extractImages(scopeNodes) {
        function bestSrcFromSet(value) {
          const candidates = String(value || "")
            .split(",")
            .map((item) => item.trim())
            .map((item) => {
              const match = item.match(/^(\S+)(?:\s+(\d+)w)?/);
              return match ? { url: match[1], width: Number(match[2] || 0) } : null;
            })
            .filter(Boolean)
            .sort((a, b) => b.width - a.width);
          return candidates[0]?.url || "";
        }

        function bestImageSrc(img) {
          return (
            img.getAttribute("data-src")
            || img.getAttribute("data-lazy-src")
            || bestSrcFromSet(img.getAttribute("data-srcset"))
            || bestSrcFromSet(img.getAttribute("srcset"))
            || img.currentSrc
            || img.src
            || ""
          );
        }

        const seen = new Set();
        return queryScopeNodes(scopeNodes, "img")
          .filter((img) => {
            const rect = img.getBoundingClientRect();
            return (isVisible(img) || Boolean(bestImageSrc(img))) && rect.width >= 24 && rect.height >= 24;
          })
          .map((img) => {
            const rect = img.getBoundingClientRect();
            return {
              src: bestImageSrc(img),
              alt: cleanText(img.getAttribute("alt") || ""),
              width: Math.round(rect.width),
              height: Math.round(rect.height),
              rect: {
                left: rect.left,
                top: rect.top,
                width: rect.width,
                height: rect.height,
              },
            };
          })
          .filter((image) => image.src && !image.src.startsWith("data:image/svg+xml"))
          .filter((image) => {
            if (seen.has(image.src)) return false;
            seen.add(image.src);
            return true;
          });
      }

      function extractLinksFromContainer(scopeNodes) {
        const seen = new Set();
        return queryScopeNodes(scopeNodes, "a[href]")
          .map((anchor) => ({
            href: anchor.href || anchor.getAttribute("href") || "",
            label: semanticText(anchor).slice(0, 160),
          }))
          .filter((link) => link.href)
          .filter((link) => {
            const key = `${link.label}\u0000${link.href}`;
            if (seen.has(key)) return false;
            seen.add(key);
            return true;
          })
          .slice(0, 24);
      }

      function inferItemLayoutHints(heading, scopeNodes, images, paragraphs) {
        const descendants = queryScopeNodes(scopeNodes, "img, p, li, blockquote, figcaption, div, span").filter((node) => {
          const text = renderedText(node);
          if (node.tagName === "IMG") return true;
          return text.length >= 20 && isVisible(node);
        });
        const firstKind = descendants[0]?.tagName === "IMG" ? "media-first" : descendants[0] ? "text-first" : "unknown";
        const textNodes = queryScopeNodes(scopeNodes, "p, li, blockquote, figcaption, div, span").filter((node) => {
          if (!isVisible(node) || node === heading || heading?.contains(node)) return false;
          const text = renderedText(node);
          if (!text || text.length < 20) return false;
          if (Array.from(node.children).some((child) => renderedText(child) === text)) return false;
          return true;
        });
        const averageCenter = (nodes) => {
          if (!nodes.length) return null;
          const centers = nodes.map((node) => {
            const rect = node.getBoundingClientRect();
            return rect.left + (rect.width / 2);
          });
          return centers.reduce((sum, value) => sum + value, 0) / centers.length;
        };
        const textCenter = averageCenter(textNodes);
        const imageCenter = images.length
          ? images.reduce((sum, image) => sum + (image.rect.left + (image.rect.width / 2)), 0) / images.length
          : null;
        let textPosition = "stacked";
        let mediaPosition = "stacked";
        if (textCenter != null && imageCenter != null) {
          const delta = imageCenter - textCenter;
          const scopeWidth = Math.max(...scopeNodes.map((node) => node.getBoundingClientRect().width), 0);
          const threshold = Math.max(scopeWidth * 0.12, 60);
          if (Math.abs(delta) > threshold) {
            mediaPosition = delta < 0 ? "left" : "right";
            textPosition = delta < 0 ? "right" : "left";
          }
        }
        return {
          mediaCount: images.length,
          paragraphCount: paragraphs.length,
          firstContentKind: firstKind,
          headingLevel: Number(heading.tagName.replace(/^H/i, "")) || null,
          textPosition,
          mediaPosition,
        };
      }

      function scoreItemContainer(node, { heading, content, main }) {
        if (!node || !main.contains(node)) return Number.NEGATIVE_INFINITY;
        if (!node.contains(heading) || !node.contains(content)) return Number.NEGATIVE_INFINITY;
        const rect = node.getBoundingClientRect();
        if (rect.width < 180 || rect.height < 80) return Number.NEGATIVE_INFINITY;
        const classText = `${node.className || ""} ${node.id || ""}`.toLowerCase();
        const imageCount = node.querySelectorAll("img").length;
        const paragraphCount = node.querySelectorAll("p, li, blockquote, figcaption").length;
        const headingCount = node.querySelectorAll("h1,h2,h3,h4,h5,h6").length;
        let score = 0;
        score += 40;
        score += Math.min(imageCount, 6) * 6;
        score += Math.min(paragraphCount, 6) * 5;
        if (headingCount === 1) score += 18;
        else score -= Math.max(0, headingCount - 1) * 12;
        if (node === content) score -= 10;
        if (/slider|carousel|gallery|nav|menu|footer|share/.test(classText)) score -= 35;
        if (rect.height > window.innerHeight * 2.5) score -= 25;
        if (rect.width < Math.min(window.innerWidth * 0.45, 320)) score -= 20;
        return score;
      }

      function findItemContainerForHeading(heading, main) {
        const content = findContentContainerForHeading(heading);
        if (!content) return null;
        const common = nearestCommonAncestor(heading, content, main) || nearestCommonAncestor(heading, content, document.body);
        const candidates = uniqueElements([
          common,
          content,
          content.parentElement,
          heading.parentElement,
          heading.parentElement?.parentElement,
          heading.closest("section,article,li,[data-testid],[class]"),
          content.closest("section,article,li,[data-testid],[class]"),
        ]).filter((node) => node && main.contains(node));
        const scored = candidates
          .map((node) => ({ node, score: scoreItemContainer(node, { heading, content, main }) }))
          .filter((entry) => Number.isFinite(entry.score))
          .sort((a, b) => b.score - a.score);
        const best = scored[0];
        if (!best) return null;
        return { container: best.node, content, score: best.score, signature: nodeSignature(best.node) };
      }

      function dominantParentGroup(matches) {
        const groups = [];
        for (const match of matches) {
          const parent = match.container.parentElement;
          if (!parent) continue;
          const existing = groups.find((group) => group.parent === parent);
          if (existing) existing.items.push(match);
          else groups.push({ parent, items: [match] });
        }
        groups.sort((a, b) => b.items.length - a.items.length);
        return groups[0] || null;
      }

      function extractRepeaters(plan) {
        const signals = Array.isArray(plan?.signals) ? plan.signals : [];
        const main = document.querySelector("main");
        const diagnostics = {
          source: "accessibility+dom",
          accessibilitySnapshotAvailable: Boolean(plan?.accessibilitySnapshotAvailable),
          signalCount: signals.length,
          candidateCount: plan?.candidateCount || signals.length,
          acceptedRepeaterCount: 0,
          signals: [],
          warnings: [...(plan?.warnings || [])],
        };
        if (!main) {
          diagnostics.warnings.push("main-content-missing: manual repeater review required");
          return { repeaters: [], diagnostics };
        }
        const headingNodes = Array.from(main.querySelectorAll("h1,h2,h3,h4,h5,h6")).filter((node) => renderedText(node));
        const headingRegistry = headingNodes.map((node, index) => ({
          node,
          index,
          text: renderedText(node),
          normalized: normalized(renderedText(node)),
          level: Number(node.tagName.replace(/^H/i, "")) || 0,
        }));
        const repeaters = signals.map((signal, signalIndex) => {
          let minIndex = -1;
          const matched = [];
          for (const expected of signal.items || []) {
            const expectedText = normalized(expected.heading);
            const match = headingRegistry.find((entry) => entry.index > minIndex && entry.level === signal.headingLevel && entry.normalized === expectedText);
            if (!match) continue;
            minIndex = match.index;
            const resolved = findItemContainerForHeading(match.node, main);
            if (!resolved) continue;
            matched.push({ ...resolved, heading: match });
          }
          const dominantParent = dominantParentGroup(matched);
          const resolvedItems = dominantParent && dominantParent.items.length >= 3 ? dominantParent.items : matched;
          const items = resolvedItems.map((resolved, resolvedIndex) => {
            const nextHeadingNode = resolvedItems[resolvedIndex + 1]?.heading?.node || null;
            const scopeNodes = collectContentNodes(resolved.content, nextHeadingNode);
            const paragraphs = extractParagraphs(scopeNodes, resolved.heading.node);
            const images = extractImages(scopeNodes);
            return {
              heading: resolved.heading.text,
              paragraphs,
              images,
              links: extractLinksFromContainer(scopeNodes),
              layoutHints: inferItemLayoutHints(resolved.heading.node, scopeNodes, images, paragraphs),
            };
          }).filter((item) => item.paragraphs.length && item.images.length);
          const signalDiagnostics = {
            label: signal.label || `main-repeater-${signalIndex + 1}`,
            roleSignature: signal.roleSignature || null,
            headingLevel: signal.headingLevel || null,
            expectedItemCount: signal.items?.length || 0,
            matchedHeadingCount: matched.length,
            resolvedItemCount: items.length,
            dominantParentTag: dominantParent?.parent?.tagName?.toLowerCase() || null,
            dominantParentClass: dominantParent?.parent?.className?.toString?.() || "",
            containerSignatures: Array.from(new Set(resolvedItems.map((item) => item.signature))).slice(0, 6),
            warnings: [],
          };
          diagnostics.signals.push(signalDiagnostics);
          if (items.length < 3) {
            signalDiagnostics.warnings.push("dom-resolution-ambiguous");
            diagnostics.warnings.push(`repeater-resolution-ambiguous:${signalDiagnostics.label}`);
            return null;
          }
          const mediaCounts = items.map((item) => item.images.length);
          const repeater = {
            kind: "content-repeater",
            source: "accessibility+dom",
            label: signal.label || `main-repeater-${signalIndex + 1}`,
            itemCount: items.length,
            schema: {
              hasHeading: items.every((item) => Boolean(item.heading)),
              hasParagraphs: items.every((item) => item.paragraphs.length > 0),
              hasImages: items.every((item) => item.images.length > 0),
              maxImagesPerItem: Math.max(...mediaCounts),
            },
            layoutHints: {
              alternating: new Set(items.map((item) => item.layoutHints.textPosition || item.layoutHints.firstContentKind)).size > 1,
            },
            items,
          };
          diagnostics.acceptedRepeaterCount += 1;
          return repeater;
        }).filter(Boolean);
        if (!signals.length) {
          const mainHeadingCount = main.querySelectorAll("h2,h3,h4,h5,h6").length;
          const mainImageCount = main.querySelectorAll("img").length;
          if (mainHeadingCount >= 4 && mainImageCount >= 4) {
            diagnostics.warnings.push("possible-repeated-content-without-high-confidence-structure: manual review required");
          }
        } else if (!repeaters.length) {
          diagnostics.warnings.push("accessibility-signals-found-but-no-structured-repeaters-resolved: manual review required");
        }
        return { repeaters, diagnostics };
      }

      function extractAccordionRepeaters(main) {
        if (!main) return [];
        const groups = [];
        const candidates = Array.from(main.querySelectorAll("details")).filter((node) => renderedText(node.querySelector("summary")));
        for (const node of candidates) {
          const parent = node.parentElement;
          if (!parent) continue;
          const existing = groups.find((group) => group.parent === parent);
          if (existing) existing.items.push(node);
          else groups.push({ parent, items: [node] });
        }
        const nativeRecords = groups.filter((group) => group.items.length >= 2).map((group, groupIndex) => {
          const items = group.items.map((node) => {
            const summary = node.querySelector("summary");
            const clone = node.cloneNode(true);
            clone.querySelector("summary")?.remove();
            const paragraphs = Array.from(clone.querySelectorAll("p,li")).map((child) => semanticText(child)).filter(Boolean);
            const fallbackText = semanticText(clone);
            const images = Array.from(clone.querySelectorAll("img")).map((image) => ({ src: image.currentSrc || image.src || "", alt: image.alt || "" })).filter((image) => image.src && !/(emoji|twemoji|wp-smiley)/i.test(image.src));
            const links = Array.from(clone.querySelectorAll("a[href]")).map((link) => ({ text: semanticText(link), url: link.href })).filter((link) => link.url);
            const content = paragraphs.length ? paragraphs : fallbackText ? [fallbackText] : [];
            return {
              heading: renderedText(summary),
              paragraphs: content,
              images,
              links,
              initialExpanded: Boolean(node.open),
              itemStructure: images.length ? content.length ? "media-and-text" : "media-only" : "text-only",
              layoutHints: { mediaCount: images.length, paragraphCount: content.length, firstContentKind: images.length ? "media-first" : "text-first", headingLevel: null },
            };
          });
          const mediaCounts = items.map((item) => item.images.length);
          const expanded = items.map((item, index) => item.initialExpanded ? index : null).filter((index) => index !== null);
          return {
            kind: "accordion-repeater",
            source: "dom:details",
            label: cleanText(group.parent.getAttribute("aria-label")) || `accordion-${groupIndex + 1}`,
            itemCount: items.length,
            schema: { hasHeading: true, hasParagraphs: items.every((item) => item.paragraphs.length > 0), hasImages: items.some((item) => item.images.length > 0), maxImagesPerItem: Math.max(...mediaCounts, 0) },
            state: { initialExpandedIndices: expanded, multipleOpen: expanded.length > 1, openBehavior: "requires-interaction-probe" },
            items,
          };
        });
        const customRoots = Array.from(main.querySelectorAll(".tatsu-accordion, [class*='accordion' i]")).filter((root, index, all) =>
          root.querySelectorAll(".accordion-head").length >= 2 && !all.some((other) => other !== root && other.contains(root) && other.querySelectorAll(".accordion-head").length >= 2),
        );
        const customRecords = customRoots.map((root, rootIndex) => {
          const heads = Array.from(root.querySelectorAll(".accordion-head")).filter((head) => renderedText(head));
          const items = heads.map((head) => {
            const contentRoot = head.nextElementSibling?.matches?.(".accordion-content,[role='region']") ? head.nextElementSibling : document.getElementById(head.getAttribute("aria-controls") || "");
            const paragraphs = Array.from(contentRoot?.querySelectorAll?.("p,li") || []).map((child) => semanticText(child)).filter(Boolean);
            const fallbackText = contentRoot ? semanticText(contentRoot) : "";
            const content = paragraphs.length ? paragraphs : fallbackText ? [fallbackText] : [];
            const images = Array.from(contentRoot?.querySelectorAll?.("img") || []).map((image) => ({ src: image.currentSrc || image.src || "", alt: image.alt || "" })).filter((image) => image.src && !/(emoji|twemoji|wp-smiley)/i.test(image.src));
            const links = Array.from(contentRoot?.querySelectorAll?.("a[href]") || []).map((link) => ({ text: semanticText(link), url: link.href })).filter((link) => link.url);
            const expanded = head.getAttribute("aria-expanded") === "true" || contentRoot && getComputedStyle(contentRoot).display !== "none" && getComputedStyle(contentRoot).visibility !== "hidden" && contentRoot.getBoundingClientRect().height > 0;
            return { heading: renderedText(head), paragraphs: content, images, links, initialExpanded: Boolean(expanded), itemStructure: images.length ? content.length ? "media-and-text" : "media-only" : "text-only", layoutHints: { mediaCount: images.length, paragraphCount: content.length, firstContentKind: images.length ? "media-first" : "text-first", headingLevel: Number(head.tagName.slice(1)) || null } };
          });
          const expanded = items.map((item, index) => item.initialExpanded ? index : null).filter((index) => index !== null);
          return { kind: "accordion-repeater", source: "dom:accordion-head", label: cleanText(root.getAttribute("aria-label")) || `accordion-${rootIndex + 1}`, itemCount: items.length, schema: { hasHeading: true, hasParagraphs: items.every((item) => item.paragraphs.length > 0), hasImages: items.some((item) => item.images.length > 0), maxImagesPerItem: Math.max(0, ...items.map((item) => item.images.length)) }, state: { initialExpandedIndices: expanded, multipleOpen: expanded.length > 1, openBehavior: root.classList.contains("tatsu-accordion") ? "single" : "requires-interaction-probe" }, items };
        }).filter((record) => record.itemCount >= 2 && record.items.every((item) => item.paragraphs.length));
        return [...nativeRecords, ...customRecords];
      }

      const repeaterResult = extractRepeaters(repeaterPlan);
      const accordionRepeaters = extractAccordionRepeaters(document.querySelector("main, [role='main'], #main, #content") || document.body);
      const visualAssets = collectVisualAssets();
      const visibleLinks = dedupeNav(Array.from(document.querySelectorAll("a[href]")).filter(isVisible).map(linkRecord)).slice(0, 240)
        .map((link) => ({ text: link.label, url: link.href }));
      return {
        sections: sectionResult.sections,
        sectionDiagnostics: sectionResult.diagnostics,
        footer,
        computedTokens,
        repeaters: [...repeaterResult.repeaters, ...accordionRepeaters],
        repeaterDiagnostics: repeaterResult.diagnostics,
        ignoredSurfaces,
        visualAssets,
        links: visibleLinks,
        chrome: {
          direction,
          viewport: { width: window.innerWidth, height: window.innerHeight },
          header: {
            variants: [initialHeader, scrolledHeader],
            maxStickyViewportRatio: 0.16,
          },
          navigation,
          heroEvidence: {
            visibleText,
            forbiddenSeoOnlyText: [],
          },
        },
      };
    }, repeaterPlan);
    const normalizedDesktopDom = await page.content();
    browserData.chrome.heroEvidence.forbiddenSeoOnlyText = seoOnlyText({ seo, visibleText: browserData.chrome.heroEvidence.visibleText });
    const extractionWarnings = [
      ...((desktopNavigation.warnings || []).map((warning) => `navigation: ${warning}`)),
      ...(browserData.sectionDiagnostics?.warnings || []),
      ...(browserData.repeaterDiagnostics?.warnings || []),
    ];
    return {
      url,
      path: new URL(url).pathname || "/",
      area: classifyUrl(url),
      title: seo.title,
      seo,
      navigation: desktopNavigation,
      sections: browserData.sections.length ? browserData.sections : extractSectionsFromHtml(html),
      sectionDiagnostics: browserData.sectionDiagnostics || {
        source: "dom-layout+a11y",
        contentRoot: "unknown",
        accessibilitySnapshotAvailable: Boolean(repeaterPlan?.accessibilitySnapshotAvailable),
        accessibilityRoot: repeaterPlan?.accessibilityRoot || null,
        candidateCount: 0,
        acceptedSectionCount: 0,
        acceptedModuleCount: 0,
        warnings: ["no-strong-section-boundaries"],
      },
      repeaters: browserData.repeaters || [],
      repeaterDiagnostics: browserData.repeaterDiagnostics || { source: "accessibility+dom", signalCount: 0, acceptedRepeaterCount: 0, warnings: [] },
      footer: browserData.footer || null,
      ignoredSurfaces: browserData.ignoredSurfaces || [],
      normalizationActions: (browserData.ignoredSurfaces || []).flatMap((surface) => [
        {
          phase: "before-scroll-sweep",
          action: "quarantine-obstructive-surface",
          surfaceId: surface.id,
          kind: surface.kind,
          reason: surface.reason,
          reversible: true,
        },
        {
          phase: "after-scroll-sweep",
          action: "verify-surface-remains-quarantined",
          surfaceId: surface.id,
          kind: surface.kind,
          reversible: true,
        },
      ]),
      visualAssets: browserData.visualAssets || [],
      links: browserData.links?.length ? browserData.links : extractLinks(html, url),
      tokens: { ...inferTokensFromHtml(html), computed: browserData.computedTokens },
      chrome: browserData.chrome,
      responsiveTextGeometry,
      screenshots: screenshotMap,
      navigationProfiles,
      rawDomSnapshots: htmlByViewport,
      normalizedDomSnapshots: { desktop: normalizedDesktopDom },
      accessibilityEvidence: {
        snapshotAvailable: Boolean(repeaterPlan?.accessibilitySnapshotAvailable),
        root: repeaterPlan?.accessibilityRoot || null,
        signalCount: repeaterPlan?.signals?.length || 0,
      },
      extractionWarnings: extractionWarnings.length ? extractionWarnings : undefined,
      extractedAt: new Date().toISOString(),
    };
  } finally {
    await browser.close();
  }
}

async function captureImportantTextGeometry(page) {
  return page.evaluate(() => {
    const clean = (value) => String(value || "").replace(/\s+/g, " ").trim();
    const visible = (node) => {
      const rect = node.getBoundingClientRect();
      const style = getComputedStyle(node);
      return rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden" && Number(style.opacity || 1) > 0;
    };
    const lineCount = (node) => {
      const tops = [];
      const walker = document.createTreeWalker(node, NodeFilter.SHOW_TEXT);
      for (let textNode = walker.nextNode(); textNode; textNode = walker.nextNode()) {
        if (!clean(textNode.nodeValue)) continue;
        const range = document.createRange();
        range.selectNodeContents(textNode);
        for (const rect of range.getClientRects()) {
          if (rect.width > 0 && rect.height > 0 && !tops.some((top) => Math.abs(top - rect.top) <= 2)) tops.push(rect.top);
        }
      }
      return Math.max(1, tops.length);
    };
    return Array.from(document.querySelectorAll("h1,h2,h3"))
      .filter(visible)
      .map((node) => {
        const rect = node.getBoundingClientRect();
        const style = getComputedStyle(node);
        const lines = lineCount(node);
        return {
          text: clean(node.textContent).slice(0, 240),
          tag: node.tagName.toLowerCase(),
          inlineSize: Math.round(rect.width * 100) / 100,
          blockSize: Math.round(rect.height * 100) / 100,
          lineCount: lines,
          wrapPolicy: lines === 1 ? "single-line" : style.whiteSpace === "nowrap" ? "clipped-or-overflowing" : "wrapped",
          fontSize: style.fontSize,
          lineHeight: style.lineHeight,
          maxWidth: style.maxWidth,
        };
      })
      .filter((item) => item.text)
      .slice(0, 48);
  });
}

async function extractWithFetch(url) {
  const html = await fetchText(url);
  const seo = extractSeo(html, url);
  return {
    url,
    path: new URL(url).pathname || "/",
    area: classifyUrl(url),
    title: seo.title,
    seo,
    sections: extractSectionsFromHtml(html),
    sectionDiagnostics: {
      source: "none",
      contentRoot: "none",
      accessibilitySnapshotAvailable: false,
      accessibilityRoot: null,
      candidateCount: 0,
      acceptedSectionCount: 0,
      acceptedModuleCount: 0,
      warnings: ["browser-unavailable: section extraction requires browser-based DOM, layout, and accessibility evidence"],
    },
    repeaters: [],
    repeaterDiagnostics: {
      source: "none",
      accessibilitySnapshotAvailable: false,
      signalCount: 0,
      acceptedRepeaterCount: 0,
      warnings: ["browser-unavailable: repeater extraction requires browser-based accessibility and DOM evidence"],
    },
    footer: null,
    links: extractLinks(html, url),
    tokens: inferTokensFromHtml(html),
    chrome: {
      direction: "unknown",
      header: { variants: [], maxStickyViewportRatio: 0.16 },
      navigation: [],
      heroEvidence: {
        visibleText: [],
        forbiddenSeoOnlyText: seoOnlyText({ seo, visibleText: [] }),
      },
      warnings: ["browser-unavailable: header behavior, dropdown hierarchy, logo footprint, and hero visible-text evidence require manual screenshot review"],
    },
    screenshots: {},
    extractionWarnings: ["browser-unavailable: repeater extraction requires browser-based accessibility and DOM evidence"],
    extractedAt: new Date().toISOString(),
  };
}

async function detectRepeaterSignals(page) {
  const candidates = [
    { selector: 'main, [role="main"]', label: "main" },
    { selector: "article", label: "article" },
    { selector: "body", label: "body" },
  ];
  const failures = [];
  for (const candidate of candidates) {
    const locator = page.locator(candidate.selector).first();
    const count = await locator.count();
    if (count === 0) {
      failures.push(`${candidate.label}: selector did not match any element`);
      continue;
    }
    try {
      const snapshot = await locator.ariaSnapshot({ mode: "ai" });
      const detection = detectRepeaterSignalsFromAria(snapshot);
      return {
        accessibilitySnapshotAvailable: true,
        accessibilityRoot: candidate.label,
        candidateCount: detection.candidateCount,
        signals: detection.signals,
        warnings: detection.signals.length
          ? []
          : [`accessibility-snapshot-captured-on-${candidate.label}-but-no-high-confidence-repeater-patterns-found`],
      };
    } catch (error) {
      failures.push(`${candidate.label}: ${error.message}`);
    }
  }
  return {
    accessibilitySnapshotAvailable: false,
    accessibilityRoot: null,
    candidateCount: 0,
    signals: [],
    warnings: [`accessibility-snapshot-unavailable: ${failures.join("; ")}`],
  };
}

async function navigateWithAdaptiveProfile(page, url) {
  const profiles = [
    { name: "normal", waitUntil: "networkidle", timeoutMs: 45000, settleMs: 0 },
    { name: "slow-site", waitUntil: "domcontentloaded", timeoutMs: 90000, settleMs: 2000 },
  ];
  const warnings = [];
  let lastError = null;
  for (const profile of profiles) {
    try {
      await page.goto(url, { waitUntil: profile.waitUntil, timeout: profile.timeoutMs });
      if (profile.settleMs > 0) {
        await page.waitForTimeout(profile.settleMs);
      }
      if (profile.name !== "normal") {
        warnings.push(`used ${profile.name} navigation profile after the default profile did not settle cleanly`);
      }
      return {
        profile: profile.name,
        waitUntil: profile.waitUntil,
        timeoutMs: profile.timeoutMs,
        warnings,
      };
    } catch (error) {
      lastError = error;
      warnings.push(`${profile.name} failed: ${error.message}`);
    }
  }
  throw lastError;
}

function detectRepeaterSignalsFromAria(snapshot) {
  const tree = parseAriaSnapshot(snapshot);
  if (!tree) return { signals: [], candidateCount: 0 };
  const mains = [];
  walkAriaTree(tree, (node) => {
    if (node.role === "main") mains.push(node);
  });
  const root = mains.at(-1) || tree;
  const candidates = [];
  walkAriaTree(root, (node) => {
    const grouped = groupHeadingContentPairs(node.children || []);
    for (const group of grouped) {
      if (group.items.length >= 3) candidates.push(group);
    }
  });
  candidates.sort((a, b) => {
    if (b.items.length !== a.items.length) return b.items.length - a.items.length;
    return averageMediaCount(b.items) - averageMediaCount(a.items);
  });
  return {
    candidateCount: candidates.length,
    signals: candidates.slice(0, 3).map((candidate, index) => ({
      label: `main-repeated-content-${index + 1}`,
      headingLevel: candidate.headingLevel,
      roleSignature: `heading-${candidate.headingLevel}+generic`,
      items: candidate.items.map((item) => ({
        heading: item.heading,
        paragraphCount: item.paragraphCount,
        imageCount: item.imageCount,
      })),
    })),
  };
}

function averageMediaCount(items) {
  return items.reduce((sum, item) => sum + item.imageCount, 0) / Math.max(items.length, 1);
}

function groupHeadingContentPairs(children = []) {
  const grouped = new Map();
  for (let index = 0; index < children.length - 1; index += 1) {
    const heading = children[index];
    const content = children[index + 1];
    if (heading.role !== "heading" || content.role !== "generic") continue;
    const headingLevel = heading.level || 0;
    if (headingLevel < 2) continue;
    const paragraphCount = countAriaRole(content, "paragraph");
    const imageCount = countAriaRole(content, "img");
    if (!heading.name || paragraphCount < 1 || imageCount < 1) continue;
    const key = String(headingLevel);
    if (!grouped.has(key)) grouped.set(key, { headingLevel, items: [] });
    grouped.get(key).items.push({
      heading: heading.name,
      paragraphCount,
      imageCount,
    });
  }
  return Array.from(grouped.values());
}

function countAriaRole(node, role) {
  let count = 0;
  walkAriaTree(node, (current) => {
    if (current.role === role) count += 1;
  });
  return count;
}

function walkAriaTree(node, visit) {
  if (!node) return;
  visit(node);
  for (const child of node.children || []) walkAriaTree(child, visit);
}

function parseAriaSnapshot(snapshot) {
  const lines = String(snapshot || "")
    .split("\n")
    .map((line) => line.match(/^(\s*)- (.*)$/))
    .filter(Boolean)
    .map(([, indent, content]) => ({ depth: Math.floor(indent.length / 2), content }));
  if (!lines.length) return null;
  const root = { role: "root", children: [] };
  const stack = [root];
  for (const line of lines) {
    const node = parseAriaLine(line.content);
    if (!node) continue;
    while (stack.length > line.depth + 1) stack.pop();
    const parent = stack[stack.length - 1];
    parent.children.push(node);
    stack.push(node);
  }
  return root;
}

function parseAriaLine(content) {
  const trimmed = String(content || "").trim();
  if (!trimmed) return null;
  if (trimmed.startsWith("text:")) {
    return { role: "text", name: trimmed.slice(5).trim(), children: [] };
  }
  const roleMatch = trimmed.match(/^([a-zA-Z0-9-]+)/);
  if (!roleMatch) return null;
  const role = roleMatch[1];
  const nameMatch = trimmed.match(/"([^"]+)"/);
  const levelMatch = trimmed.match(/\[level=(\d+)\]/);
  return {
    role,
    name: nameMatch?.[1] || "",
    level: levelMatch ? Number(levelMatch[1]) : null,
    raw: trimmed,
    children: [],
  };
}

function seoOnlyText({ seo, visibleText }) {
  const visible = new Set((visibleText || []).map(normalizeEvidenceText));
  return [
    seo?.title,
    seo?.openGraph?.["og:title"],
    seo?.jsonLd?.name,
    seo?.jsonLd?.description,
    seo?.description,
  ]
    .flat()
    .filter(Boolean)
    .map((value) => String(value).replace(/&#039;/g, "'").replace(/&quot;/g, "\"").replace(/&amp;/g, "&").trim())
    .filter((value, index, values) => values.indexOf(value) === index)
    .filter((value) => !visible.has(normalizeEvidenceText(value)));
}

function normalizeEvidenceText(value) {
  return String(value || "").replace(/\s+/g, " ").trim().toLowerCase();
}

if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((error) => {
    console.error(error.stack || error.message);
    process.exit(1);
  });
}