@detiq/crawler 1.1.13 → 1.1.15

package/src/sitemap.ts

@@ -13,7 +13,12 @@ import { logger } from './logger.js';
 const FETCH_TIMEOUT_MS = 10_000;
 const MAX_SITEMAP_INDEX_DEPTH = 3; // sitemap index -> sub-sitemaps -> (no deeper nesting expected)
 const MAX_SUB_SITEMAPS = 50; // bound fan-out from a single sitemap index
-const MAX_URLS = 5000; // sane upper bound so a huge/malicious sitemap can't blow up memory
+
+async function getSitemapMaxUrls(): Promise<number> {
+  const { getSystemConfig } = await import('@detiq/core');
+  const cfg = await getSystemConfig('crawl_tuning');
+  return parseInt(String(cfg?.sitemapMaxUrls ?? '5000'), 10);
+}
 
 function toArray<T>(x: T | T[] | undefined | null): T[] {
   if (x == null) return [];
@@ -44,7 +49,7 @@ export function sameSite(candidateUrl: string, siteOrigin: string): boolean {
  * and deduped. Pure function — no I/O — for direct unit testing without a
  * real HTTP fetch.
  */
-export function extractUrlsFromParsedSitemap(parsed: any, origin: string): { pageUrls: string[]; subSitemapUrls: string[] } {
+export function extractUrlsFromParsedSitemap(parsed: any, origin: string, maxUrls = 5000): { pageUrls: string[]; subSitemapUrls: string[] } {
   const rawPageUrls: string[] = [];
   let subSitemapUrls: string[] = [];
 
@@ -66,7 +71,7 @@ export function extractUrlsFromParsedSitemap(parsed: any, origin: string): { pag
   // Same-site only (www/protocol-tolerant) — a sitemap listing external URLs shouldn't seed this project's queue.
   const sameOrigin = rawPageUrls.filter((u) => sameSite(u, origin));
 
-  return { pageUrls: [...new Set(sameOrigin)].slice(0, MAX_URLS), subSitemapUrls };
+  return { pageUrls: [...new Set(sameOrigin)].slice(0, maxUrls), subSitemapUrls };
 }
 
 async function fetchAndParseXml(url: string, dispatcher?: any): Promise<any | null> {
@@ -103,22 +108,23 @@ async function fetchAndParseXml(url: string, dispatcher?: any): Promise<any | nu
  * Fetches and parses a sitemap (or sitemap index, recursed up to a small
  * depth) into a flat, deduped list of same-origin URLs.
  */
-export async function fetchSitemapUrls(sitemapUrl: string, origin: string, depth = 0, dispatcher?: any): Promise<string[]> {
+export async function fetchSitemapUrls(sitemapUrl: string, origin: string, depth = 0, dispatcher?: any, maxUrls?: number): Promise<string[]> {
   if (depth > MAX_SITEMAP_INDEX_DEPTH) return [];
+  if (maxUrls === undefined) maxUrls = await getSitemapMaxUrls();
   const parsed = await fetchAndParseXml(sitemapUrl, dispatcher);
   if (!parsed) return [];
 
-  const { pageUrls, subSitemapUrls } = extractUrlsFromParsedSitemap(parsed, origin);
+  const { pageUrls, subSitemapUrls } = extractUrlsFromParsedSitemap(parsed, origin, maxUrls);
   const collected = [...pageUrls];
 
-  if (subSitemapUrls.length > 0 && collected.length < MAX_URLS) {
+  if (subSitemapUrls.length > 0 && collected.length < maxUrls) {
     const subResults = await Promise.all(
-      subSitemapUrls.slice(0, 10).map(subUrl => fetchSitemapUrls(subUrl, origin, depth + 1, dispatcher))
+      subSitemapUrls.slice(0, 10).map(subUrl => fetchSitemapUrls(subUrl, origin, depth + 1, dispatcher, maxUrls))
     );
     for (const sub of subResults) collected.push(...sub);
   }
 
-  return [...new Set(collected)].slice(0, MAX_URLS);
+  return [...new Set(collected)].slice(0, maxUrls);
 }
 
 /**
@@ -192,6 +198,7 @@ export async function discoverProjectUrls(
   try { origin = new URL(appUrl).origin; } catch { return { candidates: [], sitemapFound: false }; }
 
   const dispatcher = buildProxyDispatcher(opts?.proxyUrl);
+  const maxUrls = await getSitemapMaxUrls();
 
   // 1. robots.txt → declared sitemaps
   let robotsSitemaps: string[] = [];
@@ -216,11 +223,11 @@ export async function discoverProjectUrls(
   const seen = new Map<string, UrlCandidate>();
   let sitemapFound = false;
   for (const sm of sitemapTargets) {
-    const urls = await fetchSitemapUrls(sm, origin, 0, dispatcher);
+    const urls = await fetchSitemapUrls(sm, origin, 0, dispatcher, maxUrls);
     if (urls.length) sitemapFound = true;
     const source: UrlCandidate['source'] = robotsSet.has(sm) ? 'robots' : 'sitemap';
     for (const u of urls) if (!seen.has(u)) seen.set(u, { url: u, source });
   }
 
-  return { candidates: [...seen.values()].slice(0, MAX_URLS), sitemapFound };
+  return { candidates: [...seen.values()].slice(0, maxUrls), sitemapFound };
 }

package/src/state-graph.ts

@@ -0,0 +1,280 @@
+import type { Page } from 'playwright';
+
+// ---------------------------------------------------------------------------
+// Internal: FNV-1a 32-bit SimHash
+// ---------------------------------------------------------------------------
+
+function fnv1a32(token: string): number {
+  let h = 2166136261;
+  for (let i = 0; i < token.length; i++) {
+    h = Math.imul(h ^ token.charCodeAt(i), 16777619);
+    h = h >>> 0;
+  }
+  return h;
+}
+
+export function simHash32(text: string): number {
+  const tokens = text
+    .split(/\W+/)
+    .filter((t) => t.length > 2)
+    .slice(0, 500);
+
+  const vec = new Array<number>(32).fill(0);
+
+  for (const token of tokens) {
+    const h = fnv1a32(token);
+    for (let b = 0; b < 32; b++) {
+      vec[b] += (h >>> b) & 1 ? 1 : -1;
+    }
+  }
+
+  let result = 0;
+  for (let b = 0; b < 32; b++) {
+    if (vec[b] > 0) result |= 1 << b;
+  }
+  return result >>> 0;
+}
+
+export function hammingDistance32(a: number, b: number): number {
+  let n = (a ^ b) >>> 0;
+  n = n - ((n >>> 1) & 0x55555555);
+  n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+  n = (n + (n >>> 4)) & 0x0f0f0f0f;
+  return Math.imul(n, 0x01010101) >>> 24;
+}
+
+// ---------------------------------------------------------------------------
+// URL normalisation
+// ---------------------------------------------------------------------------
+
+const STRIP_PARAMS = new Set([
+  'utm_source', 'utm_medium', 'utm_campaign',
+  'ref', '_ga', 'fbclid', 'session_id',
+]);
+
+export function normalizeUrl(raw: string): string {
+  try {
+    const u = new URL(raw);
+    u.hash = '';
+    const keep: Array<[string, string]> = [];
+    u.searchParams.forEach((v, k) => {
+      if (!STRIP_PARAMS.has(k)) keep.push([k, v]);
+    });
+    keep.sort((a, b) => a[0].localeCompare(b[0]));
+    u.search = keep.length
+      ? '?' + keep.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&')
+      : '';
+    return u.toString();
+  } catch {
+    return raw;
+  }
+}
+
+export function computeStateId(normalizedUrl: string, hash: number): string {
+  let path = normalizedUrl.slice(0, 40).replace(/[^a-zA-Z0-9]/g, '_');
+  const hex = hash.toString(16).padStart(8, '0');
+  return `${path}_${hex}`;
+}
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface UIStateNode {
+  id: string;
+  url: string;
+  normalizedUrl: string;
+  title: string;
+  interactiveElementCount: number;
+  domFingerprint: string;
+  simHashValue: number;
+  visitedAt: string;
+}
+
+export interface StateTransition {
+  fromId: string;
+  toId: string;
+  action: string;
+  label: string;
+  triggeredAt: string;
+}
+
+export interface CoverageReport {
+  totalStates: number;
+  totalTransitions: number;
+  uniqueUrls: number;
+  interactiveElementsTotal: number;
+  estimatedCoveragePercent: number;
+}
+
+// ---------------------------------------------------------------------------
+// Page fingerprinting
+// ---------------------------------------------------------------------------
+
+export async function fingerprintPage(
+  page: Page,
+  visitedAt: string,
+): Promise<{
+  fingerprint: string;
+  visibleText: string;
+  interactiveCount: number;
+  simHashValue: number;
+}> {
+  let visibleText = '';
+  let interactiveCount = 0;
+
+  try {
+    visibleText = await page.evaluate(() => {
+      const el = document.querySelector('main') ?? document.body;
+      return (el as HTMLElement).innerText ?? '';
+    });
+  } catch {
+    visibleText = '';
+  }
+
+  try {
+    interactiveCount = await page.evaluate(() =>
+      document.querySelectorAll(
+        'a[href], button, input, select, textarea, [role="button"], [role="link"], [tabindex]',
+      ).length,
+    );
+  } catch {
+    interactiveCount = 0;
+  }
+
+  const simHashValue = simHash32(visibleText + visitedAt.slice(0, 10));
+  const fingerprint = simHashValue.toString(16).padStart(8, '0');
+
+  return { fingerprint, visibleText, interactiveCount, simHashValue };
+}
+
+// ---------------------------------------------------------------------------
+// ScreenTransitionGraph
+// ---------------------------------------------------------------------------
+
+export class ScreenTransitionGraph {
+  private states = new Map<string, UIStateNode>();
+  private transitions: StateTransition[] = [];
+  /** Maps simHash value → array of state ids with that hash (for near-dup lookup) */
+  private hashIndex = new Map<number, string[]>();
+
+  // -------------------------------------------------------------------------
+  // State management
+  // -------------------------------------------------------------------------
+
+  addState(node: UIStateNode): { added: boolean; duplicateOf?: string } {
+    if (this.states.has(node.id)) {
+      return { added: false, duplicateOf: node.id };
+    }
+
+    // Check near-duplicate via hamming distance across all indexed hashes
+    for (const [indexedHash, ids] of this.hashIndex) {
+      if (hammingDistance32(node.simHashValue, indexedHash) < 3) {
+        return { added: false, duplicateOf: ids[0] };
+      }
+    }
+
+    this.states.set(node.id, node);
+
+    const bucket = this.hashIndex.get(node.simHashValue);
+    if (bucket) {
+      bucket.push(node.id);
+    } else {
+      this.hashIndex.set(node.simHashValue, [node.id]);
+    }
+
+    return { added: true };
+  }
+
+  addTransition(
+    fromId: string,
+    toId: string,
+    action: string,
+    label: string,
+    triggeredAt: string,
+  ): void {
+    this.transitions.push({ fromId, toId, action, label, triggeredAt });
+  }
+
+  isDuplicate(url: string, visibleText: string, threshold = 3): boolean {
+    const normalized = normalizeUrl(url);
+    const hash = simHash32(visibleText);
+    for (const [indexedHash] of this.hashIndex) {
+      if (hammingDistance32(hash, indexedHash) < threshold) return true;
+    }
+    // Also check exact normalized URL match
+    for (const node of this.states.values()) {
+      if (node.normalizedUrl === normalized) return true;
+    }
+    return false;
+  }
+
+  // -------------------------------------------------------------------------
+  // Reporting
+  // -------------------------------------------------------------------------
+
+  getCoverageReport(): CoverageReport {
+    const totalStates = this.states.size;
+    const totalTransitions = this.transitions.length;
+    const uniqueUrls = new Set(
+      Array.from(this.states.values()).map((n) => n.normalizedUrl),
+    ).size;
+    const interactiveElementsTotal = Array.from(this.states.values()).reduce(
+      (sum, n) => sum + n.interactiveElementCount,
+      0,
+    );
+    const estimatedCoveragePercent = Math.min(
+      100,
+      (totalTransitions / Math.max(1, totalStates)) * 50,
+    );
+    return {
+      totalStates,
+      totalTransitions,
+      uniqueUrls,
+      interactiveElementsTotal,
+      estimatedCoveragePercent,
+    };
+  }
+
+  // -------------------------------------------------------------------------
+  // Serialisation
+  // -------------------------------------------------------------------------
+
+  toJSON(): { states: UIStateNode[]; transitions: StateTransition[] } {
+    return {
+      states: Array.from(this.states.values()),
+      transitions: this.transitions,
+    };
+  }
+
+  static fromJSON(data: { states: UIStateNode[]; transitions: StateTransition[] }): ScreenTransitionGraph {
+    const graph = new ScreenTransitionGraph();
+    for (const node of data.states) {
+      graph.states.set(node.id, node);
+      const bucket = graph.hashIndex.get(node.simHashValue);
+      if (bucket) {
+        bucket.push(node.id);
+      } else {
+        graph.hashIndex.set(node.simHashValue, [node.id]);
+      }
+    }
+    graph.transitions = [...data.transitions];
+    return graph;
+  }
+
+  // -------------------------------------------------------------------------
+  // Accessors
+  // -------------------------------------------------------------------------
+
+  getState(id: string): UIStateNode | undefined {
+    return this.states.get(id);
+  }
+
+  getAllStates(): UIStateNode[] {
+    return Array.from(this.states.values());
+  }
+
+  getTransitionsFrom(id: string): StateTransition[] {
+    return this.transitions.filter((t) => t.fromId === id);
+  }
+}

package/src/stealth/human-behavior.ts

@@ -104,29 +104,62 @@ export async function injectFingerprintOverrides(page: Page): Promise<void> {
 
 export async function infiniteScrollToBottom(
   page: Page,
-  opts: { maxScrolls?: number; scrollDelay?: number; stabilizeMs?: number } = {}
+  opts: { maxScrolls?: number; scrollDelay?: number; stabilizeMs?: number } = {},
+  rawPage?: any,
 ): Promise<{ scrollCount: number; heightReached: number }> {
   const { maxScrolls = 50, scrollDelay = 400, stabilizeMs = 600 } = opts;
   let scrollCount = 0;
   let stableScrollCount = 0;
   let previousHeight = 0;
 
+  // One CDP session for wheel events (triggers IntersectionObserver-based virtual scrollers).
+  // React-window / react-virtualized / TanStack Virtual ignore window.scrollBy but respond to
+  // wheel events because they attach their own scroll listeners to the list container.
+  let cdpForWheel: any = null;
+  let viewW = 1280;
+  let viewH = 800;
+  if (rawPage && typeof rawPage.context === 'function') {
+    try {
+      const ctx = rawPage.context();
+      if (typeof ctx?.newCDPSession === 'function') {
+        cdpForWheel = await ctx.newCDPSession(rawPage);
+        const { result } = await cdpForWheel.send('Runtime.evaluate', {
+          expression: `({"w":window.innerWidth,"h":window.innerHeight})`,
+          returnByValue: true,
+        }).catch(() => ({ result: { value: null } }));
+        if (result?.value) { viewW = result.value.w ?? 1280; viewH = result.value.h ?? 800; }
+      }
+    } catch { cdpForWheel = null; }
+  }
+
   try {
     while (scrollCount < maxScrolls) {
       previousHeight = await page.evaluate(() => document.documentElement.scrollHeight).catch(() => 0);
 
       const scrollBy = 500 + Math.floor(Math.random() * 300);
+      // window.scrollBy handles standard scroll containers
       await page.evaluate((by: number) => window.scrollBy(0, by), scrollBy).catch(() => {});
+      // CDP wheel event triggers IntersectionObserver + virtual list scroll listeners
+      if (cdpForWheel) {
+        await cdpForWheel.send('Input.dispatchMouseEvent', {
+          type: 'mouseWheel',
+          x: Math.floor(viewW / 2),
+          y: Math.floor(viewH / 2),
+          deltaX: 0,
+          deltaY: scrollBy,
+          modifiers: 0,
+        }).catch(() => {});
+      }
       await humanDelay(scrollDelay - 100, scrollDelay + 200);
 
-      // Wait for potential lazy-loaded content
-      await page.waitForTimeout(stabilizeMs).catch(() => {});
+      // Use Node.js setTimeout — page.waitForTimeout may not be available on Stagehand proxy
+      await new Promise<void>(r => setTimeout(r, stabilizeMs));
       scrollCount++;
 
       const newHeight: number = await page.evaluate(() => document.documentElement.scrollHeight).catch(() => 0);
       if (newHeight - previousHeight < 10) {
         stableScrollCount++;
-        if (stableScrollCount >= 3) break; // no meaningful new content after 3 consecutive non-growing scrolls
+        if (stableScrollCount >= 3) break; // no new content after 3 consecutive non-growing scrolls
       } else {
         stableScrollCount = 0;
       }
@@ -134,6 +167,7 @@ export async function infiniteScrollToBottom(
     }
   } catch { /* non-fatal */ }
 
+  if (cdpForWheel) cdpForWheel.detach().catch(() => {});
   return { scrollCount, heightReached: previousHeight };
 }
 

package/src/url-pattern-completer.ts

@@ -27,6 +27,33 @@ interface LlmCfg {
   baseUrl?: string;
 }
 
+// Only these two providers are supported by this module (they use standard SDK calls).
+// NVIDIA, groq, ollama, openrouter, etc. are skipped — fall through to env fallback.
+const SUPPORTED = new Set(['openai', 'anthropic']);
+
+/**
+ * Resolve the effective LLM to use. Priority: openai → anthropic → skip others.
+ * Falls back to env vars when the platform-configured provider is unsupported.
+ */
+function resolveTextLLM(llmCfg: LlmCfg | null | undefined): { provider: 'openai' | 'anthropic'; apiKey: string; model: string; baseUrl?: string } | null {
+  // Use platform config if it's a supported provider with a key
+  if (llmCfg?.provider === 'openai' && llmCfg.apiKey) {
+    return { provider: 'openai', apiKey: llmCfg.apiKey, model: llmCfg.model, baseUrl: llmCfg.baseUrl };
+  }
+  if (llmCfg?.provider === 'anthropic' && llmCfg.apiKey) {
+    return { provider: 'anthropic', apiKey: llmCfg.apiKey, model: llmCfg.model };
+  }
+  // Platform provider is unsupported (nvidia, groq, etc.) or no key — fall back to env vars.
+  // OpenAI takes priority over Anthropic.
+  if (process.env.OPENAI_API_KEY) {
+    return { provider: 'openai', apiKey: process.env.OPENAI_API_KEY, model: 'gpt-4o-mini' };
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY, model: 'claude-haiku-4-5-20251001' };
+  }
+  return null;
+}
+
 /**
  * Returns validated URL candidates (HEAD=200) predicted by LLM from
  * the pattern of already-discovered URLs.
@@ -36,7 +63,8 @@ export async function runUrlPatternCompletion(
   appUrl: string,
   llmCfg: LlmCfg | null | undefined,
 ): Promise<UrlCandidate[]> {
-  if (!llmCfg?.apiKey || discoveredUrls.length < 2) return [];
+  const effective = resolveTextLLM(llmCfg);
+  if (!effective || discoveredUrls.length < 2) return [];
 
   const origin = (() => { try { return new URL(appUrl).origin; } catch { return ''; } })();
   if (!origin) return [];
@@ -49,7 +77,8 @@ export async function runUrlPatternCompletion(
 
   if (internalUrls.length < 2) return [];
 
-  const prompt = `You are analyzing a web application's URL structure to find screens that exist but weren't discovered during automated crawling.
+  const systemPrompt = 'You are a URL pattern analyst. Always respond with valid JSON only.';
+  const userPrompt = `You are analyzing a web application's URL structure to find screens that exist but weren't discovered during automated crawling.
 
 Discovered URLs:
 ${internalUrls.map(u => { try { return new URL(u).pathname + new URL(u).search; } catch { return u; } }).join('\n')}
@@ -67,18 +96,35 @@ Respond with ONLY valid JSON, no explanation:
 {"candidates":[{"path":"/settings/billing","confidence":0.85,"reason":"settings subpage pattern from /settings/profile"},{"path":"/admin/users","confidence":0.6,"reason":"admin prefix implied by /admin/dashboard"}]}`;
 
   try {
-    const Anthropic = (await import('@anthropic-ai/sdk')).default;
-    const client = new Anthropic({ apiKey: llmCfg.apiKey });
-    const response = await client.messages.create({
-      model: llmCfg.model ?? process.env.CRAWLER_DEFAULT_MODEL ?? 'claude-haiku-4-5-20251001',
-      max_tokens: 1024,
-      temperature: 0,
-      // @ts-ignore: cache_control supported in beta
-      system: [{ type: 'text', text: 'You are a URL pattern analyst. Always respond with valid JSON only.', cache_control: { type: 'ephemeral' } }],
-      messages: [{ role: 'user', content: prompt }],
-    });
-
-    const text = (response.content[0] as any)?.text ?? '';
+    let text = '';
+
+    if (effective.provider === 'openai') {
+      const { OpenAI } = await import('openai');
+      const client = new OpenAI({ apiKey: effective.apiKey, ...(effective.baseUrl ? { baseURL: effective.baseUrl } : {}) });
+      const response = await client.chat.completions.create({
+        model: effective.model ?? 'gpt-4o-mini',
+        max_tokens: 1024,
+        temperature: 0,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+      });
+      text = response.choices[0]?.message?.content ?? '';
+    } else {
+      const Anthropic = (await import('@anthropic-ai/sdk')).default;
+      const client = new Anthropic({ apiKey: effective.apiKey });
+      const response = await client.messages.create({
+        model: effective.model ?? 'claude-haiku-4-5-20251001',
+        max_tokens: 1024,
+        temperature: 0,
+        // @ts-ignore: cache_control supported in beta
+        system: [{ type: 'text', text: systemPrompt, cache_control: { type: 'ephemeral' } }],
+        messages: [{ role: 'user', content: userPrompt }],
+      });
+      text = (response.content[0] as any)?.text ?? '';
+    }
+
     const jsonMatch = text.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return [];
     const parsed = JSON.parse(jsonMatch[0]);
@@ -106,7 +152,7 @@ Respond with ONLY valid JSON, no explanation:
     }
 
     const hits = results.filter(r => r.status === 'hit');
-    logger.info({ total: results.length, hits: hits.length }, '[url-completer] pattern completion done');
+    logger.info({ total: results.length, hits: hits.length, provider: effective.provider }, '[url-completer] pattern completion done');
     return results;
   } catch (err) {
     logger.warn({ err: String(err) }, '[url-completer] LLM call failed — skipping pattern completion');

package/tsconfig.json

@@ -3,7 +3,7 @@
   "compilerOptions": {
     "rootDir": "src",
     "outDir": "dist",
-    "lib": ["ES2022", "DOM"],
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "isolatedModules": true,
     "composite": false,
     "noEmitOnError": false

package/types/accessibility-tree-crawler.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Accessibility tree crawler — extract landmark, heading, and ARIA metadata from crawled pages.
+ *
+ * Captures: landmarks with interactive counts, heading hierarchy with violation detection,
+ * interactive elements missing accessible names, live regions, and skip-link presence.
+ *
+ * This data feeds ZeTa's accessibility test generator to surface WCAG 2.1 Level A/AA
+ * failures (missing names, heading skips, absent skip links, unlabeled live regions).
+ */
+export interface LandmarkInfo {
+    role: string;
+    label: string;
+    elementId: string;
+    interactiveCount: number;
+}
+export interface HeadingInfo {
+    level: number;
+    text: string;
+    elementId: string;
+}
+export interface MissingNameEl {
+    tagName: string;
+    role: string;
+    elementId: string;
+    htmlSnippet: string;
+}
+export interface LiveRegionInfo {
+    role: string;
+    ariaLive: string;
+    ariaAtomic: string;
+    currentText: string;
+}
+export interface AccessibilityTreeResult {
+    landmarkCount: number;
+    landmarks: LandmarkInfo[];
+    headings: HeadingInfo[];
+    headingHierarchyViolations: string[];
+    missingNameElements: MissingNameEl[];
+    missingNameCount: number;
+    liveRegions: LiveRegionInfo[];
+    totalInteractiveCount: number;
+    hasSkipLink: boolean;
+}
+export declare function crawlAccessibilityTree(page: any): Promise<AccessibilityTreeResult>;

package/types/advanced-ui-probes.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Advanced UI probes — detect and exercise drag-drop, date pickers, sliders,
+ * and typeahead/autocomplete widgets on a crawled page.
+ *
+ * Results feed ZeTa's test generator so it can emit interaction-level test
+ * cases for these widget families instead of falling back to generic clicks.
+ *
+ * Each probe is independently try/caught so a broken widget does not abort
+ * the others. All browser-side code runs inside page.evaluate / page.$$eval
+ * to avoid serialisation issues with DOM handles.
+ */
+import type { Page } from 'playwright';
+export interface DragDropCapture {
+    library: 'html5' | 'dnd-kit' | 'react-beautiful-dnd' | 'sortablejs' | 'pointer-event' | 'none';
+    draggableCount: number;
+    dropZoneCount: number;
+    testAttempted: boolean;
+    testCompleted: boolean;
+}
+export interface DatePickerCapture {
+    fieldLabel: string;
+    pickerType: 'calendar-popup' | 'native-date' | 'native-datetime' | 'none';
+    minDate?: string;
+    maxDate?: string;
+    disabledDatesFound: boolean;
+    sampleSelectedValue?: string;
+}
+export interface SliderCapture {
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    currentValue: number;
+}
+export interface TypeaheadCapture {
+    label: string;
+    minCharsToTrigger: number;
+    sampleSuggestions: string[];
+    noResultsText: string | null;
+}
+export interface AdvancedProbeResult {
+    dragDrop: DragDropCapture;
+    datePickers: DatePickerCapture[];
+    sliders: SliderCapture[];
+    typeaheads: TypeaheadCapture[];
+}
+export declare function probeAdvancedUI(page: Page): Promise<AdvancedProbeResult>;