explorbot 0.1.30 → 0.1.32-beta.1

package/dist/src/config.d.ts

@@ -0,0 +1,251 @@
+interface PlaywrightConfig {
+    browser: 'chromium' | 'firefox' | 'webkit';
+    url: string;
+    show?: boolean;
+    windowSize?: string;
+    slowMo?: number;
+    chromium?: {
+        args?: string[];
+    };
+    firefox?: {
+        args?: string[];
+    };
+    webkit?: {
+        args?: string[];
+    };
+    timeout?: number;
+    waitForAction?: number;
+    waitForNavigation?: 'load' | 'domcontentloaded' | 'networkidle';
+    waitForTimeout?: number;
+    spinnerSelectors?: string[];
+    ignoreHTTPSErrors?: boolean;
+    userAgent?: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    args?: string[];
+}
+type PlaywrightHookFn = (ctx: {
+    page: any;
+    url: string;
+}) => Promise<void> | void;
+type CodeceptJSHookFn = (ctx: {
+    I: any;
+    url: string;
+}) => Promise<void> | void;
+interface PlaywrightHook {
+    type: 'playwright';
+    hook: PlaywrightHookFn;
+}
+interface CodeceptJSHook {
+    type: 'codeceptjs';
+    hook: CodeceptJSHookFn;
+}
+type Hook = PlaywrightHook | CodeceptJSHook;
+type HookPatternMap = Record<string, Hook>;
+type HookConfig = Hook | HookPatternMap;
+interface HooksConfig {
+    beforeHook?: HookConfig;
+    afterHook?: HookConfig;
+}
+interface AgentConfig extends HooksConfig {
+    model?: any;
+    enabled?: boolean;
+    systemPrompt?: string;
+    rules?: RuleEntry[];
+    providerOptions?: Record<string, any>;
+    reasoning?: 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+}
+interface ResearcherAgentConfig extends AgentConfig {
+    excludeSelectors?: string[];
+    includeSelectors?: string[];
+    stopWords?: string[];
+    maxElementsToExplore?: number;
+    maxExpandableClicks?: number;
+    retries?: number;
+    sections?: string[];
+    focusSections?: string[];
+    errorPageTimeout?: number;
+}
+interface TesterAgentConfig extends AgentConfig {
+    progressCheckInterval?: number;
+}
+interface PilotAgentConfig extends AgentConfig {
+    stepsToReview?: number;
+}
+interface NavigatorAgentConfig extends AgentConfig {
+    addHtmlOnTry?: number;
+    maxAttempts?: number;
+    verifyAttempts?: number;
+    verifyTimeout?: number;
+}
+type HealFn = (ctx: {
+    I: any;
+}) => Promise<void> | void;
+interface HealRecipe {
+    priority?: number;
+    steps?: string[];
+    fn: (context: {
+        step: any;
+        error: Error;
+        prevSteps?: any[];
+    }) => HealFn | Promise<HealFn | null> | null;
+}
+interface RerunnerAgentConfig extends AgentConfig {
+    healLimit?: number;
+    ariaSnapshotLimit?: number;
+    retryFailedStep?: Record<string, any>;
+    screenshotOnFail?: Record<string, any>;
+    recipes?: Record<string, HealRecipe>;
+}
+interface PlannerAgentConfig extends AgentConfig {
+    styles?: string[];
+    stylesDir?: string;
+}
+interface ScreencastConfig {
+    size?: {
+        width: number;
+        height: number;
+    };
+    quality?: number;
+}
+interface HistorianAgentConfig extends AgentConfig {
+    framework?: 'codeceptjs' | 'playwright';
+    screencast?: boolean | ScreencastConfig;
+}
+interface AgentsConfig {
+    tester?: TesterAgentConfig;
+    navigator?: NavigatorAgentConfig;
+    researcher?: ResearcherAgentConfig;
+    planner?: PlannerAgentConfig;
+    pilot?: PilotAgentConfig;
+    driller?: AgentConfig;
+    'experience-compactor'?: AgentConfig;
+    captain?: AgentConfig;
+    quartermaster?: AgentConfig;
+    historian?: HistorianAgentConfig;
+    fisherman?: AgentConfig;
+    chief?: AgentConfig;
+    curler?: AgentConfig;
+    rerunner?: RerunnerAgentConfig;
+    analyst?: AgentConfig;
+}
+interface AIConfig {
+    model: any;
+    apiKey?: string;
+    config?: Record<string, any>;
+    langfuse?: {
+        enabled?: boolean;
+        publicKey?: string;
+        secretKey?: string;
+        baseUrl?: string;
+    };
+    tools?: {
+        enabled: boolean;
+        maxConcurrency: number;
+        timeout: number;
+    };
+    vision?: boolean;
+    visionModel?: any;
+    agenticModel?: any;
+    maxAttempts?: number;
+    retryDelay?: number;
+    agents?: AgentsConfig;
+}
+interface HtmlConfig {
+    minimal?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    combined?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    text?: {
+        include?: string[];
+        exclude?: string[];
+    };
+}
+interface ActionConfig {
+    delay?: number;
+    retries?: number;
+}
+interface ReporterConfig {
+    enabled?: boolean;
+    html?: boolean;
+    markdown?: boolean;
+    runGroup?: string | null;
+}
+type ApiHookFn = (ctx: {
+    headers: Record<string, string>;
+    baseEndpoint: string;
+}) => Promise<Record<string, string> | undefined> | Record<string, string> | undefined;
+interface ApiConfig {
+    baseEndpoint?: string;
+    spec?: string[];
+    headers?: Record<string, string>;
+    bootstrap?: ApiHookFn;
+    teardown?: ApiHookFn;
+}
+interface WebConfig {
+    url: string;
+}
+interface ExplorbotConfig {
+    web?: WebConfig;
+    playwright: PlaywrightConfig;
+    ai: AIConfig;
+    html?: HtmlConfig;
+    action?: ActionConfig;
+    dirs?: {
+        knowledge: string;
+        experience: string;
+        output: string;
+    };
+    experience?: {
+        maxReadLines?: number;
+    };
+    reporter?: ReporterConfig;
+    api?: ApiConfig;
+    stepsFile?: string;
+    files?: Record<string, string>;
+    dynamicPageRegex?: string;
+}
+type RuleEntry = string | Record<string, string>;
+export declare const EXPLORBOT_CONFIG_PATHS: string[];
+export type { ExplorbotConfig, PlaywrightConfig, AIConfig, HtmlConfig, ActionConfig, AgentConfig, AgentsConfig, HistorianAgentConfig, ResearcherAgentConfig, NavigatorAgentConfig, PlannerAgentConfig, RerunnerAgentConfig, HealRecipe, Hook, HookConfig, HooksConfig, PlaywrightHook, CodeceptJSHook, HookPatternMap, RuleEntry, ReporterConfig, ApiConfig, WebConfig, ApiHookFn, };
+export declare class ConfigParser {
+    static instance: ConfigParser;
+    config: ExplorbotConfig | null;
+    configPath: string | null;
+    runtimeBaseUrlOverride: string | null;
+    constructor();
+    static loadEnv(filePath: string): void;
+    static getInstance(): ConfigParser;
+    loadConfig(options?: {
+        config?: string;
+        path?: string;
+        baseUrl?: string;
+    }): Promise<ExplorbotConfig>;
+    getConfig(): ExplorbotConfig;
+    getConfigPath(): string | null;
+    getOutputDir(): string;
+    getStatesDir(): string;
+    getPlansDir(): string;
+    getTestsDir(): string;
+    static resetForTesting(): void;
+    static setupTestConfig(): void;
+    static getTestDirectories(): string[];
+    static cleanupAllTestDirectories(): void;
+    findConfigFile(): string | null;
+    loadConfigModule(configPath: string): Promise<any>;
+    resolveConfig(config: ExplorbotConfig, options?: {
+        baseUrl?: string;
+    }): ExplorbotConfig;
+    validateConfig(config: ExplorbotConfig): void;
+    getNestedValue(obj: any, path: string): any;
+    mergeWithDefaults(config: Partial<ExplorbotConfig>): ExplorbotConfig;
+    deepMerge(target: any, source: any): any;
+    ensureDirectory(path: string): void;
+}
+export declare function outputPath(...segments: string[]): string;

package/dist/src/execution-controller.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'node:events';
+export type InputCallback = (prompt: string) => Promise<string | null>;
+export declare class ExecutionController extends EventEmitter {
+    static instance: ExecutionController;
+    interrupted: boolean;
+    inputCallback: InputCallback | null;
+    interruptResolvers: Array<() => void>;
+    abortController: AbortController | null;
+    awaitingInput: boolean;
+    constructor();
+    static getInstance(): ExecutionController;
+    setInputCallback(callback: InputCallback): void;
+    startExecution(): void;
+    getAbortSignal(): AbortSignal | undefined;
+    interrupt(): void;
+    isAwaitingInput(): boolean;
+    isInterrupted(): boolean;
+    waitForInterrupt(): Promise<void>;
+    checkInterrupt(): Promise<string | null>;
+    handleInterrupt(prompt?: string): Promise<string | null>;
+    requestInput(prompt: string): Promise<string | null>;
+    readlineInput(prompt: string): Promise<string | null>;
+    reset(): void;
+}
+export declare const executionController: ExecutionController;

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

@@ -0,0 +1,107 @@
+import type { ActionResult } from './action-result.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+export declare const RECENT_WINDOW_DAYS = 30;
+/**
+ * Stores and reads per-page experience files (`./experience/<stateHash>.md`).
+ *
+ * Two writers, two contracts:
+ *
+ *   writeFlow(state, body, relatedUrls?)  — caller hands in a fully-formatted
+ *                                            `## FLOW: <imperative title>` block (multi-step,
+ *                                            `*` bullets + optional ```js``` + `>` discovery,
+ *                                            ends with `---`). Tracker dedups + prepends.
+ *   writeAction(state, ActionInput)        — `## ACTION: <imperative title>`, single-step,
+ *                                            optional `Solution:` line + one ```js``` code block.
+ *                                            Title normalized via normalizeTitle().
+ *
+ * - Always h2. Never h3 for FLOW/ACTION.
+ * - On read (getSuccessfulExperience), headings are rendered as
+ *   `## HOW to <title> (multi-step|single-step)` so prompts get natural phrasing.
+ */
+export declare class ExperienceTracker {
+    experienceDir: string;
+    disabled: boolean;
+    knowledgeTracker: KnowledgeTracker;
+    constructor(options?: {
+        disabled?: boolean;
+    });
+    getExperienceDirectories(): string[];
+    ensureDirectory(dir: string): void;
+    readExperienceFile(stateHash: string): {
+        content: string;
+        data: any;
+    };
+    writeExperienceFile(stateHash: string, content: string, frontmatter?: any): void;
+    hasRecentExperience(stateHash: string, prefix?: string): boolean;
+    getExperienceFilePath(stateHash: string): string;
+    ensureExperienceFile(state: ActionResult): string;
+    updateSummary(state: ActionResult, summary: string): void;
+    isWritingDisabled(state: ActionResult): boolean;
+    writeAction(state: ActionResult, action: ActionInput): void;
+    writeFlow(state: ActionResult, body: string, relatedUrls?: string[]): void;
+    getAllExperience(): ExperienceFile[];
+    getRelevantExperience(state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): ExperienceFile[];
+    /**
+     * Clean up experience tracker (for testing)
+     */
+    cleanup(): void;
+    getSuccessfulExperience(state: ActionResult, options?: {
+        includeDescendants?: boolean;
+        stripCode?: boolean;
+    }): string[];
+    getExperienceTableOfContents(state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): ExperienceTocEntry[];
+    getExperienceSection(fileTag: string, sectionIndex: number, state: ActionResult, options?: {
+        includeDescendantExperience?: boolean;
+    }): {
+        title: string;
+        url: string;
+        content: string;
+    } | null;
+    findExperienceFileByHash(fileHash: string): string | null;
+    listAllExperienceToc(filter?: string, options?: {
+        recency?: 'recent' | 'old';
+    }): ExperienceTocEntry[];
+    getExperienceSectionByTag(fileTag: string, sectionIndex: number, filter?: string): {
+        title: string;
+        url: string;
+        content: string;
+        fileHash: string;
+    } | null;
+}
+export declare function renderExperienceToc(toc: ExperienceTocEntry[]): string;
+export interface ExperienceFile {
+    filePath: string;
+    data: {
+        url?: string;
+        title?: string;
+        [key: string]: any;
+    };
+    content: string;
+    mtime: Date;
+}
+export interface ActionInput {
+    title: string;
+    code: string;
+    explanation?: string;
+}
+export interface SessionStep {
+    message: string;
+    status: 'passed' | 'failed' | 'neutral';
+    tool?: string;
+    code?: string;
+    discovery?: string;
+}
+export interface ExperienceTocEntry {
+    fileTag: string;
+    fileHash: string;
+    url: string;
+    sections: {
+        index: number;
+        level: 2 | 3;
+        title: string;
+    }[];
+}

package/dist/src/experience-tracker.js

@@ -6,6 +6,7 @@ import { ConfigParser } from './config.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
 import { createDebug, tag } from './utils/logger.js';
 import { mdq } from './utils/markdown-query.js';
+import { redactSecrets } from './utils/secrets.js';
 import { isNonReusableCode } from "./utils/step-analyzer.js";
 import { extractStatePath } from './utils/url-matcher.js';
 const debugLog = createDebug('explorbot:experience');
@@ -93,7 +94,7 @@ export class ExperienceTracker {
             return;
         }
         const filePath = this.getExperienceFilePath(stateHash);
-        const fileContent = matter.stringify(content, frontmatter || {});
+        const fileContent = matter.stringify(redactSecrets(content), frontmatter || {});
         writeFileSync(filePath, fileContent, 'utf8');
     }
     hasRecentExperience(stateHash, prefix = '') {

package/dist/src/explorbot.d.ts

@@ -0,0 +1,107 @@
+import { Captain } from './ai/captain.js';
+import { Driller } from './ai/driller.js';
+import { ExperienceCompactor } from './ai/experience-compactor.js';
+import { Fisherman } from './ai/fisherman.js';
+import { Historian } from './ai/historian.js';
+import { Navigator } from './ai/navigator.js';
+import { Pilot } from './ai/pilot.js';
+import { Planner } from './ai/planner.js';
+import { AIProvider } from './ai/provider.js';
+import { Quartermaster } from './ai/quartermaster.js';
+import { Rerunner } from './ai/rerunner.js';
+import { Researcher } from './ai/researcher.js';
+import { SessionAnalyst } from './ai/session-analyst.js';
+import { Tester } from './ai/tester.js';
+import type { ExplorbotConfig } from './config.js';
+import { ConfigParser } from './config.js';
+import { ExperienceTracker } from './experience-tracker.js';
+import Explorer from './explorer.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+import { WebPageState } from './state-manager.js';
+import type { Suite } from './suite.js';
+import { Plan, type Test } from './test-plan.js';
+export interface ExplorBotOptions {
+    from?: string;
+    baseUrl?: string;
+    verbose?: boolean;
+    config?: string;
+    path?: string;
+    show?: boolean;
+    headless?: boolean;
+    incognito?: boolean;
+    session?: string;
+}
+export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
+export declare class ExplorBot {
+    configParser: ConfigParser;
+    explorer: Explorer;
+    provider: AIProvider;
+    config: ExplorbotConfig;
+    options: ExplorBotOptions;
+    userResolveFn: UserResolveFunction | null;
+    needsInput: boolean;
+    currentPlan?: Plan;
+    planFeature?: string;
+    lastPlanError: Error | null;
+    lastSavedPlanPath: string | null;
+    agents: Record<string, any>;
+    sessionPlans: Plan[];
+    lastReportedTestCount: number;
+    constructor(options?: ExplorBotOptions);
+    get isExploring(): boolean;
+    setUserResolve(fn: UserResolveFunction): void;
+    start(): Promise<void>;
+    startProviderOnly(): Promise<void>;
+    stop(): Promise<void>;
+    visitInitialState(): Promise<void>;
+    visit(url: string): Promise<void>;
+    openFreshTab(): Promise<void>;
+    getCurrentState(): WebPageState | null;
+    getExplorer(): Explorer;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getExperienceTracker(): ExperienceTracker;
+    getConfig(): ExplorbotConfig;
+    getOptions(): ExplorBotOptions;
+    isReady(): boolean;
+    getConfigParser(): ConfigParser;
+    getProvider(): AIProvider;
+    createAgent<T>(factory: (deps: {
+        explorer: Explorer;
+        ai: AIProvider;
+        config: ExplorbotConfig;
+    }) => T): T;
+    agentResearcher(): Researcher;
+    agentNavigator(): Navigator;
+    agentPlanner(): Planner;
+    agentPilot(): Pilot;
+    agentTester(): Tester;
+    agentCaptain(): Captain;
+    agentExperienceCompactor(): ExperienceCompactor;
+    agentQuartermaster(): Quartermaster | null;
+    agentHistorian(): Historian;
+    agentRerunner(): Rerunner;
+    agentDriller(): Driller;
+    agentSessionAnalyst(): SessionAnalyst;
+    agentFisherman(): Fisherman | null;
+    getCurrentPlan(): Plan | undefined;
+    getSuite(): Suite | null;
+    getPlanFeature(): string | undefined;
+    clearPlan(): void;
+    plan(feature?: string, opts?: {
+        fresh?: boolean;
+        style?: string;
+        extend?: Plan;
+        completedPlans?: Plan[];
+        noSave?: boolean;
+    }): Promise<Plan>;
+    getPlansDir(): string;
+    savePlan(filename?: string): string | null;
+    savePlans(plans: Plan[], filename?: string): string | null;
+    generatePlanFilename(feature?: string): string;
+    resolvePlanPath(filename: string): string;
+    loadPlan(filename: string): Plan;
+    loadPlans(filename: string): Plan[];
+    setCurrentPlan(plan?: Plan): void;
+    getSessionTests(): Test[];
+    printSessionAnalysis(): Promise<void>;
+}

package/dist/src/explorer.d.ts

@@ -0,0 +1,140 @@
+import type { BrowserContextOptions } from 'playwright';
+import { ActionResult } from './action-result.js';
+import Action from './action.js';
+import { AIProvider } from './ai/provider.js';
+import { RequestStore } from './api/request-store.js';
+import { XhrCapture } from './api/xhr-capture.js';
+import type { ExplorbotConfig } from './config.js';
+import type { UserResolveFunction } from './explorbot.js';
+import { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from './playwright-recorder.js';
+import { Reporter } from './reporter.js';
+import { StateManager } from './state-manager.js';
+import { Test } from './test-plan.js';
+import { WebElement } from './utils/web-element.js';
+declare global {
+    namespace NodeJS {
+        interface Global {
+            output_dir: string;
+        }
+    }
+}
+declare namespace CodeceptJS {
+    interface I {
+        [key: string]: any;
+    }
+}
+interface TabInfo {
+    url: string;
+    title: string;
+}
+interface BrowserExecutionErrorResult {
+    action: 'continue' | 'stop';
+    message: string;
+    recovered?: boolean;
+}
+declare class Explorer {
+    aiProvider: AIProvider;
+    playwrightHelper: any;
+    isStarted: boolean;
+    isSharedBrowser: boolean;
+    actor: CodeceptJS.I;
+    stateManager: StateManager;
+    knowledgeTracker: KnowledgeTracker;
+    config: ExplorbotConfig;
+    userResolveFn: UserResolveFunction | null;
+    options?: {
+        show?: boolean;
+        headless?: boolean;
+        incognito?: boolean;
+        session?: string;
+    };
+    reporter: Reporter;
+    otherTabs: TabInfo[];
+    _activeTest: Test | null;
+    xhrCapture: XhrCapture | null;
+    requestStore: RequestStore | null;
+    playwrightRecorder: PlaywrightRecorder;
+    observedTestPages: Set<any>;
+    testPageErrorHandler: ((error: Error) => void) | null;
+    testConsoleHandler: ((message: any) => void) | null;
+    testDialogHandler: ((dialog: any) => void) | null;
+    constructor(config: ExplorbotConfig, aiProvider: AIProvider, options?: {
+        show?: boolean;
+        headless?: boolean;
+        incognito?: boolean;
+        session?: string;
+    });
+    initializeContainer(): void;
+    convertToCodeceptConfig(config: ExplorbotConfig): any;
+    getConfig(): ExplorbotConfig;
+    getConfigPath(): string | null;
+    getAIProvider(): AIProvider;
+    getStateManager(): StateManager;
+    getCurrentUrl(): string;
+    getKnowledgeTracker(): KnowledgeTracker;
+    getReporter(): Reporter;
+    getRequestStore(): RequestStore | null;
+    extractCookies(): Promise<Record<string, string>>;
+    setupXhrCapture(reuseRequestStore?: boolean): void;
+    start(): Promise<any>;
+    connectOrLaunchBrowser(): Promise<void>;
+    createBrowserContextOptions(): BrowserContextOptions;
+    createAction(): Action;
+    runWithBrowserRecovery<T>(label: string, operation: () => Promise<T>): Promise<T>;
+    capturePageState(opts?: {
+        includeScreenshot?: boolean;
+    }): Promise<ActionResult>;
+    capturePageWithScreenshot(): Promise<ActionResult>;
+    executeAction(code: string): Promise<Action>;
+    attemptAction(code: string, originalMessage?: string, experience?: boolean): Promise<boolean>;
+    getPlaywrightRecorder(): PlaywrightRecorder;
+    visit(url: string): Promise<Action>;
+    visitOnce(url: string): Promise<Action>;
+    annotateElements(): Promise<WebElement[]>;
+    visuallyAnnotateElements(opts?: {
+        containers?: Array<{
+            css: string;
+            label: string;
+        }>;
+    }): Promise<number>;
+    getEidxInContainer(containerCss: string | null): Promise<string[]>;
+    getEidxByLocator(locator: string, container?: string | null): Promise<string | null>;
+    reload(): Promise<void>;
+    resolveBrowserUrl(url?: string): string | null;
+    isFatalBrowserError(error: unknown): boolean;
+    recoverFromBrowserError(): Promise<boolean>;
+    restartBrowser(): Promise<boolean>;
+    switchToMainFrame(): Promise<void>;
+    waitForPageReadiness(): Promise<boolean>;
+    isInsideIframe(): Promise<boolean>;
+    getCurrentIframeInfo(): string | null;
+    hasOtherTabs(): boolean;
+    getOtherTabsInfo(): TabInfo[];
+    clearOtherTabsInfo(): void;
+    setUserResolve(userResolveFn: UserResolveFunction): void;
+    listenToStateChanged(): void;
+    stop(): Promise<void>;
+    get activeTest(): Test | null;
+    startTest(test: Test): Promise<boolean>;
+    ensurePageAvailable(): Promise<boolean>;
+    ensureActiveTestPageAvailable(): Promise<boolean>;
+    handleExecutionError(error: unknown): Promise<BrowserExecutionErrorResult>;
+    watchActiveTestPage(page?: any): void;
+    stopTest(test: Test, meta?: Record<string, string>): Promise<void>;
+    unwatchActiveTestPages(): void;
+    hasPlaywrightLocator(locatorFn: (page: any) => any, opts?: {
+        multiple?: boolean;
+        contents?: boolean;
+        success?: (locator: any) => Promise<void> | void;
+    }): Promise<boolean>;
+    playwrightLocatorCount(locatorFn: (page: any) => any): Promise<number>;
+    bindFrameNavigated(page: any): void;
+    openFreshTab(): Promise<void>;
+    closeOtherTabs(): Promise<void>;
+}
+export declare function annotatePageElements(page: any): Promise<{
+    ariaSnapshot: string;
+    elements: WebElement[];
+}>;
+export default Explorer;

package/dist/src/explorer.js

@@ -629,17 +629,21 @@ class Explorer {
             test.setActiveNoteScreenshot(lastScreenshot);
         };
         this.watchActiveTestPage();
-        codeceptjs.event.dispatcher.emit('test.before', codeceptjsTest);
-        codeceptjs.event.dispatcher.emit('test.start', codeceptjsTest);
-        codeceptjs.event.dispatcher.on('step.passed', (step) => stepHandler(step, 'passed'));
-        codeceptjs.event.dispatcher.on('step.failed', (step, error) => {
+        const onStepPassed = (step) => stepHandler(step, 'passed');
+        const onStepFailed = (step, error) => {
             stepHandler(step, 'failed', error?.message || String(error), error?.stack);
-        });
-        codeceptjs.event.dispatcher.on('test.after', () => {
-            codeceptjs.event.dispatcher.off('step.passed', stepHandler);
-            codeceptjs.event.dispatcher.off('step.failed', stepHandler);
+        };
+        const onTestAfter = () => {
+            codeceptjs.event.dispatcher.off('step.passed', onStepPassed);
+            codeceptjs.event.dispatcher.off('step.failed', onStepFailed);
+            codeceptjs.event.dispatcher.off('test.after', onTestAfter);
             this.unwatchActiveTestPages();
-        });
+        };
+        codeceptjs.event.dispatcher.emit('test.before', codeceptjsTest);
+        codeceptjs.event.dispatcher.emit('test.start', codeceptjsTest);
+        codeceptjs.event.dispatcher.on('step.passed', onStepPassed);
+        codeceptjs.event.dispatcher.on('step.failed', onStepFailed);
+        codeceptjs.event.dispatcher.on('test.after', onTestAfter);
         return true;
     }
     async ensurePageAvailable() {

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { ExplorBot } from './explorbot.js';
+export type { ExplorBotOptions, UserResolveFunction } from './explorbot.js';
+export { Plan, Test, TestResult, TestStatus } from './test-plan.js';
+export type { Note, StepData, TestResultType, TestStatusType } from './test-plan.js';
+export type { Link, StateTransition, WebPageState } from './state-manager.js';
+export type { AIConfig, ExplorbotConfig, PlaywrightConfig } from './config.js';