@silasfmartins/testhub 1.0.0

package/dist/src/playwright/actions/ActionTimeline.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Timeline estruturada de ações — coleta eventos durante execução dos testes
+ * e gera relatórios ao final.
+ * @module actions/ActionTimeline
+ */
+import type { ActionEvent, ActionEventStatus, ActionEventType, TimelineSummary } from './types.js';
+/**
+ * Singleton que coleta todos os eventos de ação durante um teste.
+ * Usado internamente pelo WebActions para registrar cada ação.
+ */
+export declare class ActionTimeline {
+    private static events;
+    private static enabled;
+    /** Habilitar/desabilitar a timeline (default: true). */
+    static setEnabled(value: boolean): void;
+    /** Limpar todos os eventos (chamar no início de cada teste). */
+    static reset(): void;
+    /** Registrar um evento na timeline. */
+    static record(type: ActionEventType, action: string, status: ActionEventStatus, duration: number, details?: Partial<Pick<ActionEvent, 'selector' | 'selectorType' | 'description' | 'error' | 'value' | 'metadata'>>): void;
+    /** Obter todos os eventos registrados. */
+    static getEvents(): ReadonlyArray<ActionEvent>;
+    /** Obter os últimos N eventos. */
+    static getLastEvents(n: number): ReadonlyArray<ActionEvent>;
+    /** Obter eventos de erro/falha. */
+    static getFailures(): ReadonlyArray<ActionEvent>;
+    /** Gerar resumo da timeline. */
+    static getSummary(): TimelineSummary;
+    /**
+     * Exportar timeline como JSON (para anexar ao relatório de teste).
+     */
+    static toJSON(): string;
+    /**
+     * Exportar timeline como tabela legível para logs.
+     */
+    static toTable(): string;
+}

package/dist/src/playwright/actions/ActionTimeline.js

@@ -0,0 +1,101 @@
+/**
+ * Singleton que coleta todos os eventos de ação durante um teste.
+ * Usado internamente pelo WebActions para registrar cada ação.
+ */
+export class ActionTimeline {
+    static events = [];
+    static enabled = true;
+    /** Habilitar/desabilitar a timeline (default: true). */
+    static setEnabled(value) {
+        ActionTimeline.enabled = value;
+    }
+    /** Limpar todos os eventos (chamar no início de cada teste). */
+    static reset() {
+        ActionTimeline.events = [];
+    }
+    /** Registrar um evento na timeline. */
+    static record(type, action, status, duration, details) {
+        if (!ActionTimeline.enabled)
+            return;
+        ActionTimeline.events.push({
+            timestamp: Date.now(),
+            type,
+            action,
+            status,
+            duration,
+            ...details,
+        });
+    }
+    /** Obter todos os eventos registrados. */
+    static getEvents() {
+        return ActionTimeline.events;
+    }
+    /** Obter os últimos N eventos. */
+    static getLastEvents(n) {
+        return ActionTimeline.events.slice(-n);
+    }
+    /** Obter eventos de erro/falha. */
+    static getFailures() {
+        return ActionTimeline.events.filter(e => e.status === 'failure');
+    }
+    /** Gerar resumo da timeline. */
+    static getSummary() {
+        const events = ActionTimeline.events;
+        const byAction = {};
+        let slowest = null;
+        for (const e of events) {
+            if (!byAction[e.action]) {
+                byAction[e.action] = { count: 0, totalDuration: 0, failures: 0 };
+            }
+            byAction[e.action].count++;
+            byAction[e.action].totalDuration += e.duration;
+            if (e.status === 'failure')
+                byAction[e.action].failures++;
+            if (!slowest || e.duration > slowest.duration)
+                slowest = e;
+        }
+        const first = events[0]?.timestamp ?? 0;
+        const last = events.at(-1)?.timestamp ?? 0;
+        return {
+            totalEvents: events.length,
+            successes: events.filter(e => e.status === 'success').length,
+            failures: events.filter(e => e.status === 'failure').length,
+            retries: events.filter(e => e.status === 'retry').length,
+            totalDuration: last - first,
+            slowestAction: slowest,
+            byAction,
+        };
+    }
+    /**
+     * Exportar timeline como JSON (para anexar ao relatório de teste).
+     */
+    static toJSON() {
+        return JSON.stringify({
+            events: ActionTimeline.events,
+            summary: ActionTimeline.getSummary(),
+        }, null, 2);
+    }
+    /**
+     * Exportar timeline como tabela legível para logs.
+     */
+    static toTable() {
+        if (ActionTimeline.events.length === 0)
+            return '(nenhum evento registrado)';
+        const lines = ['#  | Ação                | Dur(ms) | Status  | Seletor'];
+        const sep = '---|---------------------|---------|---------|--------';
+        lines.push(sep);
+        for (let i = 0; i < ActionTimeline.events.length; i++) {
+            const e = ActionTimeline.events[i];
+            const idx = String(i + 1).padStart(2);
+            const action = e.action.padEnd(19).slice(0, 19);
+            const dur = String(e.duration).padStart(7);
+            const status = e.status.padEnd(7).slice(0, 7);
+            const sel = (e.selector || '-').slice(0, 40);
+            lines.push(`${idx} | ${action} | ${dur} | ${status} | ${sel}`);
+        }
+        const summary = ActionTimeline.getSummary();
+        lines.push(sep);
+        lines.push(`Total: ${summary.totalEvents} eventos | ${summary.successes} ok | ${summary.failures} falhas | ${summary.totalDuration}ms`);
+        return lines.join('\n');
+    }
+}

package/dist/src/playwright/actions/RecoveryQueue.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Fila de recuperação assíncrona e não-bloqueante.
+ * As ações principais (click, fill, etc.) enfileiram falhas
+ * e o processamento ocorre em background, sem bloquear o fluxo.
+ * @module actions/RecoveryQueue
+ */
+/** Item na fila de recuperação. */
+export interface RecoveryQueueItem {
+    /** ID único do item. */
+    id: string;
+    /** Timestamp de quando foi enfileirado. */
+    enqueuedAt: number;
+    /** Nome da ação que falhou (click, fill, etc.). */
+    action: string;
+    /** Seletor do elemento. */
+    selector: string;
+    /** Mensagem de erro. */
+    error: string;
+    /** Metadados do contexto (testName, methodName, etc.). */
+    context: Record<string, unknown>;
+    /** Status de processamento. */
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    /** Resultado do processamento (se disponível). */
+    result?: unknown;
+}
+type RecoveryHandler = (item: RecoveryQueueItem) => Promise<void>;
+/**
+ * Fila de recuperação assíncrona.
+ *
+ * Falhas de ações são enfileiradas e processadas em background,
+ * sem bloquear a execução do teste principal.
+ *
+ * O processamento pode ser:
+ * - Automático (via handler registrado)
+ * - Manual (drenando a fila ao final do teste)
+ *
+ * @example
+ * ```typescript
+ * // Registrar handler
+ * RecoveryQueue.onProcess(async (item) => {
+ *   await analyzeFailure({ selector: item.selector, ... })
+ * })
+ *
+ * // Enfileirar falha (não bloqueia)
+ * RecoveryQueue.enqueue('click', '//button', 'Element not found', { test: 'CT001' })
+ *
+ * // Ao final do teste, drenar fila
+ * await RecoveryQueue.drain()
+ * ```
+ */
+export declare class RecoveryQueue {
+    private static queue;
+    private static handler;
+    private static processing;
+    private static maxItems;
+    private static counter;
+    /** Registrar handler para processar itens da fila. */
+    static onProcess(handler: RecoveryHandler): void;
+    /** Enfileirar uma falha para processamento assíncrono. */
+    static enqueue(action: string, selector: string, error: string, context?: Record<string, unknown>): void;
+    /** Processar próximo item da fila. */
+    private static processNext;
+    /**
+     * Drenar a fila — processar todos os itens pendentes.
+     * Útil para chamar ao final do teste.
+     */
+    static drain(): Promise<void>;
+    /** Obter itens da fila. */
+    static getItems(): ReadonlyArray<RecoveryQueueItem>;
+    /** Obter itens pendentes. */
+    static getPending(): ReadonlyArray<RecoveryQueueItem>;
+    /** Limpar a fila. */
+    static clear(): void;
+    /** Estatísticas da fila. */
+    static stats(): {
+        total: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    };
+}
+export {};

package/dist/src/playwright/actions/RecoveryQueue.js

@@ -0,0 +1,130 @@
+/**
+ * Fila de recuperação assíncrona e não-bloqueante.
+ * As ações principais (click, fill, etc.) enfileiram falhas
+ * e o processamento ocorre em background, sem bloquear o fluxo.
+ * @module actions/RecoveryQueue
+ */
+/**
+ * Fila de recuperação assíncrona.
+ *
+ * Falhas de ações são enfileiradas e processadas em background,
+ * sem bloquear a execução do teste principal.
+ *
+ * O processamento pode ser:
+ * - Automático (via handler registrado)
+ * - Manual (drenando a fila ao final do teste)
+ *
+ * @example
+ * ```typescript
+ * // Registrar handler
+ * RecoveryQueue.onProcess(async (item) => {
+ *   await analyzeFailure({ selector: item.selector, ... })
+ * })
+ *
+ * // Enfileirar falha (não bloqueia)
+ * RecoveryQueue.enqueue('click', '//button', 'Element not found', { test: 'CT001' })
+ *
+ * // Ao final do teste, drenar fila
+ * await RecoveryQueue.drain()
+ * ```
+ */
+export class RecoveryQueue {
+    static queue = [];
+    static handler = null;
+    static processing = false;
+    static maxItems = 50;
+    static counter = 0;
+    /** Registrar handler para processar itens da fila. */
+    static onProcess(handler) {
+        RecoveryQueue.handler = handler;
+    }
+    /** Enfileirar uma falha para processamento assíncrono. */
+    static enqueue(action, selector, error, context = {}) {
+        // Limitar tamanho da fila
+        if (RecoveryQueue.queue.length >= RecoveryQueue.maxItems) {
+            RecoveryQueue.queue.shift(); // Remover mais antigo
+        }
+        const item = {
+            id: `rq-${++RecoveryQueue.counter}-${Date.now()}`,
+            enqueuedAt: Date.now(),
+            action,
+            selector,
+            error,
+            context,
+            status: 'pending',
+        };
+        RecoveryQueue.queue.push(item);
+        // Tentar processar em background (fire-and-forget)
+        if (RecoveryQueue.handler && !RecoveryQueue.processing) {
+            RecoveryQueue.processNext().catch(() => { });
+        }
+    }
+    /** Processar próximo item da fila. */
+    static async processNext() {
+        if (RecoveryQueue.processing || !RecoveryQueue.handler)
+            return;
+        const item = RecoveryQueue.queue.find(i => i.status === 'pending');
+        if (!item)
+            return;
+        RecoveryQueue.processing = true;
+        item.status = 'processing';
+        try {
+            await RecoveryQueue.handler(item);
+            item.status = 'completed';
+        }
+        catch (err) {
+            item.status = 'failed';
+            item.result = err instanceof Error ? err.message : String(err);
+        }
+        finally {
+            RecoveryQueue.processing = false;
+        }
+        // Continuar com o próximo
+        const hasPending = RecoveryQueue.queue.some(i => i.status === 'pending');
+        if (hasPending) {
+            RecoveryQueue.processNext().catch(() => { });
+        }
+    }
+    /**
+     * Drenar a fila — processar todos os itens pendentes.
+     * Útil para chamar ao final do teste.
+     */
+    static async drain() {
+        if (!RecoveryQueue.handler)
+            return;
+        for (const item of RecoveryQueue.queue) {
+            if (item.status !== 'pending')
+                continue;
+            item.status = 'processing';
+            try {
+                await RecoveryQueue.handler(item);
+                item.status = 'completed';
+            }
+            catch {
+                item.status = 'failed';
+            }
+        }
+    }
+    /** Obter itens da fila. */
+    static getItems() {
+        return RecoveryQueue.queue;
+    }
+    /** Obter itens pendentes. */
+    static getPending() {
+        return RecoveryQueue.queue.filter(i => i.status === 'pending');
+    }
+    /** Limpar a fila. */
+    static clear() {
+        RecoveryQueue.queue = [];
+        RecoveryQueue.counter = 0;
+    }
+    /** Estatísticas da fila. */
+    static stats() {
+        return {
+            total: RecoveryQueue.queue.length,
+            pending: RecoveryQueue.queue.filter(i => i.status === 'pending').length,
+            completed: RecoveryQueue.queue.filter(i => i.status === 'completed').length,
+            failed: RecoveryQueue.queue.filter(i => i.status === 'failed').length,
+        };
+    }
+}

package/dist/src/playwright/actions/SelectorCache.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Cache de seletores com TTL — evita queries DOM repetitivas.
+ * @module actions/SelectorCache
+ */
+/**
+ * Cache de seletores com TTL curto para reduzir queries DOM repetitivas.
+ *
+ * Quando um seletor (ou suas variantes) é resolvido com sucesso,
+ * o resultado é cacheado. Chamadas subsequentes dentro do TTL
+ * retornam o valor cacheado sem re-processar variantes.
+ *
+ * @example
+ * ```typescript
+ * // No primeiro uso, gera candidatos e busca no DOM
+ * const sel = SelectorCache.getOrResolve(xpath, candidatesFn)
+ *
+ * // No segundo uso (dentro do TTL), retorna do cache
+ * const sel2 = SelectorCache.getOrResolve(xpath, candidatesFn)
+ * ```
+ */
+export declare class SelectorCache {
+    private static cache;
+    /** TTL padrão em ms (default: 500ms — curto para não ficar stale). */
+    private static ttlMs;
+    /** Máximo de entradas no cache para evitar memory leak. */
+    private static maxEntries;
+    /**
+     * Busca seletor no cache. Retorna null se não encontrado ou expirado.
+     */
+    static get(originalSelector: string): string | null;
+    /**
+     * Armazena resultado resolvido no cache.
+     */
+    static set(originalSelector: string, resolvedSelector: string): void;
+    /**
+     * Busca no cache ou resolve via callback.
+     * Se o cache tem resultado válido, retorna direto.
+     * Caso contrário, chama resolveFn e armazena o resultado.
+     */
+    static getOrResolve(originalSelector: string, resolveFn: () => Promise<string | null>): Promise<string | null>;
+    /** Limpar todo o cache (chamar entre testes ou navegações). */
+    static clear(): void;
+    /** Remover entradas expiradas manualmente. */
+    static prune(): void;
+    /** Estatísticas do cache. */
+    static stats(): {
+        size: number;
+        ttlMs: number;
+        maxEntries: number;
+    };
+    /** Configurar TTL. */
+    static setTTL(ms: number): void;
+}

package/dist/src/playwright/actions/SelectorCache.js

@@ -0,0 +1,96 @@
+/**
+ * Cache de seletores com TTL — evita queries DOM repetitivas.
+ * @module actions/SelectorCache
+ */
+/**
+ * Cache de seletores com TTL curto para reduzir queries DOM repetitivas.
+ *
+ * Quando um seletor (ou suas variantes) é resolvido com sucesso,
+ * o resultado é cacheado. Chamadas subsequentes dentro do TTL
+ * retornam o valor cacheado sem re-processar variantes.
+ *
+ * @example
+ * ```typescript
+ * // No primeiro uso, gera candidatos e busca no DOM
+ * const sel = SelectorCache.getOrResolve(xpath, candidatesFn)
+ *
+ * // No segundo uso (dentro do TTL), retorna do cache
+ * const sel2 = SelectorCache.getOrResolve(xpath, candidatesFn)
+ * ```
+ */
+export class SelectorCache {
+    static cache = new Map();
+    /** TTL padrão em ms (default: 500ms — curto para não ficar stale). */
+    static ttlMs = Number(process.env.AUTOCORE_SELECTOR_CACHE_TTL_MS || '500');
+    /** Máximo de entradas no cache para evitar memory leak. */
+    static maxEntries = 200;
+    /**
+     * Busca seletor no cache. Retorna null se não encontrado ou expirado.
+     */
+    static get(originalSelector) {
+        const entry = SelectorCache.cache.get(originalSelector);
+        if (!entry)
+            return null;
+        if (Date.now() - entry.cachedAt > SelectorCache.ttlMs) {
+            SelectorCache.cache.delete(originalSelector);
+            return null;
+        }
+        return entry.resolvedSelector;
+    }
+    /**
+     * Armazena resultado resolvido no cache.
+     */
+    static set(originalSelector, resolvedSelector) {
+        // Evitar crescimento infinito
+        if (SelectorCache.cache.size >= SelectorCache.maxEntries) {
+            // Remover entradas mais antigas (FIFO)
+            const firstKey = SelectorCache.cache.keys().next().value;
+            if (firstKey)
+                SelectorCache.cache.delete(firstKey);
+        }
+        SelectorCache.cache.set(originalSelector, {
+            resolvedSelector,
+            cachedAt: Date.now(),
+        });
+    }
+    /**
+     * Busca no cache ou resolve via callback.
+     * Se o cache tem resultado válido, retorna direto.
+     * Caso contrário, chama resolveFn e armazena o resultado.
+     */
+    static async getOrResolve(originalSelector, resolveFn) {
+        const cached = SelectorCache.get(originalSelector);
+        if (cached)
+            return cached;
+        const resolved = await resolveFn();
+        if (resolved) {
+            SelectorCache.set(originalSelector, resolved);
+        }
+        return resolved;
+    }
+    /** Limpar todo o cache (chamar entre testes ou navegações). */
+    static clear() {
+        SelectorCache.cache.clear();
+    }
+    /** Remover entradas expiradas manualmente. */
+    static prune() {
+        const now = Date.now();
+        for (const [key, entry] of SelectorCache.cache) {
+            if (now - entry.cachedAt > SelectorCache.ttlMs) {
+                SelectorCache.cache.delete(key);
+            }
+        }
+    }
+    /** Estatísticas do cache. */
+    static stats() {
+        return {
+            size: SelectorCache.cache.size,
+            ttlMs: SelectorCache.ttlMs,
+            maxEntries: SelectorCache.maxEntries,
+        };
+    }
+    /** Configurar TTL. */
+    static setTTL(ms) {
+        SelectorCache.ttlMs = ms;
+    }
+}

package/dist/src/playwright/actions/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Módulos auxiliares para o WebActions — tipos, cache, timeline e fila de recovery.
+ *
+ * WebActions continua como fachada principal. Estes módulos são usados
+ * internamente e também podem ser importados diretamente quando necessário.
+ *
+ * @module actions
+ */
+export type { ClickOptions, FillOptions, SelectOptions, HoverOptions, ScreenshotOptions, ScrollOptions, KeyboardOptions, NavigationOptions, WaitOptions, ActionEvent, ActionEventType, ActionEventStatus, TimelineSummary, } from './types.js';
+export { ActionTimeline } from './ActionTimeline.js';
+export { SelectorCache } from './SelectorCache.js';
+export { RecoveryQueue } from './RecoveryQueue.js';
+export type { RecoveryQueueItem } from './RecoveryQueue.js';

package/dist/src/playwright/actions/index.js

@@ -0,0 +1,14 @@
+/**
+ * Módulos auxiliares para o WebActions — tipos, cache, timeline e fila de recovery.
+ *
+ * WebActions continua como fachada principal. Estes módulos são usados
+ * internamente e também podem ser importados diretamente quando necessário.
+ *
+ * @module actions
+ */
+// Timeline de ações (Item 7)
+export { ActionTimeline } from './ActionTimeline.js';
+// Cache de seletores (Item 5)
+export { SelectorCache } from './SelectorCache.js';
+// Fila de recovery assíncrona (Item 6)
+export { RecoveryQueue } from './RecoveryQueue.js';

package/dist/src/playwright/actions/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Tipos compartilhados para os módulos de ações do WebActions.
+ * @module actions/types
+ */
+/** Opções para ações de click. */
+export interface ClickOptions {
+    /** Timeout em ms (default: project timeout). */
+    timeout?: number;
+    /** Forçar click mesmo se o elemento estiver coberto. */
+    force?: boolean;
+    /** Botão do mouse. */
+    button?: 'left' | 'middle' | 'right';
+    /** Posição relativa ao canto superior-esquerdo do elemento. */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Número de cliques (1=single, 2=double). */
+    clickCount?: number;
+    /** Delay entre mousedown e mouseup em ms. */
+    delay?: number;
+    /** Modificadores de tecla pressionados durante o click. */
+    modifiers?: Array<'Alt' | 'Control' | 'Meta' | 'Shift'>;
+    /** Se deve aguardar navegação após o click. */
+    noWaitAfter?: boolean;
+}
+/** Opções para ações de fill/type. */
+export interface FillOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Se deve aguardar navegação após preencher. */
+    noWaitAfter?: boolean;
+    /** Se deve forçar a limpeza antes de preencher. */
+    force?: boolean;
+}
+/** Opções para ações de select. */
+export interface SelectOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Se deve forçar a seleção. */
+    force?: boolean;
+    /** Se deve aguardar navegação. */
+    noWaitAfter?: boolean;
+}
+/** Opções para ações de hover. */
+export interface HoverOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Posição relativa ao elemento. */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Forçar hover mesmo se coberto. */
+    force?: boolean;
+    /** Modificadores de tecla. */
+    modifiers?: Array<'Alt' | 'Control' | 'Meta' | 'Shift'>;
+}
+/** Opções para ações de screenshot. */
+export interface ScreenshotOptions {
+    /** Caminho para salvar o arquivo. */
+    path?: string;
+    /** Tipo de imagem. */
+    type?: 'png' | 'jpeg';
+    /** Qualidade (0-100, apenas jpeg). */
+    quality?: number;
+    /** Capturar página inteira vs viewport. */
+    fullPage?: boolean;
+}
+/** Opções para ações de scroll. */
+export interface ScrollOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Comportamento de scroll. */
+    behavior?: 'auto' | 'smooth';
+}
+/** Opções para ações de keyboard. */
+export interface KeyboardOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Delay entre keydown e keyup em ms. */
+    delay?: number;
+}
+/** Opções para ações de navegação. */
+export interface NavigationOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Condição para considerar a navegação completa. */
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle' | 'commit';
+}
+/** Opções para ações de wait. */
+export interface WaitOptions {
+    /** Timeout em ms. */
+    timeout?: number;
+    /** Estado esperado do elemento. */
+    state?: 'attached' | 'detached' | 'visible' | 'hidden';
+}
+/** Tipo de evento na timeline. */
+export type ActionEventType = 'action' | 'wait' | 'assertion' | 'navigation' | 'error' | 'recovery';
+/** Status do evento. */
+export type ActionEventStatus = 'success' | 'failure' | 'retry' | 'skipped';
+/** Evento individual na timeline de ações. */
+export interface ActionEvent {
+    /** Timestamp de início (Date.now()). */
+    timestamp: number;
+    /** Tipo do evento. */
+    type: ActionEventType;
+    /** Nome da ação (click, fill, waitForVisible, etc.). */
+    action: string;
+    /** Duração em ms. */
+    duration: number;
+    /** Seletor do elemento (se aplicável). */
+    selector?: string;
+    /** Tipo do seletor (XPath, CSS, Locator). */
+    selectorType?: string;
+    /** Status do evento. */
+    status: ActionEventStatus;
+    /** Descrição da ação (do parâmetro descricao). */
+    description?: string;
+    /** Mensagem de erro (se houver). */
+    error?: string;
+    /** Valor envolvido na ação (texto preenchido, opção selecionada). */
+    value?: string;
+    /** Metadados extras. */
+    metadata?: Record<string, unknown>;
+}
+/** Resumo da timeline. */
+export interface TimelineSummary {
+    /** Total de eventos. */
+    totalEvents: number;
+    /** Total de sucesso. */
+    successes: number;
+    /** Total de falhas. */
+    failures: number;
+    /** Total de retries. */
+    retries: number;
+    /** Duração total (primeiro ao último evento). */
+    totalDuration: number;
+    /** Evento mais lento. */
+    slowestAction: ActionEvent | null;
+    /** Breakdown por tipo de ação. */
+    byAction: Record<string, {
+        count: number;
+        totalDuration: number;
+        failures: number;
+    }>;
+}

package/dist/src/playwright/actions/types.js

@@ -0,0 +1,5 @@
+/**
+ * Tipos compartilhados para os módulos de ações do WebActions.
+ * @module actions/types
+ */
+export {};