explorbot 0.1.31 → 0.1.32-beta.1

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

@@ -0,0 +1,185 @@
+import { ActionResult } from './action-result.js';
+import { ExperienceTracker } from './experience-tracker.js';
+export interface Link {
+    title: string;
+    url: string;
+    visible?: boolean;
+}
+export interface WebPageState {
+    /** Unique incremental state identifier */
+    id?: number;
+    /** URL path without domain, including hash: /path/to/page#section */
+    url: string;
+    /** Page title */
+    title?: string;
+    /** HTTP status of the main document navigation */
+    httpStatus?: number;
+    /** Full URL for reference */
+    fullUrl?: string;
+    /** Timestamp when state was captured */
+    timestamp?: Date;
+    /** Hash of the state for unique identification */
+    hash?: string;
+    /** HTML file path */
+    htmlFile?: string;
+    /** Screenshot file path */
+    screenshotFile?: string;
+    /** Log file path */
+    logFile?: string;
+    /** HTML content */
+    html?: string;
+    notes?: string[];
+    /** Page headings */
+    h1?: string;
+    h2?: string;
+    h3?: string;
+    h4?: string;
+    ariaSnapshot?: string | null;
+    ariaSnapshotFile?: string;
+    links?: Link[];
+    verifications?: Record<string, boolean>;
+}
+export interface StateTransition {
+    /** Previous state (null if this is the first state) */
+    fromState: WebPageState | null;
+    /** Current state */
+    toState: WebPageState;
+    /** Code block that caused the transition */
+    codeBlock: string;
+    /** Timestamp of the transition */
+    timestamp: Date;
+    /** Any error that occurred during transition */
+    error?: string;
+    /** What triggered the state change */
+    trigger: 'manual' | 'navigation' | 'automatic';
+}
+export type StateChangeListener = (event: StateTransition) => void;
+export interface Knowledge extends WebPageState {
+    /** File path */
+    filePath: string;
+    /** Markdown content */
+    content: string;
+}
+export declare class StateManager {
+    currentState: WebPageState | null;
+    stateHistory: StateTransition[];
+    allVisitedUrls: Set<string>;
+    knowledgeCache: Knowledge[];
+    lastKnowledgeScan: Date | null;
+    stateChangeListeners: StateChangeListener[];
+    experienceTracker: ExperienceTracker;
+    knowledgeDir: string;
+    nextStateId: number;
+    constructor();
+    getExperienceTracker(): ExperienceTracker;
+    /**
+     * Subscribe to state change events
+     */
+    onStateChange(listener: StateChangeListener): () => void;
+    /**
+     * 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
+     */
+    updateState(actionResult: ActionResult, codeBlock?: string, trigger?: 'manual' | 'navigation' | 'automatic'): WebPageState;
+    /**
+     * Update state from basic data (for navigation events)
+     */
+    updateStateFromBasic(url: string, title?: string, trigger?: 'manual' | 'navigation' | 'automatic'): WebPageState;
+    hasDialogAppeared(previousState: WebPageState | null, newState: WebPageState): boolean;
+    /**
+     * Generate a basic hash for state comparison
+     */
+    generateBasicHash(url: string, title?: string): string;
+    /**
+     * Get current state
+     */
+    getCurrentState(): WebPageState | null;
+    /**
+     * Check if state has changed since a given state
+     */
+    hasStateChanged(previousState: WebPageState | null): boolean;
+    /**
+     * Compare two states by their hash
+     */
+    statesEqual(state1: WebPageState | null, state2: WebPageState | null): boolean;
+    /**
+     * Get state history
+     */
+    getStateHistory(): StateTransition[];
+    isInDeadLoop(): boolean;
+    /**
+     * 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
+     */
+    getRelevantKnowledge(): Knowledge[];
+    /**
+     * Get relevant experience files for current state
+     */
+    getRelevantExperience(): string[];
+    /**
+     * 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
+     */
+    hasVisitedState(path: string): boolean;
+    getAllVisitedUrls(): Set<string>;
+    /**
+     * Get how many times we've visited a specific path
+     */
+    getVisitCount(path: string): number;
+    /**
+     * Find the most recent transition to a specific path
+     */
+    getLastVisitToPath(path: string): StateTransition | null;
+    /**
+     * Get previous state from history for comparison.
+     * 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
+     */
+    clearHistory(): void;
+    /**
+     * Get the number of active state change listeners
+     */
+    getListenerCount(): number;
+    /**
+     * Clear all state change listeners
+     */
+    clearListeners(): void;
+    /**
+     * Complete cleanup of the StateManager instance
+     * Clears all state, history, listeners, and caches
+     */
+    cleanup(): void;
+}
+export declare function normalizeUrl(url: string): string;

package/dist/src/state-manager.js

@@ -5,7 +5,6 @@ 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 { htmlTextSnapshot } from './utils/html.js';
 import { createDebug } from './utils/logger.js';
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:state');
@@ -53,12 +52,6 @@ export class StateManager {
      * Emit state change event to all listeners
      */
     emitStateChange(event) {
-        // Log HTML content when state changes
-        if (event.toState.html && event.toState.html !== event.fromState?.html) {
-            let htmlContent = event?.toState?.html ?? '';
-            htmlContent = htmlTextSnapshot(htmlContent);
-            // tag('html').log(`Page HTML for ${event.toState.url}:\n${htmlContent}`);
-        }
         this.stateChangeListeners.forEach((listener) => {
             try {
                 listener(event);

package/dist/src/stats.d.ts

@@ -0,0 +1,24 @@
+interface TokenUsage {
+    input: number;
+    output: number;
+    total: number;
+    cached?: number;
+}
+export type ExplorbotMode = 'explore' | 'test' | 'freesail' | 'tui';
+export declare class Stats {
+    static startTime: number;
+    static sessionName: string;
+    static researches: number;
+    static tests: number;
+    static plans: number;
+    static mode?: ExplorbotMode;
+    static focus?: string;
+    static models: Record<string, TokenUsage>;
+    static recordTokens(_agent: string, model: string, usage: TokenUsage): void;
+    static getElapsedTime(): string;
+    static humanizeTokens(num: number): string;
+    static modelsTable(roleModels: Record<string, string>): string;
+    static hasActivity(): boolean;
+    static sessionLabel(): string;
+}
+export {};

package/dist/src/suite.d.ts

@@ -0,0 +1,24 @@
+export declare class Suite {
+    readonly url: string;
+    _automatedTests: AutomatedTest[] | null;
+    _plannedScenarios: string[] | null;
+    constructor(url: string);
+    getAutomatedTests(): AutomatedTest[];
+    getPlannedScenarios(): string[];
+    getActiveScenarioTitles(): Set<string>;
+    get automatedTestCount(): number;
+    getAutomatedTestNames(): string[];
+    getAutomatedTestFiles(): string[];
+    loadAutomatedTests(): AutomatedTest[];
+    parseTestFile(filePath: string): {
+        url: string;
+        tests: AutomatedTest[];
+    } | null;
+    loadPlannedScenarios(): string[];
+}
+interface AutomatedTest {
+    title: string;
+    pending: boolean;
+    file: string;
+}
+export {};

package/dist/src/test-plan.d.ts

@@ -0,0 +1,166 @@
+import { WebPageState } from './state-manager.js';
+export declare const TestResult: {
+    readonly PASSED: "passed";
+    readonly FAILED: "failed";
+    readonly SKIPPED: "skipped";
+};
+export type TestResultType = (typeof TestResult)[keyof typeof TestResult] | null;
+export declare const TestStatus: {
+    readonly PENDING: "pending";
+    readonly IN_PROGRESS: "in_progress";
+    readonly DONE: "done";
+};
+export type TestStatusType = (typeof TestStatus)[keyof typeof TestStatus];
+export interface Note {
+    message: string;
+    status?: TestResultType;
+    startTime: number;
+    endTime: number;
+    screenshot?: string;
+    log?: string;
+}
+export declare class ActiveNote {
+    task: Task;
+    startTime: number;
+    message: string;
+    status?: TestResultType;
+    screenshot?: string;
+    log?: string;
+    constructor(task: Task, message: string, status?: TestResultType);
+    commit(finalStatus?: TestResultType): void;
+    getMessage(): string;
+    getStartTime(): number;
+}
+export interface StepData {
+    text: string;
+    duration?: number;
+    status?: string;
+    error?: string;
+    log?: string;
+    artifacts?: string[];
+    noteStartTime?: number;
+}
+export declare class Task {
+    id: string;
+    description: string;
+    notes: Record<string, Note>;
+    steps: Record<string, StepData>;
+    states: WebPageState[];
+    startUrl: string;
+    verification?: Verification;
+    timestampCounter: number;
+    activeNote?: ActiveNote;
+    constructor(description: string, startUrl?: string);
+    startNote(message: string, status?: TestResultType): ActiveNote;
+    finishNote(activeNote: ActiveNote, endTime: number, finalStatus?: TestResultType): void;
+    getPrintableNotes(): string[];
+    notesToString(): string;
+    addNote(message: string, status?: TestResultType, screenshot?: string, log?: string): void;
+    addUrlNote(state: UrlNoteState, prevState?: {
+        title?: string;
+        h1?: string;
+        h2?: string;
+    }): void;
+    addState(state: WebPageState): void;
+    addStep(text: string, duration?: number, status?: string, error?: string, log?: string, artifacts?: string[]): void;
+    setActiveNoteScreenshot(screenshotFile?: string): void;
+    setVerification(message: string, status: TestResultType, state?: UrlNoteState): void;
+    addVerificationDetail(detail: string): void;
+    getLog(): Array<{
+        type: 'step' | 'note' | 'artifact';
+        content: string;
+        timestamp: number;
+    }>;
+    getLogString(): string;
+    getRunResult(): 'success' | 'partial' | 'failed';
+}
+export declare class Test extends Task {
+    scenario: string;
+    sessionName?: string;
+    status: TestStatusType;
+    result: TestResultType;
+    priority: 'critical' | 'important' | 'high' | 'normal' | 'low';
+    expected: string[];
+    plannedSteps: string[];
+    plan?: Plan;
+    summary: string;
+    artifacts: Record<string, string>;
+    generatedCode?: string;
+    style?: string;
+    planIteration: number;
+    enabled: boolean;
+    startTime?: number;
+    endTime?: number;
+    resetCount: number;
+    constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps?: string[]);
+    getVisitedUrls({ localOnly }?: {
+        localOnly?: boolean;
+    }): string[];
+    addArtifact(artifact?: string): void;
+    get hasFinished(): boolean;
+    get isSuccessful(): boolean;
+    get hasFailed(): boolean;
+    get isSkipped(): boolean;
+    getCheckedNotes(): Note[];
+    getCheckedExpectations(): string[];
+    hasAchievedAny(): boolean;
+    getRunResult(): 'success' | 'partial' | 'failed';
+    hasAchievedAll(): boolean;
+    isComplete(): boolean;
+    start(): void;
+    finish(result?: TestResultType): void;
+    getDurationMs(): number | null;
+    getRemainingExpectations(): string[];
+    getLog(): Array<{
+        type: 'step' | 'note' | 'artifact';
+        content: string;
+        timestamp: number;
+    }>;
+}
+type PlanChangeListener = (tests: Test[]) => void;
+export declare class Plan {
+    title: string;
+    tests: Test[];
+    url?: string;
+    iteration: number;
+    parentPlan?: Plan;
+    changeListeners: PlanChangeListener[];
+    constructor(title: string);
+    nextIteration(): void;
+    addTest(test: Test): void;
+    removeTest(test: Test): void;
+    onTestsChange(listener: PlanChangeListener): () => void;
+    notifyChange(): void;
+    getAllTests(): Test[];
+    listTests(): Test[];
+    getPendingTests(): Test[];
+    get isComplete(): boolean;
+    get allSuccessful(): boolean;
+    get allFailed(): boolean;
+    updateStatus(): void;
+    static fromMarkdown(filePath: string): Plan;
+    saveToMarkdown(filePath: string): void;
+    static saveMultipleToMarkdown(plans: Plan[], filePath: string): void;
+    getVisitedPages(): WebPageState[];
+    merge(otherPlan: Plan): Plan;
+    toAiContext(options?: {
+        skipSteps?: boolean;
+    }): string;
+}
+interface Verification {
+    message: string;
+    status: TestResultType;
+    screenshot?: string;
+    url?: string;
+    pageLabel?: string;
+    details: string[];
+}
+interface UrlNoteState {
+    url?: string;
+    fullUrl?: string;
+    title?: string;
+    h1?: string;
+    h2?: string;
+    screenshotFile?: string;
+}
+export {};

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

@@ -0,0 +1,20 @@
+export interface FocusAreaResult {
+    detected: boolean;
+    type: 'dialog' | 'modal' | null;
+    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 detectFocusArea: (snapshot: string | null) => FocusAreaResult;
+export declare const collectInteractiveNodes: (snapshot: string | null) => Array<Record<string, unknown>>;
+export interface FocusedElementInfo {
+    role: string;
+    name: string;
+    value?: string;
+    attributes?: string[];
+}
+export declare function extractFocusedElement(ariaSnapshot: string | null): FocusedElementInfo | null;
+export declare function parseAriaLocator(ariaStr: string): {
+    role: string;
+    text: string;
+} | null;

package/dist/src/utils/browser-errors.d.ts

@@ -0,0 +1,8 @@
+export declare class BrowserRecoveryError extends Error {
+    originalError: unknown;
+    recovered: boolean;
+    constructor(label: string, originalError: unknown, recovered: boolean);
+}
+export declare function isFatalBrowserError(error: unknown): boolean;
+export declare function isNavigationTransitionError(error: unknown): boolean;
+export declare function browserErrorMessage(error: unknown): string;

package/dist/src/utils/cli-name.d.ts

@@ -0,0 +1 @@
+export declare function getCliName(): string;

package/dist/src/utils/code-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractCodeBlocks(aiResponse: string): string[];

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

@@ -0,0 +1,25 @@
+export interface ContextData {
+    url: string;
+    title?: string;
+    headings: {
+        h1?: string;
+        h2?: string;
+        h3?: string;
+        h4?: string;
+    };
+    experience: Array<{
+        filePath: string;
+        data: any;
+        content: string;
+    }>;
+    knowledge: Array<{
+        filePath: string;
+        url: string;
+        content: string;
+    }>;
+    ariaSnapshot: string | null;
+    combinedHtml?: string;
+    research?: string;
+}
+export type ContextMode = 'attached' | 'compact' | 'full';
+export declare function formatContextSummary(data: ContextData, mode?: ContextMode): string;

package/dist/src/utils/error-page.d.ts

@@ -0,0 +1,12 @@
+import { ActionResult } from '../action-result.js';
+import type { WebPageState } from '../state-manager.js';
+export type PageCondition = 'ok' | 'loading' | 'error';
+export declare function detectPageCondition(actionResult: ActionResult): PageCondition;
+export declare function isErrorPage(actionResult: ActionResult): boolean;
+export declare function getStateErrorPageError(state: WebPageState | null | undefined): ErrorPageError | null;
+export declare class ErrorPageError extends Error {
+    readonly url: string;
+    readonly title?: string;
+    readonly httpStatus?: number;
+    constructor(url: string, title?: string, httpStatus?: number);
+}

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

@@ -0,0 +1,4 @@
+export declare const EXPANDABLE_ICON_DESCRIPTIONS: string[];
+export declare const EXPANDABLE_XPATHS: string[];
+export declare function buildExpandableXPath(excludeContainers?: string[]): string;
+export declare function buildExpandableXPathInsideContainers(containers: string[]): string[];

package/dist/src/utils/hooks-runner.d.ts

@@ -0,0 +1,15 @@
+import type { ExplorbotConfig, Hook, HookConfig } from '../config.js';
+import type Explorer from '../explorer.js';
+export declare class HooksRunner {
+    explorer: Explorer;
+    config: ExplorbotConfig;
+    constructor(explorer: Explorer, config: ExplorbotConfig);
+    runBeforeHook(agentName: string, url: string): Promise<void>;
+    runAfterHook(agentName: string, url: string): Promise<void>;
+    runHook(agentName: string, hookType: 'beforeHook' | 'afterHook', url: string): Promise<void>;
+    findMatchingHook(config: HookConfig, url: string): Hook | null;
+    patternSpecificity(pattern: string): number;
+    executeHook(hook: Hook, url: string): Promise<void>;
+    isSingleHook(config: HookConfig): boolean;
+    extractPath(url: string): string;
+}

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

@@ -0,0 +1,19 @@
+import type { HtmlConfig } from '../config.js';
+export interface HtmlDiffPart {
+    container: string;
+    subtree: string;
+    added: string[];
+    removed: string[];
+}
+export interface HtmlDiffResult {
+    parts: HtmlDiffPart[];
+    added: string[];
+    removed: string[];
+    similarity: number;
+    summary: string;
+}
+export declare function computeHtmlFingerprint(html: string): string[];
+/**
+ * Compares two HTML documents and returns differences along with a diff subtree.
+ */
+export declare function htmlDiff(originalHtml: string, modifiedHtml: string, htmlConfig?: HtmlConfig): Promise<HtmlDiffResult>;

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

@@ -0,0 +1,124 @@
+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 context: "data-explorbot-context";
+    readonly eidx: "data-explorbot-eidx";
+    readonly variant: "data-explorbot-variant";
+};
+export declare const HTML_SELECTORS: {
+    readonly headingLabel: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"]";
+    readonly interactiveContent: "button, a[href], input, select, textarea, [role=\"button\"], [role=\"link\"], [role=\"option\"], [role=\"menuitem\"], [role=\"switch\"], [role=\"checkbox\"], [role=\"radio\"], [aria-label], [tabindex]";
+    readonly interactiveControl: "button, a[href], input, select, textarea, [role=\"button\"], [role=\"link\"], [role=\"checkbox\"], [role=\"radio\"], [role=\"switch\"], [role=\"tab\"], [role=\"menuitem\"]";
+    readonly labelLike: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"], [class*=\"title\"], [class*=\"label\"], [class*=\"header\"], [class*=\"name\"]";
+    readonly semanticContextContainer: "section, article, form, fieldset, li, tr, td, th, [role=\"group\"], [role=\"tabpanel\"], [role=\"region\"], [class*=\"card\"], [class*=\"panel\"], [class*=\"item\"], [class*=\"usage\"], [class*=\"group\"]";
+    readonly semanticOverlays: readonly ["[role=\"dialog\"]", "[role=\"listbox\"]", "[role=\"menu\"]", "[role=\"tooltip\"]:not([style*=\"display: none\"]):not([style*=\"visibility: hidden\"])"];
+};
+export declare const HTML_VISIBILITY_LIMITS: {
+    readonly maxViewportOverlayRatio: 0.95;
+    readonly minOpacity: 0.1;
+    readonly minOverlayHeight: 40;
+    readonly minOverlayWidth: 80;
+};
+export declare const HTML_EXTRACTION_LIMITS: {
+    readonly componentScopeHtmlLength: 8000;
+    readonly maxOverlayCount: 3;
+    readonly maxScopeInteractiveCount: 16;
+    readonly overlayHtmlLength: 6000;
+};
+export declare const CODE_EDITOR_MARKERS: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
+export declare const HTML_INTERACTIVE_ROLES: Set<string>;
+export declare const HTML_FORM_CONTROL_ROLES: Set<string>;
+export declare const HTML_COMPOSITE_TARGET_ROLES: Set<string>;
+export declare const HTML_COMPOSITE_AREA_HINTS: Set<string>;
+export declare const HTML_FORM_CONTROL_TAGS: Set<string>;
+export declare function inferHtmlRole(data: {
+    attrs: Record<string, string>;
+    role?: string;
+    tag: string;
+    variantHints?: string[];
+}): string;
+export declare const ELEMENT_EXTRACTION_CONFIG: {
+    readonly attrs: {
+        readonly area: "data-explorbot-area";
+        readonly context: "data-explorbot-context";
+        readonly eidx: "data-explorbot-eidx";
+        readonly variant: "data-explorbot-variant";
+    };
+    readonly codeEditorMarkers: readonly ["monaco", "codemirror", "ace", "ace_editor", "code"];
+    readonly maxAreaDepth: 5;
+    readonly maxContextLength: 120;
+    readonly maxOuterHTMLLength: 2000;
+    readonly maxTextLength: 80;
+    readonly minOpacity: 0.1;
+    readonly selectors: {
+        readonly headingLabel: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"]";
+        readonly labelLike: "h1, h2, h3, h4, h5, h6, legend, caption, label, [role=\"heading\"], [class*=\"title\"], [class*=\"label\"], [class*=\"header\"], [class*=\"name\"]";
+        readonly semanticContextContainer: "section, article, form, fieldset, li, tr, td, th, [role=\"group\"], [role=\"tabpanel\"], [role=\"region\"], [class*=\"card\"], [class*=\"panel\"], [class*=\"item\"], [class*=\"usage\"], [class*=\"group\"]";
+    };
+};
+export type ElementExtractionConfig = typeof ELEMENT_EXTRACTION_CONFIG;
+export type RawElementData = NonNullable<ReturnType<typeof extractElementData>>;
+export type VisibleOverlayExtractionConfig = {
+    interactiveContentSelector: string;
+    limits: typeof HTML_EXTRACTION_LIMITS;
+    overlaySelectors: readonly string[];
+    visibilityLimits: typeof HTML_VISIBILITY_LIMITS;
+};
+export type ComponentScopeExtractionConfig = {
+    eidxAttr: string;
+    interactiveControlSelector: string;
+    limits: typeof HTML_EXTRACTION_LIMITS;
+};
+export declare function extractElementData(el: Element, config?: ElementExtractionConfig): {
+    tag: string;
+    text: string;
+    allAttrs: Record<string, string>;
+    outerHTML: string;
+    x: number;
+    y: number;
+};
+export declare function getElementDataExtractorSource(): string;
+export declare function extractVisibleOverlayHtml(config: VisibleOverlayExtractionConfig): string;
+export declare function extractComponentScopeHtml(eidx: string, config: ComponentScopeExtractionConfig): string;
+export declare function getVisibleOverlayHtmlExtractorSource(): string;
+export declare function getComponentScopeHtmlExtractorSource(): string;
+export declare const TRASH_HTML_CLASSES: RegExp;
+export declare const TAILWIND_CLASS_PATTERNS: RegExp[];
+export declare function sanitizeHtmlDocument(html: string, htmlConfig?: HtmlConfig): parse5TreeAdapter.Document;
+export declare function sanitizeHtmlString(html: string, htmlConfig?: HtmlConfig): string;
+/**
+ * Creates a minimal snapshot keeping only interactive elements and their structure
+ * Based on CodeceptJS HTML library
+ */
+export declare function htmlMinimalUISnapshot(html: string, htmlConfig?: HtmlConfig['minimal']): string;
+export declare function minifyHtml(html: string): Promise<string>;
+/**
+ * Creates a combined snapshot with interactive elements and meaningful text
+ * Preserves original HTML structure
+ */
+export declare function htmlCombinedSnapshot(html: string, htmlConfig?: HtmlConfig['combined'], opts?: {
+    keepPositions?: boolean;
+}): string;
+/**
+ * Creates text-only snapshot with markdown formatting
+ */
+export declare function htmlTextSnapshot(html: string, htmlConfig?: HtmlConfig['text']): string;
+export interface ExtractedLink {
+    title: string;
+    url: string;
+}
+export declare function extractLinks(html: string): ExtractedLink[];
+export declare function extractHeadings(html: string): {
+    h1?: string;
+    h2?: string;
+    h3?: string;
+    h4?: string;
+};
+export declare function codeToMarkdown(code: string): string;
+export declare function isBodyEmpty(html: string): boolean;
+/**
+ * Extract HTML snippet around a targeted element based on locator
+ * Used for accessibility analysis to show what element was being targeted
+ */
+export declare function extractTargetedHtml(html: string, locator: string): string;

package/dist/src/utils/log-filters.d.ts

@@ -0,0 +1,6 @@
+export declare class RecentStepFilter {
+    ttlMs: number;
+    recentStepKeys: Map<string, number>;
+    constructor(ttlMs?: number);
+    shouldSuppress(content: string, now?: number): boolean;
+}