explorbot 0.1.32-beta.1 → 0.2.1

package/dist/src/knowledge-tracker.d.ts

@@ -1,5 +1,5 @@
 import { ActionResult } from './action-result.js';
-interface Knowledge {
+export interface Knowledge {
     filePath: string;
     url: string;
     content: string;
@@ -12,6 +12,7 @@ export declare class KnowledgeTracker {
     constructor();
     loadKnowledgeFiles(): void;
     getRelevantKnowledge(state: ActionResult): Knowledge[];
+    renderRelevantKnowledge(state: ActionResult): string;
     addKnowledge(urlPattern: string, description: string): {
         filename: string;
         filePath: string;
@@ -30,4 +31,3 @@ export declare class KnowledgeTracker {
     normalizeUrl(url: string): string;
     getStateParameters(state: ActionResult, keys: string[]): Record<string, any>;
 }
-export {};

package/dist/src/knowledge-tracker.js

@@ -1,11 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import dedent from 'dedent';
 import matter from 'gray-matter';
 import { ActionResult } from './action-result.js';
 import { ConfigParser } from './config.js';
 import { getCliName } from "./utils/cli-name.js";
-import { createDebug } from './utils/logger.js';
+import { createDebug, pluralize, tag } from './utils/logger.js';
+import { loadMarkdownFiles } from './utils/markdown-files.js';
+import { mdq } from './utils/markdown-query.js';
 import { isSecretName, registerSecret } from './utils/secrets.js';
+import { slugify } from './utils/strings.js';
 const debugLog = createDebug('explorbot:knowledge-tracker');
 export class KnowledgeTracker {
     knowledgeDir;
@@ -14,14 +18,7 @@ export class KnowledgeTracker {
     constructor() {
         const configParser = ConfigParser.getInstance();
         const config = configParser.getConfig();
-        const configPath = configParser.getConfigPath();
-        if (configPath) {
-            const projectRoot = dirname(configPath);
-            this.knowledgeDir = join(projectRoot, config.dirs?.knowledge || 'knowledge');
-        }
-        else {
-            this.knowledgeDir = config.dirs?.knowledge || 'knowledge';
-        }
+        this.knowledgeDir = configParser.resolveProjectDir(config.dirs?.knowledge || 'knowledge');
         if (!existsSync(this.knowledgeDir)) {
             mkdirSync(this.knowledgeDir, { recursive: true });
         }
@@ -30,27 +27,13 @@ export class KnowledgeTracker {
         if (this.isLoaded)
             return;
         this.knowledgeFiles = [];
-        if (!existsSync(this.knowledgeDir)) {
-            return;
-        }
-        const files = readdirSync(this.knowledgeDir)
-            .filter((file) => file.endsWith('.md'))
-            .map((file) => join(this.knowledgeDir, file));
-        for (const filePath of files) {
-            try {
-                const fileContent = readFileSync(filePath, 'utf8');
-                const parsed = matter(fileContent);
-                const urlPattern = parsed.data.url || parsed.data.path || '*';
-                this.knowledgeFiles.push({
-                    filePath,
-                    url: urlPattern,
-                    content: this.interpolateVars(parsed.content),
-                    ...parsed.data,
-                });
-            }
-            catch (error) {
-                // Skip invalid files
-            }
+        for (const entry of loadMarkdownFiles(this.knowledgeDir, { recursive: true })) {
+            this.knowledgeFiles.push({
+                filePath: entry.filePath,
+                url: entry.data.url || entry.data.path || '*',
+                content: this.interpolateVars(entry.content),
+                ...entry.data,
+            });
         }
         this.isLoaded = true;
     }
@@ -60,21 +43,35 @@ export class KnowledgeTracker {
             return state.isMatchedBy(knowledge);
         });
     }
+    renderRelevantKnowledge(state) {
+        const knowledgeFiles = this.getRelevantKnowledge(state);
+        if (knowledgeFiles.length === 0)
+            return '';
+        const knowledgeContent = knowledgeFiles
+            .map((k) => k.content)
+            .filter((k) => !!k)
+            .join('\n\n');
+        tag('operation').log(`Found ${knowledgeFiles.length} relevant knowledge ${pluralize(knowledgeFiles.length, 'file')}`);
+        return dedent `
+      <knowledge>
+      Here is relevant knowledge for this page:
+
+      ${knowledgeContent}
+      </knowledge>
+    `;
+    }
     addKnowledge(urlPattern, description) {
         const configParser = ConfigParser.getInstance();
-        const config = configParser.getConfig();
         const configPath = configParser.getConfigPath();
         if (!configPath) {
             throw new Error(`No explorbot configuration found. Please run "${getCliName()} init" first.`);
         }
-        const projectRoot = dirname(configPath);
-        const knowledgeDir = join(projectRoot, config.dirs?.knowledge || 'knowledge');
-        if (!existsSync(knowledgeDir)) {
-            mkdirSync(knowledgeDir, { recursive: true });
+        if (!existsSync(this.knowledgeDir)) {
+            mkdirSync(this.knowledgeDir, { recursive: true });
         }
         const normalizedUrl = this.normalizeUrl(urlPattern);
         const filename = this.generateFilename(normalizedUrl);
-        const filePath = join(knowledgeDir, filename);
+        const filePath = join(this.knowledgeDir, filename);
         const isNewFile = !existsSync(filePath);
         if (isNewFile) {
             const frontmatter = {
@@ -101,6 +98,7 @@ export class KnowledgeTracker {
             const fileContent = matter.stringify(newContent, frontmatter);
             writeFileSync(filePath, fileContent, 'utf8');
         }
+        this.isLoaded = false;
         return { filename, filePath, isNewFile };
     }
     interpolateVars(content) {
@@ -129,12 +127,7 @@ export class KnowledgeTracker {
         });
     }
     generateFilename(url) {
-        let filename = url
-            .replace(/https?:\/\//g, '')
-            .replace(/[^a-zA-Z0-9_]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toLowerCase();
+        let filename = slugify(url.replace(/https?:\/\//g, ''));
         if (!filename || filename === '*') {
             filename = 'general';
         }
@@ -156,7 +149,7 @@ export class KnowledgeTracker {
         this.loadKnowledgeFiles();
         return this.knowledgeFiles.map((knowledge) => {
             const content = knowledge.content.trim();
-            const firstLine = content.split('\n')[0]?.trim() || '';
+            const firstLine = mdq(content).meta()[0]?.text.split('\n')[0]?.trim() || '';
             return {
                 url: knowledge.url,
                 firstLine,

package/dist/src/state-manager.d.ts

@@ -1,5 +1,6 @@
 import { ActionResult } from './action-result.js';
-import { ExperienceTracker } from './experience-tracker.js';
+import type { ExperienceTracker } from './experience-tracker.js';
+import type { Knowledge, KnowledgeTracker } from './knowledge-tracker.js';
 export interface Link {
     title: string;
     url: string;
@@ -54,24 +55,23 @@ export interface StateTransition {
     trigger: 'manual' | 'navigation' | 'automatic';
 }
 export type StateChangeListener = (event: StateTransition) => void;
-export interface Knowledge extends WebPageState {
-    /** File path */
-    filePath: string;
-    /** Markdown content */
-    content: string;
+export interface TabInfo {
+    url: string;
+    title: string;
 }
+export type { Knowledge };
 export declare class StateManager {
+    otherTabs: TabInfo[];
     currentState: WebPageState | null;
     stateHistory: StateTransition[];
     allVisitedUrls: Set<string>;
-    knowledgeCache: Knowledge[];
-    lastKnowledgeScan: Date | null;
     stateChangeListeners: StateChangeListener[];
     experienceTracker: ExperienceTracker;
-    knowledgeDir: string;
+    knowledgeTracker: KnowledgeTracker;
     nextStateId: number;
-    constructor();
+    constructor(experienceTracker: ExperienceTracker, knowledgeTracker: KnowledgeTracker);
     getExperienceTracker(): ExperienceTracker;
+    getKnowledgeTracker(): KnowledgeTracker;
     /**
      * Subscribe to state change events
      */
@@ -80,11 +80,6 @@ export declare class StateManager {
      * Emit state change event to all listeners
      */
     emitStateChange(event: StateTransition): void;
-    /**
-     * Extract state path from full URL
-     * Removes domain, port, protocol
-     * Keeps path, query, and hash: /path/to/page?tab=users#section
-     */
     /**
      * Update current state from ActionResult and record transition if state changed
      */
@@ -119,10 +114,6 @@ export declare class StateManager {
      * Get the last N transitions
      */
     getRecentTransitions(count?: number): StateTransition[];
-    /**
-     * Scan knowledge directory for .md files and cache them
-     */
-    scanKnowledgeFiles(): void;
     /**
      * Get relevant knowledge files for current state
      */
@@ -134,12 +125,6 @@ export declare class StateManager {
     /**
      * Get all context for current state (knowledge + experience)
      */
-    getCurrentContext(): {
-        state: WebPageState;
-        knowledge: Knowledge[];
-        experience: string[];
-        recentTransitions: StateTransition[];
-    };
     /**
      * Check if we've been in this state before
      */
@@ -158,11 +143,6 @@ export declare class StateManager {
      * If the last transition changed URL, returns the fromState (for URL change detection).
      * Otherwise returns the most recent toState with content (for diffing).
      */
-    getPreviousState(): WebPageState | null;
-    /**
-     * Load HTML content from file
-     */
-    loadHtmlFromFile(htmlFile: string): string | null;
     /**
      * Clear state history (useful for testing or reset)
      * Note: This preserves the current state, only clears navigation history

package/dist/src/state-manager.js

@@ -1,40 +1,28 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import matter from 'gray-matter';
 import { ActionResult } from './action-result.js';
-import { ConfigParser, outputPath } from './config.js';
-import { ExperienceTracker } from './experience-tracker.js';
 import { detectFocusArea } from './utils/aria.js';
 import { createDebug } from './utils/logger.js';
+import { slugify } from './utils/strings.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
 export class StateManager {
+    otherTabs = [];
     currentState = null;
     stateHistory = [];
     allVisitedUrls = new Set();
-    knowledgeCache = [];
-    lastKnowledgeScan = null;
     stateChangeListeners = [];
     experienceTracker;
-    knowledgeDir;
+    knowledgeTracker;
     nextStateId = 1;
-    constructor() {
-        this.experienceTracker = new ExperienceTracker();
-        const configParser = ConfigParser.getInstance();
-        const config = configParser.getConfig();
-        const configPath = configParser.getConfigPath();
-        // Resolve knowledge directory relative to the config file location (project root)
-        if (configPath) {
-            const projectRoot = dirname(configPath);
-            this.knowledgeDir = join(projectRoot, config.dirs?.knowledge || 'knowledge');
-        }
-        else {
-            this.knowledgeDir = config.dirs?.knowledge || 'knowledge';
-        }
+    constructor(experienceTracker, knowledgeTracker) {
+        this.experienceTracker = experienceTracker;
+        this.knowledgeTracker = knowledgeTracker;
     }
     getExperienceTracker() {
         return this.experienceTracker;
     }
+    getKnowledgeTracker() {
+        return this.knowledgeTracker;
+    }
     /**
      * Subscribe to state change events
      */
@@ -61,11 +49,6 @@ export class StateManager {
             }
         });
     }
-    /**
-     * Extract state path from full URL
-     * Removes domain, port, protocol
-     * Keeps path, query, and hash: /path/to/page?tab=users#section
-     */
     /**
      * Update current state from ActionResult and record transition if state changed
      */
@@ -141,13 +124,7 @@ export class StateManager {
         if (title) {
             parts.push(`title_${title}`);
         }
-        return parts
-            .join('_')
-            .replace(/[^a-zA-Z0-9_]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toLowerCase()
-            .substring(0, 200);
+        return slugify(parts.join('_')).substring(0, 200);
     }
     /**
      * Get current state
@@ -226,57 +203,14 @@ export class StateManager {
     getRecentTransitions(count = 5) {
         return this.stateHistory.slice(-count);
     }
-    /**
-     * Scan knowledge directory for .md files and cache them
-     */
-    scanKnowledgeFiles() {
-        const now = new Date();
-        // Only rescan every 30 seconds to avoid excessive file I/O
-        if (this.lastKnowledgeScan && now.getTime() - this.lastKnowledgeScan.getTime() < 30000) {
-            return;
-        }
-        this.knowledgeCache = [];
-        if (!existsSync(this.knowledgeDir)) {
-            debugLog(`Knowledge directory not found: ${this.knowledgeDir}`);
-            return;
-        }
-        try {
-            const files = readdirSync(this.knowledgeDir, { recursive: true })
-                .filter((file) => typeof file === 'string' && file.endsWith('.md'))
-                .map((file) => join(this.knowledgeDir, file));
-            for (const filePath of files) {
-                try {
-                    const fileContent = readFileSync(filePath, 'utf8');
-                    const parsed = matter(fileContent);
-                    const urlPattern = parsed.data.url || parsed.data.path || '*';
-                    this.knowledgeCache.push({
-                        filePath,
-                        url: urlPattern,
-                        ...parsed.data,
-                        content: parsed.content,
-                    });
-                    debugLog(`Loaded knowledge file: ${filePath} (pattern: ${urlPattern})`);
-                }
-                catch (error) {
-                    debugLog(`Failed to load knowledge file ${filePath}:`, error);
-                }
-            }
-            this.lastKnowledgeScan = now;
-            debugLog(`Scanned ${this.knowledgeCache.length} knowledge files`);
-        }
-        catch (error) {
-            debugLog('Failed to scan knowledge directory:', error);
-        }
-    }
     /**
      * Get relevant knowledge files for current state
      */
     getRelevantKnowledge() {
         if (!this.currentState)
             return [];
-        this.scanKnowledgeFiles();
         const actionResult = ActionResult.fromState(this.currentState);
-        return this.knowledgeCache.filter((knowledge) => actionResult.isMatchedBy(knowledge));
+        return this.knowledgeTracker.getRelevantKnowledge(actionResult);
     }
     /**
      * Get relevant experience files for current state
@@ -291,17 +225,6 @@ export class StateManager {
     /**
      * Get all context for current state (knowledge + experience)
      */
-    getCurrentContext() {
-        if (!this.currentState) {
-            throw new Error('No current state available');
-        }
-        return {
-            state: this.currentState,
-            knowledge: this.getRelevantKnowledge(),
-            experience: this.getRelevantExperience(),
-            recentTransitions: this.getRecentTransitions(),
-        };
-    }
     /**
      * Check if we've been in this state before
      */
@@ -333,41 +256,6 @@ export class StateManager {
      * If the last transition changed URL, returns the fromState (for URL change detection).
      * Otherwise returns the most recent toState with content (for diffing).
      */
-    getPreviousState() {
-        if (this.stateHistory.length === 0)
-            return null;
-        const lastTransition = this.stateHistory[this.stateHistory.length - 1];
-        if (lastTransition.fromState?.url !== lastTransition.toState?.url) {
-            return lastTransition.fromState;
-        }
-        for (let i = this.stateHistory.length - 1; i >= 0; i--) {
-            const toState = this.stateHistory[i].toState;
-            if (!toState)
-                continue;
-            if (toState.id === this.currentState?.id)
-                continue;
-            if (toState.html || toState.ariaSnapshot) {
-                return toState;
-            }
-        }
-        return null;
-    }
-    /**
-     * Load HTML content from file
-     */
-    loadHtmlFromFile(htmlFile) {
-        try {
-            const filePath = outputPath('states', htmlFile);
-            if (existsSync(filePath)) {
-                return readFileSync(filePath, 'utf8');
-            }
-            return null;
-        }
-        catch (error) {
-            debugLog('Failed to load HTML from file:', error);
-            return null;
-        }
-    }
     /**
      * Clear state history (useful for testing or reset)
      * Note: This preserves the current state, only clears navigation history
@@ -398,13 +286,7 @@ export class StateManager {
         this.stateHistory = [];
         this.allVisitedUrls.clear();
         this.stateChangeListeners = [];
-        this.knowledgeCache = [];
-        this.lastKnowledgeScan = null;
         this.nextStateId = 1;
-        // Clean up experience tracker if it has cleanup method
-        if (this.experienceTracker && typeof this.experienceTracker.cleanup === 'function') {
-            this.experienceTracker.cleanup();
-        }
         debugLog('StateManager cleanup completed');
     }
 }

package/dist/src/utils/aria.d.ts

@@ -4,7 +4,7 @@ export interface FocusAreaResult {
     name: string | null;
 }
 export declare const compactAriaSnapshot: (snapshot: string | null, keepNamed?: boolean) => string;
-export declare const diffAriaSnapshots: (previous: string | null, current: string | null) => string | null;
+export declare const diffAriaSnapshots: (previous: string | null, current: string | null) => AriaDiff;
 export declare const detectFocusArea: (snapshot: string | null) => FocusAreaResult;
 export declare const collectInteractiveNodes: (snapshot: string | null) => Array<Record<string, unknown>>;
 export interface FocusedElementInfo {
@@ -18,3 +18,8 @@ export declare function parseAriaLocator(ariaStr: string): {
     role: string;
     text: string;
 } | null;
+export declare const LARGE_ARIA_CHANGE_THRESHOLD = 50;
+export interface AriaDiff {
+    text: string | null;
+    count: number;
+}

package/dist/src/utils/aria.js

@@ -490,7 +490,9 @@ export const diffAriaSnapshots = (previous, current) => {
     const currTotals = countBy(curr.map((e) => e.summary));
     const byCount = diffByCount(prevTotals, currTotals);
     const renames = detectRenames(prev, curr, prevTotals, currTotals);
-    return formatDiff([...byCount.added, ...renames.added], [...byCount.removed, ...renames.removed], toggled);
+    const added = [...byCount.added, ...renames.added];
+    const removed = [...byCount.removed, ...renames.removed];
+    return { text: formatDiff(added, removed, toggled), count: added.length + removed.length + toggled.length };
 };
 export const detectFocusArea = (snapshot) => {
     let tree = parseSnapshot(snapshot);
@@ -543,3 +545,4 @@ export function parseAriaLocator(ariaStr) {
         return null;
     return { role: match[1], text: match[2] };
 }
+export const LARGE_ARIA_CHANGE_THRESHOLD = 50;

package/dist/src/utils/cache.d.ts

@@ -0,0 +1,15 @@
+export declare class TTLCache<T> {
+    store: Map<string, CacheEntry<T>>;
+    ttlMs: number;
+    constructor(ttlMs?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    fetch(key: string, compute: () => Promise<T>): Promise<T>;
+    delete(key: string): void;
+    clear(): void;
+}
+type CacheEntry<T> = {
+    value: T;
+    at: number;
+};
+export {};

package/dist/src/utils/cache.js

@@ -0,0 +1,34 @@
+export class TTLCache {
+    store = new Map();
+    ttlMs;
+    constructor(ttlMs = Number.POSITIVE_INFINITY) {
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.at > this.ttlMs) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        this.store.set(key, { value, at: Date.now() });
+    }
+    async fetch(key, compute) {
+        const cached = this.get(key);
+        if (cached !== undefined)
+            return cached;
+        const value = await compute();
+        this.set(key, value);
+        return value;
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/src/utils/context-formatter.d.ts

@@ -21,5 +21,11 @@ export interface ContextData {
     combinedHtml?: string;
     research?: string;
 }
+export declare function formatHeadings(headings: {
+    h1?: string;
+    h2?: string;
+    h3?: string;
+    h4?: string;
+}): string[];
 export type ContextMode = 'attached' | 'compact' | 'full';
 export declare function formatContextSummary(data: ContextData, mode?: ContextMode): string;

package/dist/src/utils/context-formatter.js

@@ -10,6 +10,18 @@ function indent(text) {
         .map((line) => chalk.gray(`    ${line}`))
         .join('\n');
 }
+export function formatHeadings(headings) {
+    const lines = [];
+    if (headings.h1)
+        lines.push(`H1: ${headings.h1}`);
+    if (headings.h2)
+        lines.push(`H2: ${headings.h2}`);
+    if (headings.h3)
+        lines.push(`H3: ${headings.h3}`);
+    if (headings.h4)
+        lines.push(`H4: ${headings.h4}`);
+    return lines;
+}
 export function formatContextSummary(data, mode = 'compact') {
     if (mode === 'full') {
         return formatContextFull(data);
@@ -27,15 +39,7 @@ function formatContextAttached(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));
@@ -88,15 +92,7 @@ function formatContextCompact(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));
@@ -144,15 +140,7 @@ function formatContextFull(data) {
         lines.push(indent(data.title));
     }
     lines.push('');
-    const headingLines = [];
-    if (data.headings.h1)
-        headingLines.push(`H1: ${data.headings.h1}`);
-    if (data.headings.h2)
-        headingLines.push(`H2: ${data.headings.h2}`);
-    if (data.headings.h3)
-        headingLines.push(`H3: ${data.headings.h3}`);
-    if (data.headings.h4)
-        headingLines.push(`H4: ${data.headings.h4}`);
+    const headingLines = formatHeadings(data.headings);
     if (headingLines.length > 0) {
         lines.push(section('HEADINGS') + chalk.gray(' (Auto-attached)'));
         lines.push(indent(headingLines.join('\n')));

package/dist/src/utils/hooks-runner.js

@@ -49,12 +49,10 @@ export class HooksRunner {
     async executeHook(hook, url) {
         try {
             if (hook.type === 'playwright') {
-                const page = this.explorer.playwrightHelper.page;
-                await hook.hook({ page, url });
+                await this.explorer.withPage(async (page) => hook.hook({ page, url }));
             }
             else {
-                const I = this.explorer.actor;
-                await hook.hook({ I, url });
+                await hook.hook({ I: this.explorer.actor, url });
             }
         }
         catch (error) {

package/dist/src/utils/html.d.ts

@@ -2,8 +2,10 @@ import type * as parse5TreeAdapter from 'parse5/lib/tree-adapters/default';
 import type { HtmlConfig } from '../config.js';
 export declare const EXPLORBOT_ATTRS: {
     readonly area: "data-explorbot-area";
+    readonly coveredBy: "data-explorbot-covered-by";
     readonly context: "data-explorbot-context";
     readonly eidx: "data-explorbot-eidx";
+    readonly hit: "data-explorbot-hit";
     readonly variant: "data-explorbot-variant";
 };
 export declare const HTML_SELECTORS: {
@@ -41,8 +43,10 @@ export declare function inferHtmlRole(data: {
 export declare const ELEMENT_EXTRACTION_CONFIG: {
     readonly attrs: {
         readonly area: "data-explorbot-area";
+        readonly coveredBy: "data-explorbot-covered-by";
         readonly context: "data-explorbot-context";
         readonly eidx: "data-explorbot-eidx";
+        readonly hit: "data-explorbot-hit";
         readonly variant: "data-explorbot-variant";
     };
     readonly codeEditorMarkers: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
@@ -70,6 +74,7 @@ export type ComponentScopeExtractionConfig = {
     interactiveControlSelector: string;
     limits: typeof HTML_EXTRACTION_LIMITS;
 };
+export declare function captureHtmlForSnapshot(): string;
 export declare function extractElementData(el: Element, config?: ElementExtractionConfig): {
     tag: string;
     text: string;