@silasfmartins/testhub 1.0.0

package/dist/src/testContext/TestAnnotations.js

@@ -0,0 +1,2647 @@
+import { ApiActions } from '../api/ApiActions.js';
+import { MobileConnection } from '../appium/MobileConnection.js';
+import { BancoActions } from '../helpers/BancoActions.js';
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { SSHActions } from '../ssh/SSHActions.js';
+import { ativarInterceptacaoMagica } from '../utils/InterceptacaoMagica.js';
+import { interceptAllStatements } from '../utils/StatementInterceptor.js';
+import { ativarStatementLogs } from '../utils/StatementLogger.js';
+import { TerminalLogCapture } from '../utils/TerminalLogCapture.js';
+import { CoverageManager } from './CoverageManager.js';
+import { TestContext } from './TestContext.js';
+import { DynamicConfigManager } from '../testhub/DynamicConfigManager.js';
+import { UnifiedReportManager, } from './UnifiedReportManager.js';
+import SystemsManager from '../testhub/SystemsManager.js';
+import DesktopConnection from '../desktop/DesktopConnection.js';
+/**
+ * 🆕 HELPER CRÍTICO: Garante que TerminalLogCapture está ativo no worker atual
+ * Em multi-worker do Playwright, cada worker é um processo separado
+ * e precisa iniciar sua própria instância de captura de logs.
+ * @param testName Nome do teste (CN) para associar logs
+ * @param ctName Nome do CT atual (opcional)
+ */
+function ensureTerminalLogCaptureActive(testName, ctName) {
+    try {
+        // Sempre chamar start() - ele tem verificação interna para evitar duplicação
+        TerminalLogCapture.start();
+        globalThis.TerminalLogCapture = TerminalLogCapture;
+        // Definir o teste atual para associar logs
+        TerminalLogCapture.setCurrentTest(testName);
+        // Definir o CT atual se fornecido
+        if (ctName) {
+            TerminalLogCapture.setCurrentCT(ctName);
+        }
+    }
+    catch {
+        // Silenciosamente ignorar erro
+    }
+}
+/**
+ * Map para rastrear início dos testes
+ */
+const testStartTimes = new Map();
+/**
+ * Tracking de CT ativo atual
+ */
+let currentActiveCT = null;
+/**
+ * Flags para evitar loop infinito de interceptadores
+ */
+const interceptorsAtivos = new Set();
+/**
+ * 🛑 Flag global para parar execução ao falhar
+ * Pode ser ativada no escopo do test.describe() para aplicar a todos os CTs
+ */
+let stopOnFailureEnabled = false;
+/**
+ * � CRÍTICO: Importar interceptador universal para garantir ativação
+ */
+// Sistema automático ativo - interceptação agora é automática via StatementTracker
+// AutoStatementInterceptor foi removido, tudo é automático agora
+/**
+ * �🆕 Sistema de captura de logs de ações de CTs
+ */
+const originalConsoleLog = console.log;
+const originalConsoleInfo = console.info;
+const originalConsoleWarn = console.warn;
+const originalConsoleError = console.error;
+let logsCapturados = [];
+let interceptacaoLogsAtiva = false;
+const LOGS_GLOBAL_KEYS = ['logsCapturados', '__AUTOCORE_LOGS_CAPTURADOS__'];
+function atualizarReferenciaGlobalDosLogs() {
+    try {
+        for (const key of LOGS_GLOBAL_KEYS) {
+            ;
+            globalThis[key] = logsCapturados;
+        }
+    }
+    catch {
+        // Não deve quebrar fluxo se globalThis não estiver disponível
+    }
+}
+atualizarReferenciaGlobalDosLogs();
+/**
+ * 🆕 Interceptar logs do console para capturar ações de CTs
+ */
+function interceptarLogs() {
+    if (interceptacaoLogsAtiva)
+        return;
+    interceptacaoLogsAtiva = true;
+    console.log = (...args) => {
+        const message = args
+            .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+            .join(' ');
+        // ✅ CORRIGIDO: Capturar TODOS os logs durante execução de CT (não apenas alguns emojis)
+        // Excluir apenas logs internos do sistema que não são relevantes para o usuário
+        const isInternalLog = message.includes('[DEBUG]') ||
+            message.includes('node_modules') ||
+            message.includes('webpack') ||
+            message.includes('Module build') ||
+            message.startsWith('Failed to load');
+        if (!isInternalLog) {
+            logsCapturados.push(`[${new Date().toISOString()}] ${message}`);
+            atualizarReferenciaGlobalDosLogs();
+            // Também registrar no UnifiedReportManager se possível
+            try {
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo?.title) {
+                    UnifiedReportManager.adicionarLog(testInfo.title, message);
+                }
+            }
+            catch {
+                // Ignorar erro se TestContext não estiver disponível
+            }
+        }
+        // Chamar console.log original
+        originalConsoleLog.apply(console, args);
+    };
+    console.info = (...args) => {
+        const message = args
+            .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+            .join(' ');
+        // ✅ Capturar todos os console.info
+        logsCapturados.push(`[${new Date().toISOString()}] INFO: ${message}`);
+        atualizarReferenciaGlobalDosLogs();
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.title) {
+                UnifiedReportManager.adicionarLog(testInfo.title, `INFO: ${message}`);
+            }
+        }
+        catch {
+            // Ignorar erro
+        }
+        originalConsoleInfo.apply(console, args);
+    };
+}
+/**
+ * Classe unificada para configurar contextos de teste e integração com UnifiedReportManager.
+ * Permite configurar automaticamente o contexto do teste (API, Frontend, Mobile, SSH, Banco, Mixed),
+ * registrar logs, metadados, screenshots e garantir limpeza automática de sessões mobile.
+ *
+ * ✅ AGORA COM SISTEMA AUTOMÁTICO - Não precisa configurar nada manualmente!
+ */
+export class TestAnnotations {
+    /**
+     * Opções do runner para testes desktop
+     * - attachWindow: se true, tentará iniciar/atacar uma janela da aplicação
+     * - closeWindow: se true, fechará a aplicação ao final do CT
+     * - app_path: caminho para o executável a ser iniciado
+     */
+    static runnerOptions = {};
+    /**
+     * Define opções do runner (attachWindow, closeWindow, app_path)
+     */
+    static async setRunnerOptions(options) {
+        this.runnerOptions = { ...(this.runnerOptions || {}), ...(options || {}) };
+        // Se attachWindow for true e app_path fornecido, tentar iniciar a app
+        try {
+            if (this.runnerOptions.attachWindow && this.runnerOptions.app_path) {
+                await DesktopConnection.startApp(this.runnerOptions.app_path);
+            }
+        }
+        catch (e) {
+            console.warn('⚠️ Falha ao iniciar aplicação via setRunnerOptions:', e);
+        }
+    }
+    /**
+     * ✅ REMOVIDO: inicializarAutoCore - Agora é automático!
+     * O sistema se inicializa sozinho quando o módulo é carregado.
+     */
+    /**
+     * 🛑 Ativa o modo "parar ao falhar" globalmente.
+     * Quando ativado, se um CT falhar, os próximos CTs não serão executados.
+     * Pode ser chamado no escopo do test.describe() para aplicar a todos os CTs do CN.
+     * @param enabled - true para ativar, false para desativar (padrão: true)
+     */
+    static stopOnFailure(enabled = true) {
+        stopOnFailureEnabled = enabled;
+        console.log(`🛑 [STOP-ON-FAILURE] ${enabled ? 'ATIVADO' : 'DESATIVADO'} globalmente`);
+    }
+    /**
+     * 🛑 Verifica se o modo "parar ao falhar" está ativo.
+     * @returns true se stopOnFailure está ativo
+     */
+    static isStopOnFailureEnabled() {
+        return stopOnFailureEnabled;
+    }
+    /**
+     * 🎯 NOVO: Captura CT diretamente do contexto do Playwright e registra automaticamente
+     */
+    static capturarCTDoPlaywright(cnName, ctName, testInfo) {
+        try {
+            // 🕐 NOVO: Capturar tempo de início para cálculo de duração
+            const ctStartTime = Date.now();
+            StatementTracker.startCT(ctName);
+            testInfo.__autocoreCtName = ctName;
+            testInfo.__autocoreCnName = cnName;
+            // Registrar relação CT ↔ CN para uso na finalização mesmo após troca de contexto
+            UnifiedReportManager.registrarCtParaCn(ctName, cnName);
+            // 2. Registrar que o CT foi detectado pelo Playwright
+            StatementTracker.recordAction('OTHER', `CT detectado pelo Playwright: ${ctName}`, true, undefined, {
+                method: 'Playwright Detection',
+                url: testInfo.file,
+            });
+            // 3. Configurar finalização automática quando o teste terminar
+            const originalAttach = testInfo.attach;
+            let ctFinalizado = false;
+            testInfo.attach = async function (name, options) {
+                // Interceptar attach para detectar fim do teste
+                const result = await originalAttach.call(this, name, options);
+                if (!ctFinalizado &&
+                    (name.includes('screenshot') || name.includes('trace'))) {
+                    // ⏱️ NOVO: Calcular duração real do teste
+                    const ctEndTime = Date.now();
+                    const ctDuration = ctEndTime - ctStartTime;
+                    console.log(`⏱️ [DURAÇÃO] CT executado em ${ctDuration}ms`);
+                    // Determinar status baseado no estado do teste
+                    const success = testInfo.status === 'passed' || testInfo.status === undefined;
+                    const errorMessage = testInfo.status === 'failed' ? 'Teste falhou' : undefined;
+                    console.log(`🏁 [PLAYWRIGHT-CT] Status do teste: ${testInfo.status}`);
+                    StatementTracker.endCT(ctName, success, errorMessage);
+                    // Fechar app se configurado no runner
+                    try {
+                        if (TestAnnotations.runnerOptions?.closeWindow) {
+                            await DesktopConnection.closeApp();
+                        }
+                    }
+                    catch (e) {
+                        console.warn('⚠️ Falha ao fechar app após CT:', e);
+                    }
+                    ctFinalizado = true;
+                }
+                return result;
+            };
+            // 4. Configurar timeout para finalizar CT caso não seja finalizado
+            setTimeout(() => {
+                if (!ctFinalizado) {
+                    // ⏱️ NOVO: Calcular duração mesmo no timeout
+                    const ctEndTime = Date.now();
+                    const ctDuration = ctEndTime - ctStartTime;
+                    console.log(`⏱️ [DURAÇÃO] CT executado em ${ctDuration}ms (timeout)`);
+                    const success = testInfo.status === 'passed' || testInfo.status === undefined;
+                    StatementTracker.endCT(ctName, success);
+                    // Fechar app se configurado no runner (fire-and-forget)
+                    try {
+                        if (TestAnnotations.runnerOptions?.closeWindow) {
+                            DesktopConnection.closeApp().catch(() => { });
+                        }
+                    }
+                    catch { }
+                    ctFinalizado = true;
+                }
+            }, 60_000); // 60 segundos
+        }
+        catch (error) {
+            console.error(`❌ [PLAYWRIGHT-CT] Erro ao capturar CT: ${error}`);
+        }
+    }
+    /**
+     * Detecta automaticamente o contexto principal do projeto a partir das variáveis de ambiente.
+     * @returns O tipo de contexto principal detectado.
+     */
+    static detectProjectContext() {
+        // 1. Verificar PROJECT_TYPE explícito
+        const projectType = process.env.PROJECT_TYPE?.toUpperCase();
+        if (projectType) {
+            switch (projectType) {
+                case 'API':
+                    return 'API';
+                case 'FRONTEND':
+                case 'WEB':
+                    return 'Frontend';
+                case 'MOBILE':
+                    return 'Mobile';
+                case 'SSH':
+                    return 'SSH';
+                case 'BANCO':
+                case 'DATABASE':
+                    return 'Banco';
+                case 'SCENARIOS':
+                    return 'Scenarios';
+                default:
+                    return 'Mixed';
+            }
+        }
+        // 2. 🔍 NOVA DETECÇÃO: Baseada no contexto real executado
+        try {
+            // Verificar se tem page Playwright ativo
+            const testContextPage = TestContext._page;
+            if (testContextPage && typeof testContextPage.goto === 'function') {
+                return 'Frontend';
+            }
+        }
+        catch { }
+        try {
+            // Verificar se tem driver mobile ativo
+            const mobileDriver = TestContext.appiumDriver;
+            if (mobileDriver) {
+                return 'Mobile';
+            }
+        }
+        catch { }
+        // 3. Detecção baseada em variáveis de ambiente
+        if (process.env.PLAYWRIGHT_BROWSERS_PATH || process.env.PWDEBUG) {
+            return 'Frontend';
+        }
+        if (process.env.APPIUM_HOME || process.env.DEVICEFARM_API_KEY) {
+            return 'Mobile';
+        }
+        // 4. Fallback: detectar por estrutura de arquivos
+        const projectStructure = process.cwd();
+        if (projectStructure.includes('mobile') ||
+            projectStructure.includes('appium')) {
+            return 'Mobile';
+        }
+        if (projectStructure.includes('frontend') ||
+            projectStructure.includes('e2e') ||
+            projectStructure.includes('ui')) {
+            return 'Frontend';
+        }
+        if (projectStructure.includes('api') &&
+            !projectStructure.includes('frontend')) {
+            return 'API';
+        }
+        // 5. Default: Mixed para projetos indefinidos
+        return 'Mixed';
+    }
+    /**
+     * Configuração automática do contexto do teste.
+     * Detecta o contexto, configura interceptadores e registra logs/metadados.
+     */
+    static Auto = {
+        set testInfo(testInfo) {
+            // 🆕 CRÍTICO: Garantir que TestContext está disponível globalmente
+            // Especialmente importante para projetos consumidores
+            const TestContext = globalThis.__TEST_CONTEXT__;
+            if (TestContext &&
+                typeof TestContext.ensureGlobalAvailability === 'function') {
+                TestContext.ensureGlobalAvailability();
+            }
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Detectar CN e CT baseado na estrutura do titlePath
+            // titlePath[0] = filename ou describe principal
+            // titlePath[1] = describe (CN) ou test (CT) se só 2 níveis
+            // titlePath[2] = test (CT) se 3 níveis
+            let cnName;
+            let ctName;
+            if (testInfo.titlePath && testInfo.titlePath.length >= 3) {
+                // 🎯 ESTRUTURA: [filename, describe/CN, test/CT]
+                cnName = testInfo.titlePath[1];
+                ctName = testInfo.titlePath[2];
+            }
+            else if (testInfo.titlePath && testInfo.titlePath.length === 2) {
+                // 🎯 ESTRUTURA: [describe/CN, test/CT] - Caso do arquivo fornecido
+                cnName = testInfo.titlePath[0];
+                ctName = testInfo.titlePath[1];
+            }
+            else {
+                // 🎯 FALLBACK: usar title como CT
+                cnName = testInfo.title;
+                ctName = testInfo.title;
+            }
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [AUTO] StatementTracker inicializado para CN: "${cnName}"`);
+            console.log(`🎯 [AUTO] CT detectado do Playwright: "${ctName}"`);
+            // 🆕 CRÍTICO: Capturar e registrar CT automaticamente do contexto do Playwright
+            TestAnnotations.capturarCTDoPlaywright(cnName, ctName, testInfo);
+            // 🆕 INICIAR INTERCEPTAÇÃO DE LOGS ANTES DE TUDO
+            interceptarLogs();
+            // 1. Detectar contexto principal
+            const contextoPrincipal = TestAnnotations.detectProjectContext();
+            // 2. Detectar se é realmente mixed (múltiplos tipos necessários)
+            const isMixed = TestAnnotations.detectIfMixed();
+            const contextoFinal = isMixed ? 'Mixed' : contextoPrincipal;
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, contextoFinal);
+            // 3. Configurar interceptadores inteligentemente
+            if (isMixed) {
+                TestAnnotations.setupAllInterceptors(cnName);
+                UnifiedReportManager.adicionarLog(cnName, '🔀 Contexto Mixed detectado - Múltiplos tipos habilitados');
+            }
+            else {
+                TestAnnotations.setupSpecificInterceptor(cnName, contextoPrincipal);
+                UnifiedReportManager.adicionarLog(cnName, `🤖 Contexto ${contextoPrincipal} detectado automaticamente`);
+            }
+            // 🆕 ESSENCIAL: Configurar interceptação de statements
+            TestAnnotations.setupStatementInterception(cnName);
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Detecta se o projeto é realmente mixed (múltiplos contextos).
+     * @returns true se for mixed, false caso contrário.
+     */
+    static detectIfMixed() {
+        const indicators = [
+            process.env.USE_MIXED === 'true',
+            process.env.PROJECT_TYPE?.toUpperCase() === 'MIXED',
+            process.env.PROJECT_TYPE?.toUpperCase() === 'SCENARIOS',
+            !!(process.env.BASE_URL && process.env.SSH_HOST),
+            !!(process.env.BASE_URL_APIGTW && process.env.DB_HOST),
+            process.cwd().includes('-scenarios') ||
+                process.cwd().includes('-cenarios'),
+        ];
+        return indicators.some((indicator) => indicator);
+    }
+    /**
+     * Configura interceptador seguro para um contexto específico.
+     * @param testName Nome do teste.
+     * @param contexto Contexto do teste.
+     */
+    static setupSpecificInterceptor(testName, contexto) {
+        switch (contexto) {
+            case 'API':
+                TestAnnotations.setupSafeInterceptor(testName, 'API', ApiActions.logEvent.bind(ApiActions), ApiActions, 'logEvent');
+                break;
+            case 'Banco':
+                TestAnnotations.setupSafeInterceptor(testName, 'BANCO', BancoActions.logEvent.bind(BancoActions), BancoActions, 'logEvent');
+                break;
+            case 'SSH':
+                TestAnnotations.setupSafeInterceptor(testName, 'SSH', SSHActions.logEvent.bind(SSHActions), SSHActions, 'logEvent');
+                break;
+            case 'Frontend':
+            case 'Mobile':
+                // Frontend e Mobile não precisam de interceptadores específicos
+                break;
+        }
+    }
+    /**
+     * Configura interceptadores para todos os contextos (usado em projetos mixed).
+     * @param testName Nome do teste.
+     */
+    static setupAllInterceptors(testName) {
+        TestAnnotations.setupSafeInterceptor(testName, 'API', ApiActions.logEvent.bind(ApiActions), ApiActions, 'logEvent');
+        TestAnnotations.setupSafeInterceptor(testName, 'SSH', SSHActions.logEvent.bind(SSHActions), SSHActions, 'logEvent');
+        TestAnnotations.setupSafeInterceptor(testName, 'BANCO', BancoActions.logEvent.bind(BancoActions), BancoActions, 'logEvent');
+    }
+    /**
+     * Configura finalização automática do teste para registrar duração.
+     * @param testInfo TestInfo do Playwright.
+     */
+    static setupTestFinalization(testInfo) {
+        const testName = testInfo.title;
+        // 🔧 NOVO: Detectar se é um test.describe (CN) ou test() (CT)
+        // Só configurar finalização para CTs individuais, NÃO para CNs
+        const titlePath = testInfo.titlePath || [];
+        const isIndividualTest = titlePath.length <= 2; // Arquivo + Test = 2 níveis
+        const isCTInsideDescribe = titlePath.length === 3; // Arquivo + Describe + Test = CT
+        // 🛡️ PROTEÇÃO: Não configurar finalização múltipla para CTs dentro de test.describe
+        // O CustomReporter já gerencia a finalização do CN completo
+        if (isCTInsideDescribe) {
+            return;
+        }
+        // ✅ NOVO: Interceptar erros não capturados para detectar falhas
+        const originalErrorHandler = process.listeners('uncaughtException');
+        const originalRejectionHandler = process.listeners('unhandledRejection');
+        const testFailureDetector = (error) => {
+            const errorMessage = error.message || error.toString();
+            if (errorMessage.includes(testName) ||
+                errorMessage.includes('AssertionError') ||
+                errorMessage.includes('expect')) {
+                console.log(`🔴 Falha detectada no teste ${testName}: ${errorMessage}`);
+                UnifiedReportManager.adicionarLog(testName, `❌ Erro capturado: ${errorMessage}`);
+                // Marcar teste como falhado imediatamente
+                UnifiedReportManager.marcarFimTeste(testName, 'failed').catch((e) => console.warn(`⚠️ Erro ao marcar teste como falhado: ${e}`));
+            }
+        };
+        // Adicionar listeners temporários para o teste atual
+        process.on('uncaughtException', testFailureDetector);
+        process.on('unhandledRejection', testFailureDetector);
+        // ✅ NOVO: Configurar monitoramento de status do teste
+        // ⚠️ PROTEÇÃO: Wrappear em try/catch para evitar unhandled rejections
+        // que podem marcar o teste como failed indevidamente
+        setTimeout(async () => {
+            try {
+                // Remover listeners temporários após finalização
+                process.removeListener('uncaughtException', testFailureDetector);
+                process.removeListener('unhandledRejection', testFailureDetector);
+                const startTime = testStartTimes.get(testName);
+                if (startTime) {
+                    const duration = (Date.now() - startTime) / 1000;
+                    UnifiedReportManager.setTestDuration(testName, duration);
+                    try {
+                        // Aguardar um pouco para permitir que o Playwright processe o status
+                        await new Promise((resolve) => setTimeout(resolve, 200));
+                        let testStatus = 'passed';
+                        const playwrightStatus = testInfo.status;
+                        if (playwrightStatus === 'failed' ||
+                            playwrightStatus === 'timedOut' ||
+                            playwrightStatus === 'interrupted') {
+                            testStatus = 'failed';
+                        }
+                        else if (playwrightStatus === 'skipped') {
+                            testStatus = 'skipped';
+                        }
+                        else if (playwrightStatus === 'passed') {
+                            testStatus = 'passed';
+                        }
+                        if (testInfo.errors && testInfo.errors.length > 0) {
+                            testStatus = 'failed';
+                        }
+                        // Fallback: analisar logs apenas se ainda não detectamos falha
+                        if (testStatus === 'passed' && TestContext.getSafeTestInfo()) {
+                            const currentTestInfo = TestContext.getSafeTestInfo();
+                            if (currentTestInfo && currentTestInfo.title === testName) {
+                                const logs = UnifiedReportManager.getTestLogs(testName);
+                                const hasErrorLogs = logs.some((log) => log.includes('❌') ||
+                                    log.includes('FAILED') ||
+                                    log.includes('erro') ||
+                                    log.includes('falhou') ||
+                                    log.includes('Error') ||
+                                    log.includes('AssertionError'));
+                                if (hasErrorLogs) {
+                                    testStatus = 'failed';
+                                }
+                            }
+                        }
+                        const detectedCnName = testInfo.__autocoreCnName ||
+                            testInfo.titlePath?.[1] ||
+                            testName;
+                        const detectedCtName = testInfo.__autocoreCtName ||
+                            testInfo.titlePath?.[2] ||
+                            testInfo.title;
+                        const errorDetails = testStatus === 'failed'
+                            ? testInfo.errors?.[0]?.message ||
+                                testInfo.error?.message ||
+                                'Playwright test failed'
+                            : undefined;
+                        if (detectedCtName) {
+                            try {
+                                const executions = StatementTracker.getExecutions();
+                                const testEntry = executions.get(detectedCnName);
+                                const runningCT = testEntry?.cts.find((ct) => ct.name === detectedCtName && ct.status === 'running');
+                                if (runningCT) {
+                                    StatementTracker.endCT(detectedCtName, testStatus !== 'failed', errorDetails);
+                                }
+                            }
+                            catch (trackerError) {
+                                console.warn(`⚠️ [PLAYWRIGHT-CT] Erro ao finalizar CT ${detectedCtName}:`, trackerError);
+                            }
+                        }
+                        console.log(`🔍 Status detectado para ${testName}: ${testStatus}`);
+                        await UnifiedReportManager.marcarFimTeste(testName, testStatus, {
+                            cnName: detectedCnName,
+                            ctName: detectedCtName,
+                            errorMessage: errorDetails,
+                        });
+                    }
+                    catch (error) {
+                        console.warn(`⚠️ Erro ao detectar status do teste ${testName}:`, error);
+                        await UnifiedReportManager.marcarFimTeste(testName, 'passed', {
+                            cnName: testInfo.__autocoreCnName ||
+                                testInfo.titlePath?.[1] ||
+                                testName,
+                            ctName: testInfo.__autocoreCtName ||
+                                testInfo.titlePath?.[2] ||
+                                testInfo.title,
+                        });
+                    }
+                    await TestAnnotations.finalizeCoverageForTest(testName, testInfo, duration * 1000);
+                    testStartTimes.delete(testName);
+                }
+            }
+            catch (fatalError) {
+                // ⚠️ PROTEÇÃO: Capturar qualquer erro para evitar unhandled rejection
+                // que pode marcar o teste como failed indevidamente
+                console.warn(`⚠️ [setupTestFinalization] Erro não-fatal durante finalização de "${testName}":`, fatalError);
+            }
+        }, 100);
+    }
+    /**
+     * ✅ NOVO: Configura cobertura automática para teste Frontend
+     * @param testInfo TestInfo do Playwright
+     */
+    static setupFrontendCoverage(testInfo) {
+        const testName = testInfo.title;
+        // Aguardar um pouco para página estar disponível
+        setTimeout(async () => {
+            try {
+                // ✅ VERIFICAR SE TESTCONTEXT.PAGE ESTÁ DISPONÍVEL
+                if (!TestContext.isPageInitialized()) {
+                    console.warn(`TestContext.page não está inicializado para ${testName}, pulando cobertura frontend`);
+                    return;
+                }
+                const currentPage = TestContext.page;
+                if (currentPage && currentPage.coverage) {
+                    await CoverageManager.startFrontendCoverage(currentPage, testName);
+                }
+            }
+            catch (error) {
+                console.warn(`Erro ao configurar cobertura para ${testName}:`, error);
+            }
+        }, 200);
+    }
+    /**
+     * ✅ NOVO: Finaliza e registra cobertura para um teste
+     * @param testName Nome do teste
+     * @param testInfo TestInfo do teste
+     * @param duration Duração do teste em ms
+     */
+    static async finalizeCoverageForTest(testName, testInfo, duration) {
+        try {
+            // 🎯 FINALIZAR CT ATIVO ANTES DE TERMINAR O TESTE
+            TestAnnotations.finalizarCTAtivo();
+            // Determinar tipo do teste baseado no contexto
+            const metrics = UnifiedReportManager.getMetrics();
+            const contextType = metrics.testes.find((t) => t.nome === testName)?.tipo || 'Frontend';
+            // Obter página se disponível
+            let currentPage;
+            try {
+                currentPage = TestContext.page;
+            }
+            catch {
+                // Página não disponível
+            }
+            // Registrar cobertura
+            await CoverageManager.registerTestCoverage(testName, contextType, currentPage, duration);
+        }
+        catch (error) {
+            console.warn(`Erro ao finalizar cobertura para ${testName}:`, error);
+        }
+    }
+    /**
+     * 🆕 Configura interceptação automática de todas as classes Statements
+     */
+    static setupStatementInterception(testName) {
+        try {
+            // 1. 🚨 INTERCEPTAÇÃO IMEDIATA - Antes de tudo!
+            TestAnnotations.setupImmediateInterception();
+            // 2. Configurar interceptação global
+            // StatementTracker não precisa setupGlobalInterception
+            // 3. Registrar o teste no sistema
+            UnifiedReportManager.registrarTeste(testName, 'API');
+            // 4. 🚀 DETECTAR AUTOMATICAMENTE classes Statement do projeto
+            const detectedStatements = TestAnnotations.detectStatementClassesFromCallStack();
+            if (detectedStatements.length > 0) {
+                detectedStatements.forEach((className, index) => {
+                    console.log(`   ${index + 1}. ${className}`);
+                });
+                console.log('');
+                // 🔥 INTERCEPTAÇÃO FORÇADA IMEDIATA para projeto real
+                TestAnnotations.forceInterceptRealProjectStatements(detectedStatements);
+            }
+            else {
+                // 🚫 NÃO usar fallback hardcoded - confiar na interceptação universal
+            }
+            // 5. Interceptar constructor global para capturar instanciações
+            TestAnnotations.setupConstructorInterception(detectedStatements);
+            // 6. 🚨 INTERCEPTAÇÃO UNIVERSAL MAIS AGRESSIVA
+            TestAnnotations.setupUniversalStatementInterception();
+            // TestAnnotations.setupRealTimeMethodInterception() // DESABILITADO - causa stack overflow
+            // 7. Métodos legacy para compatibilidade
+            try {
+                interceptAllStatements();
+                // Interceptação agora é automática via StatementTracker
+                // setupModuleInterception()
+                // StatementTracker não precisa autoDetectStatements
+            }
+            catch (legacyError) {
+                console.warn(`⚠️ Aviso: Métodos legacy falharam: ${legacyError}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Erro ao configurar interceptação de Statements: ${error}`);
+        }
+    }
+    /**
+     * 🚨 Interceptação imediata - Configurada ANTES de qualquer import
+     */
+    static setupImmediateInterception() {
+        try {
+            // 🔥 Interceptar console.info para capturar quando statements são executados
+            const originalConsoleInfo = console.info;
+            console.info = (...args) => {
+                const message = args.join(' ');
+                // 🎯 Capturar APENAS métodos que realmente são Statement execution
+                if (message.includes('Executando o método:')) {
+                    // 🔍 FILTRO RIGOROSO: Verificar se realmente é de classe Statement
+                    const methodMatches = message.match(/Executando o método:\s*(\w+)/i);
+                    if (methodMatches && methodMatches[1]) {
+                        const methodName = methodMatches[1];
+                        // Só interceptar métodos típicos de Statement classes
+                        const validStatementMethods = [
+                            'getToken',
+                            'get_token',
+                            'token',
+                            'auth',
+                            'authenticate',
+                            'consulta',
+                            'consultaEndereco',
+                            'consultaCobertura',
+                            'validar',
+                            'validarCNPJ',
+                            'criarCliente',
+                            'createContact',
+                            'create',
+                            'post',
+                            'put',
+                            'delete',
+                            'request',
+                        ];
+                        const isValidStatementMethod = validStatementMethods.some((valid) => methodName.toLowerCase().includes(valid.toLowerCase()));
+                        if (isValidStatementMethod) {
+                            originalConsoleInfo('📋 === CT EM EXECUÇÃO === [INTERCEPTADO!]');
+                            originalConsoleInfo(`   🎯 Método Statement interceptado: ${message}`);
+                            originalConsoleInfo(`   ⏰ [${new Date().toISOString()}] Execução detectada`);
+                            originalConsoleInfo('   📊 Status: INTERCEPTADO COM SUCESSO');
+                        }
+                    }
+                }
+                // 🚫 REMOVIDO: Detecção hardcoded - usar apenas métodos dinâmicos
+                // Removido fallback com métodos específicos hardcoded
+                // Sistema agora só intercepta quando detecta padrões reais de Statement execution
+                return originalConsoleInfo.apply(console, args);
+            };
+            // 🔥 Interceptar também console.log padrão - COM PROTEÇÃO ANTI-LOOP
+            const originalConsoleLog = console.log;
+            const intercepting = false; // Flag para evitar recursão
+            const detectedSteps = new Set(); // Cache para evitar repetições
+            console.log = function (...args) {
+                const message = args.join(' ');
+                // 🚨 PROTEÇÃO ANTI-LOOP: Se já estamos interceptando, apenas execute o original
+                if (intercepting) {
+                    return originalConsoleLog.apply(console, args);
+                }
+                // 🚀 DETECTAR EXECUÇÃO DE MÉTODOS CT
+                if (message.includes('Executando o método:')) {
+                    const methodMatch = message.match(/Executando o método:\s*(.+)/);
+                    if (methodMatch) {
+                        const methodName = methodMatch[1].trim();
+                        // ✅ DETECTAR CLASSE STATEMENT DO STACK TRACE
+                        let className = 'Statement';
+                        try {
+                            const stack = new Error().stack || '';
+                            // Procurar por "Statements<Nome>" no stack
+                            const stackMatch = stack.match(/Statements(\w+)\.(\w+)/);
+                            if (stackMatch) {
+                                className = `Statements${stackMatch[1]}`;
+                            }
+                        }
+                        catch {
+                            // Ignorar erro, usar className padrão
+                        }
+                        // ✅ CORREÇÃO: Usar novo sistema de Statements
+                        StatementTracker.ensureCTCreated();
+                        StatementTracker.startStatement(className, methodName);
+                        // ❌ REMOVIDO: handleMethodExecution causava logs duplicados
+                        // O log já é feito pelo StatementTracker
+                    }
+                }
+                // ✅ DETECTAR FINALIZAÇÃO DE STATEMENT COM SUCESSO
+                if (message.includes('[ STEP ]') &&
+                    message.includes('[ PASSED ]') &&
+                    !message.includes('Validação do status') &&
+                    !message.includes('Validação')) {
+                    const stepMatch = message.match(/\[\s*STEP\s*\]\s*(.+?)\s*\[\s*PASSED\s*\]/);
+                    if (stepMatch) {
+                        const stepName = stepMatch[1].trim();
+                        StatementTracker.finishStatement(Date.now(), true);
+                    }
+                }
+                // ❌ DETECTAR FINALIZAÇÃO DE STATEMENT COM ERRO
+                if (message.includes('[ STEP ]') && message.includes('[ FAILED ]')) {
+                    const stepMatch = message.match(/\[\s*STEP\s*\]\s*(.+?)\s*\[\s*FAILED\s*\]/);
+                    if (stepMatch) {
+                        const stepName = stepMatch[1].trim();
+                        // ❌ REMOVIDO: Log duplicado - já aparece no [ STEP ] [ FAILED ]
+                        StatementTracker.finishStatement(Date.now(), false, stepName);
+                    }
+                }
+                // � DETECTAR ERROS DE VALIDAÇÃO - NOVO!
+                if ((message.includes('❌ Validação falhou:') ||
+                    message.includes('Validação falhou:')) &&
+                    !message.includes('ERRO DE VALIDAÇÃO DETECTADO') &&
+                    !message.includes('CT FALHOU:') &&
+                    !this._processingError) {
+                    TestAnnotations.handleValidationError(message);
+                }
+                // �📡 DETECTAR INÍCIO DE REQUESTS
+                if (message.includes('🔄 Executando POST:') ||
+                    message.includes('🔄 Executando GET:')) {
+                    // ❌ REMOVIDO: Log duplicado de "NOVA REQUEST INICIADA"
+                    // O log já aparece no ApiActions quando a requisição é feita
+                }
+                // 🎯 FILTRO ULTRA-RIGOROSO: APENAS logs que realmente indicam execução de CT
+                if (message.includes('STEP') &&
+                    (message.includes('PASSED') || message.includes('FAILED'))) {
+                    // � PRIMEIRA VERIFICAÇÃO: EXCLUIR validações genéricas que não são CTs
+                    const isGenericValidation = message.includes('Validação do status') ||
+                        message.includes('Validação da resposta') ||
+                        message.includes('Validação de status') ||
+                        message.includes('Validação de') ||
+                        message.includes('Validação') ||
+                        message.includes('Validation of') ||
+                        message.includes('Validation') ||
+                        message.includes('Assert') ||
+                        message.includes('Expect') ||
+                        message.includes('Check') ||
+                        message.includes('Verify') ||
+                        message.includes('status code') ||
+                        message.includes('response validation') ||
+                        message.includes('campo obrigatório') ||
+                        message.includes('campo') ||
+                        message.includes('Schema') ||
+                        message.includes('Assertion');
+                    // 🔍 SEGUNDA VERIFICAÇÃO: Só permitir se realmente é de uma requisição/ação Statement
+                    const isValidStatementStep = message.includes('Requisição Token') ||
+                        message.includes('Requisição de') ||
+                        message.includes('Request Token') ||
+                        message.includes('Request') ||
+                        message.includes('POST') ||
+                        message.includes('GET') ||
+                        message.includes('PUT') ||
+                        message.includes('DELETE') ||
+                        message.includes('Token FTTH') ||
+                        message.includes('Massa SFA') ||
+                        message.includes('Auth') ||
+                        message.includes('API Call') ||
+                        message.includes('Service Call');
+                    // ✅ SÓ INTERCEPTAR se é Statement válido E NÃO é validação genérica
+                    if (isValidStatementStep && !isGenericValidation) {
+                        const stepHash = message.substring(0, 100); // Usar primeiros 100 chars como hash
+                    }
+                }
+                return originalConsoleLog.apply(console, args);
+            };
+        }
+        catch (error) {
+            console.warn(`⚠️ [IMEDIATO] Erro na interceptação imediata: ${error}`);
+        }
+    }
+    /**
+     * 🔥 Interceptação em tempo real de métodos Statement
+     */
+    static setupRealTimeMethodInterception() {
+        try {
+            console.log('🔥 === INTERCEPTAÇÃO EM TEMPO REAL ===');
+            // 🎯 Interceptar QUALQUER chamada de método que contenha padrões Statement
+            const originalApply = Function.prototype.apply;
+            const originalCall = Function.prototype.call;
+            Function.prototype.apply = function (thisArg, argsArray) {
+                // Verificar se é um método de classe Statement
+                if (thisArg &&
+                    thisArg.constructor &&
+                    thisArg.constructor.name.includes('Statement')) {
+                    const className = thisArg.constructor.name;
+                    const methodName = this.name || 'método_desconhecido';
+                    console.log(`📋 === CT EM EXECUÇÃO === ${className}.${methodName}()`);
+                    console.log(`   🎯 [TEMPO REAL] Detectada execução: ${className}.${methodName}()`);
+                    console.log(`   ⏰ [${new Date().toISOString()}] Iniciando execução...`);
+                    // Executar com tracking
+                    const startTime = Date.now();
+                    try {
+                        const result = originalApply.call(this, thisArg, argsArray);
+                        const duration = Date.now() - startTime;
+                        console.log(`   ✅ [${new Date().toISOString()}] Finalizada: ${className}.${methodName}() - ${duration}ms`);
+                        console.log('📋 === CT FINALIZADA ===');
+                        return result;
+                    }
+                    catch (error) {
+                        const duration = Date.now() - startTime;
+                        console.log(`   ❌ [${new Date().toISOString()}] Erro: ${className}.${methodName}() - ${duration}ms`);
+                        console.log('📋 === CT COM ERRO ===');
+                        throw error;
+                    }
+                }
+                return originalApply.call(this, thisArg, argsArray);
+            };
+            Function.prototype.call = function (thisArg, ...args) {
+                // Verificar se é um método de classe Statement
+                if (thisArg &&
+                    thisArg.constructor &&
+                    thisArg.constructor.name.includes('Statement')) {
+                    const className = thisArg.constructor.name;
+                    const methodName = this.name || 'método_desconhecido';
+                    console.log(`📋 === CT EM EXECUÇÃO === ${className}.${methodName}()`);
+                    console.log(`   🎯 [TEMPO REAL] Detectada execução: ${className}.${methodName}()`);
+                    console.log(`   ⏰ [${new Date().toISOString()}] Iniciando execução...`);
+                    // Executar com tracking
+                    const startTime = Date.now();
+                    try {
+                        const result = originalCall.call(this, thisArg, ...args);
+                        const duration = Date.now() - startTime;
+                        console.log(`   ✅ [${new Date().toISOString()}] Finalizada: ${className}.${methodName}() - ${duration}ms`);
+                        console.log('📋 === CT FINALIZADA ===');
+                        return result;
+                    }
+                    catch (error) {
+                        const duration = Date.now() - startTime;
+                        console.log(`   ❌ [${new Date().toISOString()}] Erro: ${className}.${methodName}() - ${duration}ms`);
+                        console.log('📋 === CT COM ERRO ===');
+                        throw error;
+                    }
+                }
+                return originalCall.call(this, thisArg, ...args);
+            };
+            console.log('🔧 [TEMPO REAL] Interceptação de métodos configurada');
+        }
+        catch (error) {
+            console.warn(`⚠️ [TEMPO REAL] Erro na interceptação: ${error}`);
+        }
+    }
+    /**
+     * 🆕 Intercepta constructors de classes Statement para capturar instanciações
+     */
+    static setupConstructorInterception(statementClasses) {
+        try {
+            // Interceptar contexto global para capturar imports/instanciações
+            const contexts = [globalThis];
+            // Adicionar outros contextos se disponíveis
+            try {
+                const windowObj = globalThis.window;
+                if (windowObj)
+                    contexts.push(windowObj);
+                const globalObj = globalThis.global;
+                if (globalObj)
+                    contexts.push(globalObj);
+            }
+            catch {
+                // Ignorar se não disponíveis
+            }
+            for (const context of contexts) {
+                for (const className of statementClasses) {
+                    try {
+                        // Verificar se a classe existe no contexto
+                        const OriginalClass = context[className];
+                        if (typeof OriginalClass === 'function') {
+                            console.log(`🔍 Encontrada classe: ${className} - preparando interceptação`);
+                            // Criar versão interceptada
+                            const InterceptedClass = StatementTracker.interceptStatement(OriginalClass);
+                            // Substituir no contexto
+                            context[className] = InterceptedClass;
+                            console.log(`✅ Classe ${className} interceptada com sucesso`);
+                        }
+                    }
+                    catch (error) {
+                        // Ignorar erros individuais de classes
+                        console.warn(`⚠️ Erro ao interceptar ${className}: ${error}`);
+                    }
+                }
+            }
+            // Interceptação dinâmica usando Proxy para capturar instanciações futuras
+            TestAnnotations.setupDynamicInterception(statementClasses);
+        }
+        catch (error) {
+            console.error(`❌ Erro na interceptação de constructors: ${error}`);
+        }
+    }
+    /**
+     * 🚀 Detecta automaticamente classes Statement via análise de arquivo .spec.ts
+     */
+    static detectStatementClassesFromCallStack() {
+        const detectedClasses = new Set();
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo?.file) {
+                const testFile = testInfo.file;
+                console.log(`📁 Arquivo de teste detectado: ${testFile}`);
+                // 🎯 NOVA ABORDAGEM: Análise robusta do arquivo .spec.ts
+                const newClasses = TestAnnotations.detectStatementClassesFromSpecFile(testFile);
+                newClasses.forEach((cls) => detectedClasses.add(cls));
+            }
+            // 🔄 Fallback: Analisar contexto global - APENAS se realmente necessário
+            if (detectedClasses.size === 0) {
+                TestAnnotations.detectStatementClassesFromGlobal(detectedClasses);
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao detectar classes Statement: ${error}`);
+        }
+        const classArray = Array.from(detectedClasses);
+        return classArray;
+    }
+    /**
+     * 🎯 Detecta classes Statement de um arquivo .spec.ts específico
+     */
+    static detectStatementClassesFromSpecFile(testFile) {
+        const detectedClasses = new Set();
+        try {
+            // 🔄 COMPATÍVEL COM ESM: Usar dynamic imports
+            const fs = globalThis.require?.('fs') ||
+                globalThis.fs ||
+                TestAnnotations.getFileSystemModule();
+            if (!fs) {
+                return TestAnnotations.detectStatementClassesFromTestContext();
+            }
+            const path = globalThis.require?.('path') ||
+                globalThis.path ||
+                TestAnnotations.getPathModule();
+            // 📂 Tentar diferentes caminhos para encontrar o arquivo
+            const possiblePaths = [
+                testFile,
+                testFile.replace('C:\\Users\\A0169497\\PlayWright\\comp-autocore-v1\\', './'),
+                './tests/' + testFile.split('\\').pop(),
+                './test/' + testFile.split('\\').pop(),
+                './' + testFile.split('\\').pop(),
+            ];
+            let content = '';
+            for (const filePath of possiblePaths) {
+                try {
+                    if (fs.existsSync && fs.existsSync(filePath)) {
+                        content = fs.readFileSync(filePath, 'utf-8');
+                        console.log(`📖 Analisando arquivo: ${filePath}`);
+                        break;
+                    }
+                }
+                catch (fileError) {
+                    // Continua tentando outros caminhos
+                }
+            }
+            if (!content) {
+                console.warn(`⚠️ Não foi possível ler o arquivo de teste: ${testFile}`);
+                console.log('🔄 Aguardando detecção dinâmica durante execução...');
+                // � REMOVIDO: Fallback hardcoded - retornar vazio para forçar detecção real
+                return [];
+            }
+            // 🔍 PADRÕES DE DETECÇÃO ROBUSTOS
+            // 1. Exports da própria classe: export class StatementsToken
+            const exportClassRegex = /export\s+class\s+(\w*Statement\w*)/g;
+            let exportMatch;
+            while ((exportMatch = exportClassRegex.exec(content)) !== null) {
+                if (exportMatch[1]) {
+                    detectedClasses.add(exportMatch[1]);
+                    console.log(`🎯 Classe Statement encontrada via export: ${exportMatch[1]}`);
+                }
+            }
+            // 2. Imports diretos: import { StatementsToken } from "..."
+            const importDirectRegex = /import\s*{\s*([^}]*)\s*}\s*from\s*['"]/g;
+            let importMatch;
+            while ((importMatch = importDirectRegex.exec(content)) !== null) {
+                const importedItems = importMatch[1].split(',');
+                importedItems.forEach((item) => {
+                    const cleanItem = item.trim();
+                    if (cleanItem.includes('Statement') ||
+                        cleanItem.startsWith('Statements')) {
+                        detectedClasses.add(cleanItem);
+                        console.log(`🎯 Classe Statement encontrada via import: ${cleanItem}`);
+                    }
+                });
+            }
+            // 3. Instanciações: new StatementsToken(), new StatementsConsultaEndereco()
+            const newStatementRegex = /new\s+(\w*Statement\w*)\s*\(/g;
+            let newMatch;
+            while ((newMatch = newStatementRegex.exec(content)) !== null) {
+                if (newMatch[1]) {
+                    detectedClasses.add(newMatch[1]);
+                    console.log(`🎯 Classe Statement encontrada via new: ${newMatch[1]}`);
+                }
+            }
+            // 4. Await new: await new StatementsToken()
+            const awaitNewRegex = /await\s+new\s+(\w*Statement\w*)\s*\(/g;
+            let awaitMatch;
+            while ((awaitMatch = awaitNewRegex.exec(content)) !== null) {
+                if (awaitMatch[1]) {
+                    detectedClasses.add(awaitMatch[1]);
+                    console.log(`🎯 Classe Statement encontrada via await new: ${awaitMatch[1]}`);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao analisar arquivo .spec.ts: ${error}`);
+            // 🚫 REMOVIDO: Fallback - retornar vazio para forçar detecção real
+            return [];
+        }
+        return Array.from(detectedClasses);
+    }
+    /**
+     * 🌐 Interceptar classes Statement disponíveis no globalThis
+     */
+    static interceptGlobalStatements() {
+        try {
+            console.log('🔍 [Global] Procurando classes Statement no globalThis...');
+            const globalObj = globalThis;
+            const foundClasses = [];
+            // Procurar no globalThis por classes que seguem padrões Statement
+            for (const key in globalObj) {
+                try {
+                    const value = globalObj[key];
+                    if (typeof value === 'function' && value.prototype) {
+                        const className = value.name || key;
+                        // Detectar padrões de Statement
+                        const isStatementClass = className &&
+                            (className.startsWith('Statements') ||
+                                className.includes('Statement') ||
+                                className.endsWith('Statement') ||
+                                className.match(/^\w*Statements?\w*$/));
+                        if (isStatementClass) {
+                            console.log(`🎯 [Global] Classe Statement encontrada: ${className}`);
+                            foundClasses.push(className);
+                            // Interceptar a classe diretamente
+                            try {
+                                const InterceptedClass = StatementTracker.interceptStatement(value);
+                                globalObj[key] = InterceptedClass;
+                                console.log(`✅ [Global] ${className} interceptado com sucesso`);
+                            }
+                            catch (error) {
+                                console.warn(`⚠️ [Global] Erro ao interceptar ${className}:`, error);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros individuais
+                }
+            }
+            console.log(`🎯 [Global] ${foundClasses.length} classes Statement interceptadas: ${foundClasses.join(', ')}`);
+            // ✅ NOVO: Interceptar construtores dinamicamente usando Proxy
+            TestAnnotations.setupDynamicConstructorInterception();
+        }
+        catch (error) {
+            console.warn('⚠️ [Global] Erro na interceptação global:', error);
+        }
+    }
+    /**
+     * ✨ NOVO: Interceptação dinâmica de construtores Statement
+     */
+    static setupDynamicConstructorInterception() {
+        try {
+            console.log('🪄 [Dynamic] Configurando interceptação dinâmica de construtores...');
+            // 🎯 Interceptar Function.prototype.constructor para capturar 'new'
+            const originalConstructor = Function.prototype.constructor;
+            // 🎁 Interceptar criação de instâncias via Proxy no globalThis
+            const originalGlobalDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'Function');
+            if (originalGlobalDescriptor) {
+                Object.defineProperty(globalThis, 'Function', {
+                    value: new Proxy(Function, {
+                        construct(target, args, newTarget) {
+                            const instance = Reflect.construct(target, args, newTarget);
+                            // Se a função criada é uma classe Statement, interceptar
+                            if (typeof instance === 'function' &&
+                                instance.name &&
+                                (instance.name.includes('Statement') ||
+                                    instance.name.includes('Statements'))) {
+                                console.log(`🪄 [Dynamic] Interceptando construtor Statement: ${instance.name}`);
+                                return StatementTracker.interceptStatement(instance);
+                            }
+                            return instance;
+                        },
+                    }),
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            console.log('✅ [Dynamic] Interceptação dinâmica ativada');
+        }
+        catch (error) {
+            console.warn('⚠️ [Dynamic] Erro na interceptação dinâmica:', error);
+        }
+    }
+    /**
+     * ✨ NOVO: Interceptar classes Statement já importadas nos módulos
+     */
+    static interceptImportedStatements() {
+        try {
+            console.log('🔍 [ImportedStatements] Procurando classes Statement importadas...');
+            // 1️⃣ ESTRATÉGIA: Interceptar via require.cache (Node.js modules)
+            if (typeof require !== 'undefined' && require.cache) {
+                const moduleIds = Object.keys(require.cache);
+                console.log(`🔍 [ImportedStatements] Analisando ${moduleIds.length} módulos carregados...`);
+                for (const moduleId of moduleIds) {
+                    try {
+                        // Verificar se o módulo contém "Statement" no caminho
+                        if (moduleId.includes('Statement') ||
+                            moduleId.includes('statements')) {
+                            console.log(`🎯 [ImportedStatements] Módulo Statement encontrado: ${moduleId}`);
+                            const moduleExports = require.cache[moduleId]?.exports;
+                            if (moduleExports && typeof moduleExports === 'object') {
+                                // Procurar por classes exportadas
+                                for (const [exportName, exportValue] of Object.entries(moduleExports)) {
+                                    if (typeof exportValue === 'function' &&
+                                        exportName.includes('Statement') &&
+                                        exportValue.prototype) {
+                                        console.log(`🎯 [ImportedStatements] Classe Statement importada: ${exportName}`);
+                                        // Interceptar a classe diretamente
+                                        try {
+                                            const InterceptedClass = StatementTracker.interceptStatement(exportValue);
+                                            moduleExports[exportName] = InterceptedClass;
+                                            console.log(`✅ [ImportedStatements] ${exportName} interceptado com sucesso!`);
+                                        }
+                                        catch (error) {
+                                            console.warn(`⚠️ [ImportedStatements] Erro ao interceptar ${exportName}:`, error);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Ignorar erros individuais de módulos
+                    }
+                }
+            }
+            // 2️⃣ ESTRATÉGIA: Interceptar via globalThis (ES modules)
+            const globalObj = globalThis;
+            for (const key in globalObj) {
+                try {
+                    const value = globalObj[key];
+                    if (typeof value === 'function' &&
+                        value.prototype &&
+                        key.includes('Statement')) {
+                        console.log(`🎯 [ImportedStatements] Statement global: ${key}`);
+                        try {
+                            const InterceptedClass = StatementTracker.interceptStatement(value);
+                            globalObj[key] = InterceptedClass;
+                            console.log(`✅ [ImportedStatements] ${key} interceptado globalmente!`);
+                        }
+                        catch (error) {
+                            console.warn(`⚠️ [ImportedStatements] Erro ao interceptar global ${key}:`, error);
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignorar erros
+                }
+            }
+            console.log('✅ [ImportedStatements] Interceptação de módulos importados concluída');
+        }
+        catch (error) {
+            console.warn('⚠️ [ImportedStatements] Erro na interceptação de módulos:', error);
+        }
+    }
+    /**
+     * 🔄 Detecta classes Statement do contexto atual do teste (fallback ESM)
+     */
+    static detectStatementClassesFromTestContext() {
+        const detectedClasses = new Set();
+        try {
+            // Analisar stack trace para encontrar classes Statement
+            const stack = new Error().stack || '';
+            // 🎯 FILTROS RIGOROSOS: Evitar métodos do sistema próprio
+            const systemMethods = [
+                'detectStatementClassesFromTestContext',
+                'detectStatementClassesFromSpecFile',
+                'detectStatementClassesFromCallStack',
+                'setupStatementInterception',
+                'setupDynamicInterception',
+                'loadStatementClassFromPath',
+                'makeStatementClassGloballyAvailable',
+            ];
+            // Procurar padrões de Statement no stack
+            const statementRegex = /(\w*Statement\w*)/g;
+            let match;
+            while ((match = statementRegex.exec(stack)) !== null) {
+                const className = match[1];
+                // 🚫 FILTRAR métodos do sistema
+                if (className &&
+                    className !== 'Statement' &&
+                    className.length > 3 &&
+                    !systemMethods.includes(className) &&
+                    !className.includes('detect') &&
+                    !className.includes('setup') &&
+                    !className.includes('load') &&
+                    !className.includes('make') &&
+                    !className.includes('get')) {
+                    detectedClasses.add(className);
+                    console.log(`🎯 Classe Statement real encontrada no stack: ${className}`);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro na análise de contexto: ${error}`);
+        }
+        return Array.from(detectedClasses);
+    }
+    /**
+     * 🛠️ Obtém módulo fs compatível com ESM
+     */
+    static getFileSystemModule() {
+        try {
+            // Tentar diferentes formas de acessar fs
+            if (typeof process !== 'undefined' && process.versions?.node) {
+                return eval('require')('fs');
+            }
+        }
+        catch { }
+        return null;
+    }
+    /**
+     * 🛠️ Obtém módulo path compatível com ESM
+     */
+    static getPathModule() {
+        try {
+            if (typeof process !== 'undefined' && process.versions?.node) {
+                return eval('require')('path');
+            }
+        }
+        catch { }
+        // Fallback manual para path
+        return {
+            basename: (p) => p.split(/[\\/]/).pop() || '',
+            dirname: (p) => p.substring(0, p.lastIndexOf('/')) ||
+                p.substring(0, p.lastIndexOf('\\')),
+            join: (...args) => args.join('/'),
+            resolve: (...args) => args.join('/'),
+        };
+    }
+    /**
+     * 🌐 Detecta classes Statement do contexto global - APENAS análise real
+     */
+    static detectStatementClassesFromGlobal(detectedClasses) {
+        try {
+            // 🔍 ANÁLISE RIGOROSA: Só aceitar classes que realmente parecem Statement
+            const contexts = [
+                globalThis,
+                globalThis.global,
+                globalThis.window,
+            ].filter(Boolean);
+            for (const context of contexts) {
+                try {
+                    const propertyNames = Object.getOwnPropertyNames(context);
+                    for (const key of propertyNames) {
+                        try {
+                            const value = context[key];
+                            // 🎯 FILTROS MAIS AGRESSIVOS para identificar classes Statement reais
+                            if (typeof value === 'function' &&
+                                key.length > 4 && // Reduzido para detectar mais classes
+                                (key.includes('Statement') ||
+                                    key.startsWith('Statements') ||
+                                    key.endsWith('Statement') ||
+                                    key.endsWith('Statements') ||
+                                    /^[A-Z][a-zA-Z]*Statement[s]?/.test(key)) && // Padrão mais amplo
+                                !key.includes('Test') &&
+                                !key.includes('Mock') &&
+                                !key.includes('Fake') &&
+                                !key.includes('Stub') &&
+                                !key.includes('Proxy') &&
+                                !key.includes('Wrapper') &&
+                                !key.includes('Helper') &&
+                                !key.includes('Util') &&
+                                !key.includes('Base') &&
+                                !key.includes('Abstract')) {
+                                // 🔍 VALIDAÇÃO MAIS FLEXÍVEL: Verificar se tem métodos típicos de Statement ou é uma classe válida
+                                const prototype = value.prototype;
+                                if (prototype) {
+                                    const methods = Object.getOwnPropertyNames(prototype);
+                                    const hasStatementMethods = methods.some((method) => method.includes('get') ||
+                                        method.includes('post') ||
+                                        method.includes('put') ||
+                                        method.includes('delete') ||
+                                        method.includes('consulta') ||
+                                        method.includes('validar') ||
+                                        method.includes('criar') ||
+                                        method.includes('request') ||
+                                        method.includes('execute') ||
+                                        method.includes('buscar') ||
+                                        method.includes('obter') ||
+                                        method.includes('enviar') ||
+                                        method.includes('processar') ||
+                                        method.includes('realizar') ||
+                                        method.includes('executar'));
+                                    // 🚀 ACEITAR se tem métodos Statement OU se é uma classe que parece Statement
+                                    const hasConstructor = methods.includes('constructor');
+                                    const isStatementLike = hasConstructor &&
+                                        (hasStatementMethods || methods.length > 2);
+                                    if (isStatementLike) {
+                                        detectedClasses.add(key);
+                                        console.log(`\n🎯 Classe Statement detectada: ${key}`);
+                                        if (hasStatementMethods) {
+                                            console.log(`   📋 Métodos relevantes encontrados: ${methods
+                                                .filter((m) => m.includes('get') ||
+                                                m.includes('post') ||
+                                                m.includes('consulta') ||
+                                                m.includes('validar') ||
+                                                m.includes('criar') ||
+                                                m.includes('request'))
+                                                .slice(0, 3)
+                                                .join(', ')}`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignorar propriedades que causam erro ao acessar
+                        }
+                    }
+                }
+                catch {
+                    // Ignorar contextos problemáticos
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao analisar contexto global: ${error}`);
+        }
+    }
+    /**
+     * 🌐 Configuração universal que intercepta qualquer instanciação de classe com padrão Statement
+     */
+    static setupUniversalStatementInterception() {
+        try {
+            // 🚀 INTERCEPTAÇÃO CRÍTICA: Interceptar Function constructor
+            const originalFunction = globalThis.Function;
+            // 🎯 INTERCEPTAÇÃO DE CONSTRUCTOR GLOBAL
+            const originalConstruct = Reflect.construct;
+            if (typeof Reflect !== 'undefined' && originalConstruct) {
+                ;
+                Reflect.construct = function (target, argumentsList, newTarget) {
+                    const instance = originalConstruct.call(this, target, argumentsList, newTarget);
+                    if (typeof target === 'function') {
+                        const className = target.name;
+                        if (className &&
+                            (className.includes('Statement') ||
+                                className.includes('statement'))) {
+                            console.log(`🎯 Interceptando via Reflect.construct: ${className}`);
+                            return StatementTracker.interceptStatement(instance.constructor);
+                        }
+                    }
+                    return instance;
+                };
+            }
+            // 🚀 NOVA ABORDAGEM: Interceptar eval para capturar imports dinâmicos
+            const originalEval = globalThis.eval;
+            globalThis.eval = function (code) {
+                const result = originalEval.call(this, code);
+                // Se o código contém Statement classes
+                if (code.includes('Statement') && typeof result === 'function') {
+                    const className = result.name;
+                    if (className && className.includes('Statement')) {
+                        console.log(`🔍 Classe Statement detectada via eval: ${className}`);
+                        TestAnnotations.interceptClassDirectly(result, className);
+                    }
+                }
+                return result;
+            };
+            // 🌐 INTERCEPTAÇÃO UNIVERSAL DE NEW - SIMPLIFICADA
+            try {
+                // Usar abordagem mais simples via monkey patching
+            }
+            catch (constructorError) {
+                console.warn(`⚠️ Erro na interceptação de constructor: ${constructorError}`);
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro na interceptação universal: ${error}`);
+        }
+    }
+    /**
+     * 🎯 Intercepta uma classe diretamente no momento da descoberta
+     */
+    static interceptClassDirectly(ClassToIntercept, className) {
+        try {
+            if (typeof ClassToIntercept !== 'function') {
+                return;
+            }
+            console.log(`🔧 Interceptando classe diretamente: ${className}`);
+            // Substituir todos os métodos da classe
+            const prototype = ClassToIntercept.prototype;
+            const methodNames = Object.getOwnPropertyNames(prototype);
+            for (const methodName of methodNames) {
+                if (methodName !== 'constructor' &&
+                    typeof prototype[methodName] === 'function') {
+                    const originalMethod = prototype[methodName];
+                    prototype[methodName] = function (...args) {
+                        const statementName = `${className}.${methodName}`;
+                        console.log(`🎯 Executando Statement: ${statementName}`);
+                        // ✅ CORREÇÃO: Garantir que existe um CT ativo antes de executar statement
+                        StatementTracker.ensureCTCreated();
+                        // ✅ CORREÇÃO: Registrar statement dentro do CT, não criar novo CT
+                        StatementTracker.startStatement(className, methodName);
+                        try {
+                            const result = originalMethod.apply(this, args);
+                            // Se é Promise
+                            if (result && typeof result.then === 'function') {
+                                return result
+                                    .then((res) => {
+                                    StatementTracker.finishStatement(Date.now(), true);
+                                    return res;
+                                })
+                                    .catch((err) => {
+                                    StatementTracker.finishStatement(Date.now(), false, err?.message || 'Erro desconhecido');
+                                    throw err;
+                                });
+                            }
+                            // Método síncrono
+                            StatementTracker.finishStatement(Date.now(), true);
+                            return result;
+                        }
+                        catch (error) {
+                            StatementTracker.finishStatement(Date.now(), false, error?.message || 'Erro desconhecido');
+                            throw error;
+                        }
+                    };
+                }
+            }
+            console.log(`✅ Classe ${className} interceptada diretamente com sucesso`);
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao interceptar classe ${className}: ${error}`);
+        }
+    }
+    /**
+     * 🏗️ Criar instância interceptada
+     */
+    static createInterceptedInstance(instance, className) {
+        try {
+            // Interceptar métodos da instância
+            const methodNames = Object.getOwnPropertyNames(Object.getPrototypeOf(instance));
+            for (const methodName of methodNames) {
+                if (methodName !== 'constructor' &&
+                    typeof instance[methodName] === 'function') {
+                    const originalMethod = instance[methodName];
+                    instance[methodName] = function (...args) {
+                        const statementName = `${className}.${methodName}`;
+                        console.log(`🎯 Executando Statement: ${statementName}`);
+                        // ✅ CORREÇÃO: Garantir que existe um CT ativo antes de executar statement
+                        StatementTracker.ensureCTCreated();
+                        // ✅ CORREÇÃO: Registrar statement dentro do CT, não criar novo CT
+                        StatementTracker.startStatement(className, methodName);
+                        try {
+                            const result = originalMethod.apply(this, args);
+                            // Se é Promise
+                            if (result && typeof result.then === 'function') {
+                                return result
+                                    .then((res) => {
+                                    StatementTracker.finishStatement(Date.now(), true);
+                                    return res;
+                                })
+                                    .catch((err) => {
+                                    StatementTracker.finishStatement(Date.now(), false, err?.message || 'Erro desconhecido');
+                                    throw err;
+                                });
+                            }
+                            // Método síncrono
+                            StatementTracker.finishStatement(Date.now(), true);
+                            return result;
+                        }
+                        catch (error) {
+                            StatementTracker.finishStatement(Date.now(), false, error?.message || 'Erro desconhecido');
+                            throw error;
+                        }
+                    };
+                }
+            }
+            return instance;
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao criar instância interceptada: ${error}`);
+            return instance;
+        }
+    }
+    /**
+     * 🌐 Configuração universal de interceptação de constructor
+     */
+    static setupUniversalConstructorInterception() {
+        try {
+            // 🎯 INTERCEPTAÇÃO GLOBAL DO NEW
+            const originalReflectConstruct = Reflect.construct;
+            if (typeof Reflect !== 'undefined' && originalReflectConstruct) {
+                Reflect.construct = function (target, argumentsList, newTarget) {
+                    const instance = originalReflectConstruct.call(this, target, argumentsList, newTarget);
+                    // Se é uma classe Statement
+                    if (typeof target === 'function' &&
+                        target.name &&
+                        (target.name.includes('Statement') ||
+                            target.name.includes('statement'))) {
+                        console.log(`🚀 NEW ${target.name}() interceptado universalmente`);
+                        return TestAnnotations.createInterceptedInstance(instance, target.name);
+                    }
+                    return instance;
+                };
+            }
+            console.log('🌐 Interceptação universal de constructor configurada');
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro na interceptação universal de constructor: ${error}`);
+        }
+    }
+    /**
+     * 🚀 Monitoramento contínuo de instanciações de Statement durante o teste
+     */
+    static setupContinuousStatementMonitoring(testName) {
+        try {
+            // Configurar um observador de mudanças no contexto global
+            const monitoringInterval = setInterval(() => {
+                try {
+                    // Verificar se há novas classes Statement no contexto global
+                    const contexts = [
+                        globalThis,
+                        globalThis.global,
+                        globalThis.window,
+                    ].filter(Boolean);
+                    for (const context of contexts) {
+                        Object.getOwnPropertyNames(context).forEach((propName) => {
+                            try {
+                                const prop = context[propName];
+                                if (typeof prop === 'function' &&
+                                    (propName.includes('Statement') ||
+                                        propName.includes('statement')) &&
+                                    !prop._alreadyIntercepted) {
+                                    // Marcar como interceptada para evitar loop
+                                    ;
+                                    prop._alreadyIntercepted = true;
+                                    // Interceptar usando Proxy no contexto
+                                    context[propName] = new Proxy(prop, {
+                                        construct(target, args, newTarget) {
+                                            console.log(`🚀 NEW ${propName}() interceptado durante execução`);
+                                            // Criar instância original
+                                            const instance = Reflect.construct(target, args, newTarget);
+                                            // Retornar versão interceptada
+                                            return StatementTracker.interceptStatement(instance.constructor);
+                                        },
+                                    });
+                                }
+                            }
+                            catch {
+                                // Ignorar propriedades problemáticas
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    console.warn(`⚠️ Erro no monitoramento contínuo: ${error}`);
+                }
+            }, 500); // Verificar a cada 500ms
+            // Limpar o monitoramento após 30 segundos
+            setTimeout(() => {
+                clearInterval(monitoringInterval);
+            }, 30_000);
+        }
+        catch (error) {
+            console.error(`❌ Erro ao configurar monitoramento contínuo: ${error}`);
+        }
+    }
+    /**
+     * 🆕 Configuração dinâmica para interceptar instanciações em tempo real
+     */
+    static setupDynamicInterception(statementClasses) {
+        try {
+            // 🎯 NOVA ABORDAGEM: Interceptar diretamente no contexto global usando substituição de classe
+            for (const className of statementClasses) {
+                try {
+                    const contexts = [
+                        globalThis,
+                        globalThis.global,
+                        globalThis.window,
+                    ].filter(Boolean);
+                    for (const context of contexts) {
+                        if (context[className] &&
+                            typeof context[className] === 'function') {
+                            const OriginalClass = context[className];
+                            console.log(`🔧 Configurando interceptação real para: ${className}`);
+                            // Criar uma nova classe que substitui a original completamente
+                            const InterceptedClass = (...args) => {
+                                console.log(`🚀 NEW ${className}() interceptado em tempo real!`);
+                                // Criar instância original
+                                const instance = new OriginalClass(...args);
+                                // Interceptar TODOS os métodos da instância
+                                const methodNames = Object.getOwnPropertyNames(Object.getPrototypeOf(instance));
+                                for (const methodName of methodNames) {
+                                    if (methodName !== 'constructor' &&
+                                        typeof instance[methodName] === 'function') {
+                                        const originalMethod = instance[methodName];
+                                        instance[methodName] = function (...methodArgs) {
+                                            // ❌ REMOVIDO: startCT/endCT - Statements não são CTs!
+                                            // Um Statement é um método DENTRO de um CT (test())
+                                            // O StatementTracker.interceptStatement() já gerencia isso corretamente
+                                            // ❌ REMOVIDO: Log duplicado - o StatementTracker já faz o log
+                                            // Apenas executar o método original sem criar CT falso
+                                            return originalMethod.apply(this, methodArgs);
+                                        };
+                                    }
+                                }
+                                return instance;
+                            };
+                            // Preservar prototype e propriedades estáticas
+                            InterceptedClass.prototype = OriginalClass.prototype;
+                            Object.setPrototypeOf(InterceptedClass, OriginalClass);
+                            // Substituir no contexto
+                            context[className] = InterceptedClass;
+                            console.log(`✅ Interceptação direta configurada para: ${className}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`⚠️ Erro ao configurar interceptação direta para ${className}: ${error}`);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro na interceptação dinâmica: ${error}`);
+        }
+    }
+    /**
+     * Configura interceptador seguro para registrar logs no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param className Nome da classe/contexto.
+     * @param originalMethod Método original de log.
+     * @param targetClass Classe alvo.
+     * @param methodName Nome do método.
+     */
+    static setupSafeInterceptor(testName, className, originalMethod, targetClass, methodName) {
+        const interceptorKey = `${className}-${testName}`;
+        if (interceptorsAtivos.has(interceptorKey)) {
+            return;
+        }
+        interceptorsAtivos.add(interceptorKey);
+        targetClass[methodName] = (message) => {
+            try {
+                originalMethod.call(targetClass, message);
+            }
+            catch {
+                // Ignorar erros do método original
+            }
+            try {
+                const prefixedMessage = className !== 'Mixed' ? `[${className}] ${message}` : message;
+                UnifiedReportManager.adicionarLog(testName, prefixedMessage);
+            }
+            catch {
+                // Ignorar erros do UnifiedReportManager
+            }
+        };
+        setTimeout(() => {
+            interceptorsAtivos.delete(interceptorKey);
+        }, 30_000);
+    }
+    // ============================================
+    // 🌐 INTEGRAÇÃO TESTHUB - SELEÇÃO DE SISTEMA
+    // ============================================
+    /**
+     * 🌐 Seleciona o sistema do TestHub para o teste.
+     * O sistema deve ser selecionado ANTES de usar qualquer ação (API, Frontend, SSH, Banco).
+     * As configurações (URLs, credenciais, hosts) serão injetadas automaticamente.
+     *
+     * @param systemName Nome do sistema (use o enum Systems para IntelliSense)
+     * @param environmentName Nome do ambiente (opcional, usa process.env.ENV se não fornecido)
+     *
+     * @example
+     * // IMPORTANTE: Na primeira execução, use string diretamente:
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     *
+     * // Após primeira execução, o enum será gerado e você pode usar:
+     * import { Systems } from "../.rbqa/SystemsEnum"
+     * await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML) // 👈 IntelliSense disponível
+     *
+     * // Exemplo completo:
+     * test("CT001", async ({}, testInfo) => {
+     *   TestAnnotations.Api.testInfo = testInfo
+     *   await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)
+     *
+     *   // Agora as URLs e credenciais estão configuradas automaticamente
+     *   await new StatementsToken().getToken()
+     * })
+     */
+    static async setSystem(systemName, environmentName) {
+        // Aguarda criação do browser se foi solicitada (Frontend/Mixed)
+        await TestContext.ensurePage();
+        try {
+            // ✅ VALIDAÇÃO: Verificar se systemName foi fornecido
+            if (!systemName ||
+                systemName === 'undefined' ||
+                typeof systemName !== 'string') {
+                throw new Error(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+❌ NOME DO SISTEMA INVÁLIDO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+O parâmetro "systemName" é obrigatório e deve ser uma string válida.
+
+Valor recebido: ${JSON.stringify(systemName)} (tipo: ${typeof systemName})
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+💡 POSSÍVEIS CAUSAS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. ❌ Tentou importar Systems do framework:
+   import { Systems } from "@silasfmartins/testhub"  // ← ERRADO!
+   
+2. ❌ Tentou usar Systems antes de gerar o enum:
+   import { Systems } from "../.rbqa/SystemsEnum"  // ← Arquivo não existe!
+   await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)
+
+3. ❌ Esqueceu de passar o parâmetro:
+   await TestAnnotations.setSystem()  // ← systemName obrigatório!
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ SOLUÇÃO - PRIMEIRA EXECUÇÃO:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Use STRING diretamente (sem import do enum):
+
+import { TestAnnotations } from "@silasfmartins/testhub"
+
+test("Meu teste", async ({}, testInfo) => {
+  TestAnnotations.Api.testInfo = testInfo
+  await TestAnnotations.setSystem("AUTENTICA_IN_HML")  // ← String direta
+})
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ SOLUÇÃO - PRÓXIMAS EXECUÇÕES (com IntelliSense):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Após a primeira execução, o arquivo .rbqa/SystemsEnum.ts será gerado.
+Então você pode importar o enum DO SEU PROJETO (NÃO do framework):
+
+import { TestAnnotations } from "@silasfmartins/testhub"
+import { Systems } from "../.rbqa/SystemsEnum"  // ← Do projeto!
+
+test("Meu teste", async ({}, testInfo) => {
+  TestAnnotations.Api.testInfo = testInfo
+  await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)  // ← Com IntelliSense!
+})
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        `);
+            }
+            // 2. Inicializar SystemsManager (carrega lista de sistemas do backend)
+            const systemsManager = SystemsManager.getInstance();
+            await systemsManager.initialize();
+            // 3. Obter tipo de projeto do ambiente
+            // ⚠️ IMPORTANTE: Para projetos Scenarios, não filtrar por tipo de ambiente
+            // Scenarios podem usar sistemas de qualquer tipo (API, Mobile, etc.)
+            const detectedProjectType = process.env.PROJECT_TYPE || 'API';
+            const isScenarios = detectedProjectType === 'Scenarios';
+            // Se for Scenarios, não passar projectType para permitir qualquer tipo de ambiente
+            const projectType = isScenarios
+                ? undefined
+                : detectedProjectType;
+            console.log(`🔍 Tipo de projeto detectado: ${detectedProjectType}${isScenarios ? ' (permitindo qualquer tipo de ambiente)' : ''}`);
+            // 4. Selecionar sistema (valida e carrega configurações)
+            const selectedSystem = await systemsManager.selectSystem(systemName, environmentName, projectType);
+            // 5. Injetar configurações automaticamente
+            const configManager = DynamicConfigManager.getInstance();
+            // Injetar em process.env para compatibilidade com código legado
+            configManager.injectIntoEnvironment();
+            // Registrar informações do CI (Azure/GitHub) — útil para identificar quem iniciou a execução
+            try {
+                UnifiedReportManager.registrarCIInfo();
+            }
+            catch (error) {
+                console.warn('⚠️ Falha ao registrar CI info:', error);
+            }
+            // Injetar baseURL no Playwright se for teste WEB
+            if (detectedProjectType === 'WEB' || detectedProjectType === 'FRONTEND') {
+                configManager.injectPlaywrightBaseUrl();
+            }
+            // 🆕 Auto-conectar SSH se for projeto SSH
+            // IMPORTANTE: Usa detectedProjectType (sempre definido), não projectType (pode ser undefined)
+            // Auto-conectar quando:
+            // - o projeto explicitamente é do tipo SSH, OU
+            // - o sistema selecionado contém informações típicas de SSH (host, username, password, privateKeyPath)
+            // Isso evita que projetos Frontend/Mixed que executam cenários SSH precisem definir PROJECT_TYPE=SSH.
+            try {
+                // Auto-conexão SSH foi desativada: os usuários devem chamar
+                // manualmente `SSHActions.connectWithKey(...)` ou usar `SSHActions` diretamente.
+                // Isto evita conexões automáticas indesejadas.
+                // Exemplo recomendado no teste:
+                //   await SSHActions.connectWithKey('secrets/UserSistAutBRM')
+                // Ou configure o SSH_KEY_PATH e chame manualmente:
+                //   await SSHActions.connectWithKey(process.env.SSH_KEY_PATH)
+            }
+            catch (sshError) {
+                console.warn(`⚠️ [SSH] Não foi possível auto-conectar: ${sshError}`);
+                console.warn('💡 Use SSHActions.connectWithKey() manualmente (ex: await SSHActions.connectWithKey("secrets/UserSistAutBRM"))');
+            }
+            // 6. Registrar no relatório
+            try {
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo?.title) {
+                    const cnName = testInfo.titlePath?.[1] || testInfo.title;
+                    UnifiedReportManager.adicionarLog(cnName, `🌐 Sistema configurado: ${selectedSystem.name} (${selectedSystem.environmentName})`);
+                }
+            }
+            catch {
+                // Ignorar se TestContext não estiver disponível ainda
+            }
+            // 7. 🆕 Registrar sistema no StatementTracker para captura nos CTs
+            try {
+                StatementTracker.setCurrentSystem(selectedSystem.name);
+            }
+            catch (error) {
+                console.warn('⚠️ Não foi possível registrar sistema no StatementTracker:', error);
+            }
+            // 8. 🔧 CRÍTICO: Limpar cache de contextos para garantir novo baseURL
+            try {
+                await ApiActions.clearContextCache();
+            }
+            catch (error) {
+                console.warn('⚠️ Não foi possível limpar cache de contextos:', error);
+            }
+            console.log(`✅ Sistema ${systemName} configurado com sucesso!`);
+        }
+        catch (error) {
+            console.error(`❌ Erro ao configurar sistema: ${error}`);
+            throw new Error(`Falha ao configurar sistema "${systemName}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * 🌐 Obtém a URL do sistema atualmente configurado.
+     * Deve ser chamado APÓS setSystem().
+     *
+     * @returns URL do sistema ou undefined se nenhum sistema foi configurado
+     *
+     * @example
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     * const url = TestAnnotations.getSystemUrl()
+     * console.log(url) // "https://autenticainthml.redecorp.br"
+     */
+    static getSystemUrl() {
+        try {
+            const systemsManager = SystemsManager.getInstance();
+            const config = systemsManager.getSystemConfig();
+            return config?.baseUrl;
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao obter URL do sistema: ${error}`);
+            return undefined;
+        }
+    }
+    /**
+     * 🌐 Obtém as configurações completas do sistema atualmente configurado.
+     * Deve ser chamado APÓS setSystem().
+     *
+     * @returns Configurações do sistema ou null se nenhum sistema foi configurado
+     *
+     * @example
+     * await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+     * const config = TestAnnotations.getSystemConfig()
+     * console.log(config?.baseUrl) // "https://autenticainthml.redecorp.br"
+     * console.log(config?.username) // "usuario"
+     */
+    static getSystemConfig() {
+        try {
+            const systemsManager = SystemsManager.getInstance();
+            return systemsManager.getSystemConfig();
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao obter configuração do sistema: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Configura um teste como API, com interceptador e logs.
+     */
+    static Api = {
+        set testInfo(testInfo) {
+            TestContext.setTestType('API');
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Detectar CN e CT baseado na estrutura do titlePath
+            let cnName;
+            let ctName;
+            if (testInfo.titlePath && testInfo.titlePath.length >= 3) {
+                cnName = testInfo.titlePath[1];
+                ctName = testInfo.titlePath[2];
+            }
+            else if (testInfo.titlePath && testInfo.titlePath.length === 2) {
+                cnName = testInfo.titlePath[0];
+                ctName = testInfo.titlePath[1];
+            }
+            else {
+                cnName = testInfo.title;
+                ctName = testInfo.title;
+            }
+            StatementTracker.setTestName(cnName);
+            // 🆕 CRÍTICO: Capturar e registrar CT automaticamente
+            TestAnnotations.capturarCTDoPlaywright(cnName, ctName, testInfo);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'API');
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName, ctName);
+            // 🔍 NOVO: Ativar logs automáticos de Statements
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            // 🆕 INTERCEPTAÇÃO AUTOMÁTICA DE STATEMENTS
+            TestAnnotations.setupStatementInterception(cnName);
+            // 🚀 MONITORAMENTO CONTÍNUO - interceptar novas instanciações
+            TestAnnotations.setupContinuousStatementMonitoring(cnName);
+            TestAnnotations.setupSafeInterceptor(cnName, 'API', ApiActions.logEvent.bind(ApiActions), ApiActions, 'logEvent');
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Configura um teste como Frontend, com logs e cobertura automática.
+     */
+    static Frontend = {
+        /**
+         * Configura contexto Frontend com TestInfo e cobertura automática
+         * @param testInfo TestInfo do Playwright
+         * @param enableCoverage Se deve habilitar cobertura automática (padrão: true)
+         */
+        configure(testInfo, enableCoverage = true) {
+            TestContext.setTestType('Frontend');
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Detectar CN e CT baseado na estrutura do titlePath
+            let cnName;
+            let ctName;
+            if (testInfo.titlePath && testInfo.titlePath.length >= 3) {
+                cnName = testInfo.titlePath[1];
+                ctName = testInfo.titlePath[2];
+            }
+            else if (testInfo.titlePath && testInfo.titlePath.length === 2) {
+                cnName = testInfo.titlePath[0];
+                ctName = testInfo.titlePath[1];
+            }
+            else {
+                cnName = testInfo.title;
+                ctName = testInfo.title;
+            }
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [FRONTEND] StatementTracker inicializado para CN: "${cnName}"`);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'Frontend');
+            // 🆕 CRÍTICO: Capturar e registrar CT automaticamente
+            TestAnnotations.capturarCTDoPlaywright(cnName, ctName, testInfo);
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName, ctName);
+            UnifiedReportManager.adicionarLog(cnName, `🌐 Inicializando contexto Frontend (cobertura: ${enableCoverage ? 'ON' : 'OFF'})`);
+            // ✅ NOVO: Configurar cobertura automática se habilitada
+            if (enableCoverage) {
+                TestAnnotations.setupFrontendCoverage(testInfo);
+            }
+            // 🔍 NOVO: Ativar logs automáticos de Statements
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+        /**
+         * 🆕 Inicializa contexto Frontend com page e testInfo em uma única chamada
+         * @param options Objeto com page e testInfo do Playwright
+         * @example
+         * test('CT001', async ({ page }, testInfo) => {
+         *   TestAnnotations.Frontend.init({ page, testInfo })
+         *   await TestAnnotations.setSystem('MEU_SISTEMA')
+         *   await new MinhaPage().minhaAcao()
+         * })
+         */
+        init(options) {
+            // ✅ Setar page no TestContext PRIMEIRO
+            TestContext.setPage(options.page);
+            // Depois configurar o resto
+            this.configure(options.testInfo, options.enableCoverage ?? true);
+        },
+        // Propriedade legacy para compatibilidade (requer TestContext.setPage manual)
+        set testInfo(testInfo) {
+            // Dispara criação lazy do browser (só quando fixture está ativo)
+            TestContext.requestBrowserCreation();
+            this.configure(testInfo, true);
+        },
+    };
+    // Removed `Front` alias: use `Frontend` instead
+    /**
+     * Configura um teste como Mobile, com limpeza automática de sessão.
+     */
+    static Mobile = {
+        set testInfo(testInfo) {
+            TestContext.setTestType('Mobile');
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Usar CN (test.describe = titlePath[1]) como identificador do teste
+            // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+            const cnName = testInfo.titlePath?.[1] || testInfo.title;
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [MOBILE] StatementTracker inicializado para CN: "${cnName}"`);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'Mobile');
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName);
+            UnifiedReportManager.adicionarLog(cnName, '📱 Inicializando contexto Mobile');
+            // 🔍 NOVO: Ativar logs automáticos de Statements
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            TestAnnotations.setupMobileAutoCleanup(testInfo);
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Configura limpeza automática para testes mobile.
+     * @param testInfo TestInfo do Playwright.
+     */
+    static setupMobileAutoCleanup(testInfo) {
+        const originalAttach = testInfo.attach;
+        let sessionClosed = false;
+        testInfo.attach = async function (name, options) {
+            if (!sessionClosed &&
+                (name.includes('stdout') ||
+                    name.includes('stderr') ||
+                    name.includes('trace'))) {
+                setTimeout(async () => {
+                    if (!sessionClosed) {
+                        sessionClosed = true;
+                        try {
+                            await MobileConnection.closeSession();
+                            UnifiedReportManager.adicionarLog(testInfo.title, '✅ Sessão mobile encerrada automaticamente');
+                        }
+                        catch (error) {
+                            UnifiedReportManager.adicionarLog(testInfo.title, `⚠️ Erro ao encerrar sessão mobile: ${String(error)}`);
+                        }
+                    }
+                }, 100);
+            }
+            return originalAttach.call(this, name, options);
+        };
+        setTimeout(async () => {
+            if (!sessionClosed) {
+                sessionClosed = true;
+                try {
+                    const hasActiveSession = MobileConnection.isConnected();
+                    if (hasActiveSession) {
+                        await MobileConnection.closeSession();
+                        UnifiedReportManager.adicionarLog(testInfo.title, '✅ Sessão mobile encerrada automaticamente (timeout)');
+                    }
+                }
+                catch {
+                    // Silenciosamente limpar em caso de erro
+                }
+            }
+        }, 35_000);
+    }
+    /**
+     * Método utilitário para configurar mobile capabilities.
+     * @param capabilities Objeto de capabilities do dispositivo.
+     */
+    static async setupMobileCapabilities(capabilities) {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            UnifiedReportManager.adicionarLog(testInfo.title, `🔧 Configurando capabilities para ${capabilities.platformName}`);
+            try {
+                const fullCapabilities = {
+                    ...capabilities,
+                    deviceName: capabilities.deviceId, // deviceName é obrigatório
+                };
+                await MobileConnection.createSession(fullCapabilities);
+                UnifiedReportManager.adicionarLog(testInfo.title, `✅ Sessão mobile criada - Device: ${capabilities.deviceId}`);
+            }
+            catch (error) {
+                UnifiedReportManager.adicionarLog(testInfo.title, `❌ Erro ao criar sessão mobile: ${String(error)}`);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Configura um teste como SSH, com interceptador e logs.
+     */
+    static SSH = {
+        set testInfo(testInfo) {
+            TestContext.setTestType('SSH');
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Usar CN (test.describe = titlePath[1]) como identificador do teste
+            // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+            const cnName = testInfo.titlePath?.[1] || testInfo.title;
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [SSH] StatementTracker inicializado para CN: "${cnName}"`);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'SSH');
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName);
+            TestAnnotations.setupSafeInterceptor(cnName, 'SSH', SSHActions.logEvent.bind(SSHActions), SSHActions, 'logEvent');
+            UnifiedReportManager.adicionarLog(cnName, '🔧 Inicializando contexto SSH');
+            // 🔍 CRITICAL: Ativar interceptação ANTES de qualquer coisa
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            // ✅ SSH: Interceptar classes Statement globais E importadas
+            TestAnnotations.interceptGlobalStatements();
+            TestAnnotations.interceptImportedStatements();
+            console.log('🌟 Interceptação mágica ativada - Statements serão logados automaticamente');
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Configura um teste como Banco, com interceptador e logs.
+     */
+    static Banco = {
+        set testInfo(testInfo) {
+            TestContext.setTestType('Banco');
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Usar CN (test.describe = titlePath[1]) como identificador do teste
+            // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+            const cnName = testInfo.titlePath?.[1] || testInfo.title;
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [BANCO] StatementTracker inicializado para CN: "${cnName}"`);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'Banco');
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName);
+            TestAnnotations.setupSafeInterceptor(cnName, 'BANCO', BancoActions.logEvent.bind(BancoActions), BancoActions, 'logEvent');
+            UnifiedReportManager.adicionarLog(cnName, '🗄️ Inicializando contexto Banco de Dados');
+            // 🔍 NOVO: Ativar logs automáticos de Statements
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Configura um teste como Mixed, com interceptadores e limpeza automática.
+     */
+    static Mixed = {
+        set testInfo(testInfo) {
+            TestContext.setTestType('Mixed');
+            // Dispara criação lazy do browser (só quando fixture está ativo)
+            TestContext.requestBrowserCreation();
+            TestContext.setTestInfo(testInfo);
+            // ✅ CRÍTICO: Usar CN (test.describe = titlePath[1]) como identificador do teste
+            // titlePath[0] = filename, titlePath[1] = CN (test.describe), titlePath[2] = CT (test)
+            const cnName = testInfo.titlePath?.[1] || testInfo.title;
+            StatementTracker.setTestName(cnName);
+            console.log(`🏷️ [MIXED] StatementTracker inicializado para CN: "${cnName}"`);
+            testStartTimes.set(cnName, Date.now());
+            UnifiedReportManager.setTestContext(cnName, 'Mixed');
+            // 🆕 CRÍTICO: Garantir TerminalLogCapture ativo no worker (multi-worker support)
+            ensureTerminalLogCaptureActive(cnName);
+            TestAnnotations.setupAllInterceptors(cnName);
+            UnifiedReportManager.adicionarLog(cnName, '🔀 Inicializando contexto Mixed - Múltiplos tipos habilitados');
+            // 🔍 NOVO: Ativar logs automáticos de Statements
+            ativarStatementLogs();
+            ativarInterceptacaoMagica();
+            TestAnnotations.setupMobileAutoCleanup(testInfo);
+            TestAnnotations.setupTestFinalization(testInfo);
+        },
+    };
+    /**
+     * Adiciona um log ao UnifiedReportManager para o teste.
+     * @param testName Nome do teste.
+     * @param message Mensagem de log.
+     * @param tipo Tipo do log ('info', 'success', 'error', 'warning').
+     */
+    static addLog(testName, message, tipo = 'info') {
+        const emojis = { info: 'ℹ️', success: '✅', error: '❌', warning: '⚠️' };
+        UnifiedReportManager.adicionarLog(testName, `${emojis[tipo]} ${message}`);
+    }
+    /**
+     * Define metadados para o teste no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param metadata Objeto de metadados.
+     */
+    static setMetadata(testName, metadata) {
+        UnifiedReportManager.setTestMetadata(testName, metadata);
+    }
+    /**
+     * Define a duração do teste no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param duracao Duração em segundos.
+     */
+    static setDuration(testName, duracao) {
+        UnifiedReportManager.setTestDuration(testName, duracao);
+    }
+    /**
+     * Obtém o contexto atual do teste.
+     * @returns O tipo de contexto ou null.
+     */
+    static getCurrentTestContext() {
+        const testInfo = TestContext.getSafeTestInfo();
+        if (testInfo?.title) {
+            const metrics = UnifiedReportManager.getMetrics();
+            const teste = metrics.testes.find((t) => t.nome === testInfo.title);
+            return teste?.tipo || null;
+        }
+        return null;
+    }
+    /**
+     * Marca o teste como falha no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param reason Motivo da falha (opcional).
+     */
+    static markTestAsFailed(testName, reason) {
+        const errorMessage = reason
+            ? `❌ Teste falhou: ${reason}`
+            : '❌ Teste marcado como falha';
+        UnifiedReportManager.adicionarLog(testName, errorMessage);
+    }
+    /**
+     * Marca o teste como sucesso no UnifiedReportManager.
+     * @param testName Nome do teste.
+     * @param message Mensagem de sucesso (opcional).
+     */
+    static markTestAsSuccess(testName, message) {
+        const successMessage = message
+            ? `✅ ${message}`
+            : '✅ Teste concluído com sucesso';
+        UnifiedReportManager.adicionarLog(testName, successMessage);
+    }
+    /**
+     * Adiciona um screenshot ao relatório do teste.
+     * @param testName Nome do teste.
+     * @param screenshotName Nome do screenshot.
+     * @param buffer Buffer da imagem.
+     */
+    static async addScreenshot(testName, screenshotName, buffer) {
+        try {
+            const testInfo = TestContext.getSafeTestInfo();
+            if (testInfo) {
+                await testInfo.attach(`📸 ${screenshotName}`, {
+                    body: buffer,
+                    contentType: 'image/png',
+                });
+                UnifiedReportManager.adicionarLog(testName, `📸 Screenshot capturado: ${screenshotName}`);
+            }
+        }
+        catch (error) {
+            UnifiedReportManager.adicionarLog(testName, `❌ Erro ao anexar screenshot: ${error}`);
+        }
+    }
+    /**
+     * Obtém estatísticas globais dos testes.
+     * @returns Objeto com total, concluídos, ativos e por tipo.
+     */
+    static getGlobalStats() {
+        const metrics = UnifiedReportManager.getMetrics();
+        return {
+            totalTests: metrics.totalTestes,
+            completedTests: metrics.testes.length,
+            activeTests: testStartTimes.size,
+            testsByType: metrics.testesPorTipo,
+        };
+    }
+    /**
+     * Limpa interceptadores ativos (debug).
+     */
+    static clearInterceptors() {
+        interceptorsAtivos.clear();
+        console.log('🧹 Interceptadores limpos');
+    }
+    /**
+     * Obtém interceptadores ativos (debug).
+     * @returns Array de chaves de interceptadores ativos.
+     */
+    static getActiveInterceptors() {
+        return Array.from(interceptorsAtivos);
+    }
+    /**
+     * 🔥 FORÇA interceptação direta das classes Statement do projeto real
+     */
+    static forceInterceptRealProjectStatements(statementClasses) {
+        try {
+            console.log('🔥 === INTERCEPTAÇÃO FORÇADA PARA PROJETO REAL ===');
+            // 🎯 Estratégia 1: Interceptar require/import para capturar no momento do carregamento
+            const originalRequire = globalThis.require;
+            if (originalRequire) {
+                ;
+                globalThis.require = function (modulePath) {
+                    const result = originalRequire.apply(this, arguments);
+                    // Se o módulo carregado contém classes Statement
+                    if (result && typeof result === 'object') {
+                        for (const exportName of Object.keys(result)) {
+                            if (statementClasses.includes(exportName) &&
+                                typeof result[exportName] === 'function') {
+                                console.log(`🎯 [REQUIRE] Interceptando classe Statement: ${exportName}`);
+                                result[exportName] =
+                                    TestAnnotations.createForceInterceptedClass(result[exportName], exportName);
+                                console.log(`✅ [REQUIRE] ${exportName} interceptada com sucesso`);
+                            }
+                        }
+                    }
+                    return result;
+                };
+            }
+            // 🎯 Estratégia 2: Monitorar globals com throttling para evitar spam
+            let lastMonitorTime = 0;
+            const monitorThrottleTime = 1000; // 1 segundo entre verificações
+            const monitoringInterval = setInterval(() => {
+                const now = Date.now();
+                if (now - lastMonitorTime < monitorThrottleTime) {
+                    return; // Skip se muito recente
+                }
+                lastMonitorTime = now;
+                statementClasses.forEach((className) => {
+                    const contexts = [
+                        globalThis,
+                        globalThis.global,
+                        globalThis.window,
+                    ].filter(Boolean);
+                    for (const context of contexts) {
+                        if (context[className] &&
+                            typeof context[className] === 'function' &&
+                            !context[className]._alreadyForceIntercepted) {
+                            console.log(`🔥 [MONITOR] Encontrada classe Statement não interceptada: ${className}`);
+                            const OriginalClass = context[className];
+                            const InterceptedClass = TestAnnotations.createForceInterceptedClass(OriginalClass, className);
+                            InterceptedClass._alreadyForceIntercepted = true;
+                            // Substituir no contexto
+                            context[className] = InterceptedClass;
+                            console.log(`✅ [MONITOR] ${className} interceptada e substituída`);
+                        }
+                    }
+                });
+            }, 500); // Verificar a cada 500ms (reduzido de 100ms)
+            // Parar o monitoramento após 10 segundos
+            setTimeout(() => {
+                clearInterval(monitoringInterval);
+                console.log('🕐 [MONITOR] Monitoramento de interceptação finalizado');
+            }, 10_000);
+            console.log(`🚀 [FORÇA] Interceptação forçada configurada para ${statementClasses.length} classes`);
+        }
+        catch (error) {
+            console.warn(`⚠️ [FORÇA] Erro na interceptação forçada: ${error}`);
+        }
+    }
+    /**
+     * 🎯 Cria uma versão completamente interceptada de uma classe Statement
+     */
+    static createForceInterceptedClass(OriginalClass, className) {
+        try {
+            console.log(`🔧 [FORÇA] Criando interceptação para: ${className}`);
+            // Criar nova classe que substitui completamente a original
+            const ForceInterceptedClass = (...args) => {
+                console.log(`🚀 [FORÇA] NEW ${className}() INTERCEPTADO DEFINITIVAMENTE!`);
+                console.log('📋 === CT EM EXECUÇÃO === [INTERCEPTAÇÃO FORÇADA]');
+                console.log(`   🎯 Classe: ${className}`);
+                console.log(`   ⏰ [${new Date().toISOString()}] Instância criada`);
+                console.log('   🚀 FUNCIONANDO NO PROJETO REAL!');
+                // Criar instância original
+                const instance = new OriginalClass(...args);
+                // Interceptar TODOS os métodos da instância
+                const proto = Object.getPrototypeOf(instance);
+                const methodNames = Object.getOwnPropertyNames(proto);
+                for (const methodName of methodNames) {
+                    if (methodName !== 'constructor' &&
+                        typeof instance[methodName] === 'function') {
+                        const originalMethod = instance[methodName];
+                        instance[methodName] = function (...methodArgs) {
+                            // ✅ CORRIGIDO: NÃO chamar startCT/endCT aqui!
+                            // O StatementTracker.interceptStatement() já faz isso automaticamente
+                            console.log(`📋 === STATEMENT EM EXECUÇÃO === ${className}.${methodName}()`);
+                            console.log(`   🎯 [FORÇA] Método interceptado: ${methodName}()`);
+                            console.log(`   ⏰ [${new Date().toISOString()}] Iniciando execução...`);
+                            console.log('   🚀 CAPTURADO NO PROJETO REAL!');
+                            const startTime = Date.now();
+                            try {
+                                const result = originalMethod.apply(this, methodArgs);
+                                // Se é Promise
+                                if (result && typeof result.then === 'function') {
+                                    return result
+                                        .then((res) => {
+                                        const duration = Date.now() - startTime;
+                                        console.log(`   ✅ [${new Date().toISOString()}] Finalizada: ${className}.${methodName}() - ${duration}ms`);
+                                        console.log(`   📊 Resultado: ${typeof res === 'boolean' ? (res ? 'true (PASS)' : 'false (FAIL)') : res ? 'success' : 'null/undefined'}`);
+                                        console.log('📋 === STATEMENT FINALIZADA ===');
+                                        return res;
+                                    })
+                                        .catch((err) => {
+                                        const duration = Date.now() - startTime;
+                                        console.log(`   ❌ [${new Date().toISOString()}] Erro: ${className}.${methodName}() - ${duration}ms`);
+                                        console.log('📋 === STATEMENT COM ERRO ===');
+                                        throw err;
+                                    });
+                                }
+                                // Método síncrono
+                                const duration = Date.now() - startTime;
+                                console.log(`   ✅ [${new Date().toISOString()}] Finalizada: ${className}.${methodName}() - ${duration}ms`);
+                                console.log(`   📊 Resultado: ${typeof result === 'boolean' ? (result ? 'true (PASS)' : 'false (FAIL)') : result ? 'success' : 'null/undefined'}`);
+                                console.log('📋 === STATEMENT FINALIZADA ===');
+                                return result;
+                            }
+                            catch (error) {
+                                const duration = Date.now() - startTime;
+                                console.log(`   ❌ [${new Date().toISOString()}] Erro: ${className}.${methodName}() - ${duration}ms`);
+                                console.log(`   🔍 Erro: ${error?.message || 'Erro desconhecido'}`);
+                                console.log('📋 === STATEMENT COM ERRO ===');
+                                throw error;
+                            }
+                        };
+                    }
+                }
+                return instance;
+            };
+            // Preservar prototype e propriedades estáticas
+            ForceInterceptedClass.prototype = OriginalClass.prototype;
+            Object.setPrototypeOf(ForceInterceptedClass, OriginalClass);
+            // Copiar propriedades estáticas
+            Object.getOwnPropertyNames(OriginalClass).forEach((prop) => {
+                if (prop !== 'length' && prop !== 'name' && prop !== 'prototype') {
+                    try {
+                        ;
+                        ForceInterceptedClass[prop] = OriginalClass[prop];
+                    }
+                    catch {
+                        // Ignorar propriedades que não podem ser copiadas
+                    }
+                }
+            });
+            console.log(`✅ [FORÇA] Classe ${className} completamente interceptada`);
+            return ForceInterceptedClass;
+        }
+        catch (error) {
+            console.warn(`⚠️ [FORÇA] Erro ao criar interceptação para ${className}: ${error}`);
+            return OriginalClass;
+        }
+    }
+    /**
+     * 🚀 Gerencia execução de métodos CT detectados via log
+     */
+    static handleMethodExecution(methodName) {
+        try {
+            // ❌ REMOVIDO: Logs de finalização de CT antigos aqui
+            // O log estava aparecendo DEPOIS do "NOVO CT INICIADO" porque é executado
+            // no início da função. A finalização correta é feita pelo StatementTracker.finalizarCT()
+            // que é chamado pelo CustomReporter quando o teste termina.
+            // ✅ CORREÇÃO: Não criar CT aqui - deixar o StatementTracker.ensureCTCreated() gerenciar
+            // O CT será criado automaticamente na primeira statement pelo interceptStatement()
+            // Aqui apenas registramos o Statement ativo para compatibilidade
+            currentActiveCT = {
+                name: methodName,
+                startTime: Date.now(),
+                statement: methodName,
+            };
+            // ❌ REMOVIDO: Logs duplicados de "NOVO CT INICIADO"
+            // O StatementTracker.startCT já faz os logs necessários
+            // ❌ REMOVIDO: Não criar CT aqui - StatementTracker.ensureCTCreated() faz isso
+            // StatementTracker.startCT(formattedCtName) ← ESTAVA CRIANDO CT PARA CADA STATEMENT!
+            // ✅ CORRIGIDO: Usar nome do método original, não ID aleatório
+            currentActiveCT.name = methodName;
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao gerenciar execução de método: ${error}`);
+        }
+    }
+    /**
+     * 🚨 NOVO: Gerencia erros de validação detectados via log
+     */
+    static handleValidationError(errorMessage) {
+        // 🔧 DESABILITADO TEMPORARIAMENTE PARA EVITAR LOOP INFINITO
+        // Este método estava causando spam de "❌ ERRO DE VALIDAÇÃO DETECTADO (sem CT ativo)"
+        // Vamos simplificar e não processar esses erros automaticamente
+        return;
+    }
+    /**
+     * 🏁 Finaliza o CT ativo quando o teste termina
+     */
+    static finalizarCTAtivo() {
+        try {
+            // 1. Finalizar CT ativo do TestAnnotations (sistema legado)
+            if (currentActiveCT) {
+                const duration = ((Date.now() - currentActiveCT.startTime) /
+                    1000).toFixed(2);
+                const currentTime = new Date().toLocaleTimeString('pt-BR');
+                console.log(`\n✅ CT FINALIZADO (FIM DO TESTE): ${currentActiveCT.statement}`);
+                console.log(`   ⏱️  Duração: ${duration}s`);
+                console.log(`   🕐 Finalizado: ${currentTime}\n`);
+                // ❌ REMOVIDO: StatementTracker.endCT() - O teardown já finaliza todos os CTs automaticamente
+                // O método finalizarCTAtivo() é do sistema legado e não deve interferir com StatementTracker
+                // Limpar CT ativo
+                currentActiveCT = null;
+            }
+            // ❌ REMOVIDO: Finalização manual de CTs
+            // O UnifiedTeardown.run() já faz isso automaticamente chamando finalizeRunningCTsAsFailed()
+            // Não precisamos fazer aqui para evitar duplicação e erros
+            // 🆕 3. Adicionar logs capturados ao relatório final
+            try {
+                const testInfo = TestContext.getSafeTestInfo();
+                if (testInfo?.title && logsCapturados.length > 0) {
+                    // Adicionar header para seção de logs de ações
+                    UnifiedReportManager.adicionarLog(testInfo.title, '\n📋 === LOGS DE AÇÕES DE CTs ===');
+                    // Adicionar todos os logs capturados
+                    for (const log of logsCapturados) {
+                        UnifiedReportManager.adicionarLog(testInfo.title, log);
+                    }
+                    console.log(`📊 Adicionados ${logsCapturados.length} logs de ações ao relatório`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️ Erro ao adicionar logs capturados: ${error}`);
+            }
+            // 🆕 4. Restaurar console original e limpar logs
+            TestAnnotations.restaurarConsoleOriginal();
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro na finalização de CTs: ${error}`);
+        }
+    }
+    /**
+     * 🆕 Restaurar console original e limpar dados
+     */
+    static restaurarConsoleOriginal() {
+        try {
+            if (interceptacaoLogsAtiva) {
+                console.log = originalConsoleLog;
+                console.info = originalConsoleInfo;
+                console.warn = originalConsoleWarn;
+                console.error = originalConsoleError;
+                interceptacaoLogsAtiva = false;
+                logsCapturados = [];
+                atualizarReferenciaGlobalDosLogs();
+                console.log('🔧 Console original restaurado e logs limpos');
+            }
+        }
+        catch (error) {
+            console.warn(`⚠️ Erro ao restaurar console: ${error}`);
+        }
+    }
+    /**
+     * 🆕 Obter logs capturados (para debugging)
+     */
+    static getLogsCapturados() {
+        return [...logsCapturados];
+    }
+    // ============================================
+    // 🔐 MÉTODOS DE AUTENTICAÇÃO E STORAGE STATE
+    // ============================================
+    /**
+     * 💾 Salva o estado de autenticação atual (cookies + localStorage + sessionStorage)
+     * @param filePath Caminho opcional para salvar (padrão: ./test-results/auth/auth-state.json)
+     * @example
+     * // Após fazer login
+     * await TestAnnotations.saveAuthState('./auth/admin-user.json')
+     */
+    static async saveAuthState(filePath) {
+        return await TestContext.saveAuthState(filePath);
+    }
+    /**
+     * 🔄 Restaura o estado de autenticação salvo
+     * @param filePath Caminho do arquivo de estado
+     * @example
+     * // Antes de rodar testes
+     * await TestAnnotations.restoreAuthState('./auth/admin-user.json')
+     */
+    static async restoreAuthState(filePath) {
+        await TestContext.restoreAuthState(filePath);
+    }
+    /**
+     * 🧹 Limpa todo o estado de autenticação
+     * @example
+     * // Logout completo
+     * await TestAnnotations.clearAuthState()
+     */
+    static async clearAuthState() {
+        await TestContext.clearAuthState();
+    }
+    /**
+     * 📄 Verifica se existe um arquivo de estado salvo
+     * @param filePath Caminho do arquivo
+     */
+    static authStateExists(filePath) {
+        return TestContext.authStateExists(filePath);
+    }
+    /**
+     * 🔍 Lê o estado salvo sem aplicar
+     * @param filePath Caminho do arquivo
+     */
+    static readAuthState(filePath) {
+        return TestContext.readAuthState(filePath);
+    }
+    /**
+     * 🗑️ Remove um arquivo de estado
+     * @param filePath Caminho do arquivo
+     */
+    static deleteAuthState(filePath) {
+        return TestContext.deleteAuthState(filePath);
+    }
+    /**
+     * 📋 Lista todos os estados salvos
+     */
+    static listAuthStates() {
+        return TestContext.listAuthStates();
+    }
+}
+// Removed uppercase aliases: keep only the typed properties (Api, Frontend, Mobile, Banco)
+// Exportar também as classes individuais para uso direto
+export const { Api, Frontend, Mobile, SSH, Banco, Mixed, Auto, } = TestAnnotations;
+// NOTE: Uppercase aliases removed. Use `Api`, `Frontend`, `Mobile`, `Banco` (camelCase) imports instead.