explorbot 0.5.3 → 0.5.5

package/dist/src/ai/rules.js

@@ -138,6 +138,13 @@ export const formRequirementsRule = dedent `
   Before filling a form that persists data (create/update), read each control's requirements (required, type/format, length, placeholder/aria-describedby hints) from <page_aria> and page HTML — call context() if not visible — and enter values that satisfy them. Search/filter/sort forms that only change the view do not need this.
   </form_requirements>
 `;
+export const credentialsRule = dedent `
+  <credentials>
+  Sign in to an existing account only with credentials present in the provided context (message, knowledge, experience).
+  Never invent, guess, or try default, common, or placeholder credentials for an existing account.
+  If the required credentials are not provided, call stop() and name what is missing — do not submit the form.
+  </credentials>
+`;
 // in rage mode we do not protect from irreversible actions
 export const protectionRule = dedent `
   <important>

package/dist/src/ai/tools.js

@@ -91,7 +91,7 @@ export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
                 const attempts = [];
                 let ambiguityError = null;
                 for (let i = 0; i < commands.length; i++) {
-                    const command = transformContainsCommand(commands[i]);
+                    let command = transformContainsCommand(commands[i]);
                     let success = await action.attempt(command, explanation);
                     const attempt = { command, success };
                     if (action.lastError)
@@ -104,9 +104,14 @@ export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
                             const index = await judge.pick(PICK_ELEMENT_QUESTION, labels, { intent: explanation, task: task.description });
                             if (index)
                                 success = await action.attemptExactElementIndex(command, index, explanation);
+                            if (success)
+                                command = action.executedSteps.map((step) => step.command).join('\n') || command;
                         }
                     }
                     if (success) {
+                        attempt.command = command;
+                        attempt.success = true;
+                        attempt.error = undefined;
                         const toolResult = await ActionResult.fromState(stateManager.getCurrentState()).toToolResult(previousState, command);
                         if (!hasObservablePageChange(toolResult)) {
                             activeNote.commit(TestResult.FAILED);

package/dist/src/explorbot.js

@@ -125,7 +125,7 @@ export class ExplorBot {
         await this.visit(this.options.from || '/');
     }
     async visit(url) {
-        return this.agentNavigator().visit(this.configParser.resolveTargetPath(url));
+        await this.agentNavigator().visit(this.configParser.resolveTargetPath(url));
     }
     async openTab() {
         await this.explorer.openTab();

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

@@ -33,6 +33,17 @@ export declare class ActiveNote {
     getMessage(): string;
     getStartTime(): number;
 }
+export type SettledStatus = 'passed' | 'failed' | 'unverified' | 'contradiction';
+export declare class SettledExpectation {
+    readonly text: string;
+    readonly status: SettledStatus;
+    readonly evidence?: string;
+    readonly resolution?: string;
+    constructor(text: string, status: SettledStatus, evidence?: string, resolution?: string);
+    get failed(): boolean;
+    get contradicted(): boolean;
+    resolve(status: SettledStatus, resolution: string): SettledExpectation;
+}
 export interface StepData {
     text: string;
     duration?: number;

package/dist/src/test-plan.js

@@ -41,6 +41,27 @@ export class ActiveNote {
         return this.startTime;
     }
 }
+export class SettledExpectation {
+    text;
+    status;
+    evidence;
+    resolution;
+    constructor(text, status, evidence, resolution) {
+        this.text = text;
+        this.status = status;
+        this.evidence = evidence;
+        this.resolution = resolution;
+    }
+    get failed() {
+        return this.status === 'failed';
+    }
+    get contradicted() {
+        return this.status === 'contradiction';
+    }
+    resolve(status, resolution) {
+        return new SettledExpectation(this.text, status, this.evidence, resolution);
+    }
+}
 export class Task {
     id;
     description;

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

@@ -1 +1,2 @@
 export declare function extractCodeBlocks(aiResponse: string): string[];
+export declare function splitTopLevel(code: string, separator: string): string[];

package/dist/src/utils/code-extractor.js

@@ -1,6 +1,9 @@
 import { createDebug } from './logger.js';
 const debugLog = createDebug('explorbot:code-extractor');
 const JS_LANGUAGES = new Set(['', 'js', 'javascript']);
+const QUOTES = ["'", '"', '`'];
+const OPENING_BRACKETS = ['(', '[', '{'];
+const CLOSING_BRACKETS = [')', ']', '}'];
 export function extractCodeBlocks(aiResponse) {
     const codeBlockRegex = /```([^\n`]*)\n([\s\S]*?)\n```/g;
     const codeBlocks = [];
@@ -22,3 +25,40 @@ export function extractCodeBlocks(aiResponse) {
     }
     return codeBlocks;
 }
+export function splitTopLevel(code, separator) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let quote = '';
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        if (quote) {
+            current += char;
+            if (char === '\\')
+                current += code[++i] || '';
+            if (char === quote)
+                quote = '';
+            continue;
+        }
+        if (char === '/' && code[i + 1] === '/') {
+            while (i + 1 < code.length && code[i + 1] !== '\n')
+                i++;
+            continue;
+        }
+        if (char === separator && depth <= 0) {
+            parts.push(current);
+            current = '';
+            depth = 0;
+            continue;
+        }
+        current += char;
+        if (QUOTES.includes(char))
+            quote = char;
+        if (OPENING_BRACKETS.includes(char))
+            depth++;
+        if (CLOSING_BRACKETS.includes(char))
+            depth--;
+    }
+    parts.push(current);
+    return parts;
+}

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

@@ -3,6 +3,7 @@ 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 isLoginPage(actionResult: ActionResult): boolean;
 export declare function getStateErrorPageError(state: WebPageState | null | undefined): ErrorPageError | null;
 export declare class ErrorPageError extends Error {
     readonly url: string;

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

@@ -1,8 +1,11 @@
 import { ActionResult } from '../action-result.js';
 import { isBodyEmpty } 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;
 const LOADING_WORD = /\bloading\b/i;
+const PASSWORD_INPUT = /<input\b[^>]*\btype\s*=\s*["']?password\b/i;
+const AUTH_PATH = /\b(log[-_]?in|sign[-_]?in|auth)\b/i;
 export function detectPageCondition(actionResult) {
     if (actionResult.httpStatus && actionResult.httpStatus >= 400)
         return 'error';
@@ -32,6 +35,11 @@ export function detectPageCondition(actionResult) {
 export function isErrorPage(actionResult) {
     return detectPageCondition(actionResult) === 'error';
 }
+export function isLoginPage(actionResult) {
+    if (PASSWORD_INPUT.test(actionResult.html || ''))
+        return true;
+    return AUTH_PATH.test(extractStatePath(actionResult.url || '').split('?')[0]);
+}
 export function getStateErrorPageError(state) {
     if (!state)
         return null;

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

@@ -5,6 +5,7 @@ export declare const EXPLORBOT_ATTRS: {
     readonly coveredBy: "data-explorbot-covered-by";
     readonly context: "data-explorbot-context";
     readonly eidx: "data-explorbot-eidx";
+    readonly hidden: "data-explorbot-hidden";
     readonly hit: "data-explorbot-hit";
     readonly variant: "data-explorbot-variant";
 };
@@ -40,6 +41,7 @@ export declare const ELEMENT_EXTRACTION_CONFIG: {
         readonly coveredBy: "data-explorbot-covered-by";
         readonly context: "data-explorbot-context";
         readonly eidx: "data-explorbot-eidx";
+        readonly hidden: "data-explorbot-hidden";
         readonly hit: "data-explorbot-hit";
         readonly variant: "data-explorbot-variant";
     };

package/dist/src/utils/html.js

@@ -70,6 +70,7 @@ export const EXPLORBOT_ATTRS = {
     coveredBy: 'data-explorbot-covered-by',
     context: 'data-explorbot-context',
     eidx: 'data-explorbot-eidx',
+    hidden: 'data-explorbot-hidden',
     hit: 'data-explorbot-hit',
     variant: 'data-explorbot-variant',
 };
@@ -159,6 +160,20 @@ export function captureHtmlForSnapshot() {
                 .join(','));
         }
     }
+    const liveElements = Array.from(document.body?.querySelectorAll('*') || []);
+    const clonedElements = Array.from(clone.querySelector('body')?.querySelectorAll('*') || []);
+    for (let i = 0; i < liveElements.length; i++) {
+        const source = liveElements[i];
+        if (source.matches('input, textarea, select, option, optgroup'))
+            continue;
+        if (source.checkVisibility())
+            continue;
+        if (!source.parentElement?.checkVisibility())
+            continue;
+        if (getComputedStyle(source).display === 'contents')
+            continue;
+        clonedElements[i]?.setAttribute('data-explorbot-hidden', 'true');
+    }
     return clone.outerHTML;
 }
 export function extractElementData(el, config) {
@@ -1347,7 +1362,27 @@ function getAttribute(element, name) {
     const attr = element.attrs.find((a) => a.name === name);
     return attr?.value;
 }
+function getImgAlt(element) {
+    let alt = '';
+    function processNode(node) {
+        if (alt)
+            return;
+        if ('tagName' in node) {
+            const el = node;
+            if (el.tagName.toLowerCase() === 'img') {
+                alt = getAttribute(el, 'alt') || '';
+                return;
+            }
+        }
+        if ('childNodes' in node)
+            node.childNodes.forEach(processNode);
+    }
+    processNode(element);
+    return alt;
+}
 function hasHiddenClass(element) {
+    if (getAttribute(element, EXPLORBOT_ATTRS.hidden))
+        return true;
     const classAttr = element.attrs.find((attr) => attr.name === 'class');
     if (!classAttr)
         return false;
@@ -1393,7 +1428,7 @@ export function extractLinks(html) {
                 if (href) {
                     const shouldSkip = skipPrefixes.some((prefix) => href.startsWith(prefix));
                     if (!shouldSkip) {
-                        const rawTitle = getAttribute(element, 'aria-label') || getTextContent(element);
+                        const rawTitle = getAttribute(element, 'aria-label') || getTextContent(element) || getImgAlt(element);
                         const title = sanitizeLinkTitle(rawTitle);
                         if (title && title.length <= 100) {
                             const key = `${href}|${title}`;

package/dist/src/utils/mdq/cli.js

@@ -5,7 +5,7 @@ const EDIT_FLAGS = ['remove', 'replace', 'insertBefore', 'insertAfter', 'prepend
 export async function runMdq(argv, readStdin) {
     const program = new Command();
     program
-        .name('mdq')
+        .name('mdq-cli')
         .description('query and edit markdown')
         .argument('[selector]', 'markdown selector')
         .argument('[file]', 'file to read; stdin when omitted')
@@ -29,6 +29,8 @@ export async function runMdq(argv, readStdin) {
         program.parse(argv, { from: 'user' });
     }
     catch (error) {
+        if (error.code === 'commander.helpDisplayed')
+            return { output: program.helpInformation(), code: 0 };
         return { output: String(error.message), code: 2 };
     }
     const options = program.opts();

package/dist/src/utils/mdq/query.d.ts

@@ -57,6 +57,8 @@ export declare class MarkdownQuery {
     sectionsOf(candidates: MatchedRange[], segment: QuerySegment): MatchedRange[];
     itemsOf(candidates: MatchedRange[]): MatchedRange[];
     expandSections(matches: MatchedRange[]): MatchedRange[];
+    evaluate(candidates: MatchedRange[], expression: QueryExpression): MatchedRange[];
+    union(results: MatchedRange[][]): MatchedRange[];
     narrow(matches: MatchedRange[], segment: QuerySegment): MatchedRange[];
     filterByText(matches: MatchedRange[], segment: QuerySegment): MatchedRange[];
     matchText(text: string, matcher: TextMatcher): boolean;
@@ -77,7 +79,7 @@ export declare class MdqOperationError extends MdqError {
     constructor(message: string);
 }
 export declare function mdq(source: Markdown): MarkdownQuery;
-export declare function parseQuery(input: string): QuerySegment[];
+export declare function parseQuery(input: string): QueryExpression;
 export declare function buildTokenIndex(source: string): MatchedRange[];
 export type Markdown = string | MarkdownQuery;
 export type Matcher = string | RegExp | ((text: string) => boolean);
@@ -92,6 +94,7 @@ export interface TextMatcher {
     flags?: string;
     predicate?: (text: string) => boolean;
 }
+export type QueryExpression = QuerySegment[][][];
 export interface QuerySegment {
     selector: SelectorType;
     textMatch?: TextMatcher;

package/dist/src/utils/mdq/query.js

@@ -9,10 +9,13 @@ export class MarkdownQuery {
         this.matches = matches || buildTokenIndex(source);
     }
     query(selector, matcher) {
-        const segments = parseQuery(selector);
-        if (matcher !== undefined && segments.length > 0)
-            segments[segments.length - 1].textMatch = this.valueMatcher(matcher);
-        return new MarkdownQuery(this.source, this.run(this.expandSections(this.matches), segments));
+        const expression = parseQuery(selector);
+        for (const chain of expression.flat()) {
+            const last = chain.at(-1);
+            if (matcher !== undefined && last)
+                last.textMatch = this.valueMatcher(matcher);
+        }
+        return new MarkdownQuery(this.source, this.evaluate(this.expandSections(this.matches), expression));
     }
     section(matcher, options) {
         return this.query(`section${options?.depth || ''}`, matcher);
@@ -299,6 +302,27 @@ export class MarkdownQuery {
         }
         return expanded;
     }
+    evaluate(candidates, expression) {
+        const results = [];
+        for (const operands of expression) {
+            const matched = operands.map((chain) => this.run(candidates, chain));
+            if (matched.some((ranges) => ranges.length === 0))
+                continue;
+            results.push(...matched);
+        }
+        return this.union(results);
+    }
+    union(results) {
+        if (results.length === 1)
+            return results[0];
+        const unique = new Map();
+        for (const range of results.flat()) {
+            const key = `${range.start}:${range.length}:${Boolean(range.innerTokens)}`;
+            if (!unique.has(key))
+                unique.set(key, range);
+        }
+        return [...unique.values()].sort((a, b) => a.start - b.start || b.length - a.length);
+    }
     narrow(matches, segment) {
         if (segment.index !== null) {
             let index = segment.index;
@@ -390,10 +414,24 @@ export function mdq(source) {
     return new MarkdownQuery(String(source));
 }
 export function parseQuery(input) {
-    const segments = [];
+    const expression = [[[]]];
+    let chain = expression[0][0];
     SEGMENT.lastIndex = 0;
     while (SEGMENT.lastIndex < input.length) {
         const at = SEGMENT.lastIndex;
+        OPERATOR.lastIndex = at;
+        const operator = OPERATOR.exec(input);
+        if (operator) {
+            if (chain.length === 0)
+                throw new MdqSelectorError(`Empty selector before ${operator[1]}`, at);
+            chain = [];
+            if (operator[1] === '||')
+                expression.push([chain]);
+            if (operator[1] === '&&')
+                expression[expression.length - 1].push(chain);
+            SEGMENT.lastIndex = OPERATOR.lastIndex;
+            continue;
+        }
         const match = SEGMENT.exec(input);
         if (!match)
             throw new MdqSelectorError(`Unexpected character "${input[at]}" in selector`, at);
@@ -424,9 +462,11 @@ export function parseQuery(input) {
             if (to)
                 segment.slice.to = Number.parseInt(to, 10);
         }
-        segments.push(segment);
+        chain.push(segment);
     }
-    return segments;
+    if (expression.flat().length > 1 && chain.length === 0)
+        throw new MdqSelectorError('Empty selector after operator', input.length);
+    return expression;
 }
 export function buildTokenIndex(source) {
     const { body, offset } = MarkdownEditor.splitFrontmatter(source);
@@ -449,3 +489,4 @@ export function buildTokenIndex(source) {
 const SELECTOR_NAMES = new Set(['section', 'heading', 'paragraph', 'table', 'list', 'item', 'code', 'blockquote', 'hr', 'html', 'comment']);
 const TOKEN_ALIASES = { item: 'list_item' };
 const SEGMENT = /(\s*\.?)([A-Za-z]\w*)(?:\((!?)(~?)(?:"((?:[^"\\]|\\.)*)"|\/((?:[^/\\]|\\.)*)\/([a-z]*))\))?((?:\[[^\]]*\])*)\s*/y;
+const OPERATOR = /\s*(&&|\|\|)\s*/y;

package/dist/src/utils/web-sandbox.js

@@ -1,16 +1,16 @@
 import { faker } from '@faker-js/faker';
 import { hopeThat, retryTo, tryTo, within } from 'codeceptjs/lib/effects';
 import step from 'codeceptjs/steps';
+import { splitTopLevel } from "./code-extractor.js";
 const SHADOWED_GLOBALS = ['process', 'global', 'globalThis', 'fetch', 'Bun', 'require', 'module', 'exports'];
 const ALLOWED_COMMAND_HEADS = ['I.', 'page.', 'await page.', 'await I.'];
 const PLAYWRIGHT_COMMAND_HEADS = ['page.', 'await page.'];
 const PLAYWRIGHT_ARG_NAMES = ['page'];
 const CODECEPT_ARG_NAMES = ['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker'];
 export function sanitizeCodeBlock(code) {
-    return code
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => ALLOWED_COMMAND_HEADS.some((head) => line.startsWith(head)))
+    return splitTopLevel(code, '\n')
+        .map((statement) => statement.trim())
+        .filter((statement) => ALLOWED_COMMAND_HEADS.some((head) => statement.startsWith(head)))
         .join('\n');
 }
 export function hasPlaywrightCommands(code) {

package/docs/doc-collection/basics.md

@@ -21,6 +21,19 @@ The collector starts at the path you give it. For each page it:
 
 It repeats this until the queue is empty or the page budget is spent. Only same-origin links are followed.
 
+## Research depth
+
+In static mode the Researcher runs in a **light, single pass**: one AI call maps the sections and interactive elements, and the locator validation, repair conversations, and screenshot annotation passes of a full research run are skipped. Docs describe pages rather than click them, so unverified locators are a fair trade for roughly one AI call per page.
+
+Interactive mode needs locators it can actually click, so it keeps the full pipeline: every locator is validated in the browser, broken ones get fixed, and a vision pass adds coordinates. Override the automatic choice with `research`:
+
+```ts
+docs: {
+  research: 'full', // always run the verified pipeline
+  // research: 'light', // single pass even in interactive mode
+}
+```
+
 ## Configure
 
 The collector runs on your regular Explorbot setup — the AI provider and browser come from `explorbot.config.js` (see [configuration](../reference/configuration.md)). Crawl behavior lives in a separate file: `docbot.config.ts` (`.js` and `.mjs` work too).

package/docs/reference/commands.md

@@ -733,16 +733,16 @@ html: /home/you/.explorbot/sites/app.example.com/output/prima/2026-08-04T10-04-2
 
 ### Browsers and sessions
 
-Prima never launches a browser implicitly. Open one first:
+Prima never launches a browser. Open a playwright-cli session first, and check prima sees it:
 
 ```bash
 playwright-cli open https://app.example.com   # the session prima attaches to by default
-npx explorbot prima browser start             # a prima-owned browser instead
+npx explorbot prima browser                   # prints the session, or fails with the command to open one
 ```
 
-By default prima attaches to the playwright-cli browser of the current workspace and works on the tabs it already has open — driving the same session from both tools is the intended usage. Stopping prima disconnects from an attached browser; it never closes it. `prima browser list` shows both kinds of browser, and the `### Instance` block names the one you are on.
+By default prima attaches to the playwright-cli browser of the current workspace and works on the tabs it already has open — driving the same session from both tools is the intended usage. Stopping prima disconnects from an attached browser; it never closes it. The `### Instance` block names the browser you are on.
 
-Prima reaches every browser over a Playwright browser-server endpoint — a playwright-cli session, an `--endpoint`, or a `prima browser start` instance — and that client needs the Node build, which is what `npx explorbot prima` and the published `prima` bin run on. Driving a browser by running the CLI from source under Bun does not connect.
+Prima reaches every browser over a Playwright browser-server endpoint — a playwright-cli session, an `--endpoint`, or an `explorbot browser start` instance — and that client needs the Node build, which is what `npx explorbot prima` and the published `prima` bin run on. Driving a browser by running the CLI from source under Bun does not connect.
 
 Every command takes these:
 
@@ -769,8 +769,6 @@ A few commands add their own:
 | `research` | `--data` | Include data extraction in the map |
 | `research` | `--deep` | Expand hidden elements for a deeper map |
 | `research` | `--fresh` | Ignore the cached map and research the page again |
-| `browser start` | `-s, --show` / `--headless` | Launch the browser with or without a window |
-| `browser stop` | `--all` | Stop every running instance |
 
 Prima carries no logging flags of its own. `DEBUG` in front of a command prints everything the run does — config and browser attachment, every step as it executes, and the debug stream of the agents behind it:
 

package/docs/web-testing/researcher.md

@@ -155,6 +155,14 @@ Expands hidden elements (dropdowns, accordions, tabs) to discover more UI. Click
 
 Extracts domain-specific content (articles, products, users) as structured data.
 
+#### Light Research
+
+```ts
+researcher.research(state, { light: true });
+```
+
+A single-pass mode for consumers that describe pages instead of acting on them. Stage 1 runs as usual; stages 2–5 (locator testing, AI fixing, the visual annotation pass, backfills, and pagination probing) are skipped, so the whole run is one AI call with no browser verification roundtrips. Locators in the UI map come straight from the model and are not verified; a light run never writes to the shared research cache, so it cannot replace a verified result. The [doc collector](../doc-collection/basics.md#research-depth) uses this mode by default.
+
 ## Page Sections
 
 The Researcher breaks each page into sections by UI purpose. Sections are identified in priority order:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/rules/navigator/output.md

@@ -1,11 +1,11 @@
 <rules>
-Do not invent locators, focus only on locators from HTML PAGE.
+Do not invent locators, focus only on locators from the <page> context.
 Provide up to {{maxAttempts}} various code suggestions to achieve the result.
 If there was already successful solution in <experience> use it as a first solution.
 
 If no successful solution was found in <experience> propose codeblocks for each area that can help to achieve the result.
 Do not stick only to the first found element as it might be hidden or not availble on the page.
-If you think HTML contains several areas that can help to achieve the result, propose codeblocks for each such area.
+If you think the page contains several areas that can help to achieve the result, propose codeblocks for each such area.
 Use exact locators that can pick the elements from each areas.
 Detect such duplicated areas by looking for duplicate IDs, data-ids, forms, etc.
 
@@ -24,7 +24,7 @@ Your response must start explanation of what you are going to do to achive the r
 It is important to explain intention before proposing code.
 Response must also valid CodeceptJS code in code blocks.
 Propose codeblock from successful solutions in <experience> first if they exist.
-Use only locators from HTML PAGE that was passed in <page> context.
+Use only locators from the <page> context.
 </output>
 
 

package/src/action.ts

@@ -589,6 +589,10 @@ export const attachStepLogger = (target: ExecutedStep[], assertionsTarget?: Arra
     if (batchFailed) return;
 
     const executed: ExecutedStep = { command: step.toCode(), success: !error };
+    if (Object.keys(step.opts || {}).length) {
+      const args = [step.humanizeArgs(), `step.opts(${JSON.stringify(step.opts)})`].filter(Boolean).join(', ');
+      executed.command = `${step.prefix}${step.actor}.${step.title}(${args})${step.suffix}`;
+    }
     if (error) {
       executed.error = errorToString(error);
       batchFailed = true;

package/src/ai/driller.ts

@@ -6,6 +6,7 @@ import { setActivity } from '../activity.ts';
 import { Observability } from '../observability.ts';
 import { Plan, Test, TestResult } from '../test-plan.ts';
 import { collectInteractiveNodes } from '../utils/aria.ts';
+import { splitTopLevel } from '../utils/code-extractor.ts';
 import { EXPLORBOT_ATTRS, HTML_COMPOSITE_AREA_HINTS, HTML_COMPOSITE_TARGET_ROLES, HTML_EXTRACTION_LIMITS, HTML_FORM_CONTROL_ROLES, HTML_FORM_CONTROL_TAGS, HTML_INTERACTIVE_ROLES, HTML_SELECTORS, getComponentScopeHtmlExtractorSource, inferHtmlRole } from '../utils/html.ts';
 import { createDebug, tag } from '../utils/logger.ts';
 import { loop, pause } from '../utils/loop.ts';
@@ -1011,39 +1012,7 @@ function countTopLevelArgCount(line: string): number {
   const end = line.lastIndexOf(')');
   if (start === -1 || end === -1 || end <= start + 1) return 0;
 
-  const body = line.slice(start + 1, end);
-  let count = 1;
-  let depth = 0;
-  let quote = '';
-
-  for (let i = 0; i < body.length; i++) {
-    const char = body[i];
-    const escaped = body[i - 1] === '\\';
-
-    if (quote) {
-      if (char === quote && !escaped) quote = '';
-      continue;
-    }
-
-    if (char === '"' || char === "'" || char === '`') {
-      quote = char;
-      continue;
-    }
-
-    if (char === '(' || char === '[' || char === '{') {
-      depth++;
-      continue;
-    }
-
-    if (char === ')' || char === ']' || char === '}') {
-      depth = Math.max(0, depth - 1);
-      continue;
-    }
-
-    if (char === ',' && depth === 0) count++;
-  }
-
-  return count;
+  return splitTopLevel(line.slice(start + 1, end), ',').length;
 }
 
 function buildClassSelector(tag: string, classes: string[]): string {