explorbot 0.1.10 → 0.1.11

package/src/explorer.ts

@@ -15,6 +15,7 @@ import type { ExplorbotConfig } from './config.js';
 import { ConfigParser, outputPath } from './config.js';
 import type { UserResolveFunction } from './explorbot.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
+import { PlaywrightRecorder } from './playwright-recorder.ts';
 import { Reporter } from './reporter.ts';
 import { StateManager } from './state-manager.js';
 import { Test } from './test-plan.ts';
@@ -60,6 +61,7 @@ class Explorer {
   private _activeTest: Test | null = null;
   private xhrCapture: XhrCapture | null = null;
   private requestStore: RequestStore | null = null;
+  private playwrightRecorder: PlaywrightRecorder = new PlaywrightRecorder();
 
   constructor(config: ExplorbotConfig, aiProvider: AIProvider, options?: { show?: boolean; headless?: boolean; incognito?: boolean; session?: string }) {
     this.config = config;
@@ -123,7 +125,7 @@ class Explorer {
       tag('substep').log(debugInfo);
     }
     const PlaywrightConfig = {
-      timeout: 1000,
+      timeout: 3000,
       highlightElement: true,
       waitForAction: 500,
       ...playwrightConfig,
@@ -237,6 +239,7 @@ class Explorer {
     const hasSession = this.options?.session && existsSync(this.options.session);
     const contextOptions = hasSession ? { storageState: this.options!.session } : undefined;
     await this.playwrightHelper._createContextPage(contextOptions);
+    await this.playwrightRecorder.start(this.playwrightHelper.browserContext);
     this.setupXhrCapture();
     if (hasSession) {
       tag('info').log(`Session restored from ${path.relative(process.cwd(), this.options!.session!)}`);
@@ -273,7 +276,11 @@ class Explorer {
   }
 
   createAction() {
-    return new Action(this.actor, this.stateManager);
+    return new Action(this.actor, this.stateManager, this.playwrightRecorder);
+  }
+
+  getPlaywrightRecorder(): PlaywrightRecorder {
+    return this.playwrightRecorder;
   }
 
   async visit(url: string) {
@@ -489,6 +496,8 @@ class Explorer {
       this.xhrCapture.detach(this.playwrightHelper.page);
     }
 
+    await this.playwrightRecorder.stop();
+
     if (this.options?.session && this.playwrightHelper?.browserContext) {
       const dir = path.dirname(this.options.session);
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });

package/src/observability.ts

@@ -1,121 +1,46 @@
-import { randomBytes } from 'node:crypto';
-import { type Span, context, trace } from '@opentelemetry/api';
+import { type Span, trace } from '@opentelemetry/api';
 
 type TelemetryMetadata = Record<string, unknown>;
 
 type TelemetryState = {
   metadata: TelemetryMetadata;
-  traceId: string;
-  updateParent: boolean;
   name: string;
   span?: Span;
 };
 
 let current: TelemetryState | null = null;
-let depth = 0;
 
 export const Observability = {
   async run<T>(name: string, metadata: TelemetryMetadata, fn: () => Promise<T>): Promise<T> {
-    const started = Observability.startTrace(name, metadata);
+    const tracer = trace.getTracer('ai');
 
-    try {
-      if (!started) {
-        const parentSpan = current?.span;
-        if (!parentSpan || !current) return await fn();
-
-        const tracer = trace.getTracer('ai');
-        const childSpan = tracer.startSpan(name, undefined, trace.setSpan(context.active(), parentSpan));
-        const savedSpan = current.span;
-        const savedName = current.name;
-        current.span = childSpan;
-        current.name = name;
-        return await context.with(trace.setSpan(context.active(), childSpan), async () => {
-          try {
-            return await fn();
-          } finally {
-            childSpan.end();
-            current!.span = savedSpan;
-            current!.name = savedName;
-          }
-        });
-      }
-
-      const tracer = trace.getTracer('ai');
-      const spanContext = {
-        traceId: current?.traceId || randomBytes(16).toString('hex'),
-        spanId: randomBytes(8).toString('hex'),
-        traceFlags: 1,
-      };
-      const rootContext = trace.setSpanContext(context.active(), spanContext);
-
-      const initSpan = tracer.startSpan(name, undefined, rootContext);
-      initSpan.setAttribute('langfuse.trace.name', name);
-      initSpan.setAttribute('langfuse.trace.id', current?.traceId || '');
-      if (current?.metadata?.sessionId) {
-        initSpan.setAttribute('langfuse.trace.session_id', String(current.metadata.sessionId));
-      }
-      if (current?.metadata?.userId) {
-        initSpan.setAttribute('langfuse.trace.user_id', String(current.metadata.userId));
-      }
-      if (current?.metadata?.tags && Array.isArray(current.metadata.tags)) {
-        initSpan.setAttribute('langfuse.trace.tags', current.metadata.tags);
-      }
-      if (current?.metadata?.input) {
-        initSpan.setAttribute('langfuse.trace.input', JSON.stringify(current.metadata.input));
-      }
-      initSpan.end();
-
-      const span = tracer.startSpan(name, undefined, rootContext);
-      current.span = span;
-
-      return await context.with(trace.setSpan(rootContext, span), async () => {
+    if (current) {
+      return await tracer.startActiveSpan(name, {}, async (span) => {
+        const saved = current!;
+        current = {
+          metadata: { ...saved.metadata, ...metadata },
+          name,
+          span,
+        };
         try {
           return await fn();
         } finally {
           span.end();
-          current.span = undefined;
+          current = saved;
         }
       });
-    } finally {
-      Observability.endTrace(started);
-    }
-  },
-
-  startTrace(name: string, metadata: TelemetryMetadata) {
-    if (current) {
-      depth += 1;
-      return false;
     }
 
-    const langfuseTraceId = metadata.langfuseTraceId || randomBytes(16).toString('hex');
-    current = {
-      metadata: {
-        ...metadata,
-        langfuseTraceId,
-      },
-      traceId: langfuseTraceId,
-      updateParent: true,
-      name,
-    };
-    depth = 1;
-    return true;
-  },
-
-  endTrace(started: boolean) {
-    if (!current) {
-      return;
-    }
-
-    if (!started) {
-      depth -= 1;
-      return;
-    }
-
-    depth -= 1;
-    if (depth <= 0) {
-      current = null;
-      depth = 0;
-    }
+    const attributes = buildRootSpanAttributes(name, metadata);
+    return await tracer.startActiveSpan(name, { attributes }, async (span) => {
+      current = { metadata, name, span };
+      try {
+        return await fn();
+      } finally {
+        span.end();
+        current = null;
+      }
+    });
   },
 
   getTelemetry() {
@@ -123,21 +48,16 @@ export const Observability = {
       return undefined;
     }
 
-    const telemetry = {
+    const metadata: Record<string, unknown> = {};
+    if (current.metadata.sessionId) metadata.sessionId = current.metadata.sessionId;
+    if (current.metadata.userId) metadata.userId = current.metadata.userId;
+    if (Array.isArray(current.metadata.tags)) metadata.tags = current.metadata.tags;
+
+    return {
       isEnabled: true,
       functionId: current.name,
-      metadata: {
-        ...current.metadata,
-        langfuseTraceId: current.traceId,
-        langfuseUpdateParent: current.updateParent,
-      },
+      metadata,
     };
-
-    if (current.updateParent) {
-      current.updateParent = false;
-    }
-
-    return telemetry;
   },
 
   isTracing() {
@@ -145,6 +65,27 @@ export const Observability = {
   },
 
   getSpan() {
-    return current?.span;
+    return current?.span ?? trace.getActiveSpan();
   },
 };
+
+function buildRootSpanAttributes(name: string, metadata: TelemetryMetadata): Record<string, any> {
+  const attributes: Record<string, any> = {
+    'langfuse.trace.name': name,
+  };
+
+  if (metadata.sessionId) {
+    attributes['session.id'] = String(metadata.sessionId);
+  }
+  if (metadata.userId) {
+    attributes['user.id'] = String(metadata.userId);
+  }
+  if (Array.isArray(metadata.tags)) {
+    attributes['langfuse.trace.tags'] = metadata.tags as string[];
+  }
+  if (metadata.input !== undefined) {
+    attributes['langfuse.trace.input'] = JSON.stringify(metadata.input);
+  }
+
+  return attributes;
+}

package/src/playwright-recorder.ts

@@ -0,0 +1,305 @@
+import { readFile } from 'node:fs/promises';
+// @ts-ignore — package ships a .js re-export without typings for this sub-path
+import * as playwrightUtils from 'playwright-core/lib/utils';
+import { createDebug } from './utils/logger.ts';
+
+const debugLog = createDebug('explorbot:playwright-recorder');
+
+const RECORDABLE: Record<string, Set<string>> = {
+  Frame: new Set(['click', 'dblclick', 'fill', 'selectOption', 'press', 'type', 'check', 'uncheck', 'hover', 'tap', 'focus', 'setInputFiles', 'scrollIntoViewIfNeeded', 'dragTo', 'goto', 'setContent']),
+  Page: new Set(['goBack', 'goForward', 'reload', 'keyboardPress', 'keyboardType', 'keyboardDown', 'keyboardUp', 'keyboardInsertText', 'mouseClick', 'mouseDblclick', 'mouseMove', 'mouseDown', 'mouseUp', 'mouseWheel']),
+};
+
+const PLAYWRIGHT_INCOMPATIBLE = "Playwright output is not compatible with this Playwright version (playwright-core/lib/utils does not expose asLocator). Use output.framework: 'codeceptjs' instead, or pin Playwright to a version shipping lib/utils/isomorphic/locatorGenerators.js.";
+
+function getAsLocator(): (lang: string, selector: string) => string {
+  const fn = (playwrightUtils as any)?.asLocator;
+  if (typeof fn !== 'function') throw new Error(PLAYWRIGHT_INCOMPATIBLE);
+  return fn;
+}
+
+export interface TraceCall {
+  class: string;
+  method: string;
+  params: Record<string, any>;
+}
+
+export interface VerificationStep {
+  name: string;
+  args: any[];
+}
+
+export class PlaywrightRecorder {
+  private context: any = null;
+  private tracing: any = null;
+  private active = false;
+  private nextGroupId = 0;
+  private verifications: VerificationStep[] = [];
+
+  recordVerification(steps: VerificationStep[]): void {
+    if (!steps?.length) return;
+    const seen = new Set(this.verifications.map((s) => `${s.name}:${JSON.stringify(s.args)}`));
+    for (const step of steps) {
+      const key = `${step.name}:${JSON.stringify(step.args)}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      this.verifications.push(step);
+    }
+  }
+
+  drainVerifications(): VerificationStep[] {
+    const drained = this.verifications;
+    this.verifications = [];
+    return drained;
+  }
+
+  async start(browserContext: any): Promise<void> {
+    if (this.active) return;
+    if (!browserContext?.tracing) {
+      debugLog('start: no tracing on browserContext, recorder inactive');
+      return;
+    }
+    this.context = browserContext;
+    this.tracing = browserContext.tracing;
+    try {
+      await this.tracing.start({});
+      this.active = true;
+      debugLog('tracing started');
+    } catch (err) {
+      debugLog('tracing.start failed:', err);
+    }
+  }
+
+  async beginAction(title: string): Promise<string | null> {
+    if (!this.active) return null;
+    const safe = title.replace(/\s+/g, ' ').slice(0, 80);
+    const groupId = `explorbot#${++this.nextGroupId}:${safe}`;
+    try {
+      await this.tracing.group(groupId);
+      return groupId;
+    } catch (err) {
+      debugLog('tracing.group failed:', err);
+      return null;
+    }
+  }
+
+  async endAction(): Promise<void> {
+    if (!this.active) return;
+    try {
+      await this.tracing.groupEnd();
+    } catch (err) {
+      debugLog('tracing.groupEnd failed:', err);
+    }
+  }
+
+  async exportChunk(): Promise<Map<string, TraceCall[]>> {
+    if (!this.active) return new Map();
+    const channel = this.tracing._channel;
+    if (!channel?.tracingStopChunk || !channel.tracingStartChunk) {
+      debugLog('exportChunk: no _channel access, returning empty');
+      return new Map();
+    }
+
+    let entries: Array<{ name: string; value: string }> = [];
+    try {
+      const result = await channel.tracingStopChunk({ mode: 'entries' });
+      entries = result?.entries || [];
+    } catch (err) {
+      debugLog('tracingStopChunk failed:', err);
+      return new Map();
+    }
+
+    const traceEntry = entries.find((e) => e.name === 'trace.trace');
+
+    let groups = new Map<string, TraceCall[]>();
+    if (traceEntry) {
+      try {
+        const ndjson = await readFile(traceEntry.value, 'utf8');
+        groups = parseTrace(ndjson);
+      } catch (err) {
+        debugLog('reading trace.trace failed:', err);
+      }
+    }
+
+    try {
+      await channel.tracingStartChunk({});
+    } catch (err) {
+      debugLog('tracingStartChunk failed after export:', err);
+      this.active = false;
+    }
+
+    return groups;
+  }
+
+  async stop(): Promise<void> {
+    if (!this.active) return;
+    try {
+      await this.tracing.stop({});
+    } catch (err) {
+      debugLog('tracing.stop failed:', err);
+    }
+    this.active = false;
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+}
+
+interface ParsedBefore {
+  callId: string;
+  class: string;
+  method: string;
+  params: Record<string, any>;
+  parentId?: string;
+  title?: string;
+  failed: boolean;
+}
+
+function parseTrace(ndjson: string): Map<string, TraceCall[]> {
+  const befores = new Map<string, ParsedBefore>();
+  const groupTitleByCallId = new Map<string, string>();
+
+  for (const line of ndjson.split('\n')) {
+    if (!line) continue;
+    let evt: any;
+    try {
+      evt = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (evt.type === 'before') {
+      befores.set(evt.callId, {
+        callId: evt.callId,
+        class: evt.class,
+        method: evt.method,
+        params: evt.params || {},
+        parentId: evt.parentId,
+        title: evt.title,
+        failed: false,
+      });
+      if (evt.class === 'Tracing' && evt.method === 'tracingGroup' && typeof evt.title === 'string') {
+        groupTitleByCallId.set(evt.callId, evt.title);
+      }
+      continue;
+    }
+    if (evt.type === 'after') {
+      const rec = befores.get(evt.callId);
+      if (rec && evt.error) rec.failed = true;
+    }
+  }
+
+  const groups = new Map<string, TraceCall[]>();
+  for (const title of groupTitleByCallId.values()) {
+    groups.set(title, []);
+  }
+
+  for (const rec of befores.values()) {
+    if (rec.failed) continue;
+    if (rec.class === 'Tracing') continue;
+    if (!rec.parentId) continue;
+    const groupTitle = groupTitleByCallId.get(rec.parentId);
+    if (!groupTitle) continue;
+    const allowed = RECORDABLE[rec.class];
+    if (!allowed?.has(rec.method)) continue;
+    groups.get(groupTitle)!.push({ class: rec.class, method: rec.method, params: rec.params });
+  }
+
+  return groups;
+}
+
+export function renderCall(call: TraceCall): string {
+  const asLocator = getAsLocator();
+  const { class: cls, method, params } = call;
+
+  if (cls === 'Frame') {
+    if (method === 'goto') return `await page.goto(${quote(params.url)});`;
+    if (method === 'setContent') return `await page.setContent(${quote(params.html)});`;
+    const locator = `page.${asLocator('javascript', params.selector || '')}`;
+    if (method === 'click') return `await ${locator}.click();`;
+    if (method === 'dblclick') return `await ${locator}.dblclick();`;
+    if (method === 'fill') return `await ${locator}.fill(${quote(params.value ?? '')});`;
+    if (method === 'press') return `await ${locator}.press(${quote(params.key ?? '')});`;
+    if (method === 'type') return `await ${locator}.type(${quote(params.text ?? '')});`;
+    if (method === 'check') return `await ${locator}.check();`;
+    if (method === 'uncheck') return `await ${locator}.uncheck();`;
+    if (method === 'hover') return `await ${locator}.hover();`;
+    if (method === 'tap') return `await ${locator}.tap();`;
+    if (method === 'focus') return `await ${locator}.focus();`;
+    if (method === 'scrollIntoViewIfNeeded') return `await ${locator}.scrollIntoViewIfNeeded();`;
+    if (method === 'setInputFiles') return `await ${locator}.setInputFiles(${formatFiles(params.localPaths ?? params.files)});`;
+    if (method === 'selectOption') return `await ${locator}.selectOption(${formatSelectOption(params.options)});`;
+    if (method === 'dragTo') return `await ${locator}.dragTo(page.locator(${quote(params.targetSelector ?? '')}));`;
+  }
+
+  if (cls === 'Page') {
+    if (method === 'goBack') return 'await page.goBack();';
+    if (method === 'goForward') return 'await page.goForward();';
+    if (method === 'reload') return 'await page.reload();';
+    if (method === 'keyboardPress') return `await page.keyboard.press(${quote(params.key ?? '')});`;
+    if (method === 'keyboardType') return `await page.keyboard.type(${quote(params.text ?? '')});`;
+    if (method === 'keyboardDown') return `await page.keyboard.down(${quote(params.key ?? '')});`;
+    if (method === 'keyboardUp') return `await page.keyboard.up(${quote(params.key ?? '')});`;
+    if (method === 'keyboardInsertText') return `await page.keyboard.insertText(${quote(params.text ?? '')});`;
+    if (method === 'mouseClick') return `await page.mouse.click(${params.x ?? 0}, ${params.y ?? 0});`;
+    if (method === 'mouseDblclick') return `await page.mouse.dblclick(${params.x ?? 0}, ${params.y ?? 0});`;
+    if (method === 'mouseMove') return `await page.mouse.move(${params.x ?? 0}, ${params.y ?? 0});`;
+    if (method === 'mouseDown') return 'await page.mouse.down();';
+    if (method === 'mouseUp') return 'await page.mouse.up();';
+    if (method === 'mouseWheel') return `await page.mouse.wheel(${params.deltaX ?? 0}, ${params.deltaY ?? 0});`;
+  }
+
+  return `// TODO(playwright): ${cls}.${method}(${JSON.stringify(params)})`;
+}
+
+function quote(value: any): string {
+  return JSON.stringify(String(value ?? ''));
+}
+
+function formatFiles(files: any): string {
+  if (!files) return '[]';
+  if (Array.isArray(files)) {
+    if (files.length === 1) return quote(files[0]);
+    return `[${files.map((f) => quote(f)).join(', ')}]`;
+  }
+  return quote(files);
+}
+
+function formatSelectOption(options: any): string {
+  if (!options) return `''`;
+  const list = Array.isArray(options) ? options : [options];
+  const values = list.map((o) => o?.valueOrLabel ?? o?.value ?? o?.label ?? '');
+  if (values.length === 1) return quote(values[0]);
+  return `[${values.map((v) => quote(v)).join(', ')}]`;
+}
+
+export function renderAssertion(assertion: { name: string; args: any[] }): string {
+  const args = assertion.args;
+  if (assertion.name === 'see' && typeof args[0] === 'string') {
+    return `await expect(page).toContainText(${JSON.stringify(args[0])});`;
+  }
+  if (assertion.name === 'dontSee' && typeof args[0] === 'string') {
+    return `await expect(page).not.toContainText(${JSON.stringify(args[0])});`;
+  }
+  if (assertion.name === 'seeElement' && typeof args[0] === 'string') {
+    return `await expect(page.locator(${JSON.stringify(args[0])})).toBeVisible();`;
+  }
+  if (assertion.name === 'dontSeeElement' && typeof args[0] === 'string') {
+    return `await expect(page.locator(${JSON.stringify(args[0])})).toBeHidden();`;
+  }
+  if (assertion.name === 'seeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+    return `await expect(page.locator(${JSON.stringify(args[0])})).toHaveValue(${JSON.stringify(String(args[1]))});`;
+  }
+  if (assertion.name === 'dontSeeInField' && typeof args[0] === 'string' && args[1] !== undefined) {
+    return `await expect(page.locator(${JSON.stringify(args[0])})).not.toHaveValue(${JSON.stringify(String(args[1]))});`;
+  }
+  if (assertion.name === 'seeInCurrentUrl' && typeof args[0] === 'string') {
+    return `await expect(page).toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+  }
+  if (assertion.name === 'dontSeeInCurrentUrl' && typeof args[0] === 'string') {
+    return `await expect(page).not.toHaveURL(new RegExp(${JSON.stringify(args[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))}));`;
+  }
+  return `// TODO(playwright): ${assertion.name}(${assertion.args.map((a) => JSON.stringify(a)).join(', ')})`;
+}
+
+export { parseTrace };

package/src/test-plan.ts

@@ -160,6 +160,11 @@ export class Task {
       .map((item) => `${item.type === 'step' ? '  ' : ''}${item.content}`)
       .join('\n');
   }
+
+  getRunResult(): 'success' | 'partial' | 'failed' {
+    const hasPassedNotes = Object.values(this.notes).some((n) => n.status === TestResult.PASSED);
+    return hasPassedNotes ? 'partial' : 'failed';
+  }
 }
 
 export class Test extends Task {
@@ -179,6 +184,7 @@ export class Test extends Task {
   enabled = true;
   startTime?: number;
   endTime?: number;
+  resetCount = 0;
 
   constructor(scenario: string, priority: 'critical' | 'important' | 'high' | 'normal' | 'low', expectedOutcome: string | string[], startUrl: string, plannedSteps: string[] = []) {
     super(scenario, startUrl);
@@ -238,6 +244,12 @@ export class Test extends Task {
     });
   }
 
+  getRunResult(): 'success' | 'partial' | 'failed' {
+    if (this.isSuccessful) return 'success';
+    if (this.hasAchievedAny()) return 'partial';
+    return super.getRunResult();
+  }
+
   hasAchievedAll(): boolean {
     return this.expected.every((expectation) => {
       return Object.values(this.notes).some((note) => note.message === expectation && note.status === TestResult.PASSED);

package/src/utils/aria.ts

@@ -644,9 +644,18 @@ const resolveDisplayName = (node: AriaNode): string | undefined => {
   return undefined;
 };
 
+const SIBLING_COLLAPSE_THRESHOLD = 50;
+const SIBLING_COLLAPSE_KEEP_EACH_SIDE = 5;
+
 const serializeAriaNodes = (nodes: AriaNode[], depth = 0): string => {
   const lines: string[] = [];
-  for (const node of nodes) {
+  const collapsed = collapseSimilarSiblingRuns(nodes, depth);
+  for (const entry of collapsed) {
+    if (entry.placeholder) {
+      lines.push(entry.placeholder);
+      continue;
+    }
+    const node = entry.node!;
     const indent = '  '.repeat(depth);
     let line = `${indent}- ${renderNodeLine(node.role, resolveDisplayName(node), node.attributes, node.value)}`;
     if (node.children.length > 0) {
@@ -660,6 +669,34 @@ const serializeAriaNodes = (nodes: AriaNode[], depth = 0): string => {
   return lines.join('\n');
 };
 
+type SerializeEntry = { node?: AriaNode; placeholder?: string };
+
+const collapseSimilarSiblingRuns = (nodes: AriaNode[], depth: number): SerializeEntry[] => {
+  const result: SerializeEntry[] = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const role = nodes[i].role;
+    let j = i;
+    while (j < nodes.length && nodes[j].role === role) j++;
+    const runLength = j - i;
+    if (runLength > SIBLING_COLLAPSE_THRESHOLD) {
+      for (let k = i; k < i + SIBLING_COLLAPSE_KEEP_EACH_SIDE; k++) {
+        result.push({ node: nodes[k] });
+      }
+      const omitted = runLength - SIBLING_COLLAPSE_KEEP_EACH_SIDE * 2;
+      const indent = '  '.repeat(depth);
+      result.push({ placeholder: `${indent}- ...${omitted} similar "${role}" items omitted...` });
+      for (let k = j - SIBLING_COLLAPSE_KEEP_EACH_SIDE; k < j; k++) {
+        result.push({ node: nodes[k] });
+      }
+    } else {
+      for (let k = i; k < j; k++) result.push({ node: nodes[k] });
+    }
+    i = j;
+  }
+  return result;
+};
+
 export const compactAriaSnapshot = (snapshot: string | null, keepNamed = false): string => {
   if (!snapshot) return '';
   const nodes = parseAriaSnapshot(snapshot, keepNamed);

package/src/utils/error-page.ts

@@ -4,22 +4,37 @@ import { isBodyEmpty } from './html.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;
 
-export function isErrorPage(actionResult: ActionResult): boolean {
-  const checkFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean) as string[];
+export type PageCondition = 'ok' | 'loading' | 'error';
+
+export function detectPageCondition(actionResult: ActionResult): PageCondition {
+  const headingFields = [actionResult.title, actionResult.h1, actionResult.h2].filter(Boolean) as string[];
 
-  for (const field of checkFields) {
+  for (const field of headingFields) {
     for (const error of HTTP_ERRORS) {
-      if (field.toLowerCase().includes(error.toLowerCase())) return true;
+      if (field.toLowerCase().includes(error.toLowerCase())) return 'error';
     }
   }
 
-  if (!actionResult.html || isBodyEmpty(actionResult.html)) return true;
+  const aria = actionResult.ariaSnapshot || '';
+  if (/\bprogressbar\b/i.test(aria)) return 'loading';
+  if (/\[busy\]/.test(aria)) return 'loading';
+
+  for (const field of headingFields) {
+    if (LOADING_WORD.test(field)) return 'loading';
+  }
+
+  if (!actionResult.html || isBodyEmpty(actionResult.html)) return 'loading';
 
   const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
-  if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD) return true;
+  if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD) return 'loading';
+
+  return 'ok';
+}
 
-  return false;
+export function isErrorPage(actionResult: ActionResult): boolean {
+  return detectPageCondition(actionResult) === 'error';
 }
 
 export class ErrorPageError extends Error {