explorbot 0.5.9 → 0.6.0

package/dist/src/components/App.d.ts

@@ -3,7 +3,6 @@ import type { ExplorBot } from '../explorbot.js';
 interface AppProps {
     explorBot: ExplorBot;
     initialShowInput?: boolean;
-    exitOnEmptyInput?: boolean;
 }
-export declare function App({ explorBot, initialShowInput, exitOnEmptyInput }: AppProps): React.JSX.Element;
+export declare function App({ explorBot, initialShowInput }: AppProps): React.JSX.Element;
 export {};

package/dist/src/components/App.js

@@ -13,14 +13,13 @@ import StateTransitionPane from './StateTransitionPane.js';
 import TaskPane, { WINDOW_SIZE } from './TaskPane.js';
 import WelcomeChecklist from './WelcomeChecklist.js';
 import WelcomeCommands from './WelcomeCommands.js';
-export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = false }) {
+export function App({ explorBot, initialShowInput = false }) {
     const sessionStartedAtRef = useRef(Date.now());
     const InputComponent = InputReadline;
     const [showSessionTimer, setShowSessionTimer] = useState(false);
     const [showInput, setShowInput] = useState(initialShowInput);
     const [interruptPrompt, setInterruptPrompt] = useState(null);
     const [currentState, setCurrentState] = useState(null);
-    const [lastTransition, setLastTransition] = useState(null);
     const [tasks, setTasks] = useState([]);
     const tasksRef = useRef([]);
     const [showPlanEditor, setShowPlanEditor] = useState(false);
@@ -50,7 +49,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         const manager = explorBot.stateManager();
         unsubscribe = manager.onStateChange((transition) => {
             if (mounted) {
-                setLastTransition(transition);
                 setCurrentState(transition.toState);
             }
         });

package/dist/src/components/InputPane.js

@@ -7,7 +7,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
     const [cursorPosition, setCursorPosition] = useState(0);
     const [showAutocomplete, setShowAutocomplete] = useState(false);
     const [selectedIndex, setSelectedIndex] = useState(0);
-    const [autoCompleteTriggered, setAutoCompleteTriggered] = useState(false);
     const inputRef = useRef(inputValue);
     const cursorRef = useRef(cursorPosition);
     const addLog = useCallback((entry) => {
@@ -137,7 +136,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                 setShowAutocomplete(false);
                 setSelectedIndex(0);
                 setCursorPosition(selectedCommand.length);
-                setAutoCompleteTriggered(true);
             }
             return;
         }
@@ -152,7 +150,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                 setInputValue(newValue);
                 setCursorPosition(nextCursor);
                 setSelectedIndex(0);
-                setAutoCompleteTriggered(false);
                 setShowAutocomplete(shouldShowAutocomplete(newValue));
             }
             return;
@@ -167,7 +164,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
             setInputValue(newValue);
             setCursorPosition(nextCursor);
             setSelectedIndex(0);
-            setAutoCompleteTriggered(false);
             setShowAutocomplete(shouldShowAutocomplete(newValue));
         }
     }, { isActive });
@@ -199,7 +195,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                     setShowAutocomplete(false);
                     setSelectedIndex(0);
                     setCursorPosition(selectedCommand.length);
-                    setAutoCompleteTriggered(true);
                 }
             }, visible: showAutocomplete })));
 };

package/dist/src/config.d.ts

@@ -106,6 +106,8 @@ interface PlannerAgentConfig extends AgentConfig {
     styles?: string[];
     stylesDir?: string;
     docsWeight?: number;
+    minTests?: number;
+    maxTests?: number;
 }
 interface ScoutAgentConfig extends AgentConfig {
     dirs?: string[];
@@ -219,7 +221,7 @@ interface ExplorbotConfig {
         knowledge: string;
         experience: string;
         output: string;
-        spec?: string;
+        spec?: string | string[];
     };
     experience?: {
         maxReadLines?: number;
@@ -282,7 +284,6 @@ export declare class ConfigParser {
     loadConfigModule(configPath: string): Promise<any>;
     resolveConfig(config: ExplorbotConfig): ExplorbotConfig;
     validateConfig(config: ExplorbotConfig): void;
-    getNestedValue(obj: any, path: string): any;
     mergeWithDefaults(config: Partial<ExplorbotConfig>): ExplorbotConfig;
     ensureDirectory(path: string): void;
 }

package/dist/src/config.js

@@ -29,15 +29,6 @@ export const PROVIDERS = {
 export const MODEL_ROLES = ['model', 'visionModel', 'agenticModel'];
 let cachedOutputRoot = null;
 let runOutputDir = null;
-const config = {
-    playwright: {
-        browser: 'chromium',
-        url: 'http://localhost:3000',
-    },
-    ai: {
-        model: null,
-    },
-};
 export { EXPLORBOT_CONFIG_PATHS };
 export const EXPLORBOT_ENV_VARS = [
     { name: 'EXPLORBOT_AI_PROVIDER', required: true, description: 'Provider name; fills every model role from its recommended models. Turns on config-free mode' },
@@ -50,6 +41,7 @@ export const EXPLORBOT_ENV_VARS = [
     { name: 'EXPLORBOT_EPHEMERAL', description: 'Keep no state between runs — output goes to a fresh temp directory instead of the site dir' },
     { name: 'EXPLORBOT_KNOWLEDGE', description: 'Inline knowledge text, applied to every page' },
     { name: 'EXPLORBOT_KNOWLEDGE_FILE', description: 'Path to a knowledge markdown file' },
+    { name: 'EXPLORBOT_AUTH', description: 'Auth details in free form (credentials, a token), kept in memory for the run and never written to disk; same as --auth', secret: true },
     { name: 'EXPLORBOT_SPEC', description: 'Docbot application spec directory or index.md, used as page knowledge' },
     { name: 'EXPLORBOT_API_SPEC', description: 'OpenAPI spec path for the API boat' },
     { name: 'EXPLORBOT_API_HEADERS', description: 'Headers sent with every API request, one "Name: value" per line', secret: true },
@@ -454,9 +446,6 @@ export class ConfigParser {
             throw new Error(`Invalid URL in configuration: ${url}`);
         }
     }
-    getNestedValue(obj, path) {
-        return path.split('.').reduce((current, key) => current?.[key], obj);
-    }
     mergeWithDefaults(config) {
         const defaults = {
             playwright: {
@@ -559,6 +548,8 @@ export function configuredModels(ai) {
         models.agenticModel = describe(ai.agenticModel);
     if (ai.visionModel)
         models.visionModel = describe(ai.visionModel);
+    if (ai.decisionModel)
+        models.decisionModel = { name: ai.decisionModel.model, provider: ai.decisionModel.provider };
     for (const [agent, agentConfig] of Object.entries(ai.agents || {})) {
         if (agentConfig?.model)
             models[agent] = describe(agentConfig.model);

package/dist/src/explorbot.d.ts

@@ -41,7 +41,7 @@ export interface ExplorBotOptions {
     optionalAi?: boolean;
     reporter?: ReporterConfig;
     attachedBrowser?: Browser;
-    applicationSpec?: string;
+    applicationSpec?: string | string[];
 }
 export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
 export declare class ExplorBot {
@@ -113,8 +113,9 @@ export declare class ExplorBot {
         fresh?: boolean;
         style?: string;
         extend?: Plan;
-        completedPlans?: Plan[];
         noSave?: boolean;
+        minTests?: number;
+        maxTests?: number;
     }): Promise<Plan>;
     getPlansDir(): string;
     savePlan(filename?: string): string | null;

package/dist/src/explorbot.js

@@ -126,7 +126,14 @@ export class ExplorBot {
         await this.visit(this.options.from || '/');
     }
     async visit(url) {
-        await this.agentNavigator().visit(this.configParser.resolveTargetPath(url));
+        const target = this.configParser.resolveTargetPath(url);
+        await this.agentNavigator()
+            .visit(target)
+            .catch(async (err) => {
+            if (await this.agentCaptain().resolveBlocker(err, () => this.agentNavigator().isOn(target)))
+                return;
+            throw err;
+        });
     }
     async openTab() {
         await this.explorer.openTab();
@@ -226,7 +233,7 @@ export class ExplorBot {
             if (this.isHistorianEnabled())
                 this.agents.tester.setHistorian(this.agentHistorian());
             this.agents.tester.setPilot(this.agentPilot());
-            this.agents.tester.setCaptain(this.agentCaptain());
+            this.agents.tester.setSupervisor((input, test) => this.agentCaptain().processSupervisorInterrupt(input, test));
             const fisherman = this.agentFisherman();
             if (fisherman)
                 this.agentPilot().setFisherman(fisherman);
@@ -320,9 +327,14 @@ export class ExplorBot {
     }
     agentScout() {
         const scoutConfig = this.config.ai?.agents?.scout;
-        if (scoutConfig?.enabled !== true)
-            return null;
         const dirs = this.scoutCorpusDirs();
+        const hasSpec = dirs.length > 0;
+        const explicitlyDisabled = scoutConfig?.enabled === false;
+        const explicitlyEnabled = scoutConfig?.enabled === true;
+        if (explicitlyDisabled)
+            return null;
+        if (!explicitlyEnabled && !hasSpec)
+            return null;
         if (dirs.length === 0) {
             tag('warning').log('Scout enabled but no documentation found — set --spec or ai.agents.scout.dirs');
             return null;
@@ -331,12 +343,11 @@ export class ExplorBot {
     }
     scoutCorpusDirs() {
         const dirs = [];
-        const specPath = this.options.applicationSpec || this.config.dirs?.spec;
-        if (specPath) {
+        const specPaths = normalizeSpecPaths(this.options.applicationSpec || this.config.dirs?.spec);
+        for (const specPath of specPaths) {
             const bundle = resolveSpecBundlePath(specPath);
-            const pagesDir = bundle && path.join(bundle, 'pages');
-            if (pagesDir && existsSync(pagesDir))
-                dirs.push(pagesDir);
+            if (bundle && existsSync(bundle))
+                dirs.push(bundle);
         }
         for (const dir of this.config.ai?.agents?.scout?.dirs || []) {
             const resolved = this.configParser.resolveProjectDir(dir);
@@ -372,14 +383,20 @@ export class ExplorBot {
         }
         const planner = this.agentPlanner();
         planner.freshStart = !!opts.fresh;
+        if (opts.minTests !== undefined || opts.maxTests !== undefined) {
+            planner.setTestCount({ minTests: opts.minTests, maxTests: opts.maxTests });
+        }
         if (this.currentPlan) {
             planner.setPlan(this.currentPlan);
         }
         this.lastPlanError = null;
+        const before = new Set(this.currentPlan?.tests ?? []);
         try {
-            this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend, opts.completedPlans));
+            this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend));
         }
         catch (err) {
+            if (await this.agentCaptain().resolveBlocker(err, () => !!this.currentPlan?.tests.some((t) => !before.has(t))))
+                return this.currentPlan;
             this.lastPlanError = err instanceof Error ? err : new Error(String(err));
             tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
             if (!this.currentPlan)
@@ -504,3 +521,8 @@ export class ExplorBot {
         }
     }
 }
+function normalizeSpecPaths(spec) {
+    if (!spec)
+        return [];
+    return Array.isArray(spec) ? spec : [spec];
+}

package/dist/src/explorer.js

@@ -148,7 +148,6 @@ class Explorer {
         if (!(await this.recoverOrRestart())) {
             return { ok: false, action: 'stop', message: 'Browser page could not be recovered' };
         }
-        this.watchActiveTestPage();
         return { ok: true, action: 'continue', recovered: true, message: 'Browser page was recovered' };
     }
     async beginTest(test) {
@@ -157,7 +156,7 @@ class Explorer {
         }
         this._activeTest = test;
         test.start();
-        await this.reporter.reportTestStart(test);
+        await this.reporter.reportTestStart();
         await this.closeOtherTabs();
         this.stateManager.otherTabs = [];
         const codeceptjsTest = toCodeceptjsTest(test);
@@ -340,7 +339,7 @@ class Explorer {
     }
     async runWithRecovery(label, operation) {
         if (!this.page && !(await this.recoverOrRestart())) {
-            throw new Error(`Browser page is unavailable before ${label}`);
+            throw new BrowserRecoveryError(label, new Error('Browser page is unavailable'), false);
         }
         try {
             return await operation();
@@ -432,7 +431,6 @@ class Explorer {
         if (!(await this.recoverOrRestart())) {
             return { ok: false, action: 'stop', recovered: false, message: `Browser could not be recovered after fatal error: ${message}` };
         }
-        this.watchActiveTestPage();
         return {
             ok: true,
             action: 'continue',
@@ -446,9 +444,10 @@ class Explorer {
         };
     }
     async recoverOrRestart() {
-        if (await this.recoverPage())
-            return true;
-        return this.restartBrowser();
+        if (!(await this.recoverPage()) && !(await this.restartBrowser()))
+            return false;
+        this.watchActiveTestPage();
+        return true;
     }
     async recoverPage() {
         try {

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

@@ -5,7 +5,7 @@ export declare class KnowledgeTracker {
     knowledgeFiles: Knowledge[];
     sessionKnowledge: Knowledge[];
     isLoaded: boolean;
-    applicationSpec?: ApplicationSpec;
+    applicationSpecs: ApplicationSpec[];
     static appendSessionKnowledge(text: string): void;
     static resetSessionKnowledge(): void;
     constructor(options?: KnowledgeTrackerOptions);
@@ -48,6 +48,6 @@ export interface Knowledge {
     [key: string]: any;
 }
 export interface KnowledgeTrackerOptions {
-    applicationSpec?: string;
+    applicationSpec?: string | string[];
     knowledgeDir?: string;
 }

package/dist/src/knowledge-tracker.js

@@ -19,7 +19,7 @@ export class KnowledgeTracker {
     knowledgeFiles = [];
     sessionKnowledge = [];
     isLoaded = false;
-    applicationSpec;
+    applicationSpecs = [];
     static appendSessionKnowledge(text) {
         sessionEntries.push(text);
     }
@@ -39,9 +39,15 @@ export class KnowledgeTracker {
         if (!existsSync(this.knowledgeDir)) {
             mkdirSync(this.knowledgeDir, { recursive: true });
         }
-        if (specPath) {
-            this.applicationSpec = new ApplicationSpec(specPath);
-            tag('info').log(`Loaded application spec with ${this.applicationSpec.pageCount} documented pages`);
+        for (const p of normalizeSpecPaths(specPath)) {
+            const spec = new ApplicationSpec(p);
+            this.applicationSpecs.push(spec);
+            if (spec.pageCount > 0) {
+                tag('info').log(`Loaded application spec with ${spec.pageCount} documented pages`);
+            }
+            else if (spec.markdownFileCount > 0) {
+                tag('info').log(`Loaded spec corpus with ${spec.markdownFileCount} markdown files`);
+            }
         }
         this.sessionKnowledge = sessionEntries.map((entry, index) => {
             const parsed = matter(entry);
@@ -77,10 +83,11 @@ export class KnowledgeTracker {
         return [this.renderRelevantKnowledge(state), this.renderApplicationSpec(state)].filter(Boolean).join('\n\n');
     }
     renderApplicationSpec(state) {
-        return this.applicationSpec?.renderFor(state) || '';
+        const parts = this.applicationSpecs.map((spec) => spec.renderFor(state)).filter(Boolean);
+        return parts.join('\n\n');
     }
     applicationSpecUrls(state) {
-        return this.applicationSpec?.matchedUrls(state) || [];
+        return this.applicationSpecs.flatMap((spec) => spec.matchedUrls(state));
     }
     addKnowledge(urlPattern, description, opts) {
         const configParser = ConfigParser.getInstance();
@@ -236,3 +243,8 @@ export class KnowledgeTracker {
     `;
     }
 }
+function normalizeSpecPaths(spec) {
+    if (!spec)
+        return [];
+    return Array.isArray(spec) ? spec : [spec];
+}

package/dist/src/playwright-recorder.d.ts

@@ -8,7 +8,6 @@ export interface VerificationStep {
     args: any[];
 }
 export declare class PlaywrightRecorder {
-    context: any;
     tracing: any;
     active: boolean;
     nextGroupId: number;

package/dist/src/playwright-recorder.js

@@ -23,7 +23,6 @@ function getAsLocator() {
     return cachedAsLocator;
 }
 export class PlaywrightRecorder {
-    context = null;
     tracing = null;
     active = false;
     nextGroupId = 0;
@@ -52,7 +51,6 @@ export class PlaywrightRecorder {
             debugLog('start: no tracing on browserContext, recorder inactive');
             return;
         }
-        this.context = browserContext;
         this.tracing = browserContext.tracing;
         try {
             await this.tracing.start({});

package/dist/src/reporter.d.ts

@@ -22,7 +22,7 @@ export declare class Reporter {
     configureMarkdownPipe(): void;
     configureRunGroup(runGroup: string | null | undefined): void;
     startRun(): Promise<void>;
-    reportTestStart(test: Test): Promise<void>;
+    reportTestStart(): Promise<void>;
     combineStepsAndNotes(test: Test, lastScreenshotFile?: string): Step[];
     buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined;
     reportTest(test: Test, meta?: ReporterMeta): Promise<void>;

package/dist/src/reporter.js

@@ -106,13 +106,13 @@ export class Reporter {
         process.env.TESTOMATIO_STACK_PASSED = 'true';
         process.env.TESTOMATIO_STEPS_PASSED = 'true';
     }
-    async reportTestStart(test) {
+    async reportTestStart() {
         await this.startRun();
     }
     combineStepsAndNotes(test, lastScreenshotFile) {
         const noteEntries = Object.entries(test.notes)
             .filter(([, note]) => !note.observation)
-            .map(([timestampKey, note]) => ({
+            .map(([, note]) => ({
             startTime: note.startTime,
             endTime: note.endTime,
             message: note.message,
@@ -122,7 +122,7 @@ export class Reporter {
         }))
             .sort((a, b) => a.startTime - b.startTime);
         const stepEntries = Object.entries(test.steps)
-            .map(([timestampKey, stepData]) => ({
+            .map(([, stepData]) => ({
             noteStartTime: stepData.noteStartTime,
             text: stepData.text,
             duration: stepData.duration,

package/dist/src/test-plan.js

@@ -461,7 +461,7 @@ export class Plan {
         if (!plansDir)
             dirs.push(...listSitePlanDirs());
         for (const dir of dirs) {
-            const filePath = names.map((name) => path.resolve(dir, name)).find(existsSync);
+            const filePath = names.map((name) => path.resolve(dir, name)).find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
             if (filePath)
                 return filePath;
         }

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

@@ -11,3 +11,20 @@ export declare class ErrorPageError extends Error {
     readonly httpStatus?: number;
     constructor(url: string, title?: string, httpStatus?: number);
 }
+export declare class BlockedError extends Error {
+    readonly url: string;
+    readonly blocker: string;
+    readonly request: string;
+    constructor(message: string, url: string, blocker: string, request: string);
+}
+export declare class PlanningBlockedError extends BlockedError {
+    readonly feature?: string;
+    readonly style?: string;
+    constructor(url: string, prerequisite: string, feature?: string, style?: string);
+}
+export declare class NavigationBlockedError extends BlockedError {
+    constructor(url: string, currentUrl: string, reason: string, tried: string[]);
+}
+export declare class TestStartBlockedError extends BlockedError {
+    constructor(scenario: string, url: string, currentUrl: string);
+}

package/dist/src/utils/error-page.js

@@ -1,5 +1,6 @@
+import dedent from 'dedent';
 import { ActionResult } from '../action-result.js';
-import { isBodyEmpty } from './html.js';
+import { isBodyEmpty, sanitizeHtmlString } from './html.js';
 import { extractStatePath } from './url-matcher.js';
 const HTTP_ERRORS = ['400 Bad Request', '401 Unauthorized', '403 Forbidden', '404 Not Found', '405 Method Not Allowed', '408 Request Timeout', '500 Internal Server Error', '502 Bad Gateway', '503 Service Unavailable', '504 Gateway Timeout'];
 const SMALL_PAGE_THRESHOLD = 500;
@@ -27,7 +28,7 @@ export function detectPageCondition(actionResult) {
     }
     if (!actionResult.html || isBodyEmpty(actionResult.html))
         return 'loading';
-    const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    const bodyMatch = sanitizeHtmlString(actionResult.html).match(/<body[^>]*>([\s\S]*?)<\/body>/i);
     if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD)
         return 'loading';
     return 'ok';
@@ -62,3 +63,53 @@ export class ErrorPageError extends Error {
         this.name = 'ErrorPageError';
     }
 }
+export class BlockedError extends Error {
+    url;
+    blocker;
+    request;
+    constructor(message, url, blocker, request) {
+        super(message);
+        this.url = url;
+        this.blocker = blocker;
+        this.request = request;
+        this.name = 'BlockedError';
+    }
+}
+export class PlanningBlockedError extends BlockedError {
+    feature;
+    style;
+    constructor(url, prerequisite, feature, style) {
+        let focus = '';
+        if (feature)
+            focus = ` focused on "${feature}"`;
+        let styleNote = '';
+        if (style)
+            styleNote = ` in ${style} style`;
+        super(`Planner could not plan ${url}: ${prerequisite}`, url, prerequisite, dedent `
+        Planner was asked to plan tests for ${url}${focus}${styleNote} but stopped: ${prerequisite}.
+        Look at the current page to find out what blocks planning, resolve it, then call plan() to re-plan this page. If it cannot be resolved, finish without planning.
+      `);
+        this.feature = feature;
+        this.style = style;
+        this.name = 'PlanningBlockedError';
+    }
+}
+export class NavigationBlockedError extends BlockedError {
+    constructor(url, currentUrl, reason, tried) {
+        const lines = [`Navigator was asked to open ${url} but stopped on ${currentUrl}: ${reason}.`];
+        if (tried.length)
+            lines.push(`Already tried: ${tried.join('; ')}.`);
+        lines.push(`Look at the current page to find out what keeps it from ${url}, resolve it, then open ${url}. If it cannot be resolved, finish without opening it.`);
+        super(`Navigation to ${url} failed: ${reason}`, url, reason, lines.join('\n'));
+        this.name = 'NavigationBlockedError';
+    }
+}
+export class TestStartBlockedError extends BlockedError {
+    constructor(scenario, url, currentUrl) {
+        super(`Test "${scenario}" could not start: ${currentUrl} is not the page it starts on`, url, 'not the start page of this test', dedent `
+        Tester was asked to start the test "${scenario}" at ${url}, but the page open at ${currentUrl} is not where this test can start.
+        Look at the current page to find out what keeps the test from starting, resolve it, then open ${url}. When you finish, the test runs again from ${url}. If it cannot be resolved, finish and the test is skipped.
+      `);
+        this.name = 'TestStartBlockedError';
+    }
+}

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

@@ -1,4 +1,3 @@
-import type { HtmlConfig } from '../config.js';
 export interface HtmlDiffPart {
     container: string;
     subtree: string;
@@ -21,7 +20,7 @@ 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>;
+export declare function htmlDiff(originalHtml: string, modifiedHtml: string): Promise<HtmlDiffResult>;
 /**
  * Text the app announced across a navigation. Only live regions: everything else on a new page is its content, not a message.
  */

package/dist/src/utils/html-diff.js

@@ -138,9 +138,9 @@ export function computeHtmlFingerprint(html) {
 /**
  * Compares two HTML documents and returns differences along with a diff subtree.
  */
-export async function htmlDiff(originalHtml, modifiedHtml, htmlConfig) {
-    const originalDocument = parseDocument(originalHtml, htmlConfig);
-    const modifiedDocument = parseDocument(modifiedHtml, htmlConfig);
+export async function htmlDiff(originalHtml, modifiedHtml) {
+    const originalDocument = parseDocument(originalHtml);
+    const modifiedDocument = parseDocument(modifiedHtml);
     const originalRoot = getRootNodeForFlatten(originalDocument);
     const modifiedRoot = getRootNodeForFlatten(modifiedDocument);
     const originalLines = flattenHtml(originalRoot);
@@ -229,7 +229,7 @@ function isLiveRegion(element) {
  * Parse HTML into a document, wrapping fragments with html/body for consistency.
  * Uses custom sanitization that removes iframes for diff purposes.
  */
-function parseDocument(html, htmlConfig) {
+function parseDocument(html) {
     const document = parse(html);
     const documentTitle = getDocumentTitle(document);
     sanitizeDocumentTreeForDiff(document);
@@ -336,34 +336,6 @@ const attributesDiffer = (current, previous) => {
     }
     return false;
 };
-const getDirectTextValues = (element) => {
-    if (!element.childNodes || element.childNodes.length === 0) {
-        return [];
-    }
-    const values = [];
-    for (const child of element.childNodes) {
-        if (child.nodeName === '#text') {
-            const value = child.value.trim();
-            if (value.length > 0) {
-                values.push(value);
-            }
-        }
-    }
-    return values;
-};
-const directTextDiffer = (current, previous) => {
-    const currentText = getDirectTextValues(current);
-    const previousText = getDirectTextValues(previous);
-    if (currentText.length !== previousText.length) {
-        return true;
-    }
-    for (let i = 0; i < currentText.length; i++) {
-        if (currentText[i] !== previousText[i]) {
-            return true;
-        }
-    }
-    return false;
-};
 function filterContainerClasses(classes) {
     return classes
         .filter((cls) => !/\d/.test(cls))
@@ -654,18 +626,6 @@ function findHtmlElement(document) {
     }
     return null;
 }
-function findHeadElement(document) {
-    const html = findHtmlElement(document);
-    if (!html || !html.childNodes) {
-        return null;
-    }
-    for (const node of html.childNodes) {
-        if ('tagName' in node && node.tagName && node.tagName.toLowerCase() === 'head') {
-            return node;
-        }
-    }
-    return null;
-}
 function findBodyElement(document) {
     const html = findHtmlElement(document);
     if (!html || !html.childNodes) {