@detiq/crawler 1.0.6 → 1.0.7

package/src/extractors/advanced.ts

@@ -17,11 +17,18 @@ export interface PageMetadata {
   ogImage: string | null;
   ogUrl: string | null;
   ogType: string | null;
+  ogSiteName: string | null;
+  ogLocale: string | null;
   twitterCard: string | null;
   twitterTitle: string | null;
   twitterDescription: string | null;
+  twitterImage: string | null;
+  twitterSite: string | null;
   canonical: string | null;
   robots: string | null;
+  hreflang: Array<{ lang: string; href: string }>;
+  themeColor: string | null;
+  favicon: string | null;
   jsonLd: object[];
   schemaTypes: string[];
   lang: string | null;
@@ -109,8 +116,12 @@ export function extractMetadata(html: string, url: string): PageMetadata {
   const meta: PageMetadata = {
     title: null, description: null, keywords: null,
     ogTitle: null, ogDescription: null, ogImage: null, ogUrl: null, ogType: null,
+    ogSiteName: null, ogLocale: null,
     twitterCard: null, twitterTitle: null, twitterDescription: null,
-    canonical: null, robots: null, jsonLd: [], schemaTypes: [], lang: null,
+    twitterImage: null, twitterSite: null,
+    canonical: null, robots: null,
+    hreflang: [], themeColor: null, favicon: null,
+    jsonLd: [], schemaTypes: [], lang: null,
   };
   try {
     const { document } = parseHTML(html);
@@ -128,16 +139,31 @@ export function extractMetadata(html: string, url: string): PageMetadata {
       if (name === 'twitter:card') meta.twitterCard = content;
       if (name === 'twitter:title') meta.twitterTitle = content;
       if (name === 'twitter:description') meta.twitterDescription = content;
+      if (name === 'twitter:image') meta.twitterImage = content;
+      if (name === 'twitter:site') meta.twitterSite = content;
+      if (name === 'theme-color') meta.themeColor = content;
       if (prop === 'og:title') meta.ogTitle = content;
       if (prop === 'og:description') meta.ogDescription = content;
       if (prop === 'og:image') meta.ogImage = content;
       if (prop === 'og:url') meta.ogUrl = content;
       if (prop === 'og:type') meta.ogType = content;
+      if (prop === 'og:site_name') meta.ogSiteName = content;
+      if (prop === 'og:locale') meta.ogLocale = content;
     }
 
     const canonical = (document as any).querySelector('link[rel="canonical"]');
     if (canonical) meta.canonical = canonical.getAttribute('href') ?? null;
 
+    const faviconEl = (document as any).querySelector('link[rel="icon"], link[rel="shortcut icon"]');
+    if (faviconEl) meta.favicon = faviconEl.getAttribute('href') ?? null;
+
+    const hreflangEls = [...(document as any).querySelectorAll('link[rel="alternate"][hreflang]')];
+    for (const el of hreflangEls) {
+      const lang = (el as any).getAttribute('hreflang') ?? '';
+      const href = (el as any).getAttribute('href') ?? '';
+      if (lang && href) meta.hreflang.push({ lang, href });
+    }
+
     const jsonLdScripts = [...(document as any).querySelectorAll('script[type="application/ld+json"]')];
     for (const s of jsonLdScripts) {
       try {

package/src/interactive-probe.ts

@@ -51,6 +51,41 @@ export interface ConditionalReveal {
   revealedText: string;
 }
 
+export interface TooltipCapture {
+  triggerLabel: string;
+  tooltipText: string;
+}
+
+export interface TabPanelCapture {
+  tabLabel: string;
+  panelContent: string;
+  panelHeading?: string;
+}
+
+export interface CarouselSlide {
+  slideIndex: number;
+  heading?: string;
+  content: string;
+}
+
+export interface WizardStep {
+  stepIndex: number;
+  stepLabel?: string;
+  content: string;
+  fields: string[];
+}
+
+export interface FocusTrapResult {
+  modalTrigger: string;
+  focusTrapped: boolean;
+  sampledFocused: string[];
+}
+
+export interface ContextMenuCapture {
+  trigger: string;
+  items: string[];
+}
+
 export interface ProbeResult {
   screenId: string;
   url: string;
@@ -59,6 +94,13 @@ export interface ProbeResult {
   modals: ModalObservation[];
   conditionals: ConditionalReveal[];
   loadingPatterns: string[];
+  tooltips?: TooltipCapture[];
+  tabPanels?: TabPanelCapture[];
+  carouselSlides?: CarouselSlide[];
+  wizardSteps?: WizardStep[];
+  focusTraps?: FocusTrapResult[];
+  skipNavIssues?: string[];
+  contextMenus?: ContextMenuCapture[];
 }
 
 // ── CSS selectors that reliably find error messages across frameworks ────────
@@ -170,7 +212,7 @@ async function findModalTriggers(page: Page): Promise<Array<{ selector: string;
         while (p) { if (NAV_PARENTS.has(p.tagName)) return false; p = p.parentElement; }
         return true;
       })
-      .slice(0, 8) // probe at most 8 buttons per screen to keep it fast
+      .slice(0, 20) // probe at most 20 buttons per screen
       .map((el) => {
         const label = (el as HTMLElement).innerText?.trim() || el.getAttribute('aria-label') || 'button';
         return { selector: `[aria-label="${label}"]`, label: label.slice(0, 60) };
@@ -244,8 +286,22 @@ export async function probeScreen(
         await page.waitForTimeout(1500);
 
         const errors = await collectErrors(page);
-        for (const errorText of errors) {
-          // Try to match error back to a field
+        // Prefer DOM-proximity mapping via aria-invalid + aria-describedby
+        const ariaFieldErrors = await page.evaluate(() =>
+          Array.from(document.querySelectorAll('[aria-invalid="true"]')).map((el) => {
+            const describedBy = el.getAttribute('aria-describedby');
+            const errorEl = describedBy ? document.getElementById(describedBy) : null;
+            const label = el.getAttribute('aria-label') || el.getAttribute('placeholder') || (el as HTMLInputElement).name || '';
+            return { label, errorText: errorEl?.textContent?.trim() || '' };
+          }).filter((f) => f.errorText)
+        );
+        const ariaMatched = new Set<string>();
+        for (const af of ariaFieldErrors) {
+          ariaMatched.add(af.errorText);
+          result.validationErrors.push({ field: af.label || 'unknown', trigger: 'empty_submit', errorText: af.errorText.slice(0, 150) });
+        }
+        // Fallback: text-proximity match for errors not covered by aria-invalid
+        for (const errorText of errors.filter((e) => !ariaMatched.has(e))) {
           const matchedField = formInputs.find((el) =>
             errorText.toLowerCase().includes(el.meaning.toLowerCase().split(' ')[0]) ||
             el.meaning.toLowerCase().includes(errorText.toLowerCase().split(' ')[0])
@@ -338,6 +394,30 @@ export async function probeScreen(
             content: dialogText.content,
             fields: dialogText.fields.slice(0, 10),
           });
+        } else {
+          // No modal appeared — check for accordion/disclosure panel reveals
+          // Clicks on accordion triggers change aria-expanded but don't open a dialog.
+          const accordionText = await page.evaluate(() => {
+            const panels = Array.from(document.querySelectorAll(
+              '[aria-expanded="true"] + *, details[open] > :not(summary), [data-state="open"]:not([role="dialog"]):not([class*="modal" i]), [data-headlessui-state="open"] > *'
+            )).filter((el) => {
+              const s = window.getComputedStyle(el as HTMLElement);
+              return s.display !== 'none' && s.visibility !== 'hidden';
+            });
+            if (panels.length === 0) return null;
+            const panel = panels[0] as HTMLElement;
+            const heading = panel.querySelector('h2,h3,h4')?.textContent?.replace(/\s+/g, ' ').trim() || '';
+            const content = panel.innerText?.replace(/\s+/g, ' ').trim().slice(0, 400) || '';
+            return content.length > 15 ? { heading, content } : null;
+          });
+          if (accordionText) {
+            result.modals.push({
+              triggerElement: trigger.label,
+              title: accordionText.heading || `${trigger.label} (revealed)`,
+              content: accordionText.content,
+              fields: [],
+            });
+          }
         }
 
         // Dismiss: Escape key first, then close button
@@ -359,6 +439,41 @@ export async function probeScreen(
     result.conditionals.push(...conditionals);
   } catch { /* non-fatal */ }
 
+  // ── Probe 5: Tab panels — click each tab, capture revealed content ────────────
+  try {
+    result.tabPanels = await probeTabPanels(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 6: Tooltips — hover/title/describedby capture ─────────────────────
+  try {
+    result.tooltips = await probeTooltips(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 7: Carousel/slider slides ──────────────────────────────────────────
+  try {
+    result.carouselSlides = await probeCarousels(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 8: Wizard/multi-step form steps ────────────────────────────────────
+  try {
+    result.wizardSteps = await probeWizardSteps(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 9: Focus-trap detection on any open dialogs ────────────────────────
+  try {
+    result.focusTraps = await detectFocusTraps(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 10: Skip navigation compliance (WCAG 2.4.1) ────────────────────────
+  try {
+    result.skipNavIssues = await probeSkipNavigation(page);
+  } catch { /* non-fatal */ }
+
+  // ── Probe 11: Context menu capture on canvas/chart elements ──────────────────
+  try {
+    result.contextMenus = await probeContextMenus(page);
+  } catch { /* non-fatal */ }
+
   return result;
 }
 
@@ -382,6 +497,27 @@ export function probeResultToObservations(result: ProbeResult): Array<{
   for (const lp of result.loadingPatterns) {
     obs.push({ elementMeaning: '(submit button)', observationType: 'LOADING_STATE', observedText: lp, triggeredBy: 'form_submit' });
   }
+  for (const tp of result.tabPanels ?? []) {
+    obs.push({ elementMeaning: tp.tabLabel, observationType: 'TAB_PANEL', observedText: tp.panelContent, triggeredBy: `tab_click:${tp.tabLabel}` });
+  }
+  for (const tt of result.tooltips ?? []) {
+    obs.push({ elementMeaning: tt.triggerLabel, observationType: 'TOOLTIP', observedText: tt.tooltipText, triggeredBy: 'hover_or_title' });
+  }
+  for (const cs of result.carouselSlides ?? []) {
+    obs.push({ elementMeaning: `Slide ${cs.slideIndex + 1}`, observationType: 'CAROUSEL_SLIDE', observedText: cs.content, triggeredBy: `carousel_next:${cs.slideIndex}` });
+  }
+  for (const ws of result.wizardSteps ?? []) {
+    obs.push({ elementMeaning: ws.stepLabel ?? `Step ${ws.stepIndex + 1}`, observationType: 'WIZARD_STEP', observedText: ws.content, triggeredBy: `wizard_next:${ws.stepIndex}` });
+  }
+  for (const ft of result.focusTraps ?? []) {
+    obs.push({ elementMeaning: ft.modalTrigger, observationType: 'FOCUS_TRAP', observedText: ft.focusTrapped ? 'Focus correctly trapped inside dialog' : 'FAIL: focus escaped dialog — WCAG 2.1.2 violation', triggeredBy: 'tab_key_sequence' });
+  }
+  for (const issue of result.skipNavIssues ?? []) {
+    obs.push({ elementMeaning: '(page)', observationType: 'SKIP_NAV_ISSUE', observedText: issue, triggeredBy: 'skip_nav_audit' });
+  }
+  for (const cm of result.contextMenus ?? []) {
+    obs.push({ elementMeaning: cm.trigger, observationType: 'CONTEXT_MENU', observedText: cm.items.join(' | '), triggeredBy: 'right_click' });
+  }
   return obs;
 }
 
@@ -419,6 +555,44 @@ export function probeResultToMarkdown(result: ProbeResult): {
     }
   }
 
+  if ((result.tabPanels ?? []).length > 0) {
+    lines.push('\n### Tab Panel Contents (observed)');
+    for (const tp of result.tabPanels!) {
+      lines.push(`- **Tab: ${tp.tabLabel}**${tp.panelHeading ? ` — ${tp.panelHeading}` : ''}: ${tp.panelContent.slice(0, 200)}`);
+    }
+  }
+
+  if ((result.tooltips ?? []).length > 0) {
+    lines.push('\n### Tooltips (observed)');
+    for (const tt of result.tooltips!) {
+      lines.push(`- **${tt.triggerLabel}**: ${tt.tooltipText}`);
+    }
+  }
+
+  if ((result.carouselSlides ?? []).length > 0) {
+    lines.push('\n### Carousel Slides (observed)');
+    for (const cs of result.carouselSlides!) {
+      lines.push(`- **Slide ${cs.slideIndex + 1}**${cs.heading ? ` — ${cs.heading}` : ''}: ${cs.content.slice(0, 200)}`);
+    }
+  }
+
+  if ((result.wizardSteps ?? []).length > 0) {
+    lines.push('\n### Wizard / Multi-Step Form (observed)');
+    for (const ws of result.wizardSteps!) {
+      const label = ws.stepLabel ? ` — ${ws.stepLabel}` : '';
+      lines.push(`- **Step ${ws.stepIndex + 1}${label}**: ${ws.content.slice(0, 200)}`);
+      if (ws.fields.length > 0) lines.push(`  - Fields: ${ws.fields.join(', ')}`);
+    }
+  }
+
+  if ((result.focusTraps ?? []).length > 0) {
+    lines.push('\n### Focus-Trap Audit (observed)');
+    for (const ft of result.focusTraps!) {
+      const verdict = ft.focusTrapped ? '✅ PASS' : '❌ FAIL (WCAG 2.1.2)';
+      lines.push(`- **${ft.modalTrigger}**: ${verdict} — focused: [${ft.sampledFocused.slice(0, 4).join(', ')}]`);
+    }
+  }
+
   if (result.conditionals.length > 0) {
     lines.push('\n### Conditional UI (observed)');
     for (const c of result.conditionals) {
@@ -551,6 +725,236 @@ export interface KeyboardNavResult {
   issues: string[];
 }
 
+/** Verify skip-navigation links exist and their targets are present in the DOM. */
+async function probeSkipNavigation(page: Page): Promise<string[]> {
+  const issues: string[] = [];
+  try {
+    const skipLinks = await page.evaluate(() =>
+      Array.from(document.querySelectorAll('a[href^="#"]'))
+        .filter((el) => /skip|jump to|main content|content|nav/i.test((el as HTMLElement).innerText?.toLowerCase().trim() || ''))
+        .map((el) => ({
+          text: (el as HTMLElement).innerText?.trim() || '',
+          href: el.getAttribute('href') || '',
+          hasTarget: !!document.querySelector(el.getAttribute('href') || '#__invalid__'),
+        }))
+    );
+    if (skipLinks.length === 0) {
+      issues.push('No skip navigation links found (WCAG 2.4.1 — keyboard users cannot bypass nav blocks)');
+    }
+    for (const link of skipLinks) {
+      if (!link.hasTarget) issues.push(`Skip link "${link.text}" → "${link.href}" target not found in DOM`);
+    }
+  } catch { /* non-fatal */ }
+  return issues;
+}
+
+/** Right-click on canvas, chart, and context-menu elements to capture context menu items. */
+async function probeContextMenus(page: Page): Promise<ContextMenuCapture[]> {
+  const results: ContextMenuCapture[] = [];
+  try {
+    const targets = await page.$$('canvas, [data-contextmenu], [oncontextmenu], [class*="chart" i]:not(script)');
+    for (const t of targets.slice(0, 4)) {
+      try {
+        await t.click({ button: 'right', timeout: 1000 });
+        await page.waitForTimeout(350);
+        const items = await page.evaluate(() =>
+          Array.from(document.querySelectorAll('[role="menu"] [role="menuitem"], .context-menu-item, [class*="contextmenu" i] li'))
+            .map((el) => (el as HTMLElement).innerText?.trim())
+            .filter(Boolean).slice(0, 12)
+        );
+        if (items.length > 0) {
+          const trigger = await t.evaluate((el) => (el as HTMLElement).getAttribute('aria-label') || (el as HTMLElement).className.slice(0, 40) || el.tagName).catch(() => '');
+          results.push({ trigger, items });
+        }
+        await page.keyboard.press('Escape').catch(() => { });
+      } catch { /* skip this target */ }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** Click carousel next buttons up to 8 slides and record content of each revealed slide. */
+async function probeCarousels(page: Page): Promise<CarouselSlide[]> {
+  const results: CarouselSlide[] = [];
+  try {
+    const CAROUSEL_SEL = '[class*="carousel" i], [class*="slider" i], [class*="swiper" i], [role="region"][aria-roledescription*="carousel" i]';
+    const hasCarousel = await page.evaluate((sel) => !!document.querySelector(sel), CAROUSEL_SEL);
+    if (!hasCarousel) return results;
+
+    const NEXT_SEL = '[aria-label*="next" i], [aria-label*="Next"], [class*="next" i]:not([class*="footnext"]):not(a), button[class*="arrow-right" i], button[class*="chevron-right" i]';
+
+    // Capture slide 0 (current state)
+    const slide0 = await page.evaluate((carSel) => {
+      const car = document.querySelector(carSel) as HTMLElement | null;
+      if (!car) return null;
+      const active = car.querySelector('[aria-hidden="false"], .active, [class*="active" i], [class*="current" i]') as HTMLElement | null;
+      const target = active ?? car;
+      return { heading: target.querySelector('h2,h3,h4')?.textContent?.trim() ?? '', content: target.innerText?.replace(/\s+/g, ' ').trim().slice(0, 300) ?? '' };
+    }, CAROUSEL_SEL);
+    if (slide0?.content && slide0.content.length > 15) results.push({ slideIndex: 0, heading: slide0.heading || undefined, content: slide0.content });
+
+    const seen = new Set<string>(slide0?.content ? [slide0.content] : []);
+    for (let i = 1; i < 8; i++) {
+      try {
+        const nextBtn = page.locator(NEXT_SEL).first();
+        const visible = await nextBtn.isVisible().catch(() => false);
+        if (!visible) break;
+        await nextBtn.click({ timeout: 1000 });
+        await page.waitForTimeout(600);
+        const slide = await page.evaluate((carSel) => {
+          const car = document.querySelector(carSel) as HTMLElement | null;
+          if (!car) return null;
+          const active = car.querySelector('[aria-hidden="false"], .active, [class*="active" i], [class*="current" i]') as HTMLElement | null;
+          const target = active ?? car;
+          return { heading: target.querySelector('h2,h3,h4')?.textContent?.trim() ?? '', content: target.innerText?.replace(/\s+/g, ' ').trim().slice(0, 300) ?? '' };
+        }, CAROUSEL_SEL);
+        if (!slide?.content || slide.content.length < 15 || seen.has(slide.content)) break;
+        seen.add(slide.content);
+        results.push({ slideIndex: i, heading: slide.heading || undefined, content: slide.content });
+      } catch { break; }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** Follow Next/Continue buttons to capture each wizard step's fields and content. */
+async function probeWizardSteps(page: Page): Promise<WizardStep[]> {
+  const results: WizardStep[] = [];
+  try {
+    const NEXT_LABELS = /^(next|continue|proceed|step \d|›|→|forward)/i;
+    const BACK_LABELS = /^(back|previous|prev|‹|←)/i;
+    const WIZARD_INDICATORS = '[role="progressbar"], [class*="stepper" i], [class*="wizard" i], [class*="progress-step" i], [aria-label*="step" i]';
+    const isWizard = await page.evaluate((sel) => !!document.querySelector(sel), WIZARD_INDICATORS);
+    if (!isWizard) return results;
+
+    const captureStep = async (stepIndex: number): Promise<WizardStep> => {
+      const data = await page.evaluate(() => {
+        const content = (document.querySelector('main, [role="main"], form') as HTMLElement | null)?.innerText?.replace(/\s+/g, ' ').trim().slice(0, 400) ?? '';
+        const stepLabel = document.querySelector('[aria-current="step"], [class*="step-label" i], [class*="stepper-label" i]')?.textContent?.trim() ?? '';
+        const fields = Array.from(document.querySelectorAll('input:not([type="hidden"]), select, textarea'))
+          .map((el) => (el as HTMLElement).getAttribute('aria-label') || (el as HTMLInputElement).placeholder || (el as HTMLInputElement).name || '')
+          .filter(Boolean).slice(0, 10);
+        return { content, stepLabel, fields };
+      });
+      return { stepIndex, stepLabel: data.stepLabel || undefined, content: data.content, fields: data.fields };
+    };
+
+    results.push(await captureStep(0));
+
+    for (let i = 1; i < 6; i++) {
+      try {
+        const nextLabel = await page.evaluate((nextRe) => {
+          const btns = Array.from(document.querySelectorAll('button, [role="button"]'));
+          const btn = btns.find((b) => new RegExp(nextRe).test((b as HTMLElement).innerText?.trim() || ''));
+          return (btn as HTMLElement)?.innerText?.trim() || null;
+        }, NEXT_LABELS.source);
+        if (!nextLabel) break;
+        const btn = page.locator(`button:has-text("${nextLabel}")`).first();
+        await btn.click({ timeout: 1500 });
+        await page.waitForTimeout(800);
+        results.push(await captureStep(i));
+      } catch { break; }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** For each open modal, Tab 8× and verify focus stays inside the dialog (focus-trap check). */
+async function detectFocusTraps(page: Page): Promise<FocusTrapResult[]> {
+  const results: FocusTrapResult[] = [];
+  try {
+    const openDialogs = await page.evaluate(() => {
+      return Array.from(document.querySelectorAll('[role="dialog"], [role="alertdialog"]'))
+        .filter((el) => window.getComputedStyle(el).display !== 'none')
+        .map((el) => el.getAttribute('aria-label') || el.querySelector('[role="heading"]')?.textContent?.trim() || 'dialog');
+    });
+    for (const dialogLabel of openDialogs.slice(0, 3)) {
+      const sampled: string[] = [];
+      let allInside = true;
+      for (let i = 0; i < 8; i++) {
+        await page.keyboard.press('Tab');
+        await page.waitForTimeout(80);
+        const focused = await page.evaluate(() => {
+          const el = document.activeElement as HTMLElement | null;
+          const inDialog = !!el?.closest('[role="dialog"], [role="alertdialog"]');
+          return { label: el?.getAttribute('aria-label') || el?.textContent?.trim().slice(0, 40) || el?.tagName || '', inDialog };
+        });
+        sampled.push(focused.label);
+        if (!focused.inDialog) { allInside = false; break; }
+      }
+      results.push({ modalTrigger: dialogLabel, focusTrapped: allInside, sampledFocused: sampled });
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** Click each visible tab and record the panel content revealed. */
+async function probeTabPanels(page: Page): Promise<TabPanelCapture[]> {
+  const results: TabPanelCapture[] = [];
+  try {
+    const tabs = await page.$$('[role="tab"]:not([aria-disabled="true"])');
+    for (const tab of tabs.slice(0, 10)) {
+      try {
+        const tabLabel = await tab.evaluate((el) => (el as HTMLElement).innerText?.trim() || el.getAttribute('aria-label') || '');
+        if (!tabLabel) continue;
+        await tab.click({ timeout: 1000 });
+        await page.waitForTimeout(400);
+        const panelContent = await page.evaluate(() => {
+          const panel = document.querySelector('[role="tabpanel"]:not([hidden])') as HTMLElement | null;
+          if (!panel) return null;
+          const style = window.getComputedStyle(panel);
+          if (style.display === 'none' || style.visibility === 'hidden') return null;
+          return {
+            heading: panel.querySelector('h2,h3,h4')?.textContent?.trim() ?? '',
+            content: panel.innerText?.replace(/\s+/g, ' ').trim().slice(0, 400) ?? '',
+          };
+        });
+        if (panelContent?.content && panelContent.content.length > 15) {
+          results.push({ tabLabel: tabLabel.slice(0, 60), panelContent: panelContent.content, panelHeading: panelContent.heading || undefined });
+        }
+      } catch { /* this tab failed, try next */ }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** Hover elements with title/aria-describedby to capture tooltip text. */
+async function probeTooltips(page: Page): Promise<TooltipCapture[]> {
+  const results: TooltipCapture[] = [];
+  try {
+    const candidates = await page.evaluate(() => {
+      return Array.from(document.querySelectorAll('[title], [aria-describedby], [data-tooltip], [data-tip], [class*="tooltip" i]'))
+        .filter((el) => {
+          const style = window.getComputedStyle(el as HTMLElement);
+          return style.display !== 'none' && style.visibility !== 'hidden';
+        })
+        .slice(0, 8)
+        .map((el) => ({
+          label: (el as HTMLElement).innerText?.trim().slice(0, 60) || el.getAttribute('aria-label') || '',
+          title: el.getAttribute('title') || '',
+          describedBy: el.getAttribute('aria-describedby') || '',
+          selector: el.tagName.toLowerCase() + (el.id ? `#${el.id}` : ''),
+        }));
+    });
+    for (const c of candidates) {
+      try {
+        // Prefer title attribute directly — no need to hover for static tooltips
+        if (c.title && c.title.length > 5) {
+          results.push({ triggerLabel: c.label || c.selector, tooltipText: c.title.slice(0, 200) });
+          continue;
+        }
+        if (c.describedBy) {
+          const tooltipText = await page.evaluate((id) => document.getElementById(id)?.textContent?.trim() ?? '', c.describedBy);
+          if (tooltipText && tooltipText.length > 5) {
+            results.push({ triggerLabel: c.label || c.selector, tooltipText: tooltipText.slice(0, 200) });
+          }
+        }
+      } catch { /* skip this element */ }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
 /**
  * Probe keyboard navigation accessibility by pressing Tab up to 50 times and
  * recording each focused element's properties and focus-indicator visibility.

package/src/screen-reader.ts

@@ -20,23 +20,29 @@ export async function readScreen(page: Page): Promise<RawElement[]> {
     const out: { role: string; label: string; selectorHint: string; expectedData?: string }[] = [];
     const seen = new Set<string>();
 
-    // Noise patterns to skip — cookie banners, footer junk, marketing copy buttons, version strings
+    // Noise patterns to skip — cookie banners, footer chrome, version strings
+    // Intentionally excludes standalone "close" and "copy" — too many false positives
+    // (Close account, Close preview, Copy link, Copy to clipboard are all valid test targets)
     const noiseLabel =
-      /^(cookie|consent|privacy policy|terms of use|copyright|©|\bv\d+\.\d+|accept|decline|got it|dismiss|close|skip to|powered by|copy|copied|\s*$)/i;
+      /^(cookie|consent|privacy policy|terms of use|copyright|©|\bv\d+\.\d+|got it|dismiss|skip to|powered by|copied|\s*$)/i;
 
-    // Select only truly interactive elements (not generic [role] containers)
+    // Include ARIA-role elements — Headless UI, Radix, Ant Design, Shadcn all use these instead of native tags
     const nodes = document.querySelectorAll(
-      'input:not([type=hidden]), select, textarea, button, a[href]'
+      'input:not([type=hidden]), select, textarea, button, a[href], ' +
+      '[role="button"], [role="combobox"], [role="slider"], [role="switch"], ' +
+      '[role="tab"], [role="menuitem"], [role="searchbox"], [role="spinbutton"]'
     );
 
     nodes.forEach((el) => {
       const htmlEl = el as HTMLElement;
 
-      // Skip invisible or zero-size elements
+      // Skip invisible elements
       const style = window.getComputedStyle(htmlEl);
       if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return;
       const rect = el.getBoundingClientRect();
-      if (rect.width === 0 && rect.height === 0) return;
+      // Allow zero-size elements that carry an accessible label (sr-only icon buttons, skip-nav links)
+      const hasAccessibleLabel = !!(el.getAttribute('aria-label') || el.getAttribute('aria-labelledby'));
+      if (rect.width === 0 && rect.height === 0 && !hasAccessibleLabel) return;
 
       // Derive role
       const tag = el.tagName.toLowerCase();

package/types/extractors/advanced.d.ts

@@ -13,11 +13,21 @@ export interface PageMetadata {
     ogImage: string | null;
     ogUrl: string | null;
     ogType: string | null;
+    ogSiteName: string | null;
+    ogLocale: string | null;
     twitterCard: string | null;
     twitterTitle: string | null;
     twitterDescription: string | null;
+    twitterImage: string | null;
+    twitterSite: string | null;
     canonical: string | null;
     robots: string | null;
+    hreflang: Array<{
+        lang: string;
+        href: string;
+    }>;
+    themeColor: string | null;
+    favicon: string | null;
     jsonLd: object[];
     schemaTypes: string[];
     lang: string | null;

package/types/interactive-probe.d.ts

@@ -43,6 +43,35 @@ export interface ConditionalReveal {
     triggerValue: string;
     revealedText: string;
 }
+export interface TooltipCapture {
+    triggerLabel: string;
+    tooltipText: string;
+}
+export interface TabPanelCapture {
+    tabLabel: string;
+    panelContent: string;
+    panelHeading?: string;
+}
+export interface CarouselSlide {
+    slideIndex: number;
+    heading?: string;
+    content: string;
+}
+export interface WizardStep {
+    stepIndex: number;
+    stepLabel?: string;
+    content: string;
+    fields: string[];
+}
+export interface FocusTrapResult {
+    modalTrigger: string;
+    focusTrapped: boolean;
+    sampledFocused: string[];
+}
+export interface ContextMenuCapture {
+    trigger: string;
+    items: string[];
+}
 export interface ProbeResult {
     screenId: string;
     url: string;
@@ -51,6 +80,13 @@ export interface ProbeResult {
     modals: ModalObservation[];
     conditionals: ConditionalReveal[];
     loadingPatterns: string[];
+    tooltips?: TooltipCapture[];
+    tabPanels?: TabPanelCapture[];
+    carouselSlides?: CarouselSlide[];
+    wizardSteps?: WizardStep[];
+    focusTraps?: FocusTrapResult[];
+    skipNavIssues?: string[];
+    contextMenus?: ContextMenuCapture[];
 }
 /**
  * Run interactive probing on a single screen page.