testchimp-runner-core 0.1.31 → 0.1.33

package/dist/execution-service.js

@@ -1993,525 +1993,544 @@ class ExecutionService {
                 applyFileUploadOverrides(page, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
                 this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
             }
-            // Create suite context manager - one context per suite, shared across all hooks and tests
-            const suiteContexts = new Map();
-            // Helper to get or create suite context
-            const getOrCreateSuiteContext = async (suitePath, suiteVariables, fileVariables) => {
-                const suiteKey = JSON.stringify(suitePath);
-                if (!suiteContexts.has(suiteKey)) {
-                    const { expect, test } = require('@playwright/test');
-                    const { ai } = require('ai-wright');
-                    const suiteContext = new PersistentExecutionContext(page, expect, test, ai, browser, context, request.tempDir);
-                    suiteContexts.set(suiteKey, { context: suiteContext, variablesInitialized: false });
-                }
-                const suiteContextData = suiteContexts.get(suiteKey);
-                if (!suiteContextData.variablesInitialized) {
-                    try {
-                        // Set testFileDir on context for module resolution (needed before executing requires)
-                        // Use testFolderPath from request if available, otherwise default to tempDir/tests
-                        const testFileDir = request.testFolderPath && request.testFolderPath.length > 0
-                            ? path.join(request.tempDir, ...request.testFolderPath)
-                            : path.join(request.tempDir, 'tests');
-                        suiteContextData.context.setTestFileDir(testFileDir);
-                        // Load .env inside VM before any user code so process.env is available in test and POM code
-                        if (request.tempDir) {
-                            await suiteContextData.context.executeCode(getEnvBootstrapCode());
-                        }
-                        // Execute imports from originalScript (for module resolution)
-                        if (originalScript && request.tempDir) {
-                            const importStatements = import_utils_1.ImportUtils.extractImportStatements(originalScript, (msg) => this.log(msg));
-                            if (importStatements.length > 0) {
-                                const importsCode = import_utils_1.ImportUtils.convertImportsToRequires(importStatements, (msg) => this.log(msg));
-                                if (importsCode) {
-                                    await suiteContextData.context.executeCode(importsCode);
+            const testFileDir = request.testFolderPath && request.testFolderPath.length > 0
+                ? path.join(request.tempDir, ...request.testFolderPath)
+                : path.join(request.tempDir, 'tests');
+            // Clear require cache for workspace so page/test files are always loaded fresh (avoids stale POM/page cache across runs)
+            const tempDirNorm = path.normalize(request.tempDir) + path.sep;
+            const cacheKeys = Object.keys(require.cache);
+            for (const id of cacheKeys) {
+                try {
+                    const normalized = path.normalize(id);
+                    if (normalized.startsWith(tempDirNorm) || normalized === path.normalize(request.tempDir)) {
+                        delete require.cache[id];
+                    }
+                }
+                catch (_) {
+                    // ignore
+                }
+            }
+            return await ModuleResolutionManager.runWithContext({ tempDir: request.tempDir, testFileDir }, async () => {
+                // Create suite context manager - one context per suite, shared across all hooks and tests
+                const suiteContexts = new Map();
+                // Helper to get or create suite context
+                const getOrCreateSuiteContext = async (suitePath, suiteVariables, fileVariables) => {
+                    const suiteKey = JSON.stringify(suitePath);
+                    if (!suiteContexts.has(suiteKey)) {
+                        const { expect, test } = require('@playwright/test');
+                        const { ai } = require('ai-wright');
+                        const suiteContext = new PersistentExecutionContext(page, expect, test, ai, browser, context, request.tempDir);
+                        suiteContexts.set(suiteKey, { context: suiteContext, variablesInitialized: false });
+                    }
+                    const suiteContextData = suiteContexts.get(suiteKey);
+                    if (!suiteContextData.variablesInitialized) {
+                        try {
+                            // Set testFileDir on context for module resolution (needed before executing requires)
+                            // Use testFolderPath from request if available, otherwise default to tempDir/tests
+                            const testFileDir = request.testFolderPath && request.testFolderPath.length > 0
+                                ? path.join(request.tempDir, ...request.testFolderPath)
+                                : path.join(request.tempDir, 'tests');
+                            suiteContextData.context.setTestFileDir(testFileDir);
+                            // Load .env inside VM before any user code so process.env is available in test and POM code
+                            if (request.tempDir) {
+                                await suiteContextData.context.executeCode(getEnvBootstrapCode());
+                            }
+                            // Execute imports from originalScript (for module resolution)
+                            if (originalScript && request.tempDir) {
+                                const importStatements = import_utils_1.ImportUtils.extractImportStatements(originalScript, (msg) => this.log(msg));
+                                if (importStatements.length > 0) {
+                                    const importsCode = import_utils_1.ImportUtils.convertImportsToRequires(importStatements, (msg) => this.log(msg));
+                                    if (importsCode) {
+                                        await suiteContextData.context.executeCode(importsCode);
+                                    }
                                 }
                             }
+                            // Initialize file variables (parent scope) - order: file variables → suite variables
+                            if (fileVariables.length > 0) {
+                                const fileVarsCode = fileVariables.join('\n');
+                                await suiteContextData.context.executeCode(fileVarsCode);
+                            }
+                            // Initialize suite variables (child scope)
+                            if (suiteVariables.length > 0) {
+                                const suiteVarsCode = suiteVariables.join('\n');
+                                await suiteContextData.context.executeCode(suiteVarsCode);
+                            }
+                            suiteContextData.variablesInitialized = true;
                         }
-                        // Initialize file variables (parent scope) - order: file variables → suite variables
-                        if (fileVariables.length > 0) {
-                            const fileVarsCode = fileVariables.join('\n');
-                            await suiteContextData.context.executeCode(fileVarsCode);
-                        }
-                        // Initialize suite variables (child scope)
-                        if (suiteVariables.length > 0) {
-                            const suiteVarsCode = suiteVariables.join('\n');
-                            await suiteContextData.context.executeCode(suiteVarsCode);
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`Variable initialization failed for suite ${suitePath.join('__')}: ${errorMsg}`, 'warn');
+                            // Continue - variables may be optional
                         }
-                        suiteContextData.variablesInitialized = true;
                     }
-                    catch (error) {
-                        const errorMsg = error instanceof Error ? error.message : String(error);
-                        this.log(`Variable initialization failed for suite ${suitePath.join('__')}: ${errorMsg}`, 'warn');
-                        // Continue - variables may be optional
+                    return suiteContextData.context;
+                };
+                // Helper to dispose suite context
+                const disposeSuiteContext = (suitePath) => {
+                    const suiteKey = JSON.stringify(suitePath);
+                    const suiteContextData = suiteContexts.get(suiteKey);
+                    if (suiteContextData) {
+                        suiteContextData.context.dispose();
+                        suiteContexts.delete(suiteKey);
                     }
-                }
-                return suiteContextData.context;
-            };
-            // Helper to dispose suite context
-            const disposeSuiteContext = (suitePath) => {
-                const suiteKey = JSON.stringify(suitePath);
-                const suiteContextData = suiteContexts.get(suiteKey);
-                if (suiteContextData) {
-                    suiteContextData.context.dispose();
-                    suiteContexts.delete(suiteKey);
-                }
-            };
-            // Create file-level shared context for file-level hooks
-            let fileLevelContext = null;
-            const initializeFileLevelContext = async () => {
-                if (!fileLevelContext && (flattened.fileVariables.length > 0 || flattened.fileLevelHooks.beforeAll.length > 0)) {
-                    const { expect, test } = require('@playwright/test');
-                    const { ai } = require('ai-wright');
-                    fileLevelContext = new PersistentExecutionContext(page, expect, test, ai, browser, context, request.tempDir);
-                    try {
-                        // Set testFileDir on context for module resolution (needed before executing requires)
-                        // Use testFolderPath from request if available, otherwise default to tempDir/tests
-                        const testFileDir = request.testFolderPath && request.testFolderPath.length > 0
-                            ? path.join(request.tempDir, ...request.testFolderPath)
-                            : path.join(request.tempDir, 'tests');
-                        fileLevelContext.setTestFileDir(testFileDir);
-                        // Load .env inside VM before any user code so process.env is available in test and POM code
-                        if (request.tempDir) {
-                            await fileLevelContext.executeCode(getEnvBootstrapCode());
-                        }
-                        // Execute imports from originalScript (for module resolution)
-                        if (originalScript && request.tempDir) {
-                            const importStatements = import_utils_1.ImportUtils.extractImportStatements(originalScript, (msg) => this.log(msg));
-                            if (importStatements.length > 0) {
-                                const importsCode = import_utils_1.ImportUtils.convertImportsToRequires(importStatements, (msg) => this.log(msg));
-                                if (importsCode) {
-                                    await fileLevelContext.executeCode(importsCode);
+                };
+                // Create file-level shared context for file-level hooks
+                let fileLevelContext = null;
+                const initializeFileLevelContext = async () => {
+                    if (!fileLevelContext && (flattened.fileVariables.length > 0 || flattened.fileLevelHooks.beforeAll.length > 0)) {
+                        const { expect, test } = require('@playwright/test');
+                        const { ai } = require('ai-wright');
+                        fileLevelContext = new PersistentExecutionContext(page, expect, test, ai, browser, context, request.tempDir);
+                        try {
+                            // Set testFileDir on context for module resolution (needed before executing requires)
+                            // Use testFolderPath from request if available, otherwise default to tempDir/tests
+                            const testFileDir = request.testFolderPath && request.testFolderPath.length > 0
+                                ? path.join(request.tempDir, ...request.testFolderPath)
+                                : path.join(request.tempDir, 'tests');
+                            fileLevelContext.setTestFileDir(testFileDir);
+                            // Load .env inside VM before any user code so process.env is available in test and POM code
+                            if (request.tempDir) {
+                                await fileLevelContext.executeCode(getEnvBootstrapCode());
+                            }
+                            // Execute imports from originalScript (for module resolution)
+                            if (originalScript && request.tempDir) {
+                                const importStatements = import_utils_1.ImportUtils.extractImportStatements(originalScript, (msg) => this.log(msg));
+                                if (importStatements.length > 0) {
+                                    const importsCode = import_utils_1.ImportUtils.convertImportsToRequires(importStatements, (msg) => this.log(msg));
+                                    if (importsCode) {
+                                        await fileLevelContext.executeCode(importsCode);
+                                    }
                                 }
                             }
+                            // Initialize file-level variables
+                            if (flattened.fileVariables.length > 0) {
+                                const fileVarsCode = flattened.fileVariables.join('\n');
+                                await fileLevelContext.executeCode(fileVarsCode);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`File-level variable initialization failed: ${errorMsg}`, 'warn');
+                            // Continue - variables may be optional
                         }
-                        // Initialize file-level variables
-                        if (flattened.fileVariables.length > 0) {
-                            const fileVarsCode = flattened.fileVariables.join('\n');
-                            await fileLevelContext.executeCode(fileVarsCode);
+                    }
+                };
+                // Initialize file-level context before file-level hooks
+                await initializeFileLevelContext();
+                // Execute file-level beforeAll hooks
+                if (flattened.fileLevelHooks.beforeAll.length > 0) {
+                    this.log(`Executing ${flattened.fileLevelHooks.beforeAll.length} file-level beforeAll hook(s)...`);
+                    try {
+                        for (const hook of flattened.fileLevelHooks.beforeAll) {
+                            await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
                         }
+                        this.log('File-level beforeAll hooks executed successfully');
                     }
                     catch (error) {
                         const errorMsg = error instanceof Error ? error.message : String(error);
-                        this.log(`File-level variable initialization failed: ${errorMsg}`, 'warn');
-                        // Continue - variables may be optional
-                    }
-                }
-            };
-            // Initialize file-level context before file-level hooks
-            await initializeFileLevelContext();
-            // Execute file-level beforeAll hooks
-            if (flattened.fileLevelHooks.beforeAll.length > 0) {
-                this.log(`Executing ${flattened.fileLevelHooks.beforeAll.length} file-level beforeAll hook(s)...`);
-                try {
-                    for (const hook of flattened.fileLevelHooks.beforeAll) {
-                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
-                    }
-                    this.log('File-level beforeAll hooks executed successfully');
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    this.log(`File-level beforeAll hook failed: ${errorMsg}`, 'error');
-                    // Cleanup browser if we created it
-                    if (browserCreated && browser) {
-                        try {
-                            await browser.close();
-                        }
-                        catch (closeError) {
-                            // Ignore close errors
+                        this.log(`File-level beforeAll hook failed: ${errorMsg}`, 'error');
+                        // Cleanup browser if we created it
+                        if (browserCreated && browser) {
+                            try {
+                                await browser.close();
+                            }
+                            catch (closeError) {
+                                // Ignore close errors
+                            }
                         }
+                        return {
+                            success: false,
+                            testResults: [],
+                            executionTime: Date.now() - startTime,
+                            error: `File-level beforeAll hook failed: ${errorMsg}`
+                        };
                     }
-                    return {
-                        success: false,
-                        testResults: [],
-                        executionTime: Date.now() - startTime,
-                        error: `File-level beforeAll hook failed: ${errorMsg}`
-                    };
                 }
-            }
-            // Helper function to create a unique key from suite path (avoids collisions if suite names contain '__')
-            const getSuiteKey = (suitePath) => {
-                // Use JSON.stringify to safely serialize the array, avoiding collisions
-                return JSON.stringify(suitePath);
-            };
-            // Build a Map of suites by key for O(1) lookups (instead of O(n) .find() calls)
-            const suiteMap = new Map();
-            for (const suite of flattened.suites) {
-                const suiteKey = getSuiteKey(suite.suitePath);
-                suiteMap.set(suiteKey, suite);
-            }
-            // Track suite execution state (which suites have had beforeAll executed)
-            const suiteBeforeAllExecuted = new Set();
-            // Track test counts per suite (for determining last test in suite)
-            const suiteTestCounts = new Map();
-            const suiteTotalTests = new Map();
-            // Initialize suite test counts
-            for (const suite of flattened.suites) {
-                const suiteKey = getSuiteKey(suite.suitePath);
-                suiteTotalTests.set(suiteKey, suite.testIndices.length);
-                suiteTestCounts.set(suiteKey, 0);
-            }
-            // Execute each test
-            for (let testIndex = 0; testIndex < flattened.tests.length; testIndex++) {
-                const testData = flattened.tests[testIndex];
-                const test = testData.test;
-                const testStartTime = Date.now();
-                // Use pre-assigned jobId when caller provides one (e.g. batch pre-create) and we have exactly one test
-                const jobId = (request.jobId && flattened.tests.length === 1)
-                    ? request.jobId
-                    : crypto.randomUUID();
-                let testStatus = 'passed';
-                let testError;
-                try {
-                    // Before test execution: Execute suite-level beforeAll hooks (if first test in suite)
-                    if (testData.suitePath.length > 0) {
-                        // Execute beforeAll for each suite in the path (in order: parent → child)
-                        for (let i = 0; i < testData.suitePath.length; i++) {
-                            const suitePath = testData.suitePath.slice(0, i + 1);
-                            const suiteKey = getSuiteKey(suitePath);
-                            // Look up suite in Map (O(1) instead of O(n) .find())
-                            const suite = suiteMap.get(suiteKey);
-                            if (suite && suite.beforeAll.length > 0 && !suiteBeforeAllExecuted.has(suiteKey)) {
-                                // Use human-readable suite name for logging
-                                const suiteDisplayName = suitePath.join('__');
-                                this.log(`Executing suite-level beforeAll hooks for suite: ${suiteDisplayName}`);
-                                try {
-                                    // Get or create suite context (includes file variables + suite variables)
-                                    const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
-                                    for (const hook of suite.beforeAll) {
-                                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
+                // Helper function to create a unique key from suite path (avoids collisions if suite names contain '__')
+                const getSuiteKey = (suitePath) => {
+                    // Use JSON.stringify to safely serialize the array, avoiding collisions
+                    return JSON.stringify(suitePath);
+                };
+                // Build a Map of suites by key for O(1) lookups (instead of O(n) .find() calls)
+                const suiteMap = new Map();
+                for (const suite of flattened.suites) {
+                    const suiteKey = getSuiteKey(suite.suitePath);
+                    suiteMap.set(suiteKey, suite);
+                }
+                // Track suite execution state (which suites have had beforeAll executed)
+                const suiteBeforeAllExecuted = new Set();
+                // Track test counts per suite (for determining last test in suite)
+                const suiteTestCounts = new Map();
+                const suiteTotalTests = new Map();
+                // Initialize suite test counts
+                for (const suite of flattened.suites) {
+                    const suiteKey = getSuiteKey(suite.suitePath);
+                    suiteTotalTests.set(suiteKey, suite.testIndices.length);
+                    suiteTestCounts.set(suiteKey, 0);
+                }
+                // Execute each test
+                for (let testIndex = 0; testIndex < flattened.tests.length; testIndex++) {
+                    const testData = flattened.tests[testIndex];
+                    const test = testData.test;
+                    const testStartTime = Date.now();
+                    // Use pre-assigned jobId when caller provides one (e.g. batch pre-create) and we have exactly one test
+                    const jobId = (request.jobId && flattened.tests.length === 1)
+                        ? request.jobId
+                        : crypto.randomUUID();
+                    let testStatus = 'passed';
+                    let testError;
+                    try {
+                        // Before test execution: Execute suite-level beforeAll hooks (if first test in suite)
+                        if (testData.suitePath.length > 0) {
+                            // Execute beforeAll for each suite in the path (in order: parent → child)
+                            for (let i = 0; i < testData.suitePath.length; i++) {
+                                const suitePath = testData.suitePath.slice(0, i + 1);
+                                const suiteKey = getSuiteKey(suitePath);
+                                // Look up suite in Map (O(1) instead of O(n) .find())
+                                const suite = suiteMap.get(suiteKey);
+                                if (suite && suite.beforeAll.length > 0 && !suiteBeforeAllExecuted.has(suiteKey)) {
+                                    // Use human-readable suite name for logging
+                                    const suiteDisplayName = suitePath.join('__');
+                                    this.log(`Executing suite-level beforeAll hooks for suite: ${suiteDisplayName}`);
+                                    try {
+                                        // Get or create suite context (includes file variables + suite variables)
+                                        const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
+                                        for (const hook of suite.beforeAll) {
+                                            await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
+                                        }
+                                        suiteBeforeAllExecuted.add(suiteKey);
+                                        this.log(`Suite-level beforeAll hooks executed for suite: ${suiteDisplayName}`);
+                                    }
+                                    catch (error) {
+                                        const errorMsg = error instanceof Error ? error.message : String(error);
+                                        this.log(`Suite-level beforeAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'error');
+                                        testStatus = 'failed';
+                                        testError = `Suite-level beforeAll hook failed: ${errorMsg}`;
                                     }
-                                    suiteBeforeAllExecuted.add(suiteKey);
-                                    this.log(`Suite-level beforeAll hooks executed for suite: ${suiteDisplayName}`);
-                                }
-                                catch (error) {
-                                    const errorMsg = error instanceof Error ? error.message : String(error);
-                                    this.log(`Suite-level beforeAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'error');
-                                    testStatus = 'failed';
-                                    testError = `Suite-level beforeAll hook failed: ${errorMsg}`;
                                 }
                             }
                         }
-                    }
-                    // Call onStartTest callback (use TestPathway)
-                    if (this.progressReporter?.onStartTest) {
-                        try {
-                            await this.progressReporter.onStartTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, page, browser, context);
-                        }
-                        catch (callbackError) {
-                            this.log(`onStartTest callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`, 'warn');
-                            // Don't fail the test if callback has issues - runner-core is a library
-                        }
-                    }
-                    // Track step counter for sequential numeric step IDs across hooks and test
-                    let testStepCounter = 0;
-                    // Execute file-level beforeEach hooks
-                    if (flattened.fileLevelHooks.beforeEach.length > 0 && testStatus === 'passed') {
-                        this.log(`Executing ${flattened.fileLevelHooks.beforeEach.length} file-level beforeEach hook(s) for test: ${test.fullName}`);
-                        try {
-                            for (const hook of flattened.fileLevelHooks.beforeEach) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
-                                testStepCounter += stepsExecuted;
+                        // Call onStartTest callback (use TestPathway)
+                        if (this.progressReporter?.onStartTest) {
+                            try {
+                                await this.progressReporter.onStartTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, page, browser, context);
                             }
-                        }
-                        catch (error) {
-                            const errorMsg = error instanceof Error ? error.message : String(error);
-                            this.log(`File-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
-                            testStatus = 'failed';
-                            testError = `File-level beforeEach hook failed: ${errorMsg}`;
-                        }
-                    }
-                    // Execute suite-level beforeEach hooks (from all parent suites, in order: parent → child)
-                    if (testData.suiteBeforeEachHooks.length > 0 && testStatus === 'passed') {
-                        this.log(`Executing ${testData.suiteBeforeEachHooks.length} suite-level beforeEach hook(s) for test: ${test.fullName}`);
-                        try {
-                            // Get or create suite context for this test's suite
-                            const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
-                            for (const hook of testData.suiteBeforeEachHooks) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
-                                testStepCounter += stepsExecuted;
+                            catch (callbackError) {
+                                this.log(`onStartTest callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`, 'warn');
+                                // Don't fail the test if callback has issues - runner-core is a library
                             }
                         }
-                        catch (error) {
-                            const errorMsg = error instanceof Error ? error.message : String(error);
-                            this.log(`Suite-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
-                            testStatus = 'failed';
-                            testError = `Suite-level beforeEach hook failed: ${errorMsg}`;
+                        // Track step counter for sequential numeric step IDs across hooks and test
+                        let testStepCounter = 0;
+                        // Execute file-level beforeEach hooks
+                        if (flattened.fileLevelHooks.beforeEach.length > 0 && testStatus === 'passed') {
+                            this.log(`Executing ${flattened.fileLevelHooks.beforeEach.length} file-level beforeEach hook(s) for test: ${test.fullName}`);
+                            try {
+                                for (const hook of flattened.fileLevelHooks.beforeEach) {
+                                    const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
+                                    testStepCounter += stepsExecuted;
+                                }
+                            }
+                            catch (error) {
+                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                this.log(`File-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
+                                testStatus = 'failed';
+                                testError = `File-level beforeEach hook failed: ${errorMsg}`;
+                            }
                         }
-                    }
-                    // Run the test if hooks didn't fail
-                    if (testStatus === 'passed') {
-                        // Count non-variable statements for step counter tracking (needed in catch block)
-                        const testStepsExecuted = test.statements.filter(stmt => !stmt.isVariableDeclaration).length;
-                        try {
-                            // Construct a script with imports + this test (needed for module resolution)
-                            // Variables are already in shared context, so we don't need to include them in script
-                            const testScript = test_file_parser_1.TestFileParser.constructTestScriptWithImports(originalScript, test.name, // Use test name only, not fullName (suite prefix not needed in generated script)
-                            test.code);
-                            // Use pre-parsed statements from initial file parse
-                            // These were extracted directly from the original AST, ensuring accuracy
-                            this.log(`Using ${test.statements.length} pre-parsed statements for test: ${test.fullName}`);
-                            // Count non-variable statements for step ID assignment
-                            let stepIndex = 0; // Track step index (only for non-variable statements)
-                            const steps = test.statements.map((stmt) => {
-                                // CRITICAL: Always use hash-based stepId from parser if available
-                                // Only assign step ID to non-variable statements
-                                const stepId = stmt.isVariableDeclaration
-                                    ? undefined
-                                    : (stmt.stepId || String(testStepCounter + stepIndex++));
-                                // Log stepId assignment for debugging
-                                if (!stmt.isVariableDeclaration) {
-                                    if (stmt.stepId) {
-                                        this.log(`[stepId] Using hash-based stepId from parser: ${stmt.stepId.substring(0, 16)}... (test: ${test.fullName})`);
-                                    }
-                                    else {
-                                        this.log(`[stepId] WARNING: No hash-based stepId from parser, using sequential: ${stepId} (test: ${test.fullName})`);
-                                    }
+                        // Execute suite-level beforeEach hooks (from all parent suites, in order: parent → child)
+                        if (testData.suiteBeforeEachHooks.length > 0 && testStatus === 'passed') {
+                            this.log(`Executing ${testData.suiteBeforeEachHooks.length} suite-level beforeEach hook(s) for test: ${test.fullName}`);
+                            try {
+                                // Get or create suite context for this test's suite
+                                const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
+                                for (const hook of testData.suiteBeforeEachHooks) {
+                                    const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
+                                    testStepCounter += stepsExecuted;
                                 }
-                                return {
-                                    id: stepId,
-                                    code: stmt.code,
-                                    description: stmt.intentComment || stmt.code.trim().substring(0, 100) || '',
-                                    isVariableDeclaration: stmt.isVariableDeclaration, // Pass AST-based detection flag
-                                    scenarioAnnotation: stmt.scenarioAnnotation
-                                };
-                            });
-                            // Get or create suite context for this test's suite
-                            const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
-                            // Execute using the existing step-wise execution infrastructure
-                            // executeStepsInPersistentContext will:
-                            // 1. Use shared context (variables already initialized)
-                            // 2. Execute ALL statements sequentially (variables + actions)
-                            // 3. Variables execute silently and persist in context
-                            // 4. Non-variable statements trigger callbacks (onStepProgress)
-                            const result = await this.executeStepsInPersistentContext(steps, // Pre-parsed steps from initial parse with AST-based flags
-                            page, browser, context, {
-                                mode: request.mode || types_1.ExecutionMode.RUN_EXACTLY,
-                                jobId: jobId,
-                                tempDir: request.tempDir,
-                                originalScript: testScript, // For module resolution (imports)
-                                model: request.model,
-                                testFolderPath: request.testFolderPath,
-                                runPomDenormalized: request.runPomDenormalized
-                            }, suiteContext // Pass shared context
-                            );
-                            if (!result.success) {
+                            }
+                            catch (error) {
+                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                this.log(`Suite-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
                                 testStatus = 'failed';
-                                testError = result.error || 'Test execution failed';
+                                testError = `Suite-level beforeEach hook failed: ${errorMsg}`;
                             }
-                            // Track repair if we're in repair mode and steps were updated
-                            // Note: updatedSteps are always returned, but in repair mode they may contain repaired code
-                            if (request.mode === types_1.ExecutionMode.RUN_WITH_AI_REPAIR && result.updatedSteps && result.updatedSteps.length > 0) {
-                                // Generate updated script from steps (will include repairs if any occurred)
-                                const updatedScript = this.generateUpdatedScript(result.updatedSteps, undefined, testScript);
-                                if (updatedScript) {
-                                    // Extract the test body from the generated script
-                                    const repairedTestBody = test_file_parser_1.TestFileParser.extractTestBodyFromScript(updatedScript);
-                                    if (repairedTestBody) {
-                                        // Compare with original test body to confirm it's actually different (repairs occurred)
-                                        const originalTestBody = test.code.trim();
-                                        const repairedTestBodyTrimmed = repairedTestBody.trim();
-                                        if (repairedTestBodyTrimmed !== originalTestBody) {
-                                            // Create TestPathway key (JSON stringified for Map lookup)
-                                            const testPathwayKey = JSON.stringify({
-                                                suitePath: test.suitePath || [],
-                                                testName: test.name.trim()
-                                            });
-                                            testRepairs.set(testPathwayKey, repairedTestBody);
-                                            this.log(`Tracked repair for test: ${test.fullName} (pathway: ${testPathwayKey})`);
+                        }
+                        // Run the test if hooks didn't fail
+                        if (testStatus === 'passed') {
+                            // Count non-variable statements for step counter tracking (needed in catch block)
+                            const testStepsExecuted = test.statements.filter(stmt => !stmt.isVariableDeclaration).length;
+                            try {
+                                // Construct a script with imports + this test (needed for module resolution)
+                                // Variables are already in shared context, so we don't need to include them in script
+                                const testScript = test_file_parser_1.TestFileParser.constructTestScriptWithImports(originalScript, test.name, // Use test name only, not fullName (suite prefix not needed in generated script)
+                                test.code);
+                                // Use pre-parsed statements from initial file parse
+                                // These were extracted directly from the original AST, ensuring accuracy
+                                this.log(`Using ${test.statements.length} pre-parsed statements for test: ${test.fullName}`);
+                                // Count non-variable statements for step ID assignment
+                                let stepIndex = 0; // Track step index (only for non-variable statements)
+                                const steps = test.statements.map((stmt) => {
+                                    // CRITICAL: Always use hash-based stepId from parser if available
+                                    // Only assign step ID to non-variable statements
+                                    const stepId = stmt.isVariableDeclaration
+                                        ? undefined
+                                        : (stmt.stepId || String(testStepCounter + stepIndex++));
+                                    // Log stepId assignment for debugging
+                                    if (!stmt.isVariableDeclaration) {
+                                        if (stmt.stepId) {
+                                            this.log(`[stepId] Using hash-based stepId from parser: ${stmt.stepId.substring(0, 16)}... (test: ${test.fullName})`);
+                                        }
+                                        else {
+                                            this.log(`[stepId] WARNING: No hash-based stepId from parser, using sequential: ${stepId} (test: ${test.fullName})`);
+                                        }
+                                    }
+                                    return {
+                                        id: stepId,
+                                        code: stmt.code,
+                                        description: stmt.intentComment || stmt.code.trim().substring(0, 100) || '',
+                                        isVariableDeclaration: stmt.isVariableDeclaration, // Pass AST-based detection flag
+                                        scenarioAnnotation: stmt.scenarioAnnotation
+                                    };
+                                });
+                                // Get or create suite context for this test's suite
+                                const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
+                                // Execute using the existing step-wise execution infrastructure
+                                // executeStepsInPersistentContext will:
+                                // 1. Use shared context (variables already initialized)
+                                // 2. Execute ALL statements sequentially (variables + actions)
+                                // 3. Variables execute silently and persist in context
+                                // 4. Non-variable statements trigger callbacks (onStepProgress)
+                                const result = await this.executeStepsInPersistentContext(steps, // Pre-parsed steps from initial parse with AST-based flags
+                                page, browser, context, {
+                                    mode: request.mode || types_1.ExecutionMode.RUN_EXACTLY,
+                                    jobId: jobId,
+                                    tempDir: request.tempDir,
+                                    originalScript: testScript, // For module resolution (imports)
+                                    model: request.model,
+                                    testFolderPath: request.testFolderPath,
+                                    runPomDenormalized: request.runPomDenormalized
+                                }, suiteContext // Pass shared context
+                                );
+                                if (!result.success) {
+                                    testStatus = 'failed';
+                                    testError = result.error || 'Test execution failed';
+                                }
+                                // Track repair if we're in repair mode and steps were updated
+                                // Note: updatedSteps are always returned, but in repair mode they may contain repaired code
+                                if (request.mode === types_1.ExecutionMode.RUN_WITH_AI_REPAIR && result.updatedSteps && result.updatedSteps.length > 0) {
+                                    // Generate updated script from steps (will include repairs if any occurred)
+                                    const updatedScript = this.generateUpdatedScript(result.updatedSteps, undefined, testScript);
+                                    if (updatedScript) {
+                                        // Extract the test body from the generated script
+                                        const repairedTestBody = test_file_parser_1.TestFileParser.extractTestBodyFromScript(updatedScript);
+                                        if (repairedTestBody) {
+                                            // Compare with original test body to confirm it's actually different (repairs occurred)
+                                            const originalTestBody = test.code.trim();
+                                            const repairedTestBodyTrimmed = repairedTestBody.trim();
+                                            if (repairedTestBodyTrimmed !== originalTestBody) {
+                                                // Create TestPathway key (JSON stringified for Map lookup)
+                                                const testPathwayKey = JSON.stringify({
+                                                    suitePath: test.suitePath || [],
+                                                    testName: test.name.trim()
+                                                });
+                                                testRepairs.set(testPathwayKey, repairedTestBody);
+                                                this.log(`Tracked repair for test: ${test.fullName} (pathway: ${testPathwayKey})`);
+                                            }
                                         }
                                     }
                                 }
+                                // Update step counter after test execution (whether success or failure)
+                                // Steps were executed up to the failure point
+                                testStepCounter += testStepsExecuted;
                             }
-                            // Update step counter after test execution (whether success or failure)
-                            // Steps were executed up to the failure point
-                            testStepCounter += testStepsExecuted;
-                        }
-                        catch (error) {
-                            testStatus = 'failed';
-                            testError = error instanceof Error ? error.message : String(error);
-                            // Still update step counter even if test failed (steps were executed up to failure point)
-                            testStepCounter += testStepsExecuted;
-                        }
-                    }
-                    // Execute suite-level afterEach hooks (from all parent suites, in reverse order: child → parent)
-                    if (testData.suiteAfterEachHooks.length > 0) {
-                        this.log(`Executing ${testData.suiteAfterEachHooks.length} suite-level afterEach hook(s) for test: ${test.fullName}`);
-                        try {
-                            // Get or create suite context for this test's suite
-                            const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
-                            for (const hook of testData.suiteAfterEachHooks) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
-                                testStepCounter += stepsExecuted;
+                            catch (error) {
+                                testStatus = 'failed';
+                                testError = error instanceof Error ? error.message : String(error);
+                                // Still update step counter even if test failed (steps were executed up to failure point)
+                                testStepCounter += testStepsExecuted;
                             }
                         }
-                        catch (error) {
-                            const errorMsg = error instanceof Error ? error.message : String(error);
-                            this.log(`Suite-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
-                            // Log but continue - don't fail the test because of afterEach failure
-                        }
-                    }
-                    // Execute file-level afterEach hooks (even if test failed)
-                    if (flattened.fileLevelHooks.afterEach.length > 0) {
-                        this.log(`Executing ${flattened.fileLevelHooks.afterEach.length} file-level afterEach hook(s) for test: ${test.fullName}`);
-                        try {
-                            for (const hook of flattened.fileLevelHooks.afterEach) {
-                                const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
-                                testStepCounter += stepsExecuted;
+                        // Execute suite-level afterEach hooks (from all parent suites, in reverse order: child → parent)
+                        if (testData.suiteAfterEachHooks.length > 0) {
+                            this.log(`Executing ${testData.suiteAfterEachHooks.length} suite-level afterEach hook(s) for test: ${test.fullName}`);
+                            try {
+                                // Get or create suite context for this test's suite
+                                const suiteContext = await getOrCreateSuiteContext(testData.suitePath, testData.suiteVariables, flattened.fileVariables);
+                                for (const hook of testData.suiteAfterEachHooks) {
+                                    const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook, jobId, testStepCounter);
+                                    testStepCounter += stepsExecuted;
+                                }
+                            }
+                            catch (error) {
+                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                this.log(`Suite-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
+                                // Log but continue - don't fail the test because of afterEach failure
                             }
                         }
-                        catch (error) {
-                            const errorMsg = error instanceof Error ? error.message : String(error);
-                            this.log(`File-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
-                            // Log but continue - don't fail the test because of afterEach failure
-                        }
-                    }
-                    // After test execution: Increment test counts and execute suite-level afterAll hooks (if last test in suite)
-                    if (testData.suitePath.length > 0) {
-                        // Increment test count for each suite in the path
-                        for (let i = 0; i < testData.suitePath.length; i++) {
-                            const suitePath = testData.suitePath.slice(0, i + 1);
-                            const suiteKey = getSuiteKey(suitePath);
-                            const currentCount = suiteTestCounts.get(suiteKey) || 0;
-                            suiteTestCounts.set(suiteKey, currentCount + 1);
+                        // Execute file-level afterEach hooks (even if test failed)
+                        if (flattened.fileLevelHooks.afterEach.length > 0) {
+                            this.log(`Executing ${flattened.fileLevelHooks.afterEach.length} file-level afterEach hook(s) for test: ${test.fullName}`);
+                            try {
+                                for (const hook of flattened.fileLevelHooks.afterEach) {
+                                    const stepsExecuted = await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook, jobId, testStepCounter);
+                                    testStepCounter += stepsExecuted;
+                                }
+                            }
+                            catch (error) {
+                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                this.log(`File-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
+                                // Log but continue - don't fail the test because of afterEach failure
+                            }
                         }
-                        // Execute afterAll for each suite in the path (in reverse order: child → parent)
-                        for (let i = testData.suitePath.length - 1; i >= 0; i--) {
-                            const suitePath = testData.suitePath.slice(0, i + 1);
-                            const suiteKey = getSuiteKey(suitePath);
-                            // Look up suite in Map (O(1) instead of O(n) .find())
-                            const suite = suiteMap.get(suiteKey);
-                            if (suite) {
-                                const totalTests = suiteTotalTests.get(suiteKey) || 0;
+                        // After test execution: Increment test counts and execute suite-level afterAll hooks (if last test in suite)
+                        if (testData.suitePath.length > 0) {
+                            // Increment test count for each suite in the path
+                            for (let i = 0; i < testData.suitePath.length; i++) {
+                                const suitePath = testData.suitePath.slice(0, i + 1);
+                                const suiteKey = getSuiteKey(suitePath);
                                 const currentCount = suiteTestCounts.get(suiteKey) || 0;
-                                // If this is the last test in the suite, execute afterAll (if any) and dispose context
-                                if (currentCount >= totalTests) {
-                                    // Use human-readable suite name for logging
-                                    const suiteDisplayName = suitePath.join('__');
-                                    // Execute afterAll hooks if they exist
-                                    if (suite.afterAll.length > 0) {
-                                        this.log(`Executing suite-level afterAll hooks for suite: ${suiteDisplayName}`);
-                                        try {
-                                            // Get or create suite context (should already exist, but safe to call)
-                                            const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
-                                            for (const hook of suite.afterAll) {
-                                                await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
+                                suiteTestCounts.set(suiteKey, currentCount + 1);
+                            }
+                            // Execute afterAll for each suite in the path (in reverse order: child → parent)
+                            for (let i = testData.suitePath.length - 1; i >= 0; i--) {
+                                const suitePath = testData.suitePath.slice(0, i + 1);
+                                const suiteKey = getSuiteKey(suitePath);
+                                // Look up suite in Map (O(1) instead of O(n) .find())
+                                const suite = suiteMap.get(suiteKey);
+                                if (suite) {
+                                    const totalTests = suiteTotalTests.get(suiteKey) || 0;
+                                    const currentCount = suiteTestCounts.get(suiteKey) || 0;
+                                    // If this is the last test in the suite, execute afterAll (if any) and dispose context
+                                    if (currentCount >= totalTests) {
+                                        // Use human-readable suite name for logging
+                                        const suiteDisplayName = suitePath.join('__');
+                                        // Execute afterAll hooks if they exist
+                                        if (suite.afterAll.length > 0) {
+                                            this.log(`Executing suite-level afterAll hooks for suite: ${suiteDisplayName}`);
+                                            try {
+                                                // Get or create suite context (should already exist, but safe to call)
+                                                const suiteContext = await getOrCreateSuiteContext(suitePath, suite.suiteVariables, flattened.fileVariables);
+                                                for (const hook of suite.afterAll) {
+                                                    await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, suiteContext, hook);
+                                                }
+                                                this.log(`Suite-level afterAll hooks executed for suite: ${suiteDisplayName}`);
+                                            }
+                                            catch (error) {
+                                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                                this.log(`Suite-level afterAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'warn');
+                                                // Log but continue - don't fail the test because of afterAll failure
                                             }
-                                            this.log(`Suite-level afterAll hooks executed for suite: ${suiteDisplayName}`);
-                                        }
-                                        catch (error) {
-                                            const errorMsg = error instanceof Error ? error.message : String(error);
-                                            this.log(`Suite-level afterAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'warn');
-                                            // Log but continue - don't fail the test because of afterAll failure
                                         }
+                                        // Dispose suite context after afterAll hooks complete (or if no afterAll hooks)
+                                        // This ensures contexts are always disposed, even for suites without afterAll hooks
+                                        disposeSuiteContext(suitePath);
                                     }
-                                    // Dispose suite context after afterAll hooks complete (or if no afterAll hooks)
-                                    // This ensures contexts are always disposed, even for suites without afterAll hooks
-                                    disposeSuiteContext(suitePath);
                                 }
                             }
                         }
-                    }
-                    // Call onEndTest callback (use TestPathway)
-                    if (this.progressReporter?.onEndTest) {
-                        try {
-                            await this.progressReporter.onEndTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, testStatus, testError, page, browser, context);
+                        // Call onEndTest callback (use TestPathway)
+                        if (this.progressReporter?.onEndTest) {
+                            try {
+                                await this.progressReporter.onEndTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, testStatus, testError, page, browser, context);
+                            }
+                            catch (callbackError) {
+                                this.log(`onEndTest callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`, 'warn');
+                                // Don't fail the test if callback has issues - runner-core is a library
+                            }
                         }
-                        catch (callbackError) {
-                            this.log(`onEndTest callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`, 'warn');
-                            // Don't fail the test if callback has issues - runner-core is a library
+                    }
+                    catch (error) {
+                        // Unexpected error during test execution
+                        testStatus = 'failed';
+                        testError = error instanceof Error ? error.message : String(error);
+                        this.log(`Unexpected error during test ${test.name}: ${testError}`, 'error');
+                        // Still call onEndTest if possible
+                        if (this.progressReporter?.onEndTest) {
+                            try {
+                                await this.progressReporter.onEndTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, testStatus, testError, page, browser, context);
+                            }
+                            catch (callbackError) {
+                                this.log(`onEndTest callback failed: ${callbackError}`, 'warn');
+                            }
                         }
                     }
-                }
-                catch (error) {
-                    // Unexpected error during test execution
-                    testStatus = 'failed';
-                    testError = error instanceof Error ? error.message : String(error);
-                    this.log(`Unexpected error during test ${test.name}: ${testError}`, 'error');
-                    // Still call onEndTest if possible
-                    if (this.progressReporter?.onEndTest) {
+                    // Record test result (use TestPathway)
+                    testResults.push({
+                        testPathway: { suitePath: test.suitePath || [], testName: test.name },
+                        jobId: jobId,
+                        status: testStatus,
+                        error: testError,
+                        executionTime: Date.now() - testStartTime
+                    });
+                    this.log(`Test ${test.fullName} completed with status: ${testStatus}`);
+                    // Call afterEndTest callback if provided (called after each test completes)
+                    // This allows each test in a file to be treated as a separate journey
+                    if (request.afterEndTest) {
                         try {
-                            await this.progressReporter.onEndTest({ suitePath: test.suitePath || [], testName: test.name }, jobId, testStatus, testError, page, browser, context);
+                            const callbackStatus = testStatus === 'passed' ? 'passed' : 'failed';
+                            await request.afterEndTest(callbackStatus, testError, page, undefined, undefined);
+                            this.log(`afterEndTest callback completed for test ${test.fullName}`);
                         }
                         catch (callbackError) {
-                            this.log(`onEndTest callback failed: ${callbackError}`, 'warn');
+                            this.log(`afterEndTest callback failed for test ${test.fullName}: ${callbackError}`, 'warn');
+                            // Don't fail the test execution if callback has issues
                         }
                     }
                 }
-                // Record test result (use TestPathway)
-                testResults.push({
-                    testPathway: { suitePath: test.suitePath || [], testName: test.name },
-                    jobId: jobId,
-                    status: testStatus,
-                    error: testError,
-                    executionTime: Date.now() - testStartTime
-                });
-                this.log(`Test ${test.fullName} completed with status: ${testStatus}`);
-                // Call afterEndTest callback if provided (called after each test completes)
-                // This allows each test in a file to be treated as a separate journey
-                if (request.afterEndTest) {
+                // Execute file-level afterAll hooks
+                if (flattened.fileLevelHooks.afterAll.length > 0) {
+                    this.log(`Executing ${flattened.fileLevelHooks.afterAll.length} file-level afterAll hook(s)...`);
                     try {
-                        const callbackStatus = testStatus === 'passed' ? 'passed' : 'failed';
-                        await request.afterEndTest(callbackStatus, testError, page, undefined, undefined);
-                        this.log(`afterEndTest callback completed for test ${test.fullName}`);
-                    }
-                    catch (callbackError) {
-                        this.log(`afterEndTest callback failed for test ${test.fullName}: ${callbackError}`, 'warn');
-                        // Don't fail the test execution if callback has issues
+                        for (const hook of flattened.fileLevelHooks.afterAll) {
+                            await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
+                        }
+                        this.log('File-level afterAll hooks executed successfully');
                     }
-                }
-            }
-            // Execute file-level afterAll hooks
-            if (flattened.fileLevelHooks.afterAll.length > 0) {
-                this.log(`Executing ${flattened.fileLevelHooks.afterAll.length} file-level afterAll hook(s)...`);
-                try {
-                    for (const hook of flattened.fileLevelHooks.afterAll) {
-                        await this.executeHook(hook.code, page, context, browser, request.tempDir, originalScript, request.testFolderPath, request.runPomDenormalized, fileLevelContext || undefined, hook);
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        this.log(`File-level afterAll hook failed: ${errorMsg}`, 'warn');
+                        // Log but don't fail overall execution
                     }
-                    this.log('File-level afterAll hooks executed successfully');
                 }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    this.log(`File-level afterAll hook failed: ${errorMsg}`, 'warn');
-                    // Log but don't fail overall execution
-                }
-            }
-            // Dispose file-level context after file-level afterAll hooks
-            if (fileLevelContext !== null && fileLevelContext !== undefined) {
-                fileLevelContext.dispose();
-                fileLevelContext = null;
-            }
-            // Cleanup browser if we created it
-            if (browserCreated && browser) {
-                try {
-                    await browser.close();
-                    this.log('Browser closed');
+                // Dispose file-level context after file-level afterAll hooks
+                if (fileLevelContext !== null && fileLevelContext !== undefined) {
+                    fileLevelContext.dispose();
+                    fileLevelContext = null;
                 }
-                catch (closeError) {
-                    this.log(`Error closing browser: ${closeError}`, 'warn');
-                }
-            }
-            // Determine overall success (all tests passed)
-            const allPassed = testResults.every(result => result.status === 'passed');
-            // Reconstruct the full test file with repairs if any tests were repaired
-            let updatedScript;
-            if (testRepairs.size > 0) {
-                this.log(`Reconstructing test file with ${testRepairs.size} repaired test(s)...`);
-                try {
-                    updatedScript = test_file_parser_1.TestFileParser.reconstructTestFileWithRepairs(originalScript, parsed, testRepairs);
-                    this.log('Test file reconstruction completed successfully');
+                // Cleanup browser if we created it
+                if (browserCreated && browser) {
+                    try {
+                        await browser.close();
+                        this.log('Browser closed');
+                    }
+                    catch (closeError) {
+                        this.log(`Error closing browser: ${closeError}`, 'warn');
+                    }
                 }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    this.log(`Failed to reconstruct test file: ${errorMsg}`, 'warn');
-                    // Continue without updatedScript - original script will be used
+                // Determine overall success (all tests passed)
+                const allPassed = testResults.every(result => result.status === 'passed');
+                // Reconstruct the full test file with repairs if any tests were repaired
+                let updatedScript;
+                if (testRepairs.size > 0) {
+                    this.log(`Reconstructing test file with ${testRepairs.size} repaired test(s)...`);
+                    try {
+                        updatedScript = test_file_parser_1.TestFileParser.reconstructTestFileWithRepairs(originalScript, parsed, testRepairs);
+                        this.log('Test file reconstruction completed successfully');
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        this.log(`Failed to reconstruct test file: ${errorMsg}`, 'warn');
+                        // Continue without updatedScript - original script will be used
+                    }
                 }
-            }
-            return {
-                success: allPassed,
-                testResults: testResults,
-                executionTime: Date.now() - startTime,
-                updatedScript: updatedScript
-            };
+                return {
+                    success: allPassed,
+                    testResults: testResults,
+                    executionTime: Date.now() - startTime,
+                    updatedScript: updatedScript
+                };
+            });
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);