@midscene/test 1.16.0 → 1.16.2

package/dist/es/cli/index.mjs

@@ -1,7 +1,7 @@
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve as external_node_path_resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { require as api_require } from "tsx/cjs/api";
-import { NodeRegistry, WorkflowError, WorkflowExecutionFailure, WorkflowParseError, WorkflowPublicationError, asExecutionError, buildTestRunReportDump, buildTestRunReportPlan, classifyWorkflowDocumentFormat, collectTestRunReportSources, createProjectRuntime, decideRetry, isFatalDeviceError, isReportSecretKey, isResourceRecoveryError, normalizeSteps, observeResourceOperations, runConcurrentJobs, runDocumentAttempts, runWorkflowDocument, sanitizeReportError, sanitizeReportText } from "@midscene/core/internal/test-runner";
+import { NodeRegistry, WorkflowError, WorkflowExecutionFailure, WorkflowParseError, WorkflowPublicationError, asExecutionError, buildTestRunReportDump, buildTestRunReportPlan, classifyWorkflowDocumentFormat, collectTestRunReportSources, createProjectRuntime, decideRetry, getPendingScopeOperations, getResourceCleanupCompletion, isFatalDeviceError, isReportSecretKey, isResourceRecoveryError, normalizeSteps, observeResourceOperations, runDocumentAttempts, runWorkflowDocument, sanitizeReportError, sanitizeReportText, sumTestRunReportMetrics as test_runner_sumTestRunReportMetrics, trackResourceOperation, waitForScopeOperations } from "@midscene/core/internal/test-runner";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { globSync } from "tinyglobby";
 import { createHash, randomUUID } from "node:crypto";
@@ -9,11 +9,14 @@ import { JSON_SCHEMA, load } from "js-yaml";
 import { mkdir, writeFile } from "node:fs/promises";
 import { setMaxListeners } from "node:events";
 import { TestRunReportAssembler, calculateTestRunHealth } from "@midscene/core/report";
-import { getDebug } from "@midscene/shared/logger";
+import { getDebug, runWithConsoleLogScope } from "@midscene/shared/logger";
+import "node:util";
+import { globalConfigManager } from "@midscene/shared/env";
 const registry_NodeRegistry = NodeRegistry;
 const projectIdFromIndex = (index)=>`project-${index}`;
 const defineTestProject = (definition)=>definition;
 const defineProjectSetup = (definition)=>definition;
+const defineFileSetup = (definition)=>definition;
 const getDefaultExport = (loaded, absolutePath)=>{
     if ('object' == typeof loaded && null !== loaded && 'default' in loaded) {
         const defaultExport = loaded.default;
@@ -130,9 +133,19 @@ const validateNonNegativeInteger = (value, fallback, label)=>{
     if (!Number.isInteger(value) || value < 0) throw new TypeError(`Midscene config ${label} must be a non-negative integer.`);
     return value;
 };
-const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
+const validateConcurrency = (value, label)=>{
+    if (null === value) return null;
+    return validatePositiveInteger(value, 1, label);
+};
+const validateFileConcurrency = (maxConcurrentFiles, fileSetup, label)=>{
+    if (maxConcurrentFiles > 1 && !fileSetup) throw new TypeError(`Midscene config ${label}.fileSetup is required when the effective maxConcurrentFiles is greater than 1.`);
+};
+const validateExecutionProjects = (value, defaultSetup, defaultFileSetup, globalNodes, test)=>{
     if (void 0 === value) {
         const setup = validateSetup(defaultSetup, 'setup');
+        const fileSetup = validateSetup(defaultFileSetup, 'fileSetup');
+        const maxConcurrentFiles = test.maxConcurrentFiles ?? 1 / 0;
+        validateFileConcurrency(maxConcurrentFiles, fileSetup, 'default');
         return {
             hasExplicitProjects: false,
             projects: Object.freeze([
@@ -142,6 +155,10 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
                     ...setup ? {
                         setup
                     } : {},
+                    ...fileSetup ? {
+                        fileSetup
+                    } : {},
+                    maxConcurrentFiles,
                     tags: Object.freeze({
                         include: [],
                         exclude: []
@@ -154,6 +171,7 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         };
     }
     if (void 0 !== defaultSetup) throw new TypeError('Midscene config setup cannot be used together with projects. Move setup to projects[].setup.');
+    if (void 0 !== defaultFileSetup) throw new TypeError('Midscene config fileSetup cannot be used together with projects. Move fileSetup to projects[].fileSetup.');
     if (!Array.isArray(value) || 0 === value.length) throw new TypeError('Midscene config projects must be a non-empty array when declared.');
     const names = new Set();
     const projects = value.map((candidate, index)=>{
@@ -162,6 +180,8 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         rejectUnknownKeys(candidate, [
             'name',
             'setup',
+            'fileSetup',
+            'maxConcurrentFiles',
             'nodes',
             'files',
             'tags',
@@ -178,10 +198,18 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
             ...globalNodes.definitions().filter((node)=>!localNodes.has(node.name)),
             ...localNodes.definitions()
         ]);
+        const fileSetup = validateSetup(candidate.fileSetup, `${label}.fileSetup`);
+        const globalFileLimit = test.maxConcurrentFiles ?? 1 / 0;
+        const maxConcurrentFiles = Math.min(globalFileLimit, validatePositiveInteger(candidate.maxConcurrentFiles, globalFileLimit, `${label}.maxConcurrentFiles`));
+        validateFileConcurrency(maxConcurrentFiles, fileSetup, label);
         return Object.freeze({
             projectId: projectIdFromIndex(index),
             name: candidate.name,
             nodes,
+            ...fileSetup ? {
+                fileSetup
+            } : {},
+            maxConcurrentFiles,
             ...files ? {
                 files
             } : {},
@@ -198,11 +226,25 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         hasExplicitProjects: true
     };
 };
-const validateTestOptions = (value)=>{
+const validateTestOptions = (value, hasExplicitProjects)=>{
     if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config test must be an object.');
     const candidate = value ?? {};
+    if (void 0 !== candidate.maxConcurrency) {
+        const limit = 'number' == typeof candidate.maxConcurrency && Number.isInteger(candidate.maxConcurrency) && candidate.maxConcurrency > 0 ? candidate.maxConcurrency : 1;
+        throw new TypeError([
+            'Midscene config test.maxConcurrency is no longer supported.',
+            'It controlled project concurrency, not file concurrency. Remove it and use:',
+            `  test: { maxConcurrentProjects: ${limit}, maxConcurrentFiles: ${hasExplicitProjects ? limit : 1} }`,
+            hasExplicitProjects ? '  Set projects[].maxConcurrentFiles to 1 to keep files sequential within each project.' : '  The implicit default project keeps running files sequentially.',
+            hasExplicitProjects ? 'For parallel files, configure fileSetup and raise both test.maxConcurrentFiles and projects[].maxConcurrentFiles.' : 'For parallel files, configure fileSetup and raise test.maxConcurrentFiles.',
+            'Migration guide: https://midscenejs.com/midscene-test/configuration.html#existing-configurations'
+        ].join('\n'));
+    }
     return Object.freeze({
-        maxConcurrency: validatePositiveInteger(candidate.maxConcurrency, 1, 'test.maxConcurrency'),
+        maxConcurrentFiles: validateConcurrency(candidate.maxConcurrentFiles, 'test.maxConcurrentFiles'),
+        maxConcurrentProjects: validateConcurrency(candidate.maxConcurrentProjects, 'test.maxConcurrentProjects'),
+        setupTimeout: validatePositiveInteger(candidate.setupTimeout, 120000, 'test.setupTimeout'),
+        teardownTimeout: validatePositiveInteger(candidate.teardownTimeout, 30000, 'test.teardownTimeout'),
         bail: validateNonNegativeInteger(candidate.bail, 0, 'test.bail'),
         testTimeout: validatePositiveInteger(candidate.testTimeout, 120000, 'test.testTimeout')
     });
@@ -232,16 +274,18 @@ const validateTestProjectDefinition = (definition)=>{
     if ('testRunner' in definition) throw new TypeError('Midscene config testRunner is not supported. Rename it to test.');
     rejectUnknownKeys(definition, [
         'setup',
+        'fileSetup',
         'projects',
         'test',
         'output',
         'nodes'
     ], 'root');
     const nodes = new registry_NodeRegistry(definition.nodes);
-    const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, nodes);
+    const test = validateTestOptions(definition.test, void 0 !== definition.projects);
+    const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, definition.fileSetup, nodes, test);
     return {
         ...resolvedProjects,
-        test: validateTestOptions(definition.test),
+        test,
         output: validateOutput(definition.output),
         nodes,
         resolveNode: (name)=>nodes.get(name)
@@ -263,7 +307,7 @@ async function loadTestProject(configPath) {
     if (!configPath) return validateTestProjectDefinition({
         nodes: []
     });
-    const absolutePath = resolve(configPath);
+    const absolutePath = external_node_path_resolve(configPath);
     const extension = assertSupportedConfig(absolutePath);
     let loaded;
     try {
@@ -318,11 +362,13 @@ function parseWorkflowSource(source) {
                 start: state.position + sourceOffset,
                 end: 0,
                 value: null,
-                children: []
+                children: [],
+                kind: null
             });
             const node = stack.pop();
             node.end = state.position + sourceOffset;
             node.value = state.result;
+            node.kind = state.kind;
             stack.at(-1)?.children.push(node);
             nodes.push(node);
             if ('mapping' !== state.kind) return;
@@ -352,6 +398,36 @@ function parseWorkflowSource(source) {
     const value = sanitizeReportText(redacted, 65536);
     return {
         parsed,
+        locate (path) {
+            let node = nodes.at(-1);
+            for (const part of path){
+                if (!node) return;
+                while(1 === node.children.length && node.children[0].value === node.value)node = node.children[0];
+                if ('number' == typeof part && 'sequence' === node.kind) node = node.children[part];
+                else {
+                    if ('string' != typeof part || 'mapping' !== node.kind) return;
+                    const children = node.children;
+                    node = void 0;
+                    for(let index = 0; index < children.length; index += 2)if (children[index].value === part) {
+                        node = children[index + 1];
+                        break;
+                    }
+                }
+            }
+            if (!node) return;
+            let start = node.start;
+            while(start < node.end)if (/\s/.test(source[start])) start++;
+            else if ('#' === source[start]) {
+                const end = source.indexOf('\n', start);
+                if (end < 0) return;
+                start = end + 1;
+            } else break;
+            const prefix = source.slice(0, start).split(/\r\n|\r|\n/);
+            return {
+                line: prefix.length,
+                column: prefix.at(-1).length + 1
+            };
+        },
         sourceYaml: {
             value,
             ...redactedPaths.size ? {
@@ -464,6 +540,18 @@ function collectWorkflowDocument(source, options) {
     const sourcePath = source.sourcePath.split(sep).join('/');
     const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
             ...step,
+            meta: {
+                ...step.meta,
+                sourceLocation: snapshot.locate('steps' === phase ? [
+                    'cases',
+                    caseIndex,
+                    'steps',
+                    stepIndex
+                ] : [
+                    phase,
+                    stepIndex
+                ])
+            },
             templateInput: step.input,
             input: resolveWorkflowVariables(step.input, {
                 variables: options.variables,
@@ -638,6 +726,9 @@ const writeTestProjectRunResult = (options)=>{
             markdown: relativeToSummary(result.summaryPath, result.markdownPath)
         } : {},
         summary: result.summary,
+        ...result.metrics ? {
+            metrics: result.metrics
+        } : {},
         projects: result.projects.map((project)=>({
                 projectId: project.projectId,
                 name: project.name,
@@ -759,7 +850,7 @@ const DEFAULT_TEST_FILE_SELECTION = {
 };
 const project_preparation_toPosix = (value)=>value.split(sep).join('/');
 const discoverResolvedTestFiles = (projectRoot, selection)=>{
-    const root = resolve(projectRoot);
+    const root = external_node_path_resolve(projectRoot);
     const match = (patterns)=>globSync(patterns, {
             absolute: true,
             caseSensitiveMatch: false,
@@ -775,7 +866,7 @@ const discoverResolvedTestFiles = (projectRoot, selection)=>{
         }).filter((file)=>/\.ya?ml$/i.test(file));
     const files = match(selection.include);
     return [
-        ...new Set(files.map((file)=>resolve(file)))
+        ...new Set(files.map((file)=>external_node_path_resolve(file)))
     ].sort((a, b)=>{
         const relativeA = project_preparation_toPosix(relative(root, a));
         const relativeB = project_preparation_toPosix(relative(root, b));
@@ -788,7 +879,7 @@ const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)
     return discoverResolvedTestFiles(projectRoot, normalized);
 };
 const discoverTestConfig = (projectRoot)=>{
-    const root = resolve(projectRoot);
+    const root = external_node_path_resolve(projectRoot);
     const candidates = readdirSync(root).filter((name)=>name.startsWith(CONFIG_PREFIX)).sort();
     const supported = candidates.filter((name)=>CONFIG_NAMES.includes(name));
     const unsupported = candidates.filter((name)=>!CONFIG_NAMES.includes(name));
@@ -842,7 +933,7 @@ const selectProjects = (projects, names)=>{
 async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, options = {}) {
     const platform = options.platform?.trim();
     const fileSelection = project.files ?? DEFAULT_TEST_FILE_SELECTION;
-    const prerequisiteFile = options.prerequisiteFile ? resolve(options.prerequisiteFile) : void 0;
+    const prerequisiteFile = options.prerequisiteFile ? external_node_path_resolve(options.prerequisiteFile) : void 0;
     const mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
     const files = [
         ...prerequisiteFile ? [
@@ -920,7 +1011,24 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
             defaultTimeoutMs,
             reportEnabled: true,
             bindings: {
-                resolveNode: project.nodes.require.bind(project.nodes)
+                resolveNode: project.nodes.require.bind(project.nodes),
+                ...project.fileSetup ? {
+                    documentSetup: {
+                        name: project.fileSetup.name,
+                        setup ({ projectContext, document, signal, onTeardown }) {
+                            return project.fileSetup.setup({
+                                project,
+                                projectContext,
+                                file: document,
+                                env: Object.freeze({
+                                    ...process.env
+                                }),
+                                signal,
+                                onTeardown
+                            });
+                        }
+                    }
+                } : {}
             }
         });
     } catch (error) {
@@ -966,9 +1074,9 @@ const assertDirectory = (path, label)=>{
     if (!existsSync(path) || !statSync(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
 };
 const resolveRunInput = (options)=>{
-    const cwd = resolve(options.cwd ?? process.cwd());
+    const cwd = external_node_path_resolve(options.cwd ?? process.cwd());
     assertDirectory(cwd, 'Test working directory');
-    const inputPath = options.projectRoot ? resolve(cwd, options.projectRoot) : void 0;
+    const inputPath = options.projectRoot ? external_node_path_resolve(cwd, options.projectRoot) : void 0;
     const singleFile = inputPath && existsSync(inputPath) && statSync(inputPath).isFile() ? inputPath : void 0;
     if (singleFile && !/\.ya?ml$/i.test(singleFile)) throw new Error(`Test input must be a YAML file or project directory: ${singleFile}`);
     const cliProjectRoot = singleFile ? dirname(singleFile) : inputPath;
@@ -987,14 +1095,14 @@ async function prepareTestRun(options) {
     const startedAt = new Date();
     const runId = createTestRunId(startedAt);
     const input = resolveRunInput(options);
-    const configPath = options.configPath ? resolve(input.configSearchRoot, options.configPath) : discoverTestConfig(input.configSearchRoot);
+    const configPath = options.configPath ? external_node_path_resolve(input.configSearchRoot, options.configPath) : discoverTestConfig(input.configSearchRoot);
     if (options.configPath && /\.ya?ml$/i.test(configPath)) throw new Error(`midscene-test --config only accepts a native TypeScript or JavaScript project config: ${configPath}. Run legacy batch YAML with \`midscene --config ${options.configPath}\`.`);
     if (options.configPath && !existsSync(configPath)) throw new Error(`Midscene config does not exist: ${configPath}`);
     const definition = await loadTestProject(configPath);
-    const resultDir = options.resultDir ? resolve(input.cwd, options.resultDir) : join(input.projectRoot, '.midscene', 'test-results');
+    const resultDir = options.resultDir ? external_node_path_resolve(input.cwd, options.resultDir) : join(input.projectRoot, '.midscene', 'test-results');
     const runDir = join(resultDir, runId);
     const summaryPath = join(runDir, 'summary.json');
-    const reportDir = resolve(input.projectRoot, definition.output.reportDir);
+    const reportDir = external_node_path_resolve(input.projectRoot, definition.output.reportDir);
     mkdirSync(resultDir, {
         recursive: true
     });
@@ -1022,7 +1130,8 @@ async function prepareTestRun(options) {
         preflightScope: hasFormatMismatch ? 'run' : 'project',
         reportEnabled: true,
         publications: [],
-        onProgress: options.onProgress ?? (()=>{})
+        onProgress: options.onProgress ?? (()=>{}),
+        onEvent: options.onEvent
     };
 }
 const result_markdown_text = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll('|', '&#124;').replaceAll('[', '&#91;').replaceAll(']', '&#93;').replaceAll('*', '&#42;').replaceAll('_', '&#95;').replaceAll('`', '&#96;').replaceAll('\\', '&#92;').replace(/[\r\n]+/g, ' ');
@@ -1100,6 +1209,38 @@ async function writeTestResultMarkdown(result, index = emptyIndex()) {
     }));
     return output;
 }
+function scopeNodeConsole(node) {
+    return {
+        ...node,
+        execute (ctx) {
+            const position = 'case' === ctx.scope ? ctx.case : ctx.document;
+            const scope = {
+                projectName: position.projectName,
+                sourcePath: position.sourcePath,
+                ...'case' === ctx.scope ? {
+                    caseId: ctx.case.caseId,
+                    caseName: ctx.case.name,
+                    runId: ctx.case.runId
+                } : {
+                    runId: ctx.document.documentRunId
+                },
+                phase: position.phase,
+                stepIndex: position.stepIndex,
+                node: node.name
+            };
+            return runWithConsoleLogScope(scope, ()=>node.execute({
+                    ...ctx,
+                    onTeardown (teardown) {
+                        ctx.onTeardown(()=>runWithConsoleLogScope({
+                                ...scope,
+                                phase: 'teardown',
+                                stepIndex: void 0
+                            }, teardown));
+                    }
+                }));
+        }
+    };
+}
 const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
 const formatStep = (info)=>{
     const position = stepPosition(info);
@@ -1123,59 +1264,149 @@ const documentHasFatalError = (result)=>[
         ...result.beforeAll,
         ...result.afterAll
     ].some((step)=>step.error && isFatalDeviceError(step.error)) || (result.teardownErrors ?? []).some(isFatalDeviceError) || !!result.executionErrors?.some(isResourceRecoveryError);
+const isSharedResourceFailure = (error)=>{
+    const seen = new Set();
+    const pending = [
+        error
+    ];
+    while(pending.length && seen.size < 50){
+        const item = pending.pop();
+        if ('object' != typeof item || null === item || seen.has(item)) continue;
+        seen.add(item);
+        const failure = item;
+        if ('PROJECT_RESOURCE_ERROR' === failure.code) return true;
+        if (failure.cause) pending.push(failure.cause);
+        if (Array.isArray(failure.errors)) pending.push(...failure.errors.slice(0, 50));
+    }
+    return false;
+};
 async function executeDocumentInvocation(options) {
     const { invocation, project, sinks } = options;
+    const isProjectResourceFailure = options.isProjectResourceFailure ?? (()=>false);
     const { document } = invocation;
     const documentRetry = 'document' === invocation.retry.scope;
     const attempts = [];
+    const fileSetup = invocation.bindings.documentSetup;
+    const documentSetup = fileSetup ? {
+        ...fileSetup,
+        setup (ctx) {
+            const scope = {
+                projectName: project.name,
+                sourcePath: document.sourcePath,
+                runId: ctx.document.documentRunId,
+                phase: 'fileSetup'
+            };
+            return runWithConsoleLogScope(scope, async ()=>{
+                try {
+                    return await fileSetup.setup({
+                        ...ctx,
+                        onTeardown (teardown) {
+                            ctx.onTeardown(()=>runWithConsoleLogScope({
+                                    ...scope,
+                                    phase: 'teardown'
+                                }, teardown));
+                        }
+                    });
+                } catch (error) {
+                    if (isProjectResourceFailure(error)) options.markProjectFatal();
+                    throw error;
+                }
+            });
+        }
+    } : void 0;
+    options.onEvent?.({
+        type: 'document-start',
+        documentId: document.documentId,
+        projectName: project.name,
+        sourcePath: document.sourcePath,
+        cases: document.cases.length
+    });
     await runDocumentAttempts({
         retry: documentRetry ? invocation.retry.count : 0,
         signal: options.signal,
         shouldStop: ()=>options.shouldBail() || options.isProjectFatal()
     }, async (documentAttemptIndex)=>{
         if (documentRetry) options.onProgress(`    file attempt ${documentAttemptIndex + 1}/${invocation.retry.count + 1}: ${document.sourcePath}`);
-        const execution = await runWorkflowDocument(document, {
-            plan: invocation.plan,
-            documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
-            ...invocation.bindings,
-            project,
-            projectContext: options.projectContext,
-            retry: documentRetry ? 0 : invocation.retry.count,
-            signal: options.signal,
-            defaultTimeoutMs: invocation.defaultTimeoutMs,
-            shouldStop: ()=>options.rootSignal.aborted || options.shouldBail() || options.isProjectFatal(),
-            stopReason: ()=>options.rootSignal.aborted ? 'interrupted' : options.isProjectFatal() ? 'fatal-error' : 'bail',
-            isFatalError: (run)=>[
-                    ...run.beforeEach,
-                    ...run.steps,
-                    ...run.afterEach
-                ].some((step)=>step.error && isFatalDeviceError(step.error)) || (run.teardownErrors ?? []).some(isFatalDeviceError),
-            onCaseStart: (collectedCase)=>{
-                options.onProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
-            },
-            onStepStart: (info)=>{
-                const indent = 'case' === info.scope ? '      ' : '    ';
-                options.onProgress(`${indent}→ ${formatStep(info)}`);
-            },
-            onStepResult: async (info, result)=>{
-                await invocation.bindings.onStepResult?.(info, result);
-                options.onProgress(formatStepResult(info, result));
-            },
-            onCaseResult: async (attempt)=>{
-                await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
-                options.onProgress(`    ${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${documentRetry ? 1 : invocation.retry.count + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
-            },
-            onCaseOutcome: (outcome)=>{
-                if (caseHasFatalError(outcome)) options.markProjectFatal();
-                if (!documentRetry && 'failed' === outcome.status) options.addFailedCases(1);
-            },
-            onDocumentResult: options.onDocumentResult
-        }).catch(async (error)=>{
+        const execution = await runWithConsoleLogScope({
+            projectName: project.name,
+            sourcePath: document.sourcePath
+        }, ()=>runWorkflowDocument(document, {
+                plan: invocation.plan,
+                documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
+                ...invocation.bindings,
+                resolveNode: (name)=>scopeNodeConsole(invocation.bindings.resolveNode(name)),
+                documentSetup,
+                setupTimeoutMs: options.setupTimeoutMs,
+                teardownTimeoutMs: options.teardownTimeoutMs,
+                project,
+                projectContext: options.projectContext,
+                retry: documentRetry ? 0 : invocation.retry.count,
+                signal: options.signal,
+                defaultTimeoutMs: invocation.defaultTimeoutMs,
+                shouldStop: ()=>options.rootSignal.aborted || options.shouldBail() || options.isProjectFatal(),
+                stopReason: ()=>options.rootSignal.aborted ? 'interrupted' : options.isProjectFatal() ? 'fatal-error' : 'bail',
+                isFatalError: (run)=>[
+                        ...run.beforeEach,
+                        ...run.steps,
+                        ...run.afterEach
+                    ].some((step)=>step.error && (isFatalDeviceError(step.error) || isProjectResourceFailure(step.error))) || (run.teardownErrors ?? []).some((error)=>isFatalDeviceError(error) || isProjectResourceFailure(error)),
+                onCaseStart: (collectedCase)=>{
+                    options.onProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
+                },
+                onStepStart: (info)=>{
+                    options.onEvent?.({
+                        type: 'step-start',
+                        projectName: project.name,
+                        info
+                    });
+                    const indent = 'case' === info.scope ? '      ' : '    ';
+                    options.onProgress(`${indent}→ ${formatStep(info)}`);
+                },
+                onStepResult: async (info, result)=>{
+                    if (isProjectResourceFailure(result.error)) options.markProjectFatal();
+                    await invocation.bindings.onStepResult?.(info, result);
+                    options.onProgress(formatStepResult(info, result));
+                    options.onEvent?.({
+                        type: 'step-end',
+                        projectName: project.name,
+                        info,
+                        result
+                    });
+                },
+                onCaseResult: async (attempt)=>{
+                    await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+                    options.onProgress(`    ${'success' === attempt.status ? '✓' : '✗'} case attempt ${attempt.attemptIndex + 1}/${documentRetry ? 1 : invocation.retry.count + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
+                    if (!documentRetry) options.onEvent?.({
+                        type: 'case-attempt-end',
+                        attempt,
+                        maxAttempts: invocation.retry.count + 1
+                    });
+                },
+                onCaseOutcome: (outcome)=>{
+                    if (documentRetry) options.onEvent?.({
+                        type: 'case-progress',
+                        outcome,
+                        documentAttemptIndex
+                    });
+                    else options.onEvent?.({
+                        type: 'case-end',
+                        outcome
+                    });
+                    if (outcome.attempts?.some((attempt)=>[
+                            ...attempt.beforeEach,
+                            ...attempt.steps,
+                            ...attempt.afterEach
+                        ].some((step)=>isProjectResourceFailure(step.error)) || attempt.teardownErrors?.some(isProjectResourceFailure))) options.markProjectFatal();
+                    if (!options.isolatedContext && caseHasFatalError(outcome)) options.markProjectFatal();
+                    if (!documentRetry && 'failed' === outcome.status) options.addFailedCases(1);
+                },
+                onDocumentResult: options.onDocumentResult
+            })).catch(async (error)=>{
             if (error instanceof WorkflowExecutionFailure) {
                 const partial = error.result;
                 const resourceOnly = error.errors.length > 0 && error.errors.every((failure)=>isResourceRecoveryError(failure) || partial.document.hostErrors?.some((host)=>'cleanup' === host.phase && (host.error === failure || host.error instanceof Error && host.error.cause === failure)));
                 if (resourceOnly) {
-                    if (error.errors.some(isResourceRecoveryError)) options.markProjectFatal();
+                    if (!options.isolatedContext && error.errors.some(isResourceRecoveryError)) options.markProjectFatal();
                     return partial;
                 }
                 if (documentRetry) partial.document.retryDecision = decideRetry({
@@ -1204,7 +1435,17 @@ async function executeDocumentInvocation(options) {
             }
             throw error;
         });
-        if (documentHasFatalError(execution.document)) options.markProjectFatal();
+        if (!options.isolatedContext && documentHasFatalError(execution.document)) options.markProjectFatal();
+        if ([
+            ...execution.document.beforeAll,
+            ...execution.document.afterAll,
+            ...(execution.document.hostErrors ?? []).map(({ error })=>({
+                    error
+                })),
+            ...(execution.document.teardownErrors ?? []).map((error)=>({
+                    error
+                }))
+        ].some(({ error })=>isProjectResourceFailure(error))) options.markProjectFatal();
         const owners = [
             execution.document,
             ...execution.cases.flatMap((outcome)=>outcome.attempts ?? [])
@@ -1212,7 +1453,10 @@ async function executeDocumentInvocation(options) {
         const cleanupPending = owners.some((owner)=>owner.cleanup?.status === 'pending');
         const operationPending = owners.some((owner)=>!!owner.pendingOperations?.length);
         const cleanupFailed = owners.some((owner)=>owner.cleanup?.status === 'failed' || !!owner.teardownErrors?.length || 'hostErrors' in owner && owner.hostErrors?.some(({ phase })=>'cleanup' === phase));
-        if (cleanupPending || cleanupFailed || operationPending) options.markProjectFatal();
+        if (cleanupPending || operationPending) {
+            options.markProjectFatal();
+            options.onUnresolvedResources?.();
+        } else if (cleanupFailed && !options.isolatedContext) options.markProjectFatal();
         const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
         const decision = decideRetry({
             scope: 'document',
@@ -1227,6 +1471,11 @@ async function executeDocumentInvocation(options) {
             shouldStop: options.shouldBail()
         });
         if (documentRetry) execution.document.retryDecision = decision;
+        if (documentRetry && 'retry' === decision.decision) options.onEvent?.({
+            type: 'document-retry',
+            document: execution.document,
+            maxAttempts: invocation.retry.count + 1
+        });
         attempts.push(execution);
         sinks.cases.push(...execution.cases.map((outcome)=>({
                 ...outcome,
@@ -1261,10 +1510,310 @@ async function executeDocumentInvocation(options) {
     });
     const final = attempts.at(-1);
     if (!final) return;
+    if (documentRetry) for (const outcome of final.cases)options.onEvent?.({
+        type: 'case-end',
+        outcome,
+        documentRetries: attempts.length - 1
+    });
     const failedCases = final.cases.filter((item)=>'failed' === item.status).length;
+    options.onEvent?.({
+        type: 'document-end',
+        document: final.document,
+        cases: final.cases,
+        durationMs: attempts.reduce((total, attempt)=>total + attempt.document.durationMs, 0)
+    });
     if (documentRetry && failedCases) options.addFailedCases(failedCases);
     else if ('failed' === final.document.status && 0 === failedCases) options.addFailedCases(Math.max(1, failedCases));
 }
+async function runPreparedFiles(options) {
+    const states = options.projects.map((prepared)=>({
+            prepared,
+            cases: [],
+            documents: [],
+            cursor: 0,
+            active: 0,
+            initializing: false,
+            finished: false,
+            fatal: false,
+            setupFailed: false
+        }));
+    let nextProject = 0;
+    let resourcesUnresolved = false;
+    let occupied = 0;
+    let occupiedProjects = 0;
+    const cleanupQueue = [];
+    const release = ()=>{
+        occupied--;
+        while(occupied < options.maxConcurrentFiles && cleanupQueue.length){
+            occupied++;
+            cleanupQueue.shift()();
+        }
+        wake?.();
+    };
+    let wake;
+    const running = new Set();
+    const stopped = (state)=>options.signal.aborted || options.shouldBail() || state.fatal;
+    const invalid = (state)=>options.preflightFailed || state.prepared.collectionErrors.length > 0;
+    const unresolved = ()=>{
+        if (resourcesUnresolved) return;
+        resourcesUnresolved = true;
+        options.onInfrastructureError(new WorkflowError('Resources are still running or cleanup is pending. No new test files will start.', {
+            code: 'UNRESOLVED_FILE_RESOURCES'
+        }));
+    };
+    const finalizeProject = (state)=>{
+        const { prepared } = state;
+        const completed = new Set(state.cases.map((item)=>item.caseId));
+        const reason = invalid(state) ? 'project-preflight-failed' : state.setupFailed ? 'project-setup-failed' : options.signal.aborted ? 'interrupted' : state.fatal ? 'fatal-error' : 'bail';
+        for (const document of prepared.documents)for (const item of document.cases)if (!completed.has(item.caseId)) state.cases.push({
+            documentId: document.documentId,
+            caseId: item.caseId,
+            projectName: prepared.project.name,
+            name: item.definition.name,
+            sourcePath: item.sourcePath,
+            caseIndex: item.caseIndex,
+            status: 'not-run',
+            notRunReason: reason
+        });
+        const order = new Map(prepared.documents.map((document, i)=>[
+                document.documentId,
+                i
+            ]));
+        const position = (id)=>order.get(id) ?? Number.MAX_SAFE_INTEGER;
+        state.cases.sort((a, b)=>position(a.documentId) - position(b.documentId) || a.caseIndex - b.caseIndex);
+        state.documents.sort((a, b)=>position(a.documentId) - position(b.documentId));
+    };
+    const finishProject = async (state)=>{
+        if (!state.runtime || state.finished) return;
+        state.finished = true;
+        try {
+            options.onEvent?.({
+                type: 'project-phase',
+                projectName: state.prepared.project.name,
+                phase: 'teardown'
+            });
+        } catch (error) {
+            options.onInfrastructureError(error);
+        }
+        const failed = state.fatal || options.signal.aborted || state.cases.some((item)=>'success' !== item.status) || state.documents.some((item)=>'success' !== item.status);
+        state.lifecycle = await runWithConsoleLogScope({
+            projectName: state.prepared.project.name,
+            phase: 'teardown'
+        }, ()=>state.runtime.finish(failed ? 'failed' : 'success'));
+        const releaseProject = ()=>{
+            occupiedProjects--;
+            wake?.();
+        };
+        if (state.lifecycle.cleanup?.status === 'pending' || state.lifecycle.pendingOperations?.length) {
+            unresolved();
+            Promise.all([
+                waitForScopeOperations(state.runtime.signal),
+                getResourceCleanupCompletion(state.runtime.signal)
+            ]).then(releaseProject, (error)=>{
+                options.onInfrastructureError(error);
+                releaseProject();
+            });
+        } else {
+            releaseProject();
+            finalizeProject(state);
+            options.onProjectEnd?.(state);
+        }
+    };
+    const admit = ()=>{
+        for(let offset = 0; offset < states.length; offset++){
+            const index = (nextProject + offset) % states.length;
+            const state = states[index];
+            if (invalid(state) || state.finished || state.initializing) continue;
+            if (!state.runtime && occupiedProjects >= options.maxConcurrentProjects) continue;
+            const cleanupOnly = !!state.runtime && 0 === state.active && (stopped(state) || state.cursor === state.prepared.invocations.length);
+            if (!cleanupOnly && (stopped(state) || state.cursor >= state.prepared.invocations.length || state.active >= (state.prepared.project.maxConcurrentFiles ?? options.maxConcurrentFiles))) continue;
+            nextProject = (index + 1) % states.length;
+            occupied++;
+            state.active++;
+            if (!state.runtime && !cleanupOnly) {
+                occupiedProjects++;
+                state.initializing = true;
+            }
+            const invocationIndex = cleanupOnly ? -1 : state.cursor++;
+            return {
+                state,
+                index,
+                invocationIndex
+            };
+        }
+    };
+    const run = async ({ state, index, invocationIndex })=>{
+        const { prepared } = state;
+        const { project } = prepared;
+        let fileResourcesPending = false;
+        try {
+            if (invocationIndex < 0) return void await finishProject(state);
+            if (!state.runtime) {
+                state.runtime = createProjectRuntime({
+                    project,
+                    setup: project.setup,
+                    signal: options.signal,
+                    setupTimeoutMs: options.setupTimeoutMs,
+                    teardownTimeoutMs: options.teardownTimeoutMs
+                });
+                setMaxListeners(Math.max(10, Math.min(prepared.invocations.length, project.maxConcurrentFiles ?? options.maxConcurrentFiles) + 1), state.runtime.signal);
+                options.announceProject(prepared, index);
+                options.onEvent?.({
+                    type: 'project-phase',
+                    projectName: project.name,
+                    phase: 'setup'
+                });
+                await runWithConsoleLogScope({
+                    projectName: project.name,
+                    phase: 'setup'
+                }, ()=>state.runtime.start());
+                options.onEvent?.({
+                    type: 'project-phase',
+                    projectName: project.name,
+                    phase: 'running'
+                });
+                state.initializing = false;
+                if (!state.runtime.canRun) {
+                    state.fatal = true;
+                    state.setupFailed = true;
+                }
+                wake?.();
+            }
+            if (stopped(state)) return;
+            const invocation = prepared.invocations[invocationIndex];
+            options.onProgress(prepared, `  [document ${invocationIndex + 1}/${prepared.invocations.length}] ${invocation.document.sourcePath}`);
+            await executeDocumentInvocation({
+                invocation,
+                project,
+                projectContext: state.runtime.context,
+                runDir: options.runDir,
+                signal: state.runtime.signal,
+                rootSignal: options.signal,
+                shouldBail: options.shouldBail,
+                isProjectFatal: ()=>state.fatal,
+                markProjectFatal: ()=>{
+                    if (state.fatal) return;
+                    state.fatal = true;
+                    state.runtime?.abort(new WorkflowError(`Project "${project.name}" shared execution environment is unavailable.`, {
+                        code: 'PROJECT_RESOURCE_ERROR'
+                    }));
+                },
+                addFailedCases: options.addFailedCases,
+                onProgress: (message)=>options.onProgress(prepared, options.maxConcurrentFiles > 1 ? ` [${invocation.document.sourcePath}]${message}` : message),
+                sinks: state,
+                onEvent: options.onEvent,
+                isolatedContext: void 0 !== project.fileSetup,
+                isProjectResourceFailure: isSharedResourceFailure,
+                setupTimeoutMs: options.setupTimeoutMs,
+                teardownTimeoutMs: options.teardownTimeoutMs,
+                onUnresolvedResources: ()=>{
+                    fileResourcesPending = true;
+                    unresolved();
+                }
+            });
+        } catch (error) {
+            state.fatal = true;
+            fileResourcesPending = !!state.runtime && getPendingScopeOperations(state.runtime.signal).length > 0;
+            options.onInfrastructureError(error);
+        } finally{
+            state.initializing = false;
+            try {
+                if (1 === state.active && (stopped(state) || state.cursor === prepared.invocations.length)) await finishProject(state);
+            } catch (error) {
+                options.onInfrastructureError(error);
+            }
+            state.active--;
+            if (state.runtime && (fileResourcesPending || state.lifecycle?.cleanup?.status === 'pending')) waitForScopeOperations(state.runtime.signal).then(release, (error)=>{
+                options.onInfrastructureError(error);
+                release();
+            });
+            else release();
+            wake?.();
+        }
+    };
+    while(true){
+        const changed = new Promise((resolve)=>{
+            wake = resolve;
+        });
+        while(occupied < options.maxConcurrentFiles){
+            const job = admit();
+            if (!job) break;
+            const task = run(job);
+            running.add(task);
+            const settled = ()=>{
+                running.delete(task);
+                wake?.();
+            };
+            task.then(settled, (error)=>{
+                options.onInfrastructureError(error);
+                settled();
+            });
+        }
+        if (!running.size) break;
+        await changed;
+    }
+    wake = void 0;
+    await Promise.all(states.map(async (state)=>{
+        if (!state.runtime || state.finished) return;
+        const admission = new Promise((resolve)=>{
+            cleanupQueue.push(resolve);
+        });
+        trackResourceOperation({}, admission, state.runtime.signal);
+        while(occupied < options.maxConcurrentFiles && cleanupQueue.length){
+            occupied++;
+            cleanupQueue.shift()();
+        }
+        try {
+            await finishProject(state);
+        } catch (error) {
+            options.onInfrastructureError(error);
+        } finally{
+            Promise.all([
+                admission,
+                getResourceCleanupCompletion(state.runtime.signal)
+            ]).then(release, (error)=>{
+                options.onInfrastructureError(error);
+                release();
+            });
+        }
+    }));
+    for (const state of states){
+        const { prepared } = state;
+        if (!state.runtime) options.announceProject(prepared, states.indexOf(state));
+        finalizeProject(state);
+    }
+    return states;
+}
+function configuredModelNames() {
+    const env = globalConfigManager.getAllEnvConfig();
+    const defaultName = env.MIDSCENE_MODEL_NAME;
+    const models = new Map();
+    for (const [intent, name] of [
+        [
+            'default',
+            defaultName
+        ],
+        [
+            'planning',
+            env.MIDSCENE_PLANNING_MODEL_NAME || defaultName
+        ],
+        [
+            'insight',
+            env.MIDSCENE_INSIGHT_MODEL_NAME || defaultName
+        ]
+    ]){
+        if (!name) continue;
+        const intents = models.get(name) ?? [];
+        intents.push(intent);
+        models.set(name, intents);
+    }
+    return [
+        ...models
+    ].map(([name, intents])=>({
+            name,
+            intents
+        }));
+}
 function createOperationJournal(runDir) {
     const path = join(runDir, 'operations.jsonl');
     writeFileSync(path, '', {
@@ -1333,8 +1882,34 @@ async function runPreparedTestProject(plan) {
     const totalDocuments = preparedProjects.reduce((total, prepared)=>total + prepared.documents.length, 0);
     const totalCases = preparedProjects.reduce((total, prepared)=>total + prepared.selectedCaseCount, 0);
     const totalErrors = preparedProjects.reduce((total, prepared)=>total + prepared.collectionErrors.length, 0);
+    plan.onEvent?.({
+        type: 'run-start',
+        configuredModels: configuredModelNames(),
+        projects: preparedProjects.length,
+        documents: totalDocuments + totalErrors,
+        cases: totalCases,
+        projectRoot,
+        configPath,
+        startedAt: startedAt.toISOString(),
+        maxConcurrentProjects: definition.test.maxConcurrentProjects,
+        maxConcurrentFiles: definition.test.maxConcurrentFiles,
+        files: preparedProjects.flatMap((prepared)=>[
+                ...prepared.documents.map((document)=>({
+                        documentId: document.documentId,
+                        projectName: prepared.project.name,
+                        sourcePath: document.sourcePath,
+                        cases: document.cases.length
+                    })),
+                ...prepared.collectionErrors.map((error)=>({
+                        documentId: error.sourcePath,
+                        projectName: prepared.project.name,
+                        sourcePath: error.sourcePath,
+                        cases: 0
+                    }))
+            ])
+    });
     progress(`midscene-test: preflighted ${preparedProjects.length} projects, ${totalDocuments} documents, ${totalCases} cases, ${totalErrors} collection errors`);
-    const effectiveConcurrency = Math.min(definition.test.maxConcurrency, preparedProjects.length);
+    const effectiveConcurrency = Math.min(definition.test.maxConcurrentFiles ?? 1 / 0, Math.max(1, totalDocuments));
     await writeTestRunPlan(runDir, preparedProjects);
     const journal = createOperationJournal(runDir);
     const rootController = new AbortController();
@@ -1348,6 +1923,18 @@ async function runPreparedTestProject(plan) {
     process.on('SIGTERM', sigterm);
     let failedCaseCount = 0;
     const bailReached = ()=>definition.test.bail > 0 && failedCaseCount >= definition.test.bail;
+    let shutdownDeadline;
+    const beginShutdown = ()=>{
+        shutdownDeadline ??= Date.now() + definition.test.teardownTimeout;
+    };
+    rootController.signal.addEventListener('abort', beginShutdown, {
+        once: true
+    });
+    const addFailedCases = (count)=>{
+        failedCaseCount += count;
+        if (bailReached()) beginShutdown();
+    };
+    const teardownTimeoutMs = ()=>Math.max(0, Math.min(definition.test.teardownTimeout, void 0 === shutdownDeadline ? 1 / 0 : shutdownDeadline - Date.now()));
     let hasInfrastructureError = false;
     const infrastructureErrors = [];
     const recordInfrastructureError = (error)=>{
@@ -1409,112 +1996,30 @@ async function runPreparedTestProject(plan) {
         announceProject(prepared, projectIndex);
         return buildProjectResult(prepared, notRunSuite(prepared, reason), []);
     };
-    const runPreparedProject = async (prepared, projectIndex)=>{
-        const { project } = prepared;
-        announceProject(prepared, projectIndex);
-        const projectProgress = (message)=>runInfrastructureCallback(()=>progress(effectiveConcurrency > 1 ? `[${project.name}]${message}` : message));
-        const cases = [];
-        const documents = [];
-        let lifecycle;
-        let projectFatal = false;
-        if (prepared.collectionErrors.length > 0 || 'run' === plan.preflightScope && totalErrors > 0) cases.push(...notRunSuite(prepared, 'project-preflight-failed'));
-        else if (rootController.signal.aborted) cases.push(...notRunSuite(prepared, 'interrupted'));
-        else if (bailReached()) cases.push(...notRunSuite(prepared, 'bail'));
-        else {
-            const runtime = createProjectRuntime({
-                project,
-                setup: project.setup,
-                signal: rootController.signal
-            });
-            let hasProjectExecutionError = false;
-            try {
-                await runtime.start();
-                if (runtime.canRun) {
-                    const runDocument = async (invocation, documentIndex)=>{
-                        const { document } = invocation;
-                        if (rootController.signal.aborted || bailReached() || projectFatal) {
-                            const reason = rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                            cases.push(...document.cases.map((item)=>asNotRun(document.documentId, item, project.name, reason)));
-                            return;
-                        }
-                        projectProgress(`  [document ${documentIndex + 1}/${prepared.documents.length}] ${document.sourcePath}`);
-                        await executeDocumentInvocation({
-                            invocation,
-                            project,
-                            projectContext: runtime.context,
-                            runDir,
-                            signal: runtime.signal,
-                            rootSignal: rootController.signal,
-                            shouldBail: bailReached,
-                            isProjectFatal: ()=>projectFatal,
-                            markProjectFatal: ()=>{
-                                projectFatal = true;
-                            },
-                            addFailedCases: (count)=>{
-                                failedCaseCount += count;
-                            },
-                            onProgress: projectProgress,
-                            sinks: {
-                                cases,
-                                documents
-                            }
-                        });
-                    };
-                    let prerequisiteFailed = false;
-                    const prerequisite = prepared.invocations.find((invocation)=>invocation.document.documentId === prepared.prerequisiteDocumentId);
-                    const prerequisiteCount = prerequisite ? 1 : 0;
-                    if (prerequisite) {
-                        await runDocument(prerequisite, 0);
-                        prerequisiteFailed = documents.at(-1)?.status === 'failed' || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status);
-                    }
-                    if (!prerequisiteFailed) await runConcurrentJobs(prepared.invocations.filter((invocation)=>invocation !== prerequisite), {
-                        concurrency: prepared.documentConcurrency,
-                        shouldStop: ()=>rootController.signal.aborted || bailReached() || projectFatal
-                    }, async (invocation, index)=>{
-                        try {
-                            await runDocument(invocation, index + prerequisiteCount);
-                        } catch (error) {
-                            recordInfrastructureError(error);
-                            throw error;
-                        }
-                    });
-                    const completed = new Set(cases.map((item)=>item.caseId));
-                    const reason = prerequisiteFailed ? 'project-setup-failed' : rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                    cases.push(...notRunSuite(prepared, reason).filter((item)=>!completed.has(item.caseId)));
-                } else cases.push(...notRunSuite(prepared, rootController.signal.aborted ? 'interrupted' : 'project-setup-failed'));
-            } catch (error) {
-                hasProjectExecutionError = true;
-                recordInfrastructureError(error);
-            } finally{
-                const hasFailure = hasProjectExecutionError || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || projectFatal || rootController.signal.aborted;
-                lifecycle = await runtime.finish(hasFailure ? 'failed' : 'success');
-            }
-            if (hasProjectExecutionError) {
-                const completed = new Set(cases.map((item)=>item.caseId));
-                cases.push(...notRunSuite(prepared, 'interrupted').filter((item)=>!completed.has(item.caseId)));
-            }
-        }
-        const order = new Map(prepared.documents.map((document, index)=>[
-                document.documentId,
-                index
-            ]));
-        const documentOrder = (id)=>order.get(id) ?? Number.MAX_SAFE_INTEGER;
-        cases.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || a.caseIndex - b.caseIndex);
-        documents.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || (a.attemptIndex ?? 0) - (b.attemptIndex ?? 0));
-        return buildProjectResult(prepared, cases, documents, lifecycle);
-    };
     const projectResults = new Array(preparedProjects.length);
     try {
-        await runConcurrentJobs(preparedProjects, {
-            concurrency: effectiveConcurrency,
-            shouldStop: ()=>hasInfrastructureError || rootController.signal.aborted || bailReached()
-        }, async (prepared, index)=>{
-            try {
-                projectResults[index] = await runPreparedProject(prepared, index);
-            } catch (error) {
-                recordInfrastructureError(error);
-                throw error;
-            }
+        const states = await runPreparedFiles({
+            projects: preparedProjects,
+            maxConcurrentFiles: effectiveConcurrency,
+            maxConcurrentProjects: definition.test.maxConcurrentProjects ?? 1 / 0,
+            setupTimeoutMs: definition.test.setupTimeout,
+            teardownTimeoutMs,
+            signal: rootController.signal,
+            runDir,
+            preflightFailed: 'run' === plan.preflightScope && totalErrors > 0,
+            shouldBail: bailReached,
+            addFailedCases,
+            announceProject,
+            onProgress: (prepared, message)=>runInfrastructureCallback(()=>progress(preparedProjects.length > 1 || effectiveConcurrency > 1 ? `[${prepared.project.name}]${message}` : message)),
+            onEvent: (event)=>runInfrastructureCallback(()=>plan.onEvent?.(event)),
+            onProjectEnd: (state)=>runInfrastructureCallback(()=>plan.onEvent?.({
+                        type: 'project-end',
+                        project: buildProjectResult(state.prepared, state.cases, state.documents, state.lifecycle)
+                    })),
+            onInfrastructureError: recordInfrastructureError
+        });
+        states.forEach((state, index)=>{
+            projectResults[index] = buildProjectResult(state.prepared, state.cases, state.documents, state.lifecycle);
         });
     } catch (error) {
         recordInfrastructureError(error);
@@ -1591,6 +2096,10 @@ async function runPreparedTestProject(plan) {
                 buildRunnerDump: (index)=>{
                     reportIndex = index;
                     const dump = buildTestRunReportDump(completedResult, index);
+                    completedResult = {
+                        ...completedResult,
+                        metrics: dump.metrics
+                    };
                     const warn = getDebug('test-runner:report-assembler', {
                         console: true
                     });
@@ -1608,6 +2117,16 @@ async function runPreparedTestProject(plan) {
         await publication.publish(completedResult);
     });
     await publish('write-result', join(dirname(summaryPath), 'result.md'), async ()=>{
+        if (!completedResult.metrics) {
+            const dump = buildTestRunReportDump(completedResult, reportIndex ?? {
+                sources: [],
+                metrics: test_runner_sumTestRunReportMetrics([])
+            });
+            completedResult = {
+                ...completedResult,
+                metrics: dump.metrics
+            };
+        }
         const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
         completedResult = {
             ...completedResult,
@@ -1621,6 +2140,6 @@ async function runPreparedTestProject(plan) {
 async function runTestProject(options = {}) {
     return runPreparedTestProject(await prepareTestRun(options));
 }
-export { DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, loadTestProject, runTestProject, validateTestFileSelection };
+export { DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineFileSetup, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, loadTestProject, runTestProject, validateTestFileSelection };
 
 //# sourceMappingURL=index.mjs.map