@midscene/test 1.17.8-beta-20261106101231.0 → 1.17.8

package/dist/es/cli/index.mjs

@@ -1,2201 +1,8 @@
-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, 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";
-import { JSON_SCHEMA, load } from "js-yaml";
-import { mkdir, writeFile } from "node:fs/promises";
-import { resolveMidsceneRunDir, runWithMidsceneRunDir } from "@midscene/shared/common";
-import { setMaxListeners } from "node:events";
-import { ReportSession, TestRunReportAssembler, calculateTestRunHealth } from "@midscene/core/report";
-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;
-        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 registry_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 registry_NodeRegistry(candidate.nodes);
-        const nodes = new registry_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. Pass the Test Project directory to midscene-test 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 registry_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 createCaseInvocationId = (projectId, sourcePath, caseIndex, invocationIndex = 0)=>createHash('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath,
-        caseIndex,
-        ...invocationIndex ? [
-            invocationIndex
-        ] : []
-    ])).digest('hex');
-const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=>createHash('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath,
-        ...invocationIndex ? [
-            invocationIndex
-        ] : []
-    ])).digest('hex');
-const normalize_normalizeSteps = normalizeSteps;
-function parseWorkflowSource(source) {
-    const stack = [];
-    const nodes = [];
-    const sensitiveNodes = new Set();
-    const sensitiveValues = new Set();
-    const redactedPaths = new Set();
-    const sourceOffset = 0xfeff === source.charCodeAt(0) ? 1 : 0;
-    const parsed = load(source, {
-        schema: JSON_SCHEMA,
-        listener (event, state) {
-            if ('open' === event) return void stack.push({
-                start: state.position + sourceOffset,
-                end: 0,
-                value: null,
-                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;
-            for(let index = 0; index < node.children.length; index += 2){
-                const key = node.children[index].value;
-                const value = node.children[index + 1];
-                if ('string' == typeof key && isReportSecretKey(key) && value) {
-                    sensitiveNodes.add(value);
-                    if (null !== value.value) sensitiveValues.add(value.value);
-                    redactedPaths.add(`$..[${JSON.stringify(key)}]`);
-                }
-            }
-        }
-    });
-    const ranges = nodes.filter((node)=>sensitiveNodes.has(node) || sensitiveValues.has(node.value)).sort((left, right)=>left.start - right.start || right.end - left.end);
-    let offset = 0;
-    let redacted = '';
-    for (const range of ranges){
-        if (range.start < offset) continue;
-        const text = source.slice(range.start, range.end);
-        const leading = text.match(/^\s*/)?.[0] ?? '';
-        const trailing = text.slice(leading.length).match(/\s*$/)?.[0] ?? '';
-        redacted += `${source.slice(offset, range.start)}${leading}"[REDACTED]"${trailing}`;
-        offset = range.end;
-    }
-    redacted += source.slice(offset);
-    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 ? {
-                redactedPaths: [
-                    ...redactedPaths
-                ]
-            } : {},
-            ...value !== redacted ? {
-                truncatedPaths: [
-                    '$'
-                ]
-            } : {}
-        }
-    };
-}
-const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
-const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
-const exactProjectExpression = /^\$\{([^{}]+)\}$/;
-const missingVariable = (kind, name, options)=>{
-    throw new WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
-        ...options.location,
-        variable: name,
-        variableKind: kind
-    });
-};
-const projectVariable = (name, options)=>{
-    if (!Object.hasOwn(options.variables ?? {}, name)) return missingVariable('project', name, options);
-    return options.variables[name];
-};
-const environmentVariable = (name, options)=>{
-    const value = options.env?.[name];
-    if (void 0 === value) return missingVariable('environment', name, options);
-    return value;
-};
-const interpolationValue = (name, value, options)=>{
-    if ('object' == typeof value && null !== value) throw new WorkflowParseError(`Project variable "${name}" must be a primitive when embedded in a string.`, {
-        ...options.location,
-        variable: name,
-        variableKind: 'project'
-    });
-    return String(value);
-};
-const resolveString = (value, options)=>{
-    const exactEnv = exactEnvExpression.exec(value);
-    if (exactEnv) return environmentVariable(exactEnv[1], options);
-    const exactProject = exactProjectExpression.exec(value);
-    if (exactProject) return projectVariable(exactProject[1], options);
-    return value.replace(interpolationExpression, (_match, environmentName, projectName)=>environmentName ? environmentVariable(environmentName, options) : interpolationValue(projectName, projectVariable(projectName, options), options));
-};
-const resolveWorkflowVariables = (value, options)=>{
-    if ('string' == typeof value) return resolveString(value, options);
-    if (Array.isArray(value)) return value.map((child)=>resolveWorkflowVariables(child, options));
-    if ('object' == typeof value && null !== value) return Object.fromEntries(Object.entries(value).map(([key, child])=>[
-            key,
-            resolveWorkflowVariables(child, options)
-        ]));
-    return value;
-};
-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;
-}
-const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-class NativeWorkflowFormatError extends WorkflowParseError {
-    constructor(actualFormat, sourcePath){
-        super('legacy' === actualFormat ? `Legacy tasks/flow YAML is not supported by midscene-test: ${sourcePath}. Run it with \`midscene ${sourcePath}\`, or migrate the file to cases/steps.` : 'legacy-batch' === actualFormat ? `Legacy YAML batch configuration is not a midscene-test workflow document: ${sourcePath}. Run it with \`midscene --config ${sourcePath}\`, or migrate it to a native project config.` : `A workflow file cannot mix legacy tasks/flow with native cases/steps or lifecycle hooks: ${sourcePath}. Keep the formats in separate files and run each file with its matching command.`, {
-            sourcePath,
-            actualFormat,
-            expectedFormat: 'native'
-        }), _define_property(this, "actualFormat", void 0);
-        this.actualFormat = actualFormat;
-    }
-}
-const collect_rejectUnknownKeys = (value, allowed, label)=>{
-    const allowedSet = new Set(allowed);
-    const unknown = Object.keys(value).filter((key)=>!allowedSet.has(key));
-    if (unknown.length) throw new WorkflowParseError(`${label} has unsupported field "${unknown[0]}".`, {
-        field: unknown[0]
-    });
-};
-const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
-const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
-function collectWorkflowDocument(source, options) {
-    let snapshot;
-    try {
-        snapshot = parseWorkflowSource(readFileSync(source.absolutePath, 'utf8'));
-    } catch (error) {
-        throw new WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
-            sourcePath: source.sourcePath
-        }, error);
-    }
-    const { parsed, sourceYaml } = snapshot;
-    if (!isMapping(parsed)) throw new WorkflowParseError('Workflow document must be a mapping.');
-    const format = classifyWorkflowDocumentFormat(parsed);
-    if ('legacy' === format || 'legacy-batch' === format || 'mixed' === format) throw new NativeWorkflowFormatError(format, source.sourcePath);
-    collect_rejectUnknownKeys(parsed, [
-        'beforeAll',
-        'beforeEach',
-        'cases',
-        'afterEach',
-        'afterAll'
-    ], 'Workflow document');
-    if (!Array.isArray(parsed.cases) || 0 === parsed.cases.length) throw new WorkflowParseError('Workflow document must contain a non-empty cases array.');
-    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,
-                env: options.env ?? process.env,
-                location: {
-                    projectName: source.projectName ?? source.projectId,
-                    sourcePath,
-                    phase,
-                    stepIndex,
-                    ...void 0 === caseIndex ? {} : {
-                        caseIndex
-                    }
-                }
-            })
-        });
-    const normalizeLifecycle = (phase)=>{
-        const value = parsed[phase];
-        if (void 0 === value) return [];
-        if (!Array.isArray(value)) throw new WorkflowParseError(`Workflow document ${phase} must be an array.`, {
-            phase
-        });
-        return normalize_normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
-            const resolved = options.resolveNode(normalized.node);
-            if (!resolved) throw new WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
-                phase,
-                stepIndex,
-                node: normalized.node
-            });
-            return resolveStepVariables(normalized, phase, stepIndex);
-        });
-    };
-    const lifecycle = {
-        beforeAll: normalizeLifecycle('beforeAll'),
-        beforeEach: normalizeLifecycle('beforeEach'),
-        afterEach: normalizeLifecycle('afterEach'),
-        afterAll: normalizeLifecycle('afterAll')
-    };
-    const ids = new Set();
-    const cases = parsed.cases.map((definition, caseIndex)=>{
-        if (!isMapping(definition)) throw new WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
-            caseIndex
-        });
-        collect_rejectUnknownKeys(definition, [
-            'name',
-            'tags',
-            'steps'
-        ], `Case ${caseIndex + 1}`);
-        if ('string' != typeof definition.name || 0 === definition.name.trim().length) throw new WorkflowParseError(`Case ${caseIndex + 1} name must be a non-empty string.`, {
-            caseIndex
-        });
-        if (!Array.isArray(definition.steps) || 0 === definition.steps.length) throw new WorkflowParseError(`Case ${caseIndex + 1} steps must be a non-empty array.`, {
-            caseIndex
-        });
-        const tags = definition.tags ?? [];
-        if (!Array.isArray(tags) || tags.some((tag)=>'string' != typeof tag || 0 === tag.trim().length)) throw new WorkflowParseError(`Case ${caseIndex + 1} tags must be an array of non-empty strings.`, {
-            caseIndex
-        });
-        const steps = normalize_normalizeSteps(definition.steps, options.resolveNode).map((normalized, stepIndex)=>{
-            if (!options.resolveNode(normalized.node)) throw new WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
-                caseIndex,
-                stepIndex,
-                node: normalized.node
-            });
-            return resolveStepVariables(normalized, 'steps', stepIndex, caseIndex);
-        });
-        const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
-        if (ids.has(caseId)) throw new WorkflowParseError(`Case id collision: ${caseId}.`, {
-            caseId
-        });
-        ids.add(caseId);
-        return {
-            caseId,
-            projectId: source.projectId,
-            sourcePath,
-            caseIndex,
-            definition: {
-                name: definition.name,
-                tags: tags,
-                steps
-            }
-        };
-    });
-    return {
-        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
-        projectId: source.projectId,
-        sourcePath,
-        sourceYaml,
-        lifecycle,
-        cases
-    };
-}
-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 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 mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection, options.excludedDirectories);
-    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) {
-        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 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;
-    if (cliProjectRoot) assertDirectory(cliProjectRoot, 'Test project directory');
-    const projectRoot = cliProjectRoot ?? cwd;
-    return {
-        cwd,
-        projectRoot,
-        configSearchRoot: projectRoot,
-        ...singleFile ? {
-            singleFile
-        } : {}
-    };
-};
-async function prepareTestRun(options) {
-    const startedAt = new Date();
-    const runId = createTestRunId(startedAt);
-    const input = resolveRunInput(options);
-    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 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, {
-            ...input.singleFile ? {
-                files: [
-                    input.singleFile
-                ]
-            } : {},
-            excludedDirectories: [
-                artifactDir,
-                resultDir,
-                reportDir,
-                ...[
-                    'cache',
-                    'log',
-                    'output',
-                    'tmp',
-                    'dump'
-                ].map((name)=>join(artifactDir, name))
-            ]
-        }));
-        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 renderTestBadgeLines({ status, summary }) {
-    if ('success' !== status && 0 === summary.failed) return [];
-    return [
-        `![Midscene Test: ${summary.passed} passed, ${summary.failed} failed](https://badge.midscenejs.com/e2e?pass=${summary.passed}&fail=${summary.failed}&style=large)`,
-        ''
-    ];
-}
-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, ' ');
-const duration = (ms)=>{
-    const seconds = Math.round(ms / 1000);
-    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-};
-const href = (from, target)=>relative(dirname(from), target).split(sep).map(encodeURIComponent).join('/');
-function renderTestResultMarkdown(dump, options = {}) {
-    const { summary } = dump;
-    const outcome = 'success' === dump.status ? `✅ **${summary.passed}/${summary.total} passed**` : `❌ **${summary.failed} failed** · ${summary.passed} passed · ${summary.notRun} not run`;
-    const lines = [
-        '## Midscene Test',
-        '',
-        ...renderTestBadgeLines(dump),
-        `${outcome} · ${duration(dump.durationMs)}`,
-        ''
-    ];
-    if (summary.filtered) lines.push(`**Filtered:** ${summary.filtered}`, '');
-    const infrastructure = [
-        summary.collectionErrors ? `${summary.collectionErrors} collection errors` : '',
-        summary.documentFailures ? `${summary.documentFailures} document failures` : '',
-        summary.projectFailures ? `${summary.projectFailures} project failures` : ''
-    ].filter(Boolean);
-    if (infrastructure.length) lines.push(`**Infrastructure:** ${infrastructure.join(' · ')}`, '');
-    const groups = [];
-    const errors = [];
-    const recordSteps = (label, steps)=>{
-        for (const step of steps)if ('failed' === step.status) errors.push(`${label} / ${step.node}: ${step.error?.message ?? 'Step failed'}`);
-    };
-    for (const project of dump.projects){
-        if (project.lifecycle?.setupError) errors.push(`${project.name}: ${project.lifecycle.setupError.message}`);
-        for (const error of project.lifecycle?.teardownErrors ?? [])errors.push(`${project.name}: ${error.message}`);
-        for (const error of project.collectionErrors)errors.push(`${project.name} / ${error.sourcePath}: ${error.error.message}`);
-        for (const document of project.documents){
-            const name = document.sourcePath.replace(/\\/g, '/').replace(/\.(?:yaml|yml)$/, '');
-            const group = {
-                name: dump.projects.length > 1 ? `${project.name} / ${name}` : name,
-                rows: []
-            };
-            groups.push(group);
-            recordSteps(`${project.name} / ${document.sourcePath}`, [
-                ...document.beforeAll,
-                ...document.afterAll
-            ]);
-            for (const error of document.teardownErrors ?? [])errors.push(`${document.sourcePath}: ${error.message}`);
-            for (const failure of document.hostErrors ?? [])errors.push(`${document.sourcePath} / ${failure.phase}: ${failure.error.message}`);
-            for (const testCase of document.cases)group.rows.push(`  - ${'success' === testCase.status ? '✅' : 'not-run' === testCase.status ? '⏭️' : '❌'} ${result_markdown_text(testCase.name)}`);
-        }
-    }
-    for (const diagnostic of dump.diagnostics ?? [])if ('error' === diagnostic.level) errors.push(diagnostic.message);
-    if (errors.length) lines.push('### Execution errors', '', ...errors.map((error)=>`- ${result_markdown_text(error)}`), '');
-    for (const group of groups)if (group.rows.length) lines.push(`- ${result_markdown_text(group.name)}`, ...group.rows);
-    if (!groups.some((group)=>group.rows.length)) lines.push('No cases were reported.');
-    if (options.reportHref) lines.push('', `[Open the Midscene Test report ↗](<${options.reportHref}>)`);
-    return `${lines.join('\n')}\n`;
-}
-const emptyIndex = ()=>({
-        sources: [],
-        metrics: {
-            modelCallCount: 0,
-            modelTimeMs: 0,
-            promptTokens: 0,
-            cachedInputTokens: 0,
-            completionTokens: 0,
-            totalTokens: 0
-        }
-    });
-async function writeTestResultMarkdown(result, index = emptyIndex()) {
-    const output = join(dirname(result.summaryPath), 'result.md');
-    const dump = buildTestRunReportDump(result, index);
-    await writeFile(output, renderTestResultMarkdown(dump, {
-        ...result.reportPath ? {
-            reportHref: href(output, result.reportPath)
-        } : {}
-    }));
-    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);
-    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 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, '', {
-        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: test_runner_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;
-}
+import { prepareTestRun, runPreparedTestProject } from "../299.mjs";
 async function runTestProject(options = {}) {
     return runPreparedTestProject(await prepareTestRun(options));
 }
-export { DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineFileSetup, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, loadTestProject, runTestProject, validateTestFileSelection };
+export { DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineFileSetup, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, loadTestProject, validateTestFileSelection } from "../299.mjs";
+export { runTestProject };
 
 //# sourceMappingURL=index.mjs.map