@testspectra/cli 1.1.11-rc.5 → 1.1.12

package/dist/lifecycle/parallel-grouping.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+/**
+ * Detects actual CPU quota available to the process, accounting for
+ * Docker and Kubernetes cgroup v1 and cgroup v2 container limits.
+ */
+export function detectContainerCpuQuota() {
+    try {
+        // 1. Check cgroup v2 (Unified Hierarchy): /sys/fs/cgroup/cpu.max
+        // Format: "<quota> <period>" e.g. "200000 100000" or "max 100000"
+        if (fs.existsSync('/sys/fs/cgroup/cpu.max')) {
+            const content = fs.readFileSync('/sys/fs/cgroup/cpu.max', 'utf-8').trim();
+            const [quotaStr, periodStr] = content.split(/\s+/);
+            if (quotaStr && quotaStr !== 'max' && periodStr) {
+                const quota = parseFloat(quotaStr);
+                const period = parseFloat(periodStr);
+                if (quota > 0 && period > 0) {
+                    return Math.max(0.5, quota / period);
+                }
+            }
+        }
+        // 2. Check cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us and cpu.cfs_period_us
+        if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
+            const quota = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf-8').trim());
+            const period = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf-8').trim());
+            if (quota > 0 && period > 0) {
+                return Math.max(0.5, quota / period);
+            }
+        }
+    }
+    catch { }
+    // 3. Fallback to host CPU count
+    if (typeof os.availableParallelism === 'function') {
+        try {
+            return os.availableParallelism();
+        }
+        catch { }
+    }
+    return os.cpus()?.length || 2;
+}
+/**
+ * Detects available memory in bytes, respecting container cgroup memory limits
+ * to prevent Linux OOM (Out of Memory) kills.
+ */
+export function detectAvailableMemoryBytes() {
+    try {
+        // 1. Check cgroup v2: /sys/fs/cgroup/memory.max and /sys/fs/cgroup/memory.current
+        if (fs.existsSync('/sys/fs/cgroup/memory.max')) {
+            const maxStr = fs.readFileSync('/sys/fs/cgroup/memory.max', 'utf-8').trim();
+            if (maxStr !== 'max') {
+                const limit = parseFloat(maxStr);
+                let usage = 0;
+                if (fs.existsSync('/sys/fs/cgroup/memory.current')) {
+                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory.current', 'utf-8').trim()) || 0;
+                }
+                if (limit > 0) {
+                    return Math.max(0, limit - usage);
+                }
+            }
+        }
+        // 2. Check cgroup v1: /sys/fs/cgroup/memory/memory.limit_in_bytes
+        if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
+            const limit = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf-8').trim());
+            // cgroup v1 sets a huge number (e.g. 9223372036854771712) when no limit is enforced
+            if (limit > 0 && limit < 1e15) {
+                let usage = 0;
+                if (fs.existsSync('/sys/fs/cgroup/memory/memory.usage_in_bytes')) {
+                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf-8').trim()) || 0;
+                }
+                return Math.max(0, limit - usage);
+            }
+        }
+    }
+    catch { }
+    // 3. Fallback to host available memory (estimating reclaimable cache/buffer on modern OS)
+    try {
+        const free = os.freemem();
+        const total = os.totalmem();
+        return Math.max(free, total * 0.4);
+    }
+    catch {
+        return 1024 * 1024 * 1024; // 1 GB fallback
+    }
+}
+/**
+ * Dynamically computes optimal worker concurrency respecting:
+ * 1. Explicit user concurrency flag (--concurrency <N> or config)
+ * 2. Real container cgroups CPU quota & host CPU count
+ * 3. Low-CPU safety ratio (clamping <=2 CPUs to 1 worker, 3-4 CPUs to 2 workers)
+ * 4. Memory-aware guard (~600MB RAM budget per Chromium instance to prevent OOM kills)
+ * 5. Target items count & maximum worker cap
+ */
+export function calculateWorkerCount(targetItems, options) {
+    const opts = typeof options === 'number' ? { maxWorkersCap: options } : options || {};
+    const itemCount = targetItems.length;
+    if (itemCount === 0)
+        return 1;
+    // 1. Explicit User Concurrency has absolute priority
+    if (opts.userConcurrency && opts.userConcurrency > 0) {
+        return Math.min(opts.userConcurrency, itemCount);
+    }
+    // 2. Determine CPU Quota (cgroups aware)
+    const cpuCount = opts.cpuQuotaOverride !== undefined ? opts.cpuQuotaOverride : detectContainerCpuQuota();
+    // 3. Low-CPU Safety Ratio:
+    // - CPU <= 2: Max 1 worker (prevents severe thrashing on 2-vCPU CI runners)
+    // - CPU 3-4: Max 2 workers
+    // - CPU > 4: cpuCount - 2 (leaves 2 cores for OS/IDE/DevTools)
+    let cpuBasedWorkers = 1;
+    if (cpuCount <= 2) {
+        cpuBasedWorkers = 1;
+    }
+    else if (cpuCount <= 4) {
+        cpuBasedWorkers = 2;
+    }
+    else {
+        cpuBasedWorkers = Math.max(1, Math.floor(cpuCount - 2));
+    }
+    // 4. Memory-Aware Guard (Anti-OOM):
+    // Allocate ~600MB per Chromium browser instance
+    const MEMORY_PER_WORKER_BYTES = 600 * 1024 * 1024;
+    const availableMemBytes = opts.memoryBytesOverride !== undefined ? opts.memoryBytesOverride : detectAvailableMemoryBytes();
+    const memBasedWorkers = Math.max(1, Math.floor(availableMemBytes / MEMORY_PER_WORKER_BYTES));
+    // 5. Apply Maximum Cap and Item Count Clamping
+    const maxCap = opts.maxWorkersCap || 6;
+    return Math.max(1, Math.min(cpuBasedWorkers, memBasedWorkers, maxCap, itemCount));
+}
+export function groupSpecs(specPaths, mode = 'suite') {
+    if (mode === 'testcase') {
+        return [...specPaths];
+    }
+    // Group by suite directory
+    const suiteGroups = new Map();
+    for (const specPath of specPaths) {
+        const normalized = specPath.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        let suiteKey = 'default';
+        const specsIdx = parts.findIndex((p) => p === 'specs' || p === 'suites');
+        if (specsIdx !== -1 && specsIdx + 1 < parts.length) {
+            suiteKey = parts.slice(0, specsIdx + 2).join('/');
+        }
+        else {
+            suiteKey = path.dirname(normalized);
+        }
+        if (!suiteGroups.has(suiteKey)) {
+            suiteGroups.set(suiteKey, []);
+        }
+        suiteGroups.get(suiteKey).push(specPath);
+    }
+    return Array.from(suiteGroups.values());
+}

package/dist/reporter/semantic-formatter.js

@@ -97,6 +97,8 @@ export function formatAction(actionKey, target, args = {}) {
             return `Scroll ${args.direction ?? '{direction}'} by ${args.pixels ?? '{pixels}'}px`;
         case 'swipe':
             return `Swipe ${args.direction ?? '{direction}'} by ${args.distance ?? '{distance}'}px`;
+        case 'upload':
+            return `Upload file "${args.files ?? args.value ?? args.file ?? '{file}'}" to ${el}`;
         case 'intercept':
             return `Intercept ${args.method ?? '{method}'} "${args.url ?? '{url}'}" mock rule registered`;
         case 'clearCookies':

package/dist/reporter/types.d.ts

@@ -1,2 +1,2 @@
-export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'intercept' | 'clearCookies' | 'setCookies' | 'clearLocalStorage';
+export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'upload' | 'intercept' | 'clearCookies' | 'setCookies' | 'clearLocalStorage';
 export type AssertionKey = 'be.visible' | 'not.be.visible' | 'exist' | 'not.exist' | 'be.clickable' | 'not.be.clickable' | 'be.enabled' | 'be.disabled' | 'be.checked' | 'not.be.checked' | 'be.selected' | 'not.be.selected' | 'be.focused' | 'not.be.focused' | 'have.text' | 'not.have.text' | 'contain.text' | 'not.contain.text' | 'have.value' | 'not.have.value' | 'contain.value' | 'not.contain.value' | 'have.attr' | 'not.have.attr' | 'have.class' | 'not.have.class' | 'have.css' | 'not.have.css' | 'have.length' | 'not.have.length' | 'have.length.greaterThan' | 'have.length.lessThan' | 'be.empty' | 'not.be.empty' | 'shouldHaveUrl' | 'shouldContainUrl' | 'shouldHaveTitle' | 'shouldContainTitle' | 'shouldBeLoaded' | 'shouldBePageLoaded' | 'shouldHaveNoConsoleErrors' | 'have.url' | 'contain.url' | 'have.title' | 'contain.title' | 'be.loaded' | 'be.pageLoaded' | 'have.noConsoleErrors';

package/dist/runner/bridge.d.ts

@@ -18,6 +18,8 @@ export interface RunOptions {
     concurrency?: number;
     failedOnly?: boolean;
     failedTarget?: string;
+    debug?: boolean;
+    inspectPort?: number;
 }
 export declare class RustCoreBridge {
     static resolveBinaryPath(): string;

package/dist/runner/bridge.js

@@ -121,6 +121,8 @@ export class RustCoreBridge {
             concurrency: options.concurrency,
             failedOnly: options.failedOnly,
             failedTarget: options.failedTarget,
+            debug: options.debug,
+            inspectPort: options.inspectPort,
         });
         const home = process.env.HOME || process.env.USERPROFILE || '';
         const globalDriversDir = path.join(home, '.testspectra', 'drivers');
@@ -162,7 +164,8 @@ export class RustCoreBridge {
                         // a real TTY (CI, or an external tool like the VS Code extension spawning this process
                         // via a pipe) — in that case this raw line is the *only* live signal a wrapping process
                         // can see, so it must still reach stdout verbatim.
-                        if (!reporter.isInteractiveMode()) {
+                        // Always forward inspector websocket URL so IDE tools can attach directly.
+                        if (line.startsWith('[TESTSPECTRA_DEBUG_INSPECTOR]') || !reporter.isInteractiveMode()) {
                             console.log(line);
                         }
                         continue;

package/dist/runner/reporter.d.ts

@@ -1,55 +1,17 @@
-export interface TestLog {
-    timestamp: string;
-    level: 'INFO' | 'SUCCESS' | 'WARNING' | 'ERROR' | 'DEBUG' | string;
-    message: string;
-}
-export interface NetworkResource {
-    requestId: string;
-    url: string;
-    method: string;
-    status: number;
-}
-export interface TestRunResult {
-    status: 'passed' | 'failed' | 'error' | string;
-    duration: string;
-    passedCount: number;
-    failedCount: number;
-    logs: TestLog[];
-    networkResources?: NetworkResource[];
-}
-export interface PendingStep {
-    text: string;
-    duration: number;
-    passed: boolean;
-}
-export interface PendingTestCase {
-    title: string;
-    workerId?: number;
-    steps: PendingStep[];
-    currentStep?: string;
-    errorMsg?: string;
-    startTime: number;
-}
-export declare class Reporter {
-    private logs;
-    private networkEvents;
-    private pendingTests;
-    private workerToTest;
-    private pendingErrorMsg?;
-    private passedCount;
-    private failedCount;
+import { type ActionKey, type AssertionKey, type ExecutionSummary, formatAction, formatAssertion, type NetworkResource, parseAndFormat, type PendingStep, type PendingTestCase, type ReporterOptions, SemanticReporter, stripAnsi, type TestLog, type TestRunResult } from '@testspectra/reporter';
+export { type ActionKey, type AssertionKey, type ExecutionSummary, formatAction, formatAssertion, type NetworkResource, parseAndFormat, type PendingStep, type PendingTestCase, type ReporterOptions, SemanticReporter, stripAnsi, type TestLog, type TestRunResult, };
+export declare class Reporter extends SemanticReporter {
     private isInteractive;
     private lastRenderedLines;
     private spinnerFrames;
     private spinnerIndex;
     private spinnerTimer;
-    constructor();
+    constructor(options?: ReporterOptions);
     /** Whether this reporter is drawing the live-updating interactive terminal UI (real TTY, not CI/VS Code/test). */
     isInteractiveMode(): boolean;
     private clearActiveSlots;
     private renderActiveSlots;
-    private resolveTestCase;
-    addLog(log: TestLog): void;
+    addLog(input: string | TestLog): void;
     addNetwork(res: NetworkResource): void;
     getLogs(): TestLog[];
     getNetworkEvents(): NetworkResource[];

package/dist/runner/reporter.js

@@ -1,169 +1,14 @@
+import { formatAction, formatAssertion, parseAndFormat, SemanticReporter, stripAnsi, } from '@testspectra/reporter';
 import chalk from 'chalk';
-import { formatAction, formatAssertion } from '../reporter/semantic-formatter.js';
-function stripAnsi(str) {
-    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
-}
-function mapActionArgs(key, arr) {
-    if (!Array.isArray(arr)) {
-        return typeof arr === 'object' && arr !== null ? arr : {};
-    }
-    switch (key) {
-        case 'type':
-            return { text: arr[0] };
-        case 'select':
-        case 'selectOption':
-            return { option: arr[0] };
-        case 'dragDrop':
-            return { dest: arr[0] };
-        case 'longPress':
-            return { durationMs: arr[0] };
-        case 'navigate':
-            return { url: arr[0] };
-        case 'setCookies':
-            return { url: arr[0] };
-        case 'setViewport':
-            return { width: arr[0], height: arr[1] };
-        case 'wait':
-            return { ms: arr[0] };
-        case 'pressKey':
-            return { key: arr[0] };
-        case 'scroll':
-            return { direction: arr[0], pixels: arr[1] };
-        case 'swipe':
-            return { direction: arr[0], distance: arr[1] };
-        case 'intercept':
-            return { method: arr[0], url: arr[1] };
-        default:
-            return {};
-    }
-}
-function mapAssertionArgs(key, arr) {
-    if (!Array.isArray(arr)) {
-        return typeof arr === 'object' && arr !== null ? arr : { expected: arr };
-    }
-    if (key === 'have.attr' || key === 'not.have.attr') {
-        return arr.length >= 2 ? { name: arr[0], value: arr[1], expected: arr[0] } : { name: arr[0], expected: arr[0] };
-    }
-    if (key === 'have.css' || key === 'not.have.css') {
-        return { name: arr[0], property: arr[0], value: arr[1], expected: arr[0] };
-    }
-    if (arr.length >= 2) {
-        return { name: arr[0], value: arr[1], expected: arr[0] };
-    }
-    return {
-        expected: arr[0],
-        name: arr[0],
-        text: arr[0],
-        value: arr[0],
-        title: arr[0],
-        url: arr[0],
-        length: arr[0],
-        min: arr[0],
-        max: arr[0],
-    };
-}
-function parseAndFormat(cmdText) {
-    try {
-        const payload = JSON.parse(cmdText);
-        // Passed through as-is (not pre-flattened to a bare string here) — `formatAction`/
-        // `formatAssertion` already do the same `.selector`/`.name`/`.target` fallback lookup
-        // themselves, and only the raw object retains `.parent` for a scoped (`element.get()`/
-        // `.getAll()`-chained) target, which they need to render the "within" phrasing.
-        const target = payload.target;
-        if (payload.type === 'action') {
-            return formatAction(payload.key, target, mapActionArgs(payload.key, payload.args || []));
-        }
-        else if (payload.type === 'assertion' || payload.type === 'browser') {
-            return formatAssertion(payload.key, target, mapAssertionArgs(payload.key, payload.args || []));
-        }
-        // Native Orchestrator payload format ({ test, action, selector, target, ... })
-        if (payload.action) {
-            const action = payload.action;
-            const t = payload.selector || payload.target;
-            switch (action) {
-                case 'navigate':
-                    return formatAction('navigate', undefined, {
-                        url: t || payload.url || payload.value || 'http://localhost:5173',
-                    });
-                case 'click':
-                    return formatAction('click', t);
-                case 'double_click':
-                case 'doubleClick':
-                    return formatAction('doubleClick', t);
-                case 'right_click':
-                case 'rightClick':
-                    return formatAction('rightClick', t);
-                case 'type':
-                case 'type_text':
-                case 'set_value':
-                    return formatAction('type', t, { text: payload.text || payload.value });
-                case 'clear':
-                    return formatAction('clear', t);
-                case 'hover':
-                    return formatAction('hover', t);
-                case 'scroll_into_view':
-                case 'scrollIntoView':
-                    return formatAction('scrollIntoView', t);
-                case 'should_be_visible':
-                    return formatAssertion('be.visible', t);
-                case 'should_not_be_visible':
-                    return formatAssertion('not.be.visible', t);
-                case 'should_exist':
-                    return formatAssertion('exist', t);
-                case 'should_not_exist':
-                    return formatAssertion('not.exist', t);
-                case 'should_be_enabled':
-                    return formatAssertion('be.enabled', t);
-                case 'should_be_disabled':
-                    return formatAssertion('be.disabled', t);
-                case 'should_be_clickable':
-                    return formatAssertion('be.clickable', t);
-                case 'should_have_text':
-                    return formatAssertion('have.text', t, { expected: payload.expected || payload.text || payload.value });
-                case 'should_contain_text':
-                    return formatAssertion('contain.text', t, {
-                        expected: payload.expected || payload.text || payload.value,
-                    });
-                case 'should_have_value':
-                    return formatAssertion('have.value', t, { expected: payload.expected || payload.value });
-                case 'should_contain_value':
-                    return formatAssertion('contain.value', t, { expected: payload.expected || payload.value });
-                case 'should_have_length':
-                    return formatAssertion('have.length', t, {
-                        expected: payload.expected || payload.length || payload.value,
-                    });
-                case 'should_have_title':
-                    return formatAssertion('have.title', undefined, {
-                        expected: payload.expected || payload.value || t || 'TestSpectra',
-                    });
-                case 'should_be_empty':
-                    return formatAssertion('be.empty', t);
-                case 'should_not_be_empty':
-                    return formatAssertion('not.be.empty', t);
-                default:
-                    return `Execute step "${action}" on ${t || 'target'}`;
-            }
-        }
-        return cmdText;
-    }
-    catch {
-        return cmdText;
-    }
-}
-export class Reporter {
-    logs = [];
-    networkEvents = [];
-    pendingTests = new Map();
-    workerToTest = new Map();
-    pendingErrorMsg;
-    passedCount = 0;
-    failedCount = 0;
+export { formatAction, formatAssertion, parseAndFormat, SemanticReporter, stripAnsi, };
+export class Reporter extends SemanticReporter {
     isInteractive;
     lastRenderedLines = 0;
     spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     spinnerIndex = 0;
     spinnerTimer = null;
-    constructor() {
+    constructor(options = {}) {
+        super(options);
         this.isInteractive = Boolean(process.stdout.isTTY && !process.env.CI && process.env.NODE_ENV !== 'test' && !process.env.VITEST);
         if (this.isInteractive) {
             this.spinnerTimer = setInterval(() => {
@@ -211,23 +56,16 @@ export class Reporter {
         }
         this.lastRenderedLines = linesCount;
     }
-    resolveTestCase(testTitle, workerId) {
-        if (testTitle && this.pendingTests.has(testTitle)) {
-            return this.pendingTests.get(testTitle);
-        }
-        if (workerId !== undefined && this.workerToTest.has(workerId)) {
-            const title = this.workerToTest.get(workerId);
-            if (title && this.pendingTests.has(title)) {
-                return this.pendingTests.get(title);
+    addLog(input) {
+        const log = typeof input === 'string'
+            ? {
+                timestamp: new Date().toISOString(),
+                level: 'INFO',
+                message: input,
             }
-        }
-        if (this.pendingTests.size === 1) {
-            return this.pendingTests.values().next().value;
-        }
-        return Array.from(this.pendingTests.values()).pop();
-    }
-    addLog(log) {
+            : input;
         this.logs.push(log);
+        this.options.onLog?.(log);
         const raw = stripAnsi(log.message || '').trim();
         if (!raw)
             return;
@@ -284,6 +122,7 @@ export class Reporter {
                 this.workerToTest.set(workerId, title);
             }
             this.renderActiveSlots();
+            this.options.onTestStart?.(pending);
             return;
         }
         // 2. Step in-progress / start
@@ -303,6 +142,7 @@ export class Reporter {
                 testCase.currentStep = formatted;
                 this.renderActiveSlots();
             }
+            this.options.onStepStart?.(testTitle || testCase?.title || '', formatted, workerId ?? testCase?.workerId);
             return;
         }
         // 3. Step passed -> record step to matching test case
@@ -321,11 +161,13 @@ export class Reporter {
             }
             catch { }
             const testCase = this.resolveTestCase(testTitle, workerId);
+            const step = { text: formatted, duration, passed: true };
             if (testCase) {
-                testCase.steps.push({ text: formatted, duration, passed: true });
+                testCase.steps.push(step);
                 testCase.currentStep = formatted;
                 this.renderActiveSlots();
             }
+            this.options.onStepPass?.(testTitle || testCase?.title || '', step, workerId ?? testCase?.workerId);
             return;
         }
         // 4. Step failed -> record failed step to matching test case
@@ -344,11 +186,28 @@ export class Reporter {
             }
             catch { }
             const testCase = this.resolveTestCase(testTitle, workerId);
+            const step = { text: formatted, duration, passed: false };
             if (testCase) {
-                testCase.steps.push({ text: formatted, duration, passed: false });
+                testCase.steps.push(step);
                 testCase.currentStep = formatted;
                 this.renderActiveSlots();
             }
+            this.options.onStepFail?.(testTitle || testCase?.title || '', step, workerId ?? testCase?.workerId);
+            return;
+        }
+        // 4.5 Video capture notification
+        if (raw.startsWith('[TESTSPECTRA_VIDEO]')) {
+            const content = raw.replace('[TESTSPECTRA_VIDEO]', '').trim();
+            try {
+                const payload = JSON.parse(content);
+                if (payload.videoPath) {
+                    const testCase = this.resolveTestCase(payload.id);
+                    if (testCase) {
+                        testCase.videoPath = payload.videoPath;
+                    }
+                }
+            }
+            catch { }
             return;
         }
         // 5. Test error detail
@@ -361,6 +220,7 @@ export class Reporter {
             else {
                 this.pendingErrorMsg = this.pendingErrorMsg ? `${this.pendingErrorMsg}\n${err}` : err;
             }
+            this.options.onTestError?.(err, latest?.title, latest?.workerId);
             return;
         }
         // 6. Test passed completely -> flush atomic test block to permanent history
@@ -384,6 +244,7 @@ export class Reporter {
             }
             console.log('');
             this.renderActiveSlots();
+            this.options.onTestPass?.({ title, duration, steps, workerId });
             return;
         }
         // 7. Test failed completely -> flush atomic failed test block to permanent history
@@ -397,6 +258,7 @@ export class Reporter {
             const steps = testCase?.steps || [];
             const errorMsg = testCase?.errorMsg || this.pendingErrorMsg;
             this.pendingErrorMsg = undefined;
+            const videoPath = testCase?.videoPath;
             const workerId = testCase?.workerId;
             this.pendingTests.delete(title);
             if (workerId !== undefined) {
@@ -419,17 +281,21 @@ export class Reporter {
                     console.log(`      \x1b[38;2;248;113;113m${errLines[i]}\x1b[0m`);
                 }
             }
+            if (videoPath) {
+                console.log(`    \x1b[38;2;251;191;36m↳ Video:\x1b[0m \x1b[38;2;251;191;36m${videoPath}\x1b[0m`);
+            }
             console.log('');
             this.renderActiveSlots();
+            this.options.onTestFail?.({ title, duration, steps, errorMsg, workerId });
             return;
         }
         // Generic errors & warnings
-        if (log.level === 'ERROR' || log.level === 'FAILED') {
+        if (log.level === 'ERROR') {
             this.clearActiveSlots();
             console.log(`  \x1b[38;2;248;113;113m${log.message}\x1b[0m`);
             this.renderActiveSlots();
         }
-        else if (log.level === 'WARN' || log.level === 'WARNING') {
+        else if (log.level === 'WARNING') {
             this.clearActiveSlots();
             console.log(`  \x1b[38;2;251;191;36m${log.message}\x1b[0m`);
             this.renderActiveSlots();
@@ -437,6 +303,7 @@ export class Reporter {
     }
     addNetwork(res) {
         this.networkEvents.push(res);
+        this.options.onNetwork?.(res);
     }
     getLogs() {
         return this.logs;

package/dist/utils/__tests__/demo-state.test.d.ts

@@ -0,0 +1 @@
+export {};