explorbot 0.5.9 → 0.6.0

package/src/components/App.tsx

@@ -3,14 +3,13 @@ import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { CommandHandler } from '../command-handler.js';
 import type { ExplorbotConfig } from '../config.js';
 import { executionController } from '../execution-controller.ts';
-import type { ExplorBot, ExplorBotOptions } from '../explorbot.ts';
+import type { ExplorBot } from '../explorbot.ts';
 import type { KnowledgeTracker } from '../knowledge-tracker.js';
 import type { StateTransition, WebPageState } from '../state-manager.js';
 import { Test } from '../test-plan.ts';
 import { tag } from '../utils/logger.js';
 import ActivityPane from './ActivityPane.js';
 import Autocomplete from './Autocomplete.js';
-import InputPane from './InputPane.js';
 import InputReadline from './InputReadline.js';
 import LogPane from './LogPane.js';
 import PlanEditor from './PlanEditor.js';
@@ -23,17 +22,15 @@ import WelcomeCommands from './WelcomeCommands.js';
 interface AppProps {
   explorBot: ExplorBot;
   initialShowInput?: boolean;
-  exitOnEmptyInput?: boolean;
 }
 
-export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = false }: AppProps) {
+export function App({ explorBot, initialShowInput = false }: AppProps) {
   const sessionStartedAtRef = useRef<number>(Date.now());
   const InputComponent = InputReadline;
   const [showSessionTimer, setShowSessionTimer] = useState(false);
   const [showInput, setShowInput] = useState(initialShowInput);
   const [interruptPrompt, setInterruptPrompt] = useState<string | null>(null);
   const [currentState, setCurrentState] = useState<WebPageState | null>(null);
-  const [lastTransition, setLastTransition] = useState<StateTransition | null>(null);
   const [tasks, setTasks] = useState<Test[]>([]);
   const tasksRef = useRef<Test[]>([]);
   const [showPlanEditor, setShowPlanEditor] = useState(false);
@@ -72,7 +69,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
 
     unsubscribe = manager.onStateChange((transition: StateTransition) => {
       if (mounted) {
-        setLastTransition(transition);
         setCurrentState(transition.toState);
       }
     });

package/src/components/InputPane.tsx

@@ -19,7 +19,6 @@ const InputPane: React.FC<InputPaneProps> = ({ commandHandler, exitOnEmptyInput
   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);
 
@@ -166,7 +165,6 @@ const InputPane: React.FC<InputPaneProps> = ({ commandHandler, exitOnEmptyInput
           setShowAutocomplete(false);
           setSelectedIndex(0);
           setCursorPosition(selectedCommand.length);
-          setAutoCompleteTriggered(true);
         }
         return;
       }
@@ -182,7 +180,6 @@ const InputPane: React.FC<InputPaneProps> = ({ commandHandler, exitOnEmptyInput
           setInputValue(newValue);
           setCursorPosition(nextCursor);
           setSelectedIndex(0);
-          setAutoCompleteTriggered(false);
           setShowAutocomplete(shouldShowAutocomplete(newValue));
         }
         return;
@@ -198,7 +195,6 @@ const InputPane: React.FC<InputPaneProps> = ({ commandHandler, exitOnEmptyInput
         setInputValue(newValue);
         setCursorPosition(nextCursor);
         setSelectedIndex(0);
-        setAutoCompleteTriggered(false);
         setShowAutocomplete(shouldShowAutocomplete(newValue));
       }
     },
@@ -247,7 +243,6 @@ const InputPane: React.FC<InputPaneProps> = ({ commandHandler, exitOnEmptyInput
             setShowAutocomplete(false);
             setSelectedIndex(0);
             setCursorPosition(selectedCommand.length);
-            setAutoCompleteTriggered(true);
           }
         }}
         visible={showAutocomplete}

package/src/config.ts

@@ -132,6 +132,8 @@ interface PlannerAgentConfig extends AgentConfig {
   styles?: string[];
   stylesDir?: string;
   docsWeight?: number;
+  minTests?: number;
+  maxTests?: number;
 }
 
 interface ScoutAgentConfig extends AgentConfig {
@@ -245,7 +247,7 @@ interface ExplorbotConfig {
     knowledge: string;
     experience: string;
     output: string;
-    spec?: string;
+    spec?: string | string[];
   };
   experience?: {
     maxReadLines?: number;
@@ -258,17 +260,6 @@ interface ExplorbotConfig {
   dynamicPageRegex?: string;
 }
 
-const config: ExplorbotConfig = {
-  playwright: {
-    browser: 'chromium',
-    url: 'http://localhost:3000',
-  },
-
-  ai: {
-    model: null as any,
-  },
-};
-
 type RuleEntry = string | Record<string, string>;
 
 export { EXPLORBOT_CONFIG_PATHS };
@@ -284,6 +275,7 @@ export const EXPLORBOT_ENV_VARS: EnvVar[] = [
   { 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 },
@@ -762,10 +754,6 @@ export class ConfigParser {
     }
   }
 
-  private getNestedValue(obj: any, path: string): any {
-    return path.split('.').reduce((current, key) => current?.[key], obj);
-  }
-
   public mergeWithDefaults(config: Partial<ExplorbotConfig>): ExplorbotConfig {
     const defaults = {
       playwright: {
@@ -878,6 +866,7 @@ export function configuredModels(ai?: AIConfig): Record<string, ConfiguredModel>
   const models: Record<string, ConfiguredModel> = { model: describe(ai.model) };
   if (ai.agenticModel) 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/src/experience-tracker.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import matter from 'gray-matter';
 import type { ActionResult } from './action-result.js';

package/src/explorbot.ts

@@ -55,7 +55,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>;
@@ -156,7 +156,13 @@ export class ExplorBot {
   }
 
   async visit(url: string): Promise<void> {
-    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(): Promise<void> {
@@ -274,7 +280,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: string, test: Test) => this.agentCaptain().processSupervisorInterrupt(input, test));
 
       const fisherman = this.agentFisherman();
       if (fisherman) this.agentPilot().setFisherman(fisherman);
@@ -377,9 +383,14 @@ export class ExplorBot {
 
   agentScout(): Scout | null {
     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;
@@ -391,11 +402,10 @@ export class ExplorBot {
   private scoutCorpusDirs(): string[] {
     const dirs: string[] = [];
 
-    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 || []) {
@@ -423,7 +433,7 @@ export class ExplorBot {
     this.agents.planner = undefined;
   }
 
-  async plan(feature?: string, opts: { fresh?: boolean; style?: string; extend?: Plan; completedPlans?: Plan[]; noSave?: boolean } = {}) {
+  async plan(feature?: string, opts: { fresh?: boolean; style?: string; extend?: Plan; noSave?: boolean; minTests?: number; maxTests?: number } = {}) {
     this.planFeature = feature;
 
     if (opts.fresh) {
@@ -440,13 +450,18 @@ 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) return undefined;
@@ -575,3 +590,8 @@ export class ExplorBot {
     }
   }
 }
+
+function normalizeSpecPaths(spec: string | string[] | undefined): string[] {
+  if (!spec) return [];
+  return Array.isArray(spec) ? spec : [spec];
+}

package/src/explorer.ts

@@ -17,7 +17,7 @@ import type { KnowledgeTracker } from './knowledge-tracker.js';
 import type { PlaywrightRecorder } from './playwright-recorder.ts';
 import type { Reporter } from './reporter.ts';
 import type { StateManager } from './state-manager.js';
-import { Test, TestResult } from './test-plan.ts';
+import { Test } from './test-plan.ts';
 import { BrowserRecoveryError, browserErrorMessage, isFatalBrowserError, isNavigationTransitionError } from './utils/browser-errors.ts';
 import { createDebug, log, tag } from './utils/logger.js';
 import { sleep, waitForPageReadiness } from './utils/page-readiness.ts';
@@ -190,7 +190,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' };
   }
 
@@ -201,7 +200,7 @@ class Explorer {
 
     this._activeTest = test;
     test.start();
-    await this.reporter.reportTestStart(test);
+    await this.reporter.reportTestStart();
     await this.closeOtherTabs();
     this.stateManager.otherTabs = [];
 
@@ -414,7 +413,7 @@ class Explorer {
 
   private async runWithRecovery<T>(label: string, operation: () => Promise<T>): Promise<T> {
     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 {
@@ -516,7 +515,6 @@ class Explorer {
       return { ok: false, action: 'stop', recovered: false, message: `Browser could not be recovered after fatal error: ${message}` };
     }
 
-    this.watchActiveTestPage();
     return {
       ok: true,
       action: 'continue',
@@ -531,8 +529,9 @@ class Explorer {
   }
 
   private async recoverOrRestart(): Promise<boolean> {
-    if (await this.recoverPage()) return true;
-    return this.restartBrowser();
+    if (!(await this.recoverPage()) && !(await this.restartBrowser())) return false;
+    this.watchActiveTestPage();
+    return true;
   }
 
   private async recoverPage(): Promise<boolean> {

package/src/knowledge-tracker.ts

@@ -22,7 +22,7 @@ export class KnowledgeTracker {
   private knowledgeFiles: Knowledge[] = [];
   private sessionKnowledge: Knowledge[] = [];
   private isLoaded = false;
-  private applicationSpec?: ApplicationSpec;
+  private applicationSpecs: ApplicationSpec[] = [];
 
   static appendSessionKnowledge(text: string): void {
     sessionEntries.push(text);
@@ -49,9 +49,14 @@ export class KnowledgeTracker {
       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) => {
@@ -99,11 +104,12 @@ export class KnowledgeTracker {
   }
 
   renderApplicationSpec(state: ActionResult): string {
-    return this.applicationSpec?.renderFor(state) || '';
+    const parts = this.applicationSpecs.map((spec) => spec.renderFor(state)).filter(Boolean);
+    return parts.join('\n\n');
   }
 
   applicationSpecUrls(state: ActionResult): string[] {
-    return this.applicationSpec?.matchedUrls(state) || [];
+    return this.applicationSpecs.flatMap((spec) => spec.matchedUrls(state));
   }
 
   addKnowledge(urlPattern: string, description: string, opts?: { replace?: boolean }): { filename: string; filePath: string; isNewFile: boolean } {
@@ -293,6 +299,11 @@ export class KnowledgeTracker {
   }
 }
 
+function normalizeSpecPaths(spec: string | string[] | undefined): string[] {
+  if (!spec) return [];
+  return Array.isArray(spec) ? spec : [spec];
+}
+
 export interface Knowledge {
   filePath: string;
   url?: string;
@@ -302,6 +313,6 @@ export interface Knowledge {
 }
 
 export interface KnowledgeTrackerOptions {
-  applicationSpec?: string;
+  applicationSpec?: string | string[];
   knowledgeDir?: string;
 }

package/src/playwright-recorder.ts

@@ -39,7 +39,6 @@ export interface VerificationStep {
 }
 
 export class PlaywrightRecorder {
-  private context: any = null;
   private tracing: any = null;
   private active = false;
   private nextGroupId = 0;
@@ -68,7 +67,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/src/reporter.ts

@@ -1,4 +1,3 @@
-import { join } from 'node:path';
 import { Client } from '@testomatio/reporter';
 import type { Step } from '@testomatio/reporter/types/types.js';
 import { outputPath } from './config.js';
@@ -132,14 +131,14 @@ export class Reporter {
     process.env.TESTOMATIO_STEPS_PASSED = 'true';
   }
 
-  async reportTestStart(test: Test): Promise<void> {
+  async reportTestStart(): Promise<void> {
     await this.startRun();
   }
 
   protected combineStepsAndNotes(test: Test, lastScreenshotFile?: string): Step[] {
     const noteEntries = Object.entries(test.notes)
       .filter(([, note]) => !note.observation)
-      .map(([timestampKey, note]) => ({
+      .map(([, note]) => ({
         startTime: note.startTime,
         endTime: note.endTime,
         message: note.message,
@@ -150,7 +149,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/src/test-plan.ts

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
-import figures from 'figures';
 import type { ActionResult } from './action-result.ts';
 import { listSitePlanDirs } from './global-config.ts';
 import { WebPageState } from './state-manager.ts';
@@ -545,7 +544,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;
     }
     return null;

package/src/utils/error-page.ts

@@ -1,6 +1,7 @@
+import dedent from 'dedent';
 import { ActionResult } from '../action-result.js';
 import type { WebPageState } from '../state-manager.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'];
@@ -33,7 +34,7 @@ export function detectPageCondition(actionResult: ActionResult): PageCondition {
 
   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';
@@ -67,3 +68,64 @@ export class ErrorPageError extends Error {
     this.name = 'ErrorPageError';
   }
 }
+
+export class BlockedError extends Error {
+  constructor(
+    message: string,
+    public readonly url: string,
+    public readonly blocker: string,
+    public readonly request: string
+  ) {
+    super(message);
+    this.name = 'BlockedError';
+  }
+}
+
+export class PlanningBlockedError extends BlockedError {
+  constructor(
+    url: string,
+    prerequisite: string,
+    public readonly feature?: string,
+    public readonly style?: string
+  ) {
+    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.name = 'PlanningBlockedError';
+  }
+}
+
+export class NavigationBlockedError extends BlockedError {
+  constructor(url: string, currentUrl: string, reason: string, tried: string[]) {
+    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: string, url: string, currentUrl: string) {
+    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/src/utils/html-diff.ts

@@ -1,6 +1,5 @@
 import { parse, serialize } from 'parse5';
 import type * as parse5TreeAdapter from 'parse5/lib/tree-adapters/default';
-import type { HtmlConfig } from '../config.ts';
 import { isTailwindClass, isTrashClass, minifyHtml } from './html.ts';
 import { isDynamicId, isGenericClass } from './xpath.ts';
 
@@ -203,9 +202,9 @@ export function computeHtmlFingerprint(html: string): string[] {
 /**
  * Compares two HTML documents and returns differences along with a diff subtree.
  */
-export async function htmlDiff(originalHtml: string, modifiedHtml: string, htmlConfig?: HtmlConfig): Promise<HtmlDiffResult> {
-  const originalDocument = parseDocument(originalHtml, htmlConfig);
-  const modifiedDocument = parseDocument(modifiedHtml, htmlConfig);
+export async function htmlDiff(originalHtml: string, modifiedHtml: string): Promise<HtmlDiffResult> {
+  const originalDocument = parseDocument(originalHtml);
+  const modifiedDocument = parseDocument(modifiedHtml);
 
   const originalRoot = getRootNodeForFlatten(originalDocument);
   const modifiedRoot = getRootNodeForFlatten(modifiedDocument);
@@ -308,7 +307,7 @@ function isLiveRegion(element: ElementNode): boolean {
  * Parse HTML into a document, wrapping fragments with html/body for consistency.
  * Uses custom sanitization that removes iframes for diff purposes.
  */
-function parseDocument(html: string, htmlConfig?: HtmlConfig): DocumentNode {
+function parseDocument(html: string): DocumentNode {
   const document = parse(html);
   const documentTitle = getDocumentTitle(document);
   sanitizeDocumentTreeForDiff(document);
@@ -432,42 +431,6 @@ const attributesDiffer = (current: ElementNode, previous: ElementNode): boolean
   return false;
 };
 
-const getDirectTextValues = (element: ElementNode): string[] => {
-  if (!element.childNodes || element.childNodes.length === 0) {
-    return [];
-  }
-
-  const values: string[] = [];
-
-  for (const child of element.childNodes) {
-    if (child.nodeName === '#text') {
-      const value = (child as parse5TreeAdapter.TextNode).value.trim();
-      if (value.length > 0) {
-        values.push(value);
-      }
-    }
-  }
-
-  return values;
-};
-
-const directTextDiffer = (current: ElementNode, previous: ElementNode): boolean => {
-  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: string[]): string[] {
   return classes
     .filter((cls) => !/\d/.test(cls))
@@ -792,21 +755,6 @@ function findHtmlElement(document: DocumentNode): ElementNode | null {
   return null;
 }
 
-function findHeadElement(document: DocumentNode): ElementNode | null {
-  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 as ElementNode;
-    }
-  }
-
-  return null;
-}
-
 function findBodyElement(document: DocumentNode): ElementNode | null {
   const html = findHtmlElement(document);
   if (!html || !html.childNodes) {

package/src/utils/html.ts

@@ -1,4 +1,3 @@
-import dedent from 'dedent';
 import { minify } from 'html-minifier-next';
 import { parse, parseFragment, serialize } from 'parse5';
 import type * as parse5TreeAdapter from 'parse5/lib/tree-adapters/default';