@midscene/test 1.17.8-beta-20261106101231.0 → 1.17.8

package/dist/es/299.mjs

@@ -0,0 +1,1886 @@
+import { inspect, stripVTControlCharacters } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolveMidsceneRunDir, runWithMidsceneRunDir } from "@midscene/shared/common";
+import { globSync } from "tinyglobby";
+import { require as api_require } from "tsx/cjs/api";
+import { setMaxListeners } from "node:events";
+import { ReportSession, TestRunReportAssembler, calculateTestRunHealth } from "@midscene/core/report";
+import { WorkflowExecutionFailure, WorkflowError, isFatalDeviceError, decideRetry, WorkflowPublicationError, runDocumentAttempts, getPendingScopeOperations, runWorkflowDocument, asExecutionError, WorkflowParseError, waitForScopeOperations, createProjectRuntime, sanitizeReportError, buildTestRunReportDump, collectTestRunReportSources, buildTestRunReportPlan, trackResourceOperation, isResourceRecoveryError, observeResourceOperations, getResourceCleanupCompletion, sumTestRunReportMetrics } from "./793.mjs";
+import { globalConfigManager } from "./209.mjs";
+import { createHash, writeFile, NodeRegistry, randomUUID, NativeWorkflowFormatError, mkdir, collectWorkflowDocument, writeTestResultMarkdown } from "./431.mjs";
+import { sep, dirname, readdirSync, resolve as external_node_path_resolve, realpathSync, existsSync, statSync, relative, isAbsolute, mkdirSync, writeFileSync, join, appendFileSync } from "./154.mjs";
+import { runWithConsoleLogScope, getDebug } from "./470.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+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
+        }));
+}
+class CliModelUsage {
+    add(step) {
+        for (const trace of step.report?.traces ?? [])if (trace.metrics) {
+            this.executions.set(trace.executionId, trace.metrics);
+            this.missing.delete(trace.executionId);
+        } else if (!this.executions.has(trace.executionId)) this.missing.add(trace.executionId);
+    }
+    snapshot() {
+        if (!this.executions.size && !this.missing.size) return;
+        return sumTestRunReportMetrics([
+            ...this.executions.values()
+        ], this.missing.size ? [
+            'Some execution usage has not been recorded.'
+        ] : []);
+    }
+    constructor(){
+        _define_property(this, "executions", new Map());
+        _define_property(this, "missing", new Set());
+    }
+}
+function formatTokenCount(value) {
+    if (value < 1000) return String(Math.round(value));
+    if (value < 1000000) return `${(value / 1000).toFixed(1)}k`;
+    return `${(value / 1000000).toFixed(1)}m`;
+}
+function formatModelUsage(metrics) {
+    if (!metrics) return [
+        '—'
+    ];
+    if (!metrics.models?.length) {
+        const name = metrics.modelCallCount || metrics.collection?.status === 'unknown' ? 'unknown' : '—';
+        return [
+            `${name} · ${formatTokenUsage(metrics)}`
+        ];
+    }
+    return metrics.models.map((model)=>{
+        const name = stripVTControlCharacters(model.modelName).replace(/\s+/g, ' ').trim() || 'unknown';
+        const usage = formatTokenUsage({
+            ...metrics,
+            modelCallCount: model.callCount,
+            promptTokens: model.promptTokens,
+            cachedInputTokens: model.cachedInputTokens,
+            completionTokens: model.completionTokens,
+            totalTokens: model.totalTokens
+        });
+        return `${name} · ${usage}`;
+    });
+}
+function formatTokenUsage(metrics, includeCached = true) {
+    if (!metrics) return '—';
+    const state = (field)=>metrics.collection?.fields?.[field] ?? metrics.collection?.status ?? 'complete';
+    if ('unknown' === state('totalTokens')) return '— (usage unavailable)';
+    if (!metrics.modelCallCount && !metrics.totalTokens && 'complete' === state('totalTokens')) return '0 (no model calls)';
+    const count = (field)=>'unknown' === state(field) ? '—' : `${'partial' === state(field) ? '≥' : ''}${formatTokenCount(metrics[field])}`;
+    return [
+        `${count('totalTokens')} total${'partial' === state('totalTokens') ? ' (partial)' : ''}`,
+        `${count('promptTokens')} input${includeCached && metrics.cachedInputTokens ? ` (${formatTokenCount(metrics.cachedInputTokens)} cached)` : ''}`,
+        `${count('completionTokens')} output`
+    ].join(' · ');
+}
+const writeJson = async (path, value)=>{
+    try {
+        await mkdir(dirname(path), {
+            recursive: true
+        });
+        await writeFile(path, JSON.stringify(value, null, 2));
+    } catch (error) {
+        throw new WorkflowPublicationError('write-result', path, error);
+    }
+};
+const writeTestRunPlan = (runDir, projects)=>writeJson(join(runDir, 'plan.json'), {
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        projects: projects.map((item)=>({
+                projectId: item.project.projectId,
+                name: item.project.name,
+                documents: item.plans ?? []
+            }))
+    });
+const toPosix = (value)=>value.split(sep).join('/');
+const caseAttemptResultPath = (projectId, documentId, result)=>toPosix(join(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
+const workflowDocumentResultPath = (result)=>toPosix(join(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
+const collectionErrorPath = (projectId, sourcePath)=>{
+    const id = createHash('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath
+    ])).digest('hex');
+    return toPosix(join(projectId, 'collection-errors', `${id}.json`));
+};
+const writeWorkflowDocumentResult = (runDir, result)=>{
+    const { documentRunId: _documentRunId, ...persistedResult } = result;
+    return writeJson(join(runDir, workflowDocumentResultPath(result)), persistedResult);
+};
+const writeCaseAttemptResult = (runDir, projectId, documentId, result)=>{
+    const { runId: attemptId, ...persistedResult } = result;
+    return writeJson(join(runDir, caseAttemptResultPath(projectId, documentId, result)), {
+        ...persistedResult,
+        attemptId
+    });
+};
+const writeCollectionError = (runDir, collectionError)=>writeJson(join(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
+        kind: 'collection-error',
+        ...collectionError
+    });
+const relativeToSummary = (summaryPath, target)=>{
+    const value = relative(dirname(summaryPath), target);
+    return toPosix(value || '.');
+};
+const errorJson = sanitizeReportError;
+const writeTestProjectRunResult = (options)=>{
+    const { result } = options;
+    const fact = (path)=>toPosix(path);
+    return writeJson(result.summaryPath, {
+        schemaVersion: result.schemaVersion,
+        runId: result.runId,
+        startedAt: result.startedAt,
+        endedAt: result.endedAt,
+        durationMs: result.durationMs,
+        status: result.status,
+        exitCode: result.exitCode,
+        ...result.errors?.length ? {
+            errors: result.errors.map(errorJson)
+        } : {},
+        projectRoot: options.projectRoot,
+        ...options.configPath ? {
+            configPath: options.configPath
+        } : {},
+        factsRoot: '.',
+        plan: 'plan.json',
+        ...result.operationLog ? {
+            operationLog: {
+                ...result.operationLog,
+                path: relativeToSummary(result.summaryPath, result.operationLog.path)
+            }
+        } : {},
+        reportDir: relativeToSummary(result.summaryPath, result.reportDir),
+        ...result.reportPath ? {
+            report: relativeToSummary(result.summaryPath, result.reportPath)
+        } : {},
+        ...result.markdownPath ? {
+            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,
+                status: project.status,
+                retry: project.retry,
+                fileSelection: project.fileSelection,
+                tagSelection: project.tagSelection,
+                sourceCount: project.sourceCount,
+                selectedCaseCount: project.selectedCaseCount,
+                filteredCaseCount: project.filteredCaseCount,
+                ...project.lifecycle ? {
+                    lifecycle: {
+                        status: project.lifecycle.status,
+                        startedAt: project.lifecycle.startedAt,
+                        endedAt: project.lifecycle.endedAt,
+                        durationMs: project.lifecycle.durationMs,
+                        ...project.lifecycle.cleanup ? {
+                            cleanup: project.lifecycle.cleanup
+                        } : {},
+                        ...project.lifecycle.pendingOperations ? {
+                            pendingOperations: project.lifecycle.pendingOperations
+                        } : {},
+                        ...project.lifecycle.setupError ? {
+                            setupError: errorJson(project.lifecycle.setupError)
+                        } : {},
+                        ...project.lifecycle.teardownErrors ? {
+                            teardownErrors: project.lifecycle.teardownErrors.map(errorJson)
+                        } : {}
+                    }
+                } : {},
+                cases: project.cases.map((outcome)=>({
+                        ...outcome.documentRunId ? {
+                            documentRunId: outcome.documentRunId
+                        } : {},
+                        documentId: outcome.documentId,
+                        caseId: outcome.caseId,
+                        sourcePath: outcome.sourcePath,
+                        caseIndex: outcome.caseIndex,
+                        name: outcome.name,
+                        status: outcome.status,
+                        ...outcome.notRunReason ? {
+                            notRunReason: outcome.notRunReason
+                        } : {},
+                        ...outcome.attempts ? {
+                            attempts: outcome.attempts.map((attempt)=>({
+                                    attemptId: attempt.runId,
+                                    attemptIndex: attempt.attemptIndex,
+                                    status: attempt.status,
+                                    ...attempt.cleanup ? {
+                                        cleanup: attempt.cleanup
+                                    } : {},
+                                    ...attempt.pendingOperations ? {
+                                        pendingOperations: attempt.pendingOperations
+                                    } : {},
+                                    ...attempt.executionStatus ? {
+                                        executionStatus: attempt.executionStatus
+                                    } : {},
+                                    ...attempt.retryDecision ? {
+                                        retryDecision: attempt.retryDecision
+                                    } : {},
+                                    resultFile: fact(caseAttemptResultPath(project.projectId, outcome.documentId, attempt)),
+                                    ...attempt.reportPaths?.length ? {
+                                        reports: attempt.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
+                                    } : {}
+                                }))
+                        } : {}
+                    })),
+                documents: project.documents.map((document)=>({
+                        documentId: document.documentId,
+                        ...void 0 === document.attemptIndex ? {} : {
+                            attemptIndex: document.attemptIndex,
+                            documentRunId: document.documentRunId
+                        },
+                        sourcePath: document.sourcePath,
+                        status: document.status,
+                        ...document.cleanup ? {
+                            cleanup: document.cleanup
+                        } : {},
+                        ...document.pendingOperations ? {
+                            pendingOperations: document.pendingOperations
+                        } : {},
+                        ...document.executionStatus ? {
+                            executionStatus: document.executionStatus
+                        } : {},
+                        ...document.retryDecision ? {
+                            retryDecision: document.retryDecision
+                        } : {},
+                        resultFile: fact(workflowDocumentResultPath(document)),
+                        ...document.reportPaths?.length ? {
+                            reports: document.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
+                        } : {}
+                    })),
+                collectionErrors: project.collectionErrors.map((error)=>({
+                        sourcePath: error.sourcePath,
+                        errorFile: fact(collectionErrorPath(error.projectId, error.sourcePath))
+                    }))
+            }))
+    });
+};
+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;
+        if ('object' == typeof defaultExport && null !== defaultExport && '__esModule' in defaultExport) {
+            if ('default' in defaultExport) return defaultExport.default;
+            throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
+        }
+        return defaultExport;
+    }
+    throw new TypeError(`Midscene config "${absolutePath}" must have a default export.`);
+};
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const rejectUnknownKeys = (value, allowedKeys, label)=>{
+    const allowed = new Set(allowedKeys);
+    const unknown = Object.keys(value).find((key)=>!allowed.has(key));
+    if (unknown) throw new TypeError(`Midscene config ${label}.${unknown} is not supported.`);
+};
+const isAbsolutePattern = (pattern)=>isAbsolute(pattern) || /^[A-Za-z]:[\\/]/.test(pattern) || pattern.startsWith('\\\\');
+const validatePatterns = (value, field, label = 'files', allowEmptyInclude = false)=>{
+    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
+    if ('include' === field && 0 === value.length && !allowEmptyInclude) throw new TypeError(`Midscene config ${label}.include must be a non-empty array.`);
+    return value.map((pattern, index)=>{
+        if ('string' != typeof pattern || 0 === pattern.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
+        if (isAbsolutePattern(pattern)) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be relative to the project root.`);
+        if (pattern.split(/[\\/]/).includes('..')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must not contain a ".." path segment.`);
+        if (pattern.includes('\\')) throw new TypeError(`Midscene config ${label}.${field}[${index}] must use POSIX path separators (/).`);
+        if (pattern.startsWith('!')) {
+            if ('include' === field) throw new TypeError(`Midscene config ${label}.include[${index}] must not be a negated pattern. Use files.exclude instead.`);
+            throw new TypeError(`Midscene config ${label}.exclude[${index}] must not be a negated pattern.`);
+        }
+        return pattern;
+    });
+};
+const validateTestFileSelection = (value, label = 'files')=>{
+    if (void 0 === value) return;
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    rejectUnknownKeys(value, [
+        'include',
+        'exclude'
+    ], label);
+    const include = validatePatterns(value.include, 'include', label);
+    const exclude = void 0 === value.exclude ? void 0 : validatePatterns(value.exclude, 'exclude', label);
+    return Object.freeze({
+        include: Object.freeze(include),
+        ...exclude ? {
+            exclude: Object.freeze(exclude)
+        } : {}
+    });
+};
+const validateTagList = (value, field, label)=>{
+    if (void 0 === value) return [];
+    if (!Array.isArray(value)) throw new TypeError(`Midscene config ${label}.${field} must be an array.`);
+    return value.map((tag, index)=>{
+        if ('string' != typeof tag || 0 === tag.trim().length) throw new TypeError(`Midscene config ${label}.${field}[${index}] must be a non-empty string.`);
+        return tag;
+    });
+};
+const validateTagSelection = (value, label)=>{
+    if (void 0 === value) return Object.freeze({
+        include: [],
+        exclude: []
+    });
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    return Object.freeze({
+        include: Object.freeze(validateTagList(value.include, 'include', label)),
+        exclude: Object.freeze(validateTagList(value.exclude, 'exclude', label))
+    });
+};
+function assertJsonValue(value, path, seen) {
+    if (null === value || 'string' == typeof value || 'boolean' == typeof value) return;
+    if ('number' == typeof value) {
+        if (Number.isFinite(value)) return;
+        throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
+    }
+    if ('object' != typeof value || void 0 === value) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && null !== Object.getPrototypeOf(value)) throw new TypeError(`Midscene config ${path} must be JSON-compatible.`);
+    if (seen.has(value)) throw new TypeError(`Midscene config ${path} must not contain cycles.`);
+    seen.add(value);
+    if (Array.isArray(value)) value.forEach((item, index)=>assertJsonValue(item, `${path}[${index}]`, seen));
+    else for (const [key, child] of Object.entries(value))assertJsonValue(child, `${path}.${key}`, seen);
+    seen.delete(value);
+}
+const deepFreezeJson = (value)=>{
+    if ('object' == typeof value && null !== value) {
+        for (const child of Object.values(value))deepFreezeJson(child);
+        Object.freeze(value);
+    }
+    return value;
+};
+const validateVariables = (value, label)=>{
+    if (void 0 === value) return Object.freeze({});
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    assertJsonValue(value, label, new Set());
+    return deepFreezeJson(value);
+};
+const validateSetup = (value, label)=>{
+    if (void 0 === value) return;
+    if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    rejectUnknownKeys(value, [
+        'name',
+        'setup'
+    ], label);
+    if ('string' != typeof value.name || 0 === value.name.trim().length) throw new TypeError(`Midscene config ${label}.name must be non-empty.`);
+    if ('function' != typeof value.setup) throw new TypeError(`Midscene config ${label}.setup must be a function.`);
+    return value;
+};
+const validatePositiveInteger = (value, fallback, label)=>{
+    if (void 0 === value) return fallback;
+    if (!Number.isInteger(value) || value <= 0) throw new TypeError(`Midscene config ${label} must be a positive integer.`);
+    return value;
+};
+const validateNonNegativeInteger = (value, fallback, label)=>{
+    if (void 0 === value) return fallback;
+    if (!Number.isInteger(value) || value < 0) throw new TypeError(`Midscene config ${label} must be a non-negative integer.`);
+    return value;
+};
+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([
+                Object.freeze({
+                    projectId: projectIdFromIndex(0),
+                    name: 'default',
+                    ...setup ? {
+                        setup
+                    } : {},
+                    ...fileSetup ? {
+                        fileSetup
+                    } : {},
+                    maxConcurrentFiles,
+                    tags: Object.freeze({
+                        include: [],
+                        exclude: []
+                    }),
+                    retry: 0,
+                    variables: Object.freeze({}),
+                    nodes: new NodeRegistry(globalNodes.definitions())
+                })
+            ])
+        };
+    }
+    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)=>{
+        const label = `projects[${index}]`;
+        if (!isRecord(candidate)) throw new TypeError(`Midscene config ${label} must be an object.`);
+        rejectUnknownKeys(candidate, [
+            'name',
+            'setup',
+            'fileSetup',
+            'maxConcurrentFiles',
+            'nodes',
+            'files',
+            'tags',
+            'retry',
+            'variables'
+        ], label);
+        if ('string' != typeof candidate.name || 0 === candidate.name.trim().length) throw new TypeError(`Midscene config ${label}.name must be non-empty.`);
+        if (names.has(candidate.name)) throw new TypeError(`Midscene config project name "${candidate.name}" must be unique.`);
+        names.add(candidate.name);
+        const files = validateTestFileSelection(candidate.files, `${label}.files`);
+        if (void 0 !== candidate.nodes && !Array.isArray(candidate.nodes)) throw new TypeError(`Midscene config ${label}.nodes must be an array.`);
+        const localNodes = new NodeRegistry(candidate.nodes);
+        const nodes = new NodeRegistry([
+            ...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
+            } : {},
+            tags: validateTagSelection(candidate.tags, `${label}.tags`),
+            retry: validateNonNegativeInteger(candidate.retry, 0, `${label}.retry`),
+            variables: validateVariables(candidate.variables, `${label}.variables`),
+            ...void 0 === candidate.setup ? {} : {
+                setup: validateSetup(candidate.setup, `${label}.setup`)
+            }
+        });
+    });
+    return {
+        projects: Object.freeze(projects),
+        hasExplicitProjects: true
+    };
+};
+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({
+        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')
+    });
+};
+const validateOutputPath = (value, label)=>{
+    if ('string' != typeof value || 0 === value.trim().length) throw new TypeError(`Midscene config ${label} must be non-empty.`);
+    return value;
+};
+const validateOutput = (value)=>{
+    if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config output must be an object.');
+    const candidate = value ?? {};
+    rejectUnknownKeys(candidate, [
+        'reportDir',
+        'reportFormat'
+    ], 'output');
+    if (void 0 !== candidate.reportFormat && 'single-html' !== candidate.reportFormat && 'html-and-external-assets' !== candidate.reportFormat) throw new TypeError('Midscene config output.reportFormat must be single-html or html-and-external-assets.');
+    return Object.freeze({
+        reportFormat: candidate.reportFormat ?? 'single-html',
+        ...void 0 === candidate.reportDir ? {} : {
+            reportDir: validateOutputPath(candidate.reportDir, 'output.reportDir')
+        }
+    });
+};
+const validateTestProjectDefinition = (definition)=>{
+    if (!isRecord(definition)) throw new TypeError('Midscene config must default export an object.');
+    if (void 0 !== definition.nodes && !Array.isArray(definition.nodes)) throw new TypeError('Midscene config nodes must be an array.');
+    if ('setupWorkflow' in definition) throw new TypeError('Midscene config setupWorkflow is no longer supported. Use setup or projects[].setup instead.');
+    if ('setupDocument' in definition) throw new TypeError('Midscene config setupDocument is not supported. Use setup or projects[].setup for resources, and beforeAll/afterAll for document lifecycle steps.');
+    if ('root' in definition) throw new TypeError('Midscene config root is not supported. Run midscene-test from the project directory or select its config with --config instead.');
+    if ('files' in definition) throw new TypeError('Midscene config files is not supported at the root. Move it to projects[].files.');
+    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 NodeRegistry(definition.nodes);
+    const test = validateTestOptions(definition.test, void 0 !== definition.projects);
+    const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, definition.fileSetup, nodes, test);
+    return {
+        ...resolvedProjects,
+        test,
+        output: validateOutput(definition.output),
+        nodes,
+        resolveNode: (name)=>nodes.get(name)
+    };
+};
+const assertSupportedConfig = (absolutePath)=>{
+    if (!absolutePath.endsWith('.ts') && !absolutePath.endsWith('.mjs')) {
+        const extension = absolutePath.match(/(\.[^./\\]+)$/)?.[1] ?? '(none)';
+        throw new TypeError(`Unsupported Midscene config extension: ${extension}. Supported extensions: .ts, .mjs.`);
+    }
+    return absolutePath.endsWith('.mjs') ? '.mjs' : '.ts';
+};
+const canRetryWithCjsLoader = (error)=>{
+    if (!(error instanceof Error)) return false;
+    const errorCode = error.code;
+    return error instanceof SyntaxError && /^Unexpected (?:identifier|reserved word|token)/.test(error.message) || 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' === errorCode || 'ERR_UNKNOWN_FILE_EXTENSION' === errorCode && /^Unknown file extension\b/.test(error.message);
+};
+async function loadTestProject(configPath) {
+    if (!configPath) return validateTestProjectDefinition({
+        nodes: []
+    });
+    const absolutePath = external_node_path_resolve(configPath);
+    const extension = assertSupportedConfig(absolutePath);
+    let loaded;
+    try {
+        if ('.mjs' === extension) loaded = await import(pathToFileURL(absolutePath).href);
+        else {
+            const { tsImport } = await import("tsx/esm/api");
+            loaded = await tsImport(pathToFileURL(absolutePath).href, {
+                parentURL: pathToFileURL(`${dirname(absolutePath)}${sep}`).href,
+                tsconfig: false
+            });
+        }
+    } catch (error) {
+        try {
+            if ('.mjs' === extension || !canRetryWithCjsLoader(error)) throw error;
+            loaded = api_require(absolutePath, pathToFileURL(absolutePath));
+        } catch (fallbackError) {
+            const message = fallbackError instanceof Error ? `: ${fallbackError.message}` : '';
+            throw new Error(`Failed to load Midscene config "${absolutePath}"${message}`, {
+                cause: fallbackError
+            });
+        }
+    }
+    return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
+}
+const CONFIG_NAMES = [
+    'midscene.config.ts',
+    'midscene.config.mjs'
+];
+const CONFIG_PREFIX = 'midscene.config.';
+const ALWAYS_IGNORED_PATTERNS = [
+    '.git/**',
+    '.midscene/**',
+    'midscene_run/**',
+    'node_modules/**',
+    '**/.git/**',
+    '**/.midscene/**',
+    '**/midscene_run/**',
+    '**/node_modules/**'
+];
+const DEFAULT_TEST_FILE_SELECTION = {
+    include: [
+        '**/*.{yaml,yml}'
+    ]
+};
+const project_preparation_toPosix = (value)=>value.split(sep).join('/');
+const discoverResolvedTestFiles = (projectRoot, selection, excludedDirectories = [])=>{
+    const root = external_node_path_resolve(projectRoot);
+    const outputPatterns = excludedDirectories.flatMap((directory)=>{
+        const withinRoot = relative(root, directory);
+        if (!withinRoot || isAbsolute(withinRoot) || '..' === withinRoot || withinRoot.startsWith(`..${sep}`)) return [];
+        const literal = project_preparation_toPosix(withinRoot).replace(/([*?{}[\]()!])/g, '\\$1');
+        return [
+            `${literal}/**`
+        ];
+    });
+    const match = (patterns)=>globSync(patterns, {
+            absolute: true,
+            caseSensitiveMatch: false,
+            cwd: root,
+            dot: true,
+            expandDirectories: false,
+            followSymbolicLinks: false,
+            ignore: [
+                ...ALWAYS_IGNORED_PATTERNS,
+                ...outputPatterns,
+                ...selection.exclude ?? []
+            ],
+            onlyFiles: true
+        }).filter((file)=>/\.ya?ml$/i.test(file));
+    const files = match(selection.include);
+    return [
+        ...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));
+        return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
+    });
+};
+const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)=>{
+    const normalized = validateTestFileSelection(selection);
+    if (!normalized) throw new TypeError('Test file selection is required.');
+    return discoverResolvedTestFiles(projectRoot, normalized);
+};
+const discoverTestConfig = (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));
+    if (unsupported.length > 0) throw new Error([
+        `Unsupported or conflicting Midscene configs found in ${root}:`,
+        ...candidates.map((name)=>`- ${name}`),
+        `Only ${CONFIG_NAMES.join(' and ')} are supported.`
+    ].join('\n'));
+    if (supported.length > 1) throw new Error([
+        `Multiple Midscene configs found in ${root}:`,
+        ...supported.map((name)=>`- ${name}`),
+        'Pass --config <path> to select one explicitly.'
+    ].join('\n'));
+    return supported[0] ? join(root, supported[0]) : void 0;
+};
+const asCollectionError = (projectId, projectName, sourcePath, error)=>({
+        projectId,
+        projectName,
+        sourcePath,
+        error: error instanceof WorkflowError ? error : new WorkflowParseError(`Failed to collect workflow document "${sourcePath}": ${error instanceof Error ? error.message : String(error)}`, {
+            projectName,
+            sourcePath
+        }, error)
+    });
+const matchesTags = (tags, selection)=>{
+    if (selection.exclude.some((tag)=>tags.includes(tag))) return false;
+    return 0 === selection.include.length || selection.include.some((tag)=>tags.includes(tag));
+};
+const filterDocumentCases = (document, project)=>{
+    const cases = document.cases.filter((item)=>matchesTags(item.definition.tags ?? [], project.tags));
+    const filtered = document.cases.length - cases.length;
+    return 0 === cases.length ? {
+        filtered
+    } : {
+        document: {
+            ...document,
+            cases
+        },
+        filtered
+    };
+};
+const selectProjects = (projects, names)=>{
+    if (!names || 0 === names.length) return projects;
+    const requested = new Set(names);
+    if (requested.size !== names.length) throw new Error('Each --project name may only be specified once.');
+    const known = new Set(projects.map((project)=>project.name));
+    const unknown = names.find((name)=>!known.has(name));
+    if (unknown) throw new Error(`Unknown Midscene project: ${unknown}`);
+    return projects.filter((project)=>requested.has(project.name));
+};
+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 ? external_node_path_resolve(options.prerequisiteFile) : void 0;
+    const discoveredFiles = options.files ?? discoverResolvedTestFiles(options.discoveryRoot ?? projectRoot, fileSelection, options.excludedDirectories);
+    const selectedPath = options.testPath ? realpathSync(options.testPath) : void 0;
+    const mainFiles = selectedPath ? discoveredFiles.filter((file)=>{
+        const within = relative(selectedPath, realpathSync(file));
+        return '' === within || !isAbsolute(within) && '..' !== within && !within.startsWith(`..${sep}`);
+    }) : discoveredFiles;
+    const files = [
+        ...prerequisiteFile ? [
+            prerequisiteFile
+        ] : [],
+        ...mainFiles.filter((file)=>file !== prerequisiteFile)
+    ];
+    const occurrences = new Map();
+    const sources = files.map((absolutePath)=>{
+        const invocationIndex = occurrences.get(absolutePath) ?? 0;
+        occurrences.set(absolutePath, invocationIndex + 1);
+        return {
+            projectId: project.projectId,
+            projectName: project.name,
+            sourcePath: project_preparation_toPosix(relative(projectRoot, absolutePath)),
+            absolutePath,
+            invocationIndex
+        };
+    });
+    const collectionErrors = [];
+    const invocations = [];
+    const plans = [];
+    let filteredCaseCount = 0;
+    if (0 === sources.length && !options.testPath) {
+        const error = asCollectionError(project.projectId, project.name, '<project>', new WorkflowParseError(`No workflow YAML files found for project "${project.name}" in ${projectRoot}.`, {
+            projectName: project.name,
+            projectRoot
+        }));
+        collectionErrors.push(error);
+        await writeCollectionError(runDir, error);
+    }
+    for (const source of sources)try {
+        const collected = await options.collectDocument?.(source, project);
+        if (collected) {
+            filteredCaseCount += collected.filteredCaseCount;
+            if (collected.invocation) {
+                const plan = buildTestRunReportPlan(collected.invocation.document, {
+                    defaultTimeoutMs: collected.invocation.defaultTimeoutMs,
+                    retry: collected.invocation.retry
+                });
+                invocations.push({
+                    ...collected.invocation,
+                    plan
+                });
+                plans.push(plan);
+            }
+            continue;
+        }
+        const document = collectWorkflowDocument(source, {
+            resolveNode: project.nodes.get.bind(project.nodes),
+            variables: project.variables,
+            env: process.env
+        });
+        const filtered = source.absolutePath === prerequisiteFile ? {
+            document,
+            filtered: 0
+        } : filterDocumentCases(document, project);
+        const plan = buildTestRunReportPlan(document, {
+            selectedCaseIds: filtered.document?.cases.map((item)=>item.caseId) ?? [],
+            defaultTimeoutMs,
+            retry: {
+                scope: 'case',
+                count: project.retry
+            }
+        });
+        plans.push(plan);
+        filteredCaseCount += filtered.filtered;
+        if (filtered.document) invocations.push({
+            plan,
+            document: filtered.document,
+            retry: {
+                scope: 'case',
+                count: project.retry
+            },
+            defaultTimeoutMs,
+            reportEnabled: true,
+            bindings: {
+                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) {
+        const collectionError = asCollectionError(project.projectId, project.name, source.sourcePath, error);
+        collectionErrors.push(collectionError);
+        await writeCollectionError(runDir, collectionError);
+    }
+    const documents = invocations.map((invocation)=>invocation.document);
+    const prerequisiteSource = sources.find((source)=>source.absolutePath === prerequisiteFile);
+    const prerequisiteDocument = documents.find((document)=>document.sourcePath === prerequisiteSource?.sourcePath);
+    return {
+        project,
+        ...platform ? {
+            platform
+        } : {},
+        documentConcurrency: options.documentConcurrency ?? 1,
+        ...prerequisiteDocument ? {
+            prerequisiteDocumentId: prerequisiteDocument.documentId
+        } : {},
+        fileSelection,
+        sources,
+        documents,
+        invocations,
+        plans,
+        collectionErrors,
+        selectedCaseCount: documents.reduce((total, document)=>total + document.cases.length, 0),
+        filteredCaseCount
+    };
+}
+const padDatePart = (value)=>String(value).padStart(2, '0');
+const createTestRunId = (date = new Date(), uuid = randomUUID())=>{
+    const timestamp = [
+        date.getFullYear(),
+        padDatePart(date.getMonth() + 1),
+        padDatePart(date.getDate()),
+        padDatePart(date.getHours()),
+        padDatePart(date.getMinutes()),
+        padDatePart(date.getSeconds())
+    ].join('');
+    return `${timestamp}-${uuid.slice(0, 8)}`;
+};
+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 = external_node_path_resolve(options.cwd ?? process.cwd());
+    assertDirectory(cwd, 'Test working directory');
+    const searchRoot = external_node_path_resolve(cwd, options.projectRoot ?? '.');
+    assertDirectory(searchRoot, 'Test project directory');
+    const configPath = options.configPath ? external_node_path_resolve(cwd, options.configPath) : discoverTestConfig(searchRoot);
+    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 (configPath && (!existsSync(configPath) || !statSync(configPath).isFile())) throw new Error(`Midscene config does not exist or is not a file: ${configPath}`);
+    const testPath = options.testPath ? external_node_path_resolve(cwd, options.testPath) : void 0;
+    if (testPath) {
+        if (!existsSync(testPath)) throw new Error(`Test path does not exist: ${testPath}`);
+        const stat = statSync(testPath);
+        if (!stat.isDirectory() && !(stat.isFile() && /\.ya?ml$/i.test(testPath))) throw new Error(`Test input must be a YAML file or directory: ${testPath}`);
+    }
+    return {
+        cwd,
+        projectRoot: configPath ? dirname(configPath) : searchRoot,
+        ...configPath ? {
+            configPath
+        } : {},
+        ...testPath ? {
+            testPath
+        } : {}
+    };
+};
+async function prepareTestRun(options) {
+    const startedAt = new Date();
+    const runId = createTestRunId(startedAt);
+    const input = resolveRunInput(options);
+    const { configPath } = input;
+    const standalonePath = configPath ? void 0 : input.testPath;
+    const discovery = standalonePath && statSync(standalonePath).isFile() ? {
+        files: [
+            standalonePath
+        ]
+    } : {
+        discoveryRoot: standalonePath
+    };
+    const definition = await loadTestProject(configPath);
+    const artifactDir = resolveMidsceneRunDir(input.projectRoot);
+    return runWithMidsceneRunDir(artifactDir, async ()=>{
+        const resultDir = options.resultDir ? external_node_path_resolve(input.cwd, options.resultDir) : join(artifactDir, 'test-results');
+        const runDir = join(resultDir, runId);
+        const summaryPath = join(runDir, 'summary.json');
+        const reportDir = definition.output.reportDir ? external_node_path_resolve(input.projectRoot, definition.output.reportDir) : join(artifactDir, 'report');
+        mkdirSync(resultDir, {
+            recursive: true
+        });
+        mkdirSync(runDir);
+        const projects = [];
+        for (const project of selectProjects(definition.projects, options.projectNames))projects.push(await prepareProject(project, input.projectRoot, runDir, definition.test.testTimeout, {
+            testPath: input.testPath,
+            ...discovery,
+            excludedDirectories: [
+                artifactDir,
+                resultDir,
+                reportDir,
+                ...[
+                    'cache',
+                    'log',
+                    'output',
+                    'tmp',
+                    'dump'
+                ].map((name)=>join(artifactDir, name))
+            ]
+        }));
+        if (input.testPath && projects.every((project)=>0 === project.selectedCaseCount && 0 === project.collectionErrors.length)) throw new Error(`No test cases match "${input.testPath}" in ${input.projectRoot}. Check --project, files.include/files.exclude, tags, and ignored output directories.`);
+        const hasFormatMismatch = projects.some((project)=>project.collectionErrors.some(({ error })=>error instanceof NativeWorkflowFormatError));
+        return {
+            startedAt,
+            runId,
+            projectRoot: input.projectRoot,
+            artifactDir,
+            ...configPath ? {
+                configPath
+            } : {},
+            resultDir,
+            runDir,
+            summaryPath,
+            reportDir,
+            definition,
+            projects,
+            preflightScope: hasFormatMismatch ? 'run' : 'project',
+            reportEnabled: true,
+            publications: [],
+            onProgress: options.onProgress ?? (()=>{}),
+            onEvent: options.onEvent
+        };
+    });
+}
+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);
+    const phase = 'steps' === position.phase ? 'step' : position.phase;
+    return `${phase} ${position.stepIndex + 1}/${info.stepCount}: ${info.node}`;
+};
+const formatStepResult = (info, result)=>{
+    const indent = 'case' === info.scope ? '      ' : '    ';
+    if ('not-run' === result.status) return `${indent}– ${formatStep(info)} (not run: ${result.notRunReason})`;
+    const symbol = 'success' === result.status ? '✓' : '✗';
+    const error = result.error ? ` — ${result.error.message}` : '';
+    const continuation = result.continuedAfterError ? '; continuing' : '';
+    return `${indent}${symbol} ${formatStep(info)} (${result.durationMs} ms)${error}${continuation}`;
+};
+const caseHasFatalError = (outcome)=>(outcome.attempts ?? []).some((attempt)=>[
+            ...attempt.beforeEach,
+            ...attempt.steps,
+            ...attempt.afterEach
+        ].some((step)=>step.error && isFatalDeviceError(step.error)) || (attempt.teardownErrors ?? []).some(isFatalDeviceError) || !!attempt.executionErrors?.some(isResourceRecoveryError));
+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 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 (!options.isolatedContext && error.errors.some(isResourceRecoveryError)) options.markProjectFatal();
+                    return partial;
+                }
+                if (documentRetry) partial.document.retryDecision = decideRetry({
+                    scope: 'document',
+                    retryCount: invocation.retry.count,
+                    attemptIndex: documentAttemptIndex,
+                    status: 'failed',
+                    infrastructureError: true
+                });
+                attempts.push(partial);
+                sinks.documents.push(partial.document);
+                sinks.cases.push(...partial.cases.map((outcome)=>({
+                        ...outcome,
+                        documentId: document.documentId,
+                        documentRunId: partial.document.documentRunId
+                    })));
+                try {
+                    for (const outcome of partial.cases)for (const attempt of outcome.attempts ?? [])await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+                    await writeWorkflowDocumentResult(options.runDir, partial.document);
+                } catch (publicationError) {
+                    throw new WorkflowExecutionFailure(partial, [
+                        ...error.errors,
+                        publicationError
+                    ]);
+                }
+            }
+            throw error;
+        });
+        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 ?? [])
+        ];
+        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 || 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',
+            retryCount: invocation.retry.count,
+            attemptIndex: documentAttemptIndex,
+            status: failed ? 'failed' : 'success',
+            cleanupPending,
+            cleanupFailed,
+            operationPending,
+            fatalError: options.isProjectFatal(),
+            interrupted: options.signal.aborted || options.rootSignal.aborted,
+            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,
+                documentId: document.documentId,
+                documentRunId: execution.document.documentRunId
+            })));
+        sinks.documents.push(execution.document);
+        try {
+            for (const outcome of execution.cases)for (const attempt of outcome.attempts ?? [])await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+            await writeWorkflowDocumentResult(options.runDir, execution.document);
+        } catch (error) {
+            execution.document.status = 'failed';
+            execution.document.hostErrors = [
+                ...execution.document.hostErrors ?? [],
+                {
+                    phase: 'publication',
+                    error
+                }
+            ];
+            if (documentRetry) execution.document.retryDecision = decideRetry({
+                scope: 'document',
+                retryCount: invocation.retry.count,
+                attemptIndex: documentAttemptIndex,
+                status: 'failed',
+                infrastructureError: true
+            });
+            throw new WorkflowExecutionFailure(execution, [
+                error
+            ]);
+        }
+        return 'retry' === decision.decision ? 'failed' : void 0;
+    });
+    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 createOperationJournal(runDir) {
+    const path = join(runDir, 'operations.jsonl');
+    writeFileSync(path, '', {
+        flag: 'wx'
+    });
+    return {
+        path,
+        append (event) {
+            appendFileSync(path, `${JSON.stringify(event)}\n`);
+        }
+    };
+}
+const asNotRun = (documentId, collectedCase, projectName, reason)=>({
+        documentId,
+        caseId: collectedCase.caseId,
+        projectName,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        status: 'not-run',
+        notRunReason: reason
+    });
+const summarize = (projects)=>{
+    const healthCases = projects.flatMap((project)=>{
+        const documentAttemptByRunId = new Map(project.documents.map((document)=>[
+                document.documentRunId,
+                document.attemptIndex ?? 0
+            ]));
+        return latestById(project.cases, (item)=>item.caseId).map((item)=>({
+                status: item.status,
+                ...item.run ? {
+                    run: item.run
+                } : {},
+                ...item.attempts ? {
+                    attempts: item.attempts
+                } : {},
+                retryCount: item.documentRunId ? documentAttemptByRunId.get(item.documentRunId) ?? 0 : 0
+            }));
+    });
+    const documents = projects.flatMap((project)=>latestById(project.documents, (item)=>item.documentId));
+    const health = calculateTestRunHealth(healthCases);
+    return {
+        total: health.total,
+        passed: health.passed,
+        failed: health.failed,
+        notRun: health.notRun,
+        passedAfterRetry: health.passedAfterRetry,
+        finalPassRate: health.finalPassRate,
+        firstPassRate: health.firstPassRate,
+        filtered: projects.reduce((total, project)=>total + project.filteredCaseCount, 0),
+        collectionErrors: projects.reduce((total, project)=>total + project.collectionErrors.length, 0),
+        documentFailures: documents.filter((document)=>'failed' === document.status).length,
+        projectFailures: projects.filter((project)=>'failed' === project.status).length
+    };
+};
+const latestById = (items, id)=>[
+        ...new Map(items.map((item)=>[
+                id(item),
+                item
+            ])).values()
+    ];
+const notRunSuite = (prepared, reason)=>prepared.documents.flatMap((document)=>document.cases.map((item)=>asNotRun(document.documentId, item, prepared.project.name, reason)));
+async function runPreparedTestProject(plan) {
+    const reports = new ReportSession(join(plan.runDir, 'records'));
+    return runWithMidsceneRunDir(plan.artifactDir, ()=>reports.run(()=>runWithReportSession(plan, reports)));
+}
+async function runWithReportSession(plan, reports) {
+    const { startedAt, runId, projectRoot, configPath, resultDir, runDir, summaryPath, reportDir, definition, projects: preparedProjects } = plan;
+    const progress = plan.onProgress;
+    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.maxConcurrentFiles ?? 1 / 0, Math.max(1, totalDocuments));
+    await writeTestRunPlan(runDir, preparedProjects);
+    const journal = createOperationJournal(runDir);
+    const rootController = new AbortController();
+    setMaxListeners(Math.max(10, effectiveConcurrency + 1), rootController.signal);
+    const handleSignal = (signal)=>{
+        rootController.abort(new Error(`Workflow interrupted by ${signal}.`));
+    };
+    const sigint = ()=>handleSignal('SIGINT');
+    const sigterm = ()=>handleSignal('SIGTERM');
+    process.on('SIGINT', sigint);
+    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)=>{
+        const errors = error instanceof WorkflowExecutionFailure ? error.errors : [
+            error
+        ];
+        for (const item of errors)if (!infrastructureErrors.includes(item)) infrastructureErrors.push(item);
+        hasInfrastructureError = true;
+        rootController.abort(error);
+    };
+    const runInfrastructureCallback = (callback)=>{
+        try {
+            return callback();
+        } catch (error) {
+            recordInfrastructureError(error);
+            throw error;
+        }
+    };
+    const stopObservingOperations = observeResourceOperations(rootController.signal, (event)=>{
+        try {
+            journal.append(event);
+        } catch (error) {
+            recordInfrastructureError(new WorkflowPublicationError('write-result', journal.path, error));
+            getDebug('test-runner:operations', {
+                console: true
+            })(`Could not persist operation event: ${String(error)}`);
+        }
+    });
+    const announceProject = (prepared, projectIndex)=>{
+        const { project } = prepared;
+        runInfrastructureCallback(()=>progress(`[project ${projectIndex + 1}/${preparedProjects.length}] ${project.name}`));
+    };
+    const buildProjectResult = (prepared, cases, documents, lifecycle)=>{
+        const { project } = prepared;
+        const projectFailed = prepared.collectionErrors.length > 0 || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
+        return {
+            projectId: project.projectId,
+            name: project.name,
+            ...prepared.platform ? {
+                platform: prepared.platform
+            } : {},
+            status: projectFailed ? 'failed' : 'success',
+            retry: project.retry,
+            fileSelection: prepared.fileSelection,
+            tagSelection: project.tags,
+            sourceCount: prepared.sources.length,
+            selectedCaseCount: prepared.selectedCaseCount,
+            filteredCaseCount: prepared.filteredCaseCount,
+            ...lifecycle ? {
+                lifecycle
+            } : {},
+            cases,
+            plans: prepared.plans,
+            documents,
+            collectionErrors: prepared.collectionErrors
+        };
+    };
+    const buildSkippedProjectResult = (prepared, projectIndex, reason)=>{
+        announceProject(prepared, projectIndex);
+        return buildProjectResult(prepared, notRunSuite(prepared, reason), []);
+    };
+    const projectResults = new Array(preparedProjects.length);
+    try {
+        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);
+    } finally{
+        stopObservingOperations();
+        process.off('SIGINT', sigint);
+        process.off('SIGTERM', sigterm);
+    }
+    const completedProjectResults = preparedProjects.map((prepared, projectIndex)=>{
+        const result = projectResults[projectIndex];
+        if (result) return result;
+        const reason = prepared.collectionErrors.length ? 'project-preflight-failed' : rootController.signal.aborted ? 'interrupted' : bailReached() ? 'bail' : void 0;
+        if (!reason) throw new Error(`Project scheduler did not produce a result for "${prepared.project.name}".`);
+        return buildSkippedProjectResult(prepared, projectIndex, reason);
+    });
+    const summary = summarize(completedProjectResults);
+    const failed = hasInfrastructureError || rootController.signal.aborted || summary.failed > 0 || summary.notRun > 0 || summary.collectionErrors > 0 || summary.documentFailures > 0 || summary.projectFailures > 0;
+    const endedAt = new Date();
+    const result = {
+        schemaVersion: 3,
+        operationLog: {
+            path: journal.path,
+            snapshotAt: endedAt.toISOString()
+        },
+        runId,
+        startedAt: startedAt.toISOString(),
+        endedAt: endedAt.toISOString(),
+        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
+        status: failed ? 'failed' : 'success',
+        exitCode: failed ? 1 : 0,
+        resultDir,
+        summaryPath,
+        reportDir,
+        summary,
+        projects: completedProjectResults,
+        cases: completedProjectResults.flatMap((project)=>project.cases),
+        documents: completedProjectResults.flatMap((project)=>project.documents),
+        collectionErrors: completedProjectResults.flatMap((project)=>project.collectionErrors),
+        ...hasInfrastructureError ? {
+            errors: infrastructureErrors.map(asExecutionError)
+        } : {}
+    };
+    let completedResult = result;
+    let reportIndex;
+    const publish = async (operation, path, callback)=>{
+        try {
+            await callback();
+            return true;
+        } catch (error) {
+            recordInfrastructureError(error instanceof WorkflowPublicationError || error instanceof WorkflowExecutionFailure ? error : new WorkflowPublicationError(operation, path, error));
+            completedResult = {
+                ...completedResult,
+                status: 'failed',
+                exitCode: 1,
+                errors: infrastructureErrors.map(asExecutionError)
+            };
+            return false;
+        }
+    };
+    const writeSummary = ()=>publish('write-result', summaryPath, ()=>writeTestProjectRunResult({
+                projectRoot,
+                ...configPath ? {
+                    configPath
+                } : {},
+                result: completedResult
+            }));
+    let extraSources = [];
+    await publish('write-report', reports.directory, async ()=>{
+        extraSources = await reports.finish();
+    });
+    const writeReport = ()=>publish('write-report', reportDir, async ()=>{
+            if (!plan.reportEnabled) return;
+            const reportPath = await new TestRunReportAssembler().assembleAsync({
+                outputDir: reportDir,
+                outputFormat: plan.definition.output.reportFormat,
+                reportFileName: `midscene-e2e-${runId}`,
+                overwrite: false,
+                sources: [
+                    ...collectTestRunReportSources(completedResult),
+                    ...extraSources.map((source)=>({
+                            ...source,
+                            scopeId: runId
+                        }))
+                ],
+                buildRunnerDump: (index)=>{
+                    reportIndex = index;
+                    const dump = buildTestRunReportDump(completedResult, index);
+                    completedResult = {
+                        ...completedResult,
+                        metrics: dump.metrics
+                    };
+                    const warn = getDebug('test-runner:report-assembler', {
+                        console: true
+                    });
+                    for (const diagnostic of dump.diagnostics ?? [])warn(diagnostic.message);
+                    return dump;
+                }
+            });
+            completedResult = {
+                ...completedResult,
+                reportPath
+            };
+        });
+    await writeReport();
+    for (const publication of plan.publications)await publish(publication.operation, publication.path, async ()=>{
+        await publication.publish(completedResult);
+    });
+    await publish('write-result', join(dirname(summaryPath), 'result.md'), async ()=>{
+        if (!completedResult.metrics) {
+            const dump = buildTestRunReportDump(completedResult, reportIndex ?? {
+                sources: [],
+                metrics: sumTestRunReportMetrics([])
+            });
+            completedResult = {
+                ...completedResult,
+                metrics: dump.metrics
+            };
+        }
+        const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
+        completedResult = {
+            ...completedResult,
+            markdownPath
+        };
+    });
+    if (completedResult.reportPath && !hasInfrastructureError) await publish('write-result', reports.directory, ()=>reports.prune());
+    await writeSummary();
+    if (hasInfrastructureError) throw new WorkflowExecutionFailure(completedResult, infrastructureErrors);
+    return completedResult;
+}
+export { CliModelUsage, DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineFileSetup, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, fileURLToPath, formatModelUsage, inspect, loadTestProject, prepareTestRun, runPreparedTestProject, stripVTControlCharacters, validateTestFileSelection };
+
+//# sourceMappingURL=299.mjs.map