@midscene/test 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/lib/test-cli.js

@@ -14,6 +14,11 @@ var __webpack_modules__ = {
     },
     "yargs/yargs" (module) {
         module.exports = require("yargs/yargs");
+    },
+    "./package.json" (module) {
+        module.exports = {
+            rE: "1.13.0"
+        };
     }
 };
 var __webpack_module_cache__ = {};
@@ -75,6 +80,7 @@ var __webpack_exports__ = {};
 (()=>{
     var external_node_fs_ = __webpack_require__("node:fs");
     var external_node_path_ = __webpack_require__("node:path");
+    var package_0 = __webpack_require__("./package.json");
     const v4_namespaceObject = require("zod/v4");
     const GENERATED_COMMENT = '<!-- Generated by `midscene-test nodes`. Do not edit directly. -->';
     const sortNodesForReference = (nodes)=>{
@@ -127,7 +133,9 @@ cases:
             continue-on-error: false
 \`\`\`
 
-A Node may map a string step value to one declared input field. Each Node section states whether it supports this shorthand and names the target field.`;
+A Node may map a string step value to one declared input field. Each Node section states whether it supports this shorthand and names the target field.
+
+Each Node's returned \`data\` is saved on that Step's result. Results are not named or automatically passed to later Steps. A failed Case does not stop later Cases by default; \`test.bail\` controls early stopping across the run.`;
     const sortJsonValue = (value)=>{
         if (Array.isArray(value)) return value.map(sortJsonValue);
         if ('object' != typeof value || null === value) return value;
@@ -208,275 +216,8 @@ A Node may map a string step value to one declared input field. Each Node sectio
     const external_node_url_namespaceObject = require("node:url");
     const api_namespaceObject = require("tsx/cjs/api");
     const esm_api_namespaceObject = require("tsx/esm/api");
-    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;
-    }
-    class WorkflowError extends Error {
-        toJSON() {
-            return {
-                name: this.name,
-                message: this.message,
-                code: this.code,
-                ...void 0 === this.details ? {} : {
-                    details: this.details
-                }
-            };
-        }
-        constructor(message, options = {}){
-            super(message, {
-                cause: options.cause
-            }), _define_property(this, "code", void 0), _define_property(this, "details", void 0);
-            this.name = new.target.name;
-            this.code = options.code ?? 'WORKFLOW_ERROR';
-            this.details = options.details;
-        }
-    }
-    class WorkflowParseError extends WorkflowError {
-        constructor(message, details, cause){
-            super(message, {
-                code: 'WORKFLOW_PARSE_ERROR',
-                details,
-                cause
-            });
-        }
-    }
-    class NodeDefinitionError extends WorkflowError {
-        constructor(message, details){
-            super(message, {
-                code: 'NODE_DEFINITION_ERROR',
-                details
-            });
-        }
-    }
-    class DuplicateNodeError extends WorkflowError {
-        constructor(node){
-            super(`Node "${node}" is already registered.`, {
-                code: 'DUPLICATE_NODE',
-                details: {
-                    node
-                }
-            }), _define_property(this, "node", void 0);
-            this.node = node;
-        }
-    }
-    class NodeNotFoundError extends WorkflowError {
-        constructor(node){
-            super(`Node "${node}" is not registered.`, {
-                code: 'NODE_NOT_FOUND',
-                details: {
-                    node
-                }
-            }), _define_property(this, "node", void 0);
-            this.node = node;
-        }
-    }
-    class NodeInputValidationError extends WorkflowError {
-        static fromZod(node, error) {
-            const issues = error.issues.map((issue)=>({
-                    code: issue.code,
-                    path: issue.path.map(String).join('.'),
-                    message: issue.message
-                }));
-            const firstIssue = issues[0];
-            const path = firstIssue?.path || '<root>';
-            const message = firstIssue?.message ?? 'invalid input';
-            return new NodeInputValidationError(`Node "${node}" input validation failed at "${path}": ${message}`, {
-                node,
-                issues
-            });
-        }
-        constructor(message, details){
-            super(message, {
-                code: 'NODE_INPUT_VALIDATION_ERROR',
-                details
-            });
-        }
-    }
-    class StepTimeoutError extends WorkflowError {
-        constructor(timeoutMs, node){
-            super(node ? `Node "${node}" timed out after ${timeoutMs}ms.` : `Step timed out after ${timeoutMs}ms.`, {
-                code: 'STEP_TIMEOUT',
-                details: {
-                    timeoutMs,
-                    ...void 0 === node ? {} : {
-                        node
-                    }
-                }
-            }), _define_property(this, "timeoutMs", void 0), _define_property(this, "node", void 0);
-            this.timeoutMs = timeoutMs;
-            this.node = node;
-        }
-    }
-    class NodeExecutionError extends WorkflowError {
-        constructor(node, cause){
-            const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-            super(`Node "${node}" failed: ${causeMessage}`, {
-                code: 'NODE_EXECUTION_ERROR',
-                details: {
-                    node
-                },
-                cause
-            }), _define_property(this, "node", void 0);
-            this.node = node;
-        }
-    }
-    class WorkflowLifecycleError extends WorkflowError {
-        constructor(message, details){
-            super(message, {
-                code: 'WORKFLOW_LIFECYCLE_ERROR',
-                details
-            });
-        }
-    }
-    class ProjectSetupError extends WorkflowError {
-        constructor(cause, details){
-            const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-            super(`Project "${details.projectName}" setup failed: ${causeMessage}`, {
-                code: 'PROJECT_SETUP_ERROR',
-                details,
-                cause
-            });
-        }
-    }
-    class ProjectTeardownError extends WorkflowError {
-        constructor(cause, details){
-            const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-            super(`Project "${details.projectName}" teardown failed: ${causeMessage}`, {
-                code: 'PROJECT_TEARDOWN_ERROR',
-                details,
-                cause
-            });
-        }
-    }
-    class NodeScopeTeardownError extends WorkflowError {
-        constructor(cause, details){
-            const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-            super(`${'case' === details.scope ? 'Case attempt' : 'Workflow document'} node teardown failed for "${details.node}": ${causeMessage}`, {
-                code: 'NODE_SCOPE_TEARDOWN_ERROR',
-                details,
-                cause
-            });
-        }
-    }
-    class FatalDeviceError extends WorkflowError {
-        constructor(message, cause){
-            super(message, {
-                code: 'FATAL_DEVICE_ERROR',
-                cause
-            });
-        }
-    }
-    const isFatalDeviceError = (error)=>{
-        if (error instanceof FatalDeviceError) return true;
-        if (error instanceof WorkflowError && 'FATAL_DEVICE_ERROR' === error.code) return true;
-        if (error instanceof Error && /device offline|device not found|(?:adb|bdc|device) connection (?:was )?closed/i.test(error.message)) return true;
-        return error instanceof Error && void 0 !== error.cause ? isFatalDeviceError(error.cause) : false;
-    };
-    function normalizeNodeExecutionError(error, node) {
-        return error instanceof WorkflowError ? error : new NodeExecutionError(node, error);
-    }
-    const validateOptionalText = (value, field, node)=>{
-        if (void 0 !== value && ('string' != typeof value || 0 === value.trim().length)) throw new NodeDefinitionError(`Node "${node}" ${field} must be a non-empty string.`, {
-            node,
-            field
-        });
-    };
-    const validateInputSchema = (schema, node)=>{
-        if (void 0 === schema) return;
-        if (!(schema instanceof v4_namespaceObject.z.ZodObject)) throw new NodeDefinitionError(`Node "${node}" inputSchema must be a Zod object schema.`, {
-            node,
-            field: 'inputSchema'
-        });
-        if ('$' in schema.shape) throw new NodeDefinitionError(`Node "${node}" inputSchema must not declare "$" as an input property.`, {
-            node,
-            field: 'inputSchema.$'
-        });
-    };
-    const validateDefinition = (options)=>{
-        if (!options || 'object' != typeof options) throw new NodeDefinitionError('Node definition must be an object.');
-        if ('string' != typeof options.name || 0 === options.name.trim().length) throw new NodeDefinitionError('Node name must be a non-empty string.');
-        validateOptionalText(options.title, 'title', options.name);
-        validateOptionalText(options.description, "description", options.name);
-        if (void 0 !== options.stringInputKey && false !== options.stringInputKey && ('string' != typeof options.stringInputKey || 0 === options.stringInputKey.trim().length)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must be a non-empty string or false.`, {
-            node: options.name,
-            field: 'stringInputKey'
-        });
-        validateInputSchema(options.inputSchema, options.name);
-        if ('string' == typeof options.stringInputKey && options.inputSchema instanceof v4_namespaceObject.z.ZodObject && !(options.stringInputKey in options.inputSchema.shape)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must reference a field in inputSchema.`, {
-            node: options.name,
-            field: 'stringInputKey'
-        });
-        if ('function' != typeof options.execute) throw new NodeDefinitionError(`Node "${options.name}" must provide an execute function.`, {
-            node: options.name
-        });
-    };
-    function defineNode(options) {
-        validateDefinition(options);
-        return options;
-    }
-    function _check_private_redeclaration(obj, privateCollection) {
-        if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
-    }
-    function _class_apply_descriptor_get(receiver, descriptor) {
-        if (descriptor.get) return descriptor.get.call(receiver);
-        return descriptor.value;
-    }
-    function _class_extract_field_descriptor(receiver, privateMap, action) {
-        if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
-        return privateMap.get(receiver);
-    }
-    function _class_private_field_get(receiver, privateMap) {
-        var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-        return _class_apply_descriptor_get(receiver, descriptor);
-    }
-    function _class_private_field_init(obj, privateMap, value) {
-        _check_private_redeclaration(obj, privateMap);
-        privateMap.set(obj, value);
-    }
-    var _nodes = /*#__PURE__*/ new WeakMap();
-    class NodeRegistry {
-        register(node) {
-            defineNode(node);
-            if (_class_private_field_get(this, _nodes).has(node.name)) throw new DuplicateNodeError(node.name);
-            _class_private_field_get(this, _nodes).set(node.name, node);
-            return this;
-        }
-        get(name) {
-            return _class_private_field_get(this, _nodes).get(name);
-        }
-        require(name) {
-            const node = this.get(name);
-            if (!node) throw new NodeNotFoundError(name);
-            return node;
-        }
-        has(name) {
-            return _class_private_field_get(this, _nodes).has(name);
-        }
-        names() {
-            return [
-                ..._class_private_field_get(this, _nodes).keys()
-            ];
-        }
-        definitions() {
-            return [
-                ..._class_private_field_get(this, _nodes).values()
-            ];
-        }
-        constructor(nodes = []){
-            _class_private_field_init(this, _nodes, {
-                writable: true,
-                value: new Map()
-            });
-            for (const node of nodes)this.register(node);
-        }
-    }
+    const test_runner_namespaceObject = require("@midscene/core/internal/test-runner");
+    const NodeRegistry = test_runner_namespaceObject.NodeRegistry;
     const projectIdFromIndex = (index)=>`project-${index}`;
     const getDefaultExport = (loaded, absolutePath)=>{
         if ('object' == typeof loaded && null !== loaded && 'default' in loaded) {
@@ -511,9 +252,13 @@ A Node may map a string step value to one declared input field. Each Node sectio
             return pattern;
         });
     };
-    const validateTestFileSelection = (value, label = 'files')=>{
+    const test_project_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({
@@ -569,7 +314,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
         assertJsonValue(value, label, new Set());
         return deepFreezeJson(value);
     };
-    const validateProjectSetup = (value, label)=>{
+    const validateSetup = (value, label)=>{
         if (void 0 === value) return;
         if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
         rejectUnknownKeys(value, [
@@ -592,7 +337,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
     };
     const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         if (void 0 === value) {
-            const setup = validateProjectSetup(defaultSetup, 'setup');
+            const setup = validateSetup(defaultSetup, 'setup');
             return {
                 hasExplicitProjects: false,
                 projects: Object.freeze([
@@ -631,7 +376,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
             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`);
+            const files = test_project_validateTestFileSelection(candidate.files, `${label}.files`);
             if (void 0 !== candidate.nodes && !Array.isArray(candidate.nodes)) throw new TypeError(`Midscene config ${label}.nodes must be an array.`);
             const localNodes = new NodeRegistry(candidate.nodes);
             const nodes = new NodeRegistry([
@@ -649,7 +394,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
                 retry: validateNonNegativeInteger(candidate.retry, 0, `${label}.retry`),
                 variables: validateVariables(candidate.variables, `${label}.variables`),
                 ...void 0 === candidate.setup ? {} : {
-                    setup: validateProjectSetup(candidate.setup, `${label}.setup`)
+                    setup: validateSetup(candidate.setup, `${label}.setup`)
                 }
             });
         });
@@ -744,877 +489,151 @@ A Node may map a string step value to one declared input field. Each Node sectio
         }
         return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
     }
-    const external_node_crypto_namespaceObject = require("node:crypto");
-    const external_node_events_namespaceObject = require("node:events");
-    const report_namespaceObject = require("@midscene/core/report");
     const external_tinyglobby_namespaceObject = require("tinyglobby");
-    const createProjectRuntime = (options)=>{
-        const startedAt = new Date();
-        const controller = new AbortController();
-        const parentSignal = options.signal;
-        const abortFromParent = ()=>controller.abort(parentSignal?.reason);
-        if (parentSignal?.aborted) abortFromParent();
-        else parentSignal?.addEventListener('abort', abortFromParent, {
-            once: true
+    const external_js_yaml_namespaceObject = require("js-yaml");
+    const external_node_crypto_namespaceObject = require("node:crypto");
+    const createCaseInvocationId = (projectId, sourcePath, caseIndex, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
+            projectId,
+            sourcePath,
+            caseIndex,
+            ...invocationIndex ? [
+                invocationIndex
+            ] : []
+        ])).digest('hex');
+    const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
+            projectId,
+            sourcePath,
+            ...invocationIndex ? [
+                invocationIndex
+            ] : []
+        ])).digest('hex');
+    const normalizeSteps = test_runner_namespaceObject.normalizeSteps;
+    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 test_runner_namespaceObject.WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
+            ...options.location,
+            variable: name,
+            variableKind: kind
         });
-        const teardownStack = [];
-        let context;
-        let setupError;
-        let started = false;
-        let acceptingTeardowns = void 0 !== options.setup;
-        let finishedResult;
-        const createResult = (requestedStatus, teardownErrors = [])=>{
-            const endedAt = new Date();
-            return {
-                projectName: options.project.name,
-                status: 'failed' === requestedStatus || setupError || teardownErrors.length > 0 ? 'failed' : 'success',
-                ...setupError ? {
-                    setupError
-                } : {},
-                ...teardownErrors.length > 0 ? {
-                    teardownErrors
-                } : {},
-                startedAt: startedAt.toISOString(),
-                endedAt: endedAt.toISOString(),
-                durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-            };
-        };
-        const onTeardown = (teardown)=>{
-            if (!acceptingTeardowns) throw new WorkflowLifecycleError('onTeardown() can only be called while Project setup is running.', {
-                projectName: options.project.name
-            });
-            if ('function' != typeof teardown) throw new WorkflowLifecycleError('Project onTeardown() requires a teardown function.', {
-                projectName: options.project.name
-            });
-            teardownStack.push({
-                registrationIndex: teardownStack.length,
-                teardown
-            });
-        };
-        return {
-            get context () {
-                return context;
-            },
-            get signal () {
-                return controller.signal;
-            },
-            get canRun () {
-                return started && !setupError && !controller.signal.aborted;
-            },
-            async start () {
-                if (started) throw new WorkflowLifecycleError('Project runtime has already started.', {
-                    projectName: options.project.name
-                });
-                started = true;
-                if (controller.signal.aborted) {
-                    acceptingTeardowns = false;
-                    return createResult('failed');
-                }
-                if (options.setup) try {
-                    context = await options.setup.setup({
-                        project: options.project,
-                        env: Object.freeze({
-                            ...process.env
-                        }),
-                        signal: controller.signal,
-                        onTeardown
-                    });
-                } catch (error) {
-                    setupError = new ProjectSetupError(error, {
-                        projectName: options.project.name
-                    });
-                } finally{
-                    acceptingTeardowns = false;
-                }
-                return createResult(setupError ? 'failed' : 'success');
-            },
-            async finish (requestedStatus = 'success') {
-                if (finishedResult) return finishedResult;
-                if (!started) throw new WorkflowLifecycleError('Project runtime must start before it can finish.', {
-                    projectName: options.project.name
-                });
-                const statusBeforeTeardown = createResult(requestedStatus).status;
-                const teardownErrors = [];
-                for (const { registrationIndex, teardown } of teardownStack.reverse())try {
-                    await teardown({
-                        project: options.project,
-                        context,
-                        status: statusBeforeTeardown,
-                        ...setupError ? {
-                            setupError
-                        } : {}
-                    });
-                } catch (error) {
-                    teardownErrors.push(new ProjectTeardownError(error, {
-                        projectName: options.project.name,
-                        registrationIndex
-                    }));
-                }
-                parentSignal?.removeEventListener('abort', abortFromParent);
-                finishedResult = createResult(requestedStatus, teardownErrors);
-                return finishedResult;
-            },
-            abort (reason) {
-                controller.abort(reason);
-            }
-        };
     };
-    const assertJsonSerializable = (value, label, node)=>{
-        const visit = (candidate, path, seen)=>{
-            if (null === candidate || 'string' == typeof candidate || 'boolean' == typeof candidate) return;
-            if ('number' == typeof candidate) {
-                if (Number.isFinite(candidate)) return;
-                throw new TypeError(`${path} contains a non-finite number.`);
-            }
-            if (void 0 === candidate) throw new TypeError(`${path} contains undefined.`);
-            if ('object' != typeof candidate) throw new TypeError(`${path} is not JSON-serializable.`);
-            if (!Array.isArray(candidate) && Object.getPrototypeOf(candidate) !== Object.prototype && null !== Object.getPrototypeOf(candidate)) throw new TypeError(`${path} must contain only plain objects.`);
-            if (seen.has(candidate)) throw new TypeError(`${path} contains a cycle.`);
-            seen.add(candidate);
-            if (Array.isArray(candidate)) candidate.forEach((child, index)=>visit(child, `${path}[${index}]`, seen));
-            else for (const [key, child] of Object.entries(candidate))visit(child, `${path}.${key}`, seen);
-            seen.delete(candidate);
-        };
-        try {
-            visit(value, label, new Set());
-        } catch (error) {
-            throw new NodeExecutionError(node, error);
-        }
+    const projectVariable = (name, options)=>{
+        if (!Object.hasOwn(options.variables ?? {}, name)) return missingVariable('project', name, options);
+        return options.variables[name];
     };
-    function validateNodeOutput(output, node) {
-        if (void 0 === output) return;
-        if ('object' != typeof output || null === output || Array.isArray(output)) throw new NodeExecutionError(node, new TypeError('Node output must be an object or undefined.'));
-        if ('summary' in output && void 0 !== output.summary && 'string' != typeof output.summary) throw new NodeExecutionError(node, new TypeError('Node output summary must be a string.'));
-        if ('data' in output && void 0 !== output.data) assertJsonSerializable(output.data, 'output.data', node);
-        return output;
-    }
-    function createStepResultBase(step, startedAt, phase, stepIndex) {
-        const endedAt = new Date();
-        return {
-            node: step.node,
-            phase,
-            stepIndex,
-            input: step.input,
-            meta: step.meta,
-            startedAt: startedAt.toISOString(),
-            endedAt: endedAt.toISOString(),
-            durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-        };
-    }
-    async function executeNode(step, execute, phase, stepIndex, options) {
-        const startedAt = new Date();
-        const abortController = new AbortController();
-        const parentSignal = options.parentSignal;
-        const abortFromParent = ()=>abortController.abort(parentSignal?.reason);
-        if (parentSignal?.aborted) abortFromParent();
-        else parentSignal?.addEventListener('abort', abortFromParent, {
-            once: true
-        });
-        const timeoutMs = step.meta.timeoutMs ?? options.defaultTimeoutMs;
-        let timeout;
-        let abortGraceTimeout;
-        const execution = Promise.resolve().then(()=>{
-            abortController.signal.throwIfAborted();
-            return execute(abortController.signal);
+    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 test_runner_namespaceObject.WorkflowParseError(`Project variable "${name}" must be a primitive when embedded in a string.`, {
+            ...options.location,
+            variable: name,
+            variableKind: 'project'
         });
-        let settleOnAbort;
-        const abortedExecution = new Promise((_, reject)=>{
-            settleOnAbort = ()=>{
-                abortGraceTimeout = setTimeout(()=>{
-                    reject(abortController.signal.reason);
-                }, 0);
-            };
-            if (abortController.signal.aborted) settleOnAbort();
-            else abortController.signal.addEventListener('abort', settleOnAbort, {
-                once: true
-            });
+        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
         });
-        const timeoutExecution = void 0 === timeoutMs ? void 0 : new Promise((_, reject)=>{
-            timeout = setTimeout(()=>{
-                if (abortController.signal.aborted) return void reject(abortController.signal.reason);
-                const timeoutError = new StepTimeoutError(timeoutMs, step.node);
-                abortController.abort(timeoutError);
-                reject(timeoutError);
-            }, timeoutMs);
+        else obj[key] = value;
+        return obj;
+    }
+    const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+    class NativeWorkflowFormatError extends test_runner_namespaceObject.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 test_runner_namespaceObject.WorkflowParseError(`${label} has unsupported field "${unknown[0]}".`, {
+            field: unknown[0]
         });
-        const settledExecution = Promise.race([
-            execution,
-            abortedExecution,
-            ...void 0 === timeoutExecution ? [] : [
-                timeoutExecution
-            ]
-        ]);
+    };
+    const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
+    const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
+    function collectWorkflowDocument(source, options) {
+        let parsed;
         try {
-            const output = validateNodeOutput(await settledExecution, step.node);
-            return {
-                ...createStepResultBase(step, startedAt, phase, stepIndex),
-                status: 'success',
-                continuedAfterError: false,
-                ...void 0 === output ? {} : {
-                    output
-                }
-            };
+            parsed = (0, external_js_yaml_namespaceObject.load)((0, external_node_fs_.readFileSync)(source.absolutePath, 'utf8'), {
+                schema: external_js_yaml_namespaceObject.JSON_SCHEMA
+            });
         } catch (error) {
-            return {
-                ...createStepResultBase(step, startedAt, phase, stepIndex),
-                status: 'failed',
-                continuedAfterError: step.meta.continueOnError,
-                error: normalizeNodeExecutionError(error, step.node)
-            };
-        } finally{
-            if (void 0 !== timeout) clearTimeout(timeout);
-            if (void 0 !== abortGraceTimeout) clearTimeout(abortGraceTimeout);
-            if (void 0 !== settleOnAbort) abortController.signal.removeEventListener('abort', settleOnAbort);
-            parentSignal?.removeEventListener('abort', abortFromParent);
+            throw new test_runner_namespaceObject.WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
+                sourcePath: source.sourcePath
+            }, error);
         }
-    }
-    function createNodeReportCollector(node) {
-        const traces = new Map();
-        let accepting = true;
-        return {
-            collector: Object.freeze({
-                addTrace (trace) {
-                    if (!accepting) throw new NodeExecutionError(node, new Error('Report traces can only be added while the current Step is running.'));
-                    if (!trace || 'object' != typeof trace || 'midscene-execution' !== trace.type) throw new NodeExecutionError(node, new TypeError('Report trace type must be "midscene-execution".'));
-                    if ('string' != typeof trace.executionId || 0 === trace.executionId.trim().length) throw new NodeExecutionError(node, new TypeError('Report trace executionId must be non-empty.'));
-                    const normalized = Object.freeze({
-                        type: 'midscene-execution',
-                        executionId: trace.executionId
-                    });
-                    traces.set(`${normalized.type}:${normalized.executionId}`, normalized);
-                }
-            }),
-            close () {
-                accepting = false;
-                return Object.freeze([
-                    ...traces.values()
-                ]);
-            }
-        };
-    }
-    async function parseNodeInput(node, input) {
-        if (!node.inputSchema) return input;
-        const parsed = await node.inputSchema.safeParseAsync(input);
-        if (!parsed.success) throw NodeInputValidationError.fromZod(node.name, parsed.error);
-        return parsed.data;
-    }
-    async function executeStep(step, node, target, context, execution = {}) {
-        const phase = 'case' === target.scope ? target.case.phase : target.document.phase;
-        const stepIndex = 'case' === target.scope ? target.case.stepIndex : target.document.stepIndex;
-        const reportCollector = createNodeReportCollector(step.node);
-        let result;
-        try {
-            result = await executeNode(step, async (signal)=>{
-                const input = await parseNodeInput(node, step.input);
-                signal.throwIfAborted();
-                const common = {
-                    input,
-                    $: step.meta,
-                    signal,
-                    context,
-                    report: reportCollector.collector,
-                    onTeardown: (teardown)=>{
-                        if (!execution.onTeardown) throw new NodeExecutionError(step.node, new Error('The current execution scope cannot register teardown.'));
-                        execution.onTeardown(step.node, teardown);
+        if (!isMapping(parsed)) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must be a mapping.');
+        const format = (0, test_runner_namespaceObject.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 test_runner_namespaceObject.WorkflowParseError('Workflow document must contain a non-empty cases array.');
+        const sourcePath = source.sourcePath.split(external_node_path_.sep).join('/');
+        const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
+                ...step,
+                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
+                        }
                     }
-                };
-                return 'case' === target.scope ? node.execute({
-                    ...common,
-                    scope: 'case',
-                    case: target.case
-                }) : node.execute({
-                    ...common,
-                    scope: 'document',
-                    document: target.document
+                })
+            });
+        const normalizeLifecycle = (phase)=>{
+            const value = parsed[phase];
+            if (void 0 === value) return [];
+            if (!Array.isArray(value)) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} must be an array.`, {
+                phase
+            });
+            return normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
+                const resolved = options.resolveNode(normalized.node);
+                if (!resolved) throw new test_runner_namespaceObject.WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
+                    phase,
+                    stepIndex,
+                    node: normalized.node
                 });
-            }, phase, stepIndex, {
-                parentSignal: execution.signal,
-                defaultTimeoutMs: execution.defaultTimeoutMs
-            });
-        } finally{
-            const traces = reportCollector.close();
-            if (traces.length > 0 && result) result = {
-                ...result,
-                report: {
-                    traces
-                }
-            };
-        }
-        if (!result) throw new NodeExecutionError(step.node, new Error('Step execution completed without a result.'));
-        return result;
-    }
-    const reportPathsFromTeardown = (result)=>{
-        if (void 0 === result) return [];
-        if ('object' != typeof result || null === result || Array.isArray(result)) throw new TypeError('Node teardown result must be an object or undefined.');
-        const paths = result.reportPaths;
-        if (void 0 === paths) return [];
-        if (!Array.isArray(paths)) throw new TypeError('Node teardown reportPaths must be an array.');
-        return paths.map((path, index)=>{
-            if ('string' != typeof path || 0 === path.trim().length) throw new TypeError(`Node teardown reportPaths[${index}] must be a non-empty string.`);
-            if (!(0, external_node_path_.isAbsolute)(path)) throw new TypeError(`Node teardown reportPaths[${index}] must be an absolute path.`);
-            return path;
-        });
-    };
-    function createDocumentRuntime(document, options) {
-        const documentRunId = options.createDocumentRunId?.() ?? (0, external_node_crypto_namespaceObject.randomUUID)();
-        const startedAt = new Date();
-        const beforeAll = [];
-        const afterAll = [];
-        const nodes = {
-            beforeAll: document.lifecycle.beforeAll.map((step)=>options.resolveNode(step.node)),
-            afterAll: document.lifecycle.afterAll.map((step)=>options.resolveNode(step.node))
-        };
-        const project = options.project ?? Object.freeze({
-            projectId: document.projectId,
-            name: document.projectId,
-            tags: Object.freeze({
-                include: [],
-                exclude: []
-            }),
-            retry: 0,
-            variables: Object.freeze({})
-        });
-        const context = options.projectContext;
-        const signal = options.signal ?? new AbortController().signal;
-        const nodeTeardownStack = [];
-        let acceptingNodeTeardowns = true;
-        let started = false;
-        let finishedResult;
-        const reportPaths = new Set();
-        const createResult = (teardownErrors = [])=>{
-            const endedAt = new Date();
-            return {
-                documentId: document.documentId,
-                documentRunId,
-                projectId: document.projectId,
-                projectName: project.name,
-                sourcePath: document.sourcePath,
-                status: beforeAll.some((step)=>'failed' === step.status) || afterAll.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
-                startedAt: startedAt.toISOString(),
-                endedAt: endedAt.toISOString(),
-                durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
-                beforeAll: [
-                    ...beforeAll
-                ],
-                afterAll: [
-                    ...afterAll
-                ],
-                ...teardownErrors.length > 0 ? {
-                    teardownErrors
-                } : {},
-                ...reportPaths.size > 0 ? {
-                    reportPaths: [
-                        ...reportPaths
-                    ]
-                } : {}
-            };
-        };
-        const runPhase = async (phase, results, executionSignal = signal)=>{
-            for (const [stepIndex, step] of document.lifecycle[phase].entries()){
-                const documentContext = {
-                    documentId: document.documentId,
-                    documentRunId,
-                    projectId: document.projectId,
-                    projectName: project.name,
-                    sourcePath: document.sourcePath,
-                    phase,
-                    stepIndex
-                };
-                const stepInfo = {
-                    scope: 'document',
-                    node: step.node,
-                    stepCount: document.lifecycle[phase].length,
-                    document: documentContext
-                };
-                await options.onStepStart?.(stepInfo);
-                const result = await executeStep(step, nodes[phase][stepIndex], {
-                    scope: 'document',
-                    document: documentContext
-                }, context, {
-                    signal: executionSignal,
-                    defaultTimeoutMs: options.defaultTimeoutMs,
-                    onTeardown (node, teardown) {
-                        if (!acceptingNodeTeardowns) throw new WorkflowLifecycleError('Node teardown can only be registered while a workflow document is running.', {
-                            documentId: document.documentId,
-                            documentRunId,
-                            node
-                        });
-                        if ('function' != typeof teardown) throw new WorkflowLifecycleError('Node onTeardown() requires a teardown function.', {
-                            documentId: document.documentId,
-                            documentRunId,
-                            node
-                        });
-                        nodeTeardownStack.push({
-                            registrationIndex: nodeTeardownStack.length,
-                            node,
-                            teardown
-                        });
-                    }
-                });
-                await options.onStepResult?.(stepInfo, result);
-                results.push(result);
-                if ('failed' === result.status && !result.continuedAfterError) break;
-            }
-        };
-        return {
-            get context () {
-                return context;
-            },
-            get canRunCases () {
-                return started && !signal.aborted && !beforeAll.some((step)=>'failed' === step.status);
-            },
-            async start () {
-                if (started) throw new WorkflowLifecycleError('Workflow document runtime has already started.', {
-                    documentId: document.documentId,
-                    documentRunId
-                });
-                started = true;
-                if (!signal.aborted) await runPhase('beforeAll', beforeAll);
-                return createResult();
-            },
-            async finish () {
-                if (finishedResult) return finishedResult;
-                if (!started) throw new WorkflowLifecycleError('Workflow document runtime must start before it can finish.', {
-                    documentId: document.documentId,
-                    documentRunId
-                });
-                let finishError;
-                try {
-                    await runPhase('afterAll', afterAll, signal.aborted ? new AbortController().signal : signal);
-                } catch (error) {
-                    finishError = error;
-                }
-                acceptingNodeTeardowns = false;
-                const teardownErrors = [];
-                for (const { registrationIndex, node, teardown } of nodeTeardownStack.reverse())try {
-                    for (const path of reportPathsFromTeardown(await teardown()))reportPaths.add(path);
-                } catch (error) {
-                    teardownErrors.push(new NodeScopeTeardownError(error, {
-                        scope: 'document',
-                        scopeId: documentRunId,
-                        node,
-                        registrationIndex
-                    }));
-                }
-                finishedResult = createResult(teardownErrors);
-                if (finishError) throw finishError;
-                await options.onResult?.(finishedResult);
-                return finishedResult;
-            }
-        };
-    }
-    async function runCollectedCase(collectedCase, options) {
-        const phases = {
-            beforeEach: options.beforeEach ?? [],
-            steps: collectedCase.definition.steps,
-            afterEach: options.afterEach ?? []
-        };
-        const nodes = {
-            beforeEach: phases.beforeEach.map((step)=>options.resolveNode(step.node)),
-            steps: phases.steps.map((step)=>options.resolveNode(step.node)),
-            afterEach: phases.afterEach.map((step)=>options.resolveNode(step.node))
-        };
-        const runId = options.createRunId?.() ?? (0, external_node_crypto_namespaceObject.randomUUID)();
-        const startedAt = new Date();
-        const beforeEach = [];
-        const steps = [];
-        const afterEach = [];
-        const teardownStack = [];
-        let acceptingTeardowns = true;
-        const onTeardown = (node, teardown)=>{
-            if (!acceptingTeardowns) throw new WorkflowLifecycleError('Node teardown can only be registered while a case attempt is running.', {
-                runId,
-                node
-            });
-            if ('function' != typeof teardown) throw new WorkflowLifecycleError('Node onTeardown() requires a teardown function.', {
-                runId,
-                node
-            });
-            teardownStack.push({
-                registrationIndex: teardownStack.length,
-                node,
-                teardown
-            });
-        };
-        const runPhase = async (phase, results, signal = options.signal)=>{
-            for (const [stepIndex, step] of phases[phase].entries()){
-                const caseContext = {
-                    caseId: collectedCase.caseId,
-                    runId,
-                    projectName: options.projectName ?? collectedCase.projectId,
-                    attemptIndex: options.attemptIndex ?? 0,
-                    name: collectedCase.definition.name,
-                    sourcePath: collectedCase.sourcePath,
-                    caseIndex: collectedCase.caseIndex,
-                    phase,
-                    stepIndex
-                };
-                const stepInfo = {
-                    scope: 'case',
-                    node: step.node,
-                    stepCount: phases[phase].length,
-                    case: caseContext
-                };
-                await options.onStepStart?.(stepInfo);
-                const result = await executeStep(step, nodes[phase][stepIndex], {
-                    scope: 'case',
-                    case: caseContext
-                }, options.context, {
-                    signal,
-                    defaultTimeoutMs: options.defaultTimeoutMs,
-                    onTeardown
-                });
-                await options.onStepResult?.(stepInfo, result);
-                results.push(result);
-                if ('failed' === result.status && !result.continuedAfterError) break;
-            }
-        };
-        let executionError;
-        try {
-            await runPhase('beforeEach', beforeEach);
-            if (!beforeEach.some((step)=>'failed' === step.status)) await runPhase('steps', steps);
-        } catch (error) {
-            executionError = error;
-        }
-        try {
-            const cleanupSignal = options.signal?.aborted ? new AbortController().signal : options.signal;
-            await runPhase('afterEach', afterEach, cleanupSignal);
-        } catch (error) {
-            executionError ??= error;
-        }
-        acceptingTeardowns = false;
-        const teardownErrors = [];
-        const reportPaths = new Set();
-        for (const { registrationIndex, node, teardown } of teardownStack.reverse())try {
-            for (const path of reportPathsFromTeardown(await teardown()))reportPaths.add(path);
-        } catch (error) {
-            teardownErrors.push(new NodeScopeTeardownError(error, {
-                scope: 'case',
-                scopeId: runId,
-                node,
-                registrationIndex
-            }));
-        }
-        if (executionError) throw executionError;
-        const endedAt = new Date();
-        const result = {
-            caseId: collectedCase.caseId,
-            runId,
-            projectName: options.projectName ?? collectedCase.projectId,
-            attemptIndex: options.attemptIndex ?? 0,
-            name: collectedCase.definition.name,
-            sourcePath: collectedCase.sourcePath,
-            caseIndex: collectedCase.caseIndex,
-            status: beforeEach.some((step)=>'failed' === step.status) || steps.some((step)=>'failed' === step.status) || afterEach.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
-            beforeEach,
-            steps,
-            afterEach,
-            ...teardownErrors.length > 0 ? {
-                teardownErrors
-            } : {},
-            ...reportPaths.size > 0 ? {
-                reportPaths: [
-                    ...reportPaths
-                ]
-            } : {},
-            startedAt: startedAt.toISOString(),
-            endedAt: endedAt.toISOString(),
-            durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-        };
-        await options.onResult?.(result);
-        return result;
-    }
-    const asNotRun = (collectedCase, projectName, reason)=>({
-            caseId: collectedCase.caseId,
-            projectName,
-            name: collectedCase.definition.name,
-            sourcePath: collectedCase.sourcePath,
-            caseIndex: collectedCase.caseIndex,
-            status: 'not-run',
-            notRunReason: reason
-        });
-    async function runWorkflowDocument(document, options) {
-        const createDocumentRunId = options.createDocumentRunId;
-        const createCaseRunId = options.createCaseRunId;
-        const projectName = options.project?.name ?? document.projectId;
-        const retry = options.retry ?? options.project?.retry ?? 0;
-        if (!Number.isInteger(retry) || retry < 0) throw new TypeError('Workflow document retry must be a non-negative integer.');
-        const runtime = createDocumentRuntime(document, {
-            resolveNode: options.resolveNode,
-            project: options.project,
-            projectContext: options.projectContext,
-            signal: options.signal,
-            defaultTimeoutMs: options.defaultTimeoutMs,
-            onStepStart: options.onStepStart,
-            onStepResult: options.onStepResult,
-            onResult: options.onDocumentResult,
-            createDocumentRunId: createDocumentRunId ? ()=>createDocumentRunId(document) : void 0
-        });
-        const cases = [];
-        let runtimeStarted = false;
-        let documentResult;
-        let executionError;
-        let fatalError = false;
-        try {
-            runtimeStarted = true;
-            await runtime.start();
-            if (runtime.canRunCases) for (const collectedCase of document.cases){
-                if (fatalError || options.shouldStop?.()) {
-                    const outcome = asNotRun(collectedCase, projectName, fatalError ? 'fatal-error' : options.stopReason?.() ?? 'interrupted');
-                    cases.push(outcome);
-                    await options.onCaseOutcome?.(outcome);
-                    continue;
-                }
-                await options.onCaseStart?.(collectedCase);
-                const attempts = [];
-                for(let attemptIndex = 0; attemptIndex <= retry; attemptIndex += 1){
-                    const run = await runCollectedCase(collectedCase, {
-                        resolveNode: options.resolveNode,
-                        beforeEach: document.lifecycle.beforeEach,
-                        afterEach: document.lifecycle.afterEach,
-                        context: runtime.context,
-                        projectName,
-                        attemptIndex,
-                        signal: options.signal,
-                        defaultTimeoutMs: options.defaultTimeoutMs,
-                        onStepStart: options.onStepStart,
-                        onStepResult: options.onStepResult,
-                        onResult: options.onCaseResult,
-                        createRunId: createCaseRunId ? ()=>createCaseRunId(collectedCase, attemptIndex) : void 0
-                    });
-                    attempts.push(run);
-                    fatalError = options.isFatalError?.(run) ?? false;
-                    if ('success' === run.status || fatalError) break;
-                }
-                const run = attempts.at(-1);
-                const outcome = {
-                    caseId: collectedCase.caseId,
-                    projectName,
-                    name: collectedCase.definition.name,
-                    sourcePath: collectedCase.sourcePath,
-                    caseIndex: collectedCase.caseIndex,
-                    status: run.status,
-                    run,
-                    attempts
-                };
-                cases.push(outcome);
-                await options.onCaseOutcome?.(outcome);
-            }
-            else {
-                const reason = options.signal?.aborted ? options.stopReason?.() ?? 'interrupted' : 'document-start-failed';
-                cases.push(...document.cases.map((collectedCase)=>asNotRun(collectedCase, projectName, reason)));
-            }
-        } catch (error) {
-            executionError = error;
-        } finally{
-            if (runtimeStarted) try {
-                documentResult = await runtime.finish();
-            } catch (error) {
-                executionError ??= error;
-            }
-        }
-        if (executionError) throw executionError;
-        if (!documentResult) throw new Error(`Workflow document "${document.sourcePath}" did not produce a result.`);
-        return {
-            document: documentResult,
-            cases
-        };
-    }
-    const external_js_yaml_namespaceObject = require("js-yaml");
-    const supportedMetaKeys = new Set([
-        'timeout',
-        'continue-on-error'
-    ]);
-    function isMapping(value) {
-        return 'object' == typeof value && null !== value && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
-    }
-    function formatStep(index) {
-        return `step ${index + 1}`;
-    }
-    function normalizeMeta(value, index) {
-        if (void 0 === value) return {
-            continueOnError: false
-        };
-        if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} "$" must be a mapping.`, {
-            index
-        });
-        for (const key of Object.keys(value))if (!supportedMetaKeys.has(key)) throw new WorkflowParseError(`${formatStep(index)} has unsupported engine metadata "${key}".`, {
-            index,
-            key
-        });
-        const timeout = value.timeout;
-        if (void 0 !== timeout && ('number' != typeof timeout || !Number.isFinite(timeout) || timeout <= 0)) throw new WorkflowParseError(`${formatStep(index)} "$.timeout" must be a positive number of milliseconds.`, {
-            index,
-            timeout
-        });
-        const continueOnError = value['continue-on-error'];
-        if (void 0 !== continueOnError && 'boolean' != typeof continueOnError) throw new WorkflowParseError(`${formatStep(index)} "$.continue-on-error" must be a boolean.`, {
-            index,
-            continueOnError
-        });
-        return {
-            ...void 0 === timeout ? {} : {
-                timeoutMs: timeout
-            },
-            continueOnError: continueOnError ?? false
-        };
-    }
-    function normalizeStep(value, index = 0, resolveNode) {
-        if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} must be a mapping.`, {
-            index
-        });
-        const entries = Object.entries(value);
-        if (1 !== entries.length) throw new WorkflowParseError(`${formatStep(index)} must contain exactly one node.`, {
-            index,
-            nodes: Object.keys(value)
-        });
-        const [node, rawValue] = entries[0];
-        if (0 === node.trim().length) throw new WorkflowParseError(`${formatStep(index)} node name must not be empty.`, {
-            index
-        });
-        if ('string' == typeof rawValue) {
-            const resolvedNode = resolveNode?.(node);
-            const stringInputKey = resolvedNode ? resolvedNode.stringInputKey : 'prompt';
-            if (false === stringInputKey || void 0 === stringInputKey) throw new WorkflowParseError(`${formatStep(index)} node "${node}" does not accept string shorthand.`, {
-                index,
-                node
-            });
-            return {
-                node,
-                input: {
-                    [stringInputKey]: rawValue
-                },
-                meta: {
-                    continueOnError: false
-                }
-            };
-        }
-        if (!isMapping(rawValue)) throw new WorkflowParseError(`${formatStep(index)} value must be a string shorthand or a mapping.`, {
-            index,
-            node
-        });
-        const { $: rawMeta, ...input } = rawValue;
-        return {
-            node,
-            input,
-            meta: normalizeMeta(rawMeta, index)
-        };
-    }
-    function normalizeSteps(steps, resolveNode) {
-        if (!Array.isArray(steps)) throw new WorkflowParseError('Steps must be an array.');
-        return steps.map((step, index)=>normalizeStep(step, index, resolveNode));
-    }
-    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;
-    };
-    const collect_isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-    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)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
-            projectId,
-            sourcePath,
-            caseIndex
-        ])).digest('hex');
-    const createWorkflowDocumentId = (projectId, sourcePath)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
-            projectId,
-            sourcePath
-        ])).digest('hex');
-    function collectWorkflowDocument(source, options) {
-        let parsed;
-        try {
-            parsed = (0, external_js_yaml_namespaceObject.load)((0, external_node_fs_.readFileSync)(source.absolutePath, 'utf8'), {
-                schema: external_js_yaml_namespaceObject.JSON_SCHEMA
-            });
-        } catch (error) {
-            throw new WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
-                sourcePath: source.sourcePath
-            }, error);
-        }
-        if (!collect_isMapping(parsed)) throw new WorkflowParseError('Workflow document must be a mapping.');
-        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(external_node_path_.sep).join('/');
-        const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
-                ...step,
-                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 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);
+                return resolveStepVariables(normalized, phase, stepIndex);
             });
         };
         const lifecycle = {
@@ -1625,7 +644,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
         };
         const ids = new Set();
         const cases = parsed.cases.map((definition, caseIndex)=>{
-            if (!collect_isMapping(definition)) throw new WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
+            if (!isMapping(definition)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
                 caseIndex
             });
             collect_rejectUnknownKeys(definition, [
@@ -1633,18 +652,18 @@ A Node may map a string step value to one declared input field. Each Node sectio
                 '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.`, {
+            if ('string' != typeof definition.name || 0 === definition.name.trim().length) throw new test_runner_namespaceObject.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.`, {
+            if (!Array.isArray(definition.steps) || 0 === definition.steps.length) throw new test_runner_namespaceObject.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.`, {
+            if (!Array.isArray(tags) || tags.some((tag)=>'string' != typeof tag || 0 === tag.trim().length)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} tags must be an array of non-empty strings.`, {
                 caseIndex
             });
             const steps = 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}".`, {
+                if (!options.resolveNode(normalized.node)) throw new test_runner_namespaceObject.WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                     caseIndex,
                     stepIndex,
                     node: normalized.node
@@ -1652,7 +671,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
                 return resolveStepVariables(normalized, 'steps', stepIndex, caseIndex);
             });
             const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
-            if (ids.has(caseId)) throw new WorkflowParseError(`Case id collision: ${caseId}.`, {
+            if (ids.has(caseId)) throw new test_runner_namespaceObject.WorkflowParseError(`Case id collision: ${caseId}.`, {
                 caseId
             });
             ids.add(caseId);
@@ -1669,435 +688,27 @@ A Node may map a string step value to one declared input field. Each Node sectio
             };
         });
         return {
-            documentId: createWorkflowDocumentId(source.projectId, sourcePath),
-            projectId: source.projectId,
-            sourcePath,
-            lifecycle,
-            cases
-        };
-    }
-    const logger_namespaceObject = require("@midscene/shared/logger");
-    const MAX_DEPTH = 6;
-    const MAX_STRING_LENGTH = 2000;
-    const MAX_ARRAY_ITEMS = 50;
-    const MAX_OBJECT_KEYS = 50;
-    const MAX_SERIALIZED_BYTES = 65536;
-    const TRUNCATED_VALUE = '[Truncated: display value exceeded 64 KiB]';
-    const normalizedSecretKeys = [
-        'password',
-        'passwd',
-        'secret',
-        'token',
-        'authorization',
-        'cookie',
-        'apikey'
-    ];
-    const normalizedKey = (key)=>key.toLowerCase().replace(/[^a-z0-9]/g, '');
-    const isSecretKey = (key)=>{
-        const normalized = normalizedKey(key);
-        return normalizedSecretKeys.some((secret)=>normalized.includes(secret));
-    };
-    const objectPath = (parent, key)=>/^[A-Za-z_$][\w$]*$/.test(key) ? `${parent}.${key}` : `${parent}[${JSON.stringify(key)}]`;
-    const stringByteLength = (value)=>Buffer.byteLength(value, 'utf8');
-    function sanitizeReportText(value, maximumLength = MAX_STRING_LENGTH) {
-        return value.length <= maximumLength ? value : `${value.slice(0, maximumLength)}… [truncated]`;
-    }
-    function sanitizeReportValue(value) {
-        const truncatedPaths = new Set();
-        const redactedPaths = new Set();
-        const ancestors = new WeakSet();
-        let remainingBytes = MAX_SERIALIZED_BYTES;
-        const consume = (path, text)=>{
-            remainingBytes -= stringByteLength(text);
-            if (remainingBytes >= 0) return true;
-            truncatedPaths.add(path);
-            return false;
-        };
-        const visit = (current, path, depth)=>{
-            if (remainingBytes <= 0) {
-                truncatedPaths.add(path);
-                return '[Truncated: size limit]';
-            }
-            if (null === current || 'boolean' == typeof current) {
-                consume(path, String(current));
-                return current;
-            }
-            if ('string' == typeof current) {
-                if (current.length > MAX_STRING_LENGTH) {
-                    truncatedPaths.add(path);
-                    const shortened = `${current.slice(0, MAX_STRING_LENGTH)}… [truncated]`;
-                    consume(path, shortened);
-                    return shortened;
-                }
-                consume(path, current);
-                return current;
-            }
-            if ('number' == typeof current) {
-                if (Number.isFinite(current)) {
-                    consume(path, String(current));
-                    return current;
-                }
-                truncatedPaths.add(path);
-                return `[Unsupported number: ${String(current)}]`;
-            }
-            if ('bigint' == typeof current) {
-                truncatedPaths.add(path);
-                return `[Unsupported bigint: ${String(current)}]`;
-            }
-            if (void 0 === current || 'function' == typeof current || 'symbol' == typeof current) {
-                truncatedPaths.add(path);
-                return `[Unsupported ${typeof current}]`;
-            }
-            if (depth >= MAX_DEPTH) {
-                truncatedPaths.add(path);
-                return '[Truncated: maximum depth]';
-            }
-            if (current instanceof Date) {
-                const date = Number.isNaN(current.getTime()) ? '[Invalid Date]' : current.toISOString();
-                consume(path, date);
-                return date;
-            }
-            if (ancestors.has(current)) {
-                truncatedPaths.add(path);
-                return '[Unsupported circular value]';
-            }
-            if (Array.isArray(current)) {
-                ancestors.add(current);
-                const output = [];
-                const itemCount = Math.min(current.length, MAX_ARRAY_ITEMS);
-                for(let index = 0; index < itemCount; index += 1){
-                    if (remainingBytes <= 0) break;
-                    output.push(visit(current[index], `${path}[${index}]`, depth + 1));
-                }
-                if (current.length > output.length) truncatedPaths.add(path);
-                ancestors.delete(current);
-                return output;
-            }
-            const prototype = Object.getPrototypeOf(current);
-            if (prototype !== Object.prototype && null !== prototype) {
-                truncatedPaths.add(path);
-                const constructorName = current.constructor?.name ?? 'object';
-                return `[Unsupported object: ${constructorName}]`;
-            }
-            ancestors.add(current);
-            const output = {};
-            const keys = Object.keys(current);
-            for (const key of keys.slice(0, MAX_OBJECT_KEYS)){
-                const childPath = objectPath(path, key);
-                if (!consume(childPath, key)) break;
-                if (isSecretKey(key)) {
-                    output[key] = '[REDACTED]';
-                    redactedPaths.add(childPath);
-                } else output[key] = visit(current[key], childPath, depth + 1);
-                if (remainingBytes <= 0) break;
-            }
-            if (keys.length > Object.keys(output).length) truncatedPaths.add(path);
-            ancestors.delete(current);
-            return output;
-        };
-        const sanitized = visit(value, '$', 0);
-        const serialized = JSON.stringify(sanitized);
-        if (void 0 === serialized || stringByteLength(serialized) > MAX_SERIALIZED_BYTES) return {
-            value: TRUNCATED_VALUE,
-            truncatedPaths: [
-                '$'
-            ]
-        };
-        return {
-            value: sanitized,
-            ...truncatedPaths.size > 0 ? {
-                truncatedPaths: [
-                    ...truncatedPaths
-                ]
-            } : {},
-            ...redactedPaths.size > 0 ? {
-                redactedPaths: [
-                    ...redactedPaths
-                ]
-            } : {}
-        };
-    }
-    function sanitizeReportError(error) {
-        if (error instanceof Error) {
-            const workflowLike = error;
-            return {
-                name: sanitizeReportText(error.name || 'Error', 200),
-                message: sanitizeReportText(error.message || String(error)),
-                ...'string' == typeof workflowLike.code ? {
-                    code: sanitizeReportText(workflowLike.code, 200)
-                } : {},
-                ...void 0 === workflowLike.details ? {} : {
-                    details: sanitizeReportValue(workflowLike.details)
-                }
-            };
-        }
-        return {
-            name: 'Error',
-            message: sanitizeReportText(String(error))
-        };
-    }
-    const warnReport = (0, logger_namespaceObject.getDebug)('test-runner:report-assembler', {
-        console: true
-    });
-    const exactMidsceneDetailNodes = new Set([
-        'aiAct',
-        'aiAssert',
-        'recordToReport'
-    ]);
-    const scopedExecutionKey = (scopeId, executionId)=>`${scopeId}\u0000${executionId}`;
-    const reportSourcesForScope = (context, scopeId)=>context.sourcesByScope.get(scopeId) ?? [];
-    const addDiagnostic = (context, diagnostic)=>{
-        context.diagnostics.push(diagnostic);
-        const key = JSON.stringify([
-            diagnostic.code,
-            diagnostic.scopeId,
-            diagnostic.executionId
-        ]);
-        if (!context.warnedDiagnostics.has(key)) {
-            context.warnedDiagnostics.add(key);
-            warnReport(diagnostic.message);
-        }
-    };
-    const buildStep = (step, scopeId, context)=>{
-        const details = [];
-        const unresolvedExecutionIds = [];
-        for (const trace of step.report?.traces ?? []){
-            const previousScope = context.tracedScopeByExecution.get(trace.executionId);
-            if (previousScope && previousScope !== scopeId) throw new Error(`Agent execution ${trace.executionId} was traced by multiple test scopes (${previousScope}, ${scopeId}).`);
-            context.tracedScopeByExecution.set(trace.executionId, scopeId);
-            const detail = context.detailsByScopeAndExecution.get(scopedExecutionKey(scopeId, trace.executionId));
-            if (detail) details.push(detail);
-            else unresolvedExecutionIds.push(trace.executionId);
-        }
-        let agentDetailDiagnostic;
-        if (unresolvedExecutionIds.length > 0) {
-            agentDetailDiagnostic = `Agent detail could not be resolved for ${unresolvedExecutionIds.join(', ')}.`;
-            const sources = reportSourcesForScope(context, scopeId);
-            for (const executionId of unresolvedExecutionIds)addDiagnostic(context, {
-                level: 'warning',
-                code: 'agent-detail-unresolved',
-                message: `Agent detail could not be resolved for execution ${executionId} in test scope ${scopeId}.`,
-                scopeId,
-                executionId,
-                ...sources.length > 0 ? {
-                    sourcePaths: sources.map((source)=>source.sourcePath)
-                } : {}
-            });
-        } else if (0 === details.length && exactMidsceneDetailNodes.has(step.node)) {
-            agentDetailDiagnostic = 'This Agent did not expose a stable execution reference for the Step.';
-            addDiagnostic(context, {
-                level: 'warning',
-                code: 'agent-detail-unavailable',
-                message: `No stable Agent execution reference was captured for ${step.node} in test scope ${scopeId}.`,
-                scopeId,
-                ...reportSourcesForScope(context, scopeId).length > 0 ? {
-                    sourcePaths: reportSourcesForScope(context, scopeId).map((source)=>source.sourcePath)
-                } : {}
-            });
-        }
-        const prompt = 'string' == typeof step.input?.prompt ? step.input.prompt : void 0;
-        return {
-            id: `${scopeId}:${step.phase}:${step.stepIndex}`,
-            phase: step.phase,
-            stepIndex: step.stepIndex,
-            node: step.node,
-            ...prompt ? {
-                title: sanitizeReportText(prompt, 240)
-            } : {},
-            status: step.status,
-            continuedAfterError: step.continuedAfterError,
-            startedAt: step.startedAt,
-            endedAt: step.endedAt,
-            durationMs: step.durationMs,
-            input: sanitizeReportValue(step.input),
-            ...step.output ? {
-                output: {
-                    ...void 0 === step.output.summary ? {} : {
-                        summary: sanitizeReportText(step.output.summary)
-                    },
-                    ...void 0 === step.output.data ? {} : {
-                        data: sanitizeReportValue(step.output.data)
-                    }
-                }
-            } : {},
-            ...step.error ? {
-                error: sanitizeReportError(step.error)
-            } : {},
-            ...details.length > 0 ? {
-                agentDetails: details
-            } : {},
-            ...agentDetailDiagnostic ? {
-                agentDetailDiagnostic
-            } : {}
-        };
-    };
-    const buildAttempt = (attempt, context)=>({
-            attemptId: attempt.runId,
-            attemptIndex: attempt.attemptIndex,
-            status: attempt.status,
-            startedAt: attempt.startedAt,
-            endedAt: attempt.endedAt,
-            durationMs: attempt.durationMs,
-            beforeEach: attempt.beforeEach.map((step)=>buildStep(step, attempt.runId, context)),
-            steps: attempt.steps.map((step)=>buildStep(step, attempt.runId, context)),
-            afterEach: attempt.afterEach.map((step)=>buildStep(step, attempt.runId, context)),
-            ...attempt.teardownErrors?.length ? {
-                teardownErrors: attempt.teardownErrors.map(sanitizeReportError)
-            } : {},
-            ...reportSourcesForScope(context, attempt.runId).length > 0 ? {
-                scopeReportIds: reportSourcesForScope(context, attempt.runId).map((source)=>source.reportId)
-            } : {}
-        });
-    const buildCase = (outcome, context)=>({
-            caseId: outcome.caseId,
-            name: outcome.name,
-            caseIndex: outcome.caseIndex,
-            status: outcome.status,
-            ...outcome.notRunReason ? {
-                notRunReason: outcome.notRunReason
-            } : {},
-            attempts: (outcome.attempts ?? (outcome.run ? [
-                outcome.run
-            ] : [])).map((attempt)=>buildAttempt(attempt, context))
-        });
-    const buildDocument = (documentId, document, cases, context)=>{
-        const sourcePath = document?.sourcePath ?? cases[0]?.sourcePath ?? '<unknown>';
-        const status = document?.status ?? (cases.some((item)=>'success' !== item.status) ? 'failed' : 'success');
-        return {
-            documentId,
-            sourcePath,
-            status,
-            ...document ? {
-                startedAt: document.startedAt,
-                endedAt: document.endedAt,
-                durationMs: document.durationMs
-            } : {},
-            beforeAll: (document?.beforeAll ?? []).map((step)=>buildStep(step, document.documentRunId, context)),
-            cases: cases.map((outcome)=>buildCase(outcome, context)),
-            afterAll: (document?.afterAll ?? []).map((step)=>buildStep(step, document.documentRunId, context)),
-            ...document?.teardownErrors?.length ? {
-                teardownErrors: document.teardownErrors.map(sanitizeReportError)
-            } : {},
-            ...document && reportSourcesForScope(context, document.documentRunId).length > 0 ? {
-                scopeReportIds: reportSourcesForScope(context, document.documentRunId).map((source)=>source.reportId)
-            } : {}
-        };
-    };
-    const buildProject = (project, context)=>{
-        const documentById = new Map(project.documents.map((document)=>[
-                document.documentId,
-                document
-            ]));
-        const casesByDocumentId = new Map();
-        for (const outcome of project.cases){
-            const current = casesByDocumentId.get(outcome.documentId) ?? [];
-            current.push(outcome);
-            casesByDocumentId.set(outcome.documentId, current);
-        }
-        const documentIds = new Set([
-            ...project.documents.map((document)=>document.documentId),
-            ...project.cases.map((outcome)=>outcome.documentId)
-        ]);
-        return {
-            projectId: project.projectId,
-            name: project.name,
-            status: project.status,
-            retry: project.retry,
-            ...project.lifecycle ? {
-                lifecycle: {
-                    status: project.lifecycle.status,
-                    startedAt: project.lifecycle.startedAt,
-                    endedAt: project.lifecycle.endedAt,
-                    durationMs: project.lifecycle.durationMs,
-                    ...project.lifecycle.setupError ? {
-                        setupError: sanitizeReportError(project.lifecycle.setupError)
-                    } : {},
-                    ...project.lifecycle.teardownErrors?.length ? {
-                        teardownErrors: project.lifecycle.teardownErrors.map(sanitizeReportError)
-                    } : {}
-                }
-            } : {},
-            documents: [
-                ...documentIds
-            ].map((documentId)=>buildDocument(documentId, documentById.get(documentId), casesByDocumentId.get(documentId) ?? [], context)),
-            collectionErrors: project.collectionErrors.map((collectionError)=>({
-                    sourcePath: collectionError.sourcePath,
-                    error: sanitizeReportError(collectionError.error)
-                }))
+            documentId: createWorkflowDocumentId(source.projectId, sourcePath),
+            projectId: source.projectId,
+            sourcePath,
+            lifecycle,
+            cases
         };
-    };
-    function collectTestRunReportSources(result) {
-        const sources = [];
-        for (const project of result.projects){
-            for (const document of project.documents)for (const sourcePath of document.reportPaths ?? [])sources.push({
-                scopeId: document.documentRunId,
-                sourcePath
-            });
-            for (const outcome of project.cases)for (const attempt of outcome.attempts ?? (outcome.run ? [
-                outcome.run
-            ] : []))for (const sourcePath of attempt.reportPaths ?? [])sources.push({
-                scopeId: attempt.runId,
-                sourcePath
-            });
-        }
-        return sources;
     }
-    function buildTestRunReportDump(result, index) {
-        const sourcesByScope = new Map();
-        const detailsByScopeAndExecution = new Map();
-        for (const source of index.sources){
-            const scopeSources = sourcesByScope.get(source.scopeId) ?? [];
-            scopeSources.push(source);
-            sourcesByScope.set(source.scopeId, scopeSources);
-            for (const executionId of source.executionIds)detailsByScopeAndExecution.set(scopedExecutionKey(source.scopeId, executionId), {
-                reportId: source.reportId,
-                executionId
+    const promises_namespaceObject = require("node:fs/promises");
+    const writeJson = async (path, value)=>{
+        try {
+            await (0, promises_namespaceObject.mkdir)((0, external_node_path_.dirname)(path), {
+                recursive: true
             });
+            await (0, promises_namespaceObject.writeFile)(path, JSON.stringify(value, null, 2));
+        } catch (error) {
+            throw new test_runner_namespaceObject.WorkflowPublicationError('write-result', path, error);
         }
-        const context = {
-            diagnostics: [],
-            sourcesByScope,
-            detailsByScopeAndExecution,
-            tracedScopeByExecution: new Map(),
-            warnedDiagnostics: new Set()
-        };
-        for (const source of index.sources)if (0 === source.executionIds.length) addDiagnostic(context, {
-            level: 'warning',
-            code: 'source-without-executions',
-            message: `Agent report contains no executions: ${source.sourcePath}`,
-            scopeId: source.scopeId,
-            sourcePaths: [
-                source.sourcePath
-            ]
-        });
-        const projects = result.projects.map((project)=>buildProject(project, context));
-        return {
-            schemaVersion: 1,
-            kind: 'test-runner',
-            runId: result.runId,
-            status: result.status,
-            startedAt: result.startedAt,
-            endedAt: result.endedAt,
-            durationMs: result.durationMs,
-            summary: {
-                ...result.summary
-            },
-            metrics: index.metrics,
-            projects,
-            ...context.diagnostics.length > 0 ? {
-                diagnostics: context.diagnostics
-            } : {}
-        };
-    }
-    const writeJson = (path, value)=>{
-        (0, external_node_fs_.mkdirSync)((0, external_node_path_.dirname)(path), {
-            recursive: true
-        });
-        (0, external_node_fs_.writeFileSync)(path, JSON.stringify(value, null, 2));
     };
     const toPosix = (value)=>value.split(external_node_path_.sep).join('/');
     const caseAttemptResultPath = (projectId, documentId, result)=>toPosix((0, external_node_path_.join)(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
-    const workflowDocumentResultPath = (result)=>toPosix((0, external_node_path_.join)(result.projectId, 'documents', result.documentId, 'document.json'));
+    const workflowDocumentResultPath = (result)=>toPosix((0, external_node_path_.join)(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
     const collectionErrorPath = (projectId, sourcePath)=>{
         const id = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
             projectId,
@@ -2107,21 +718,19 @@ A Node may map a string step value to one declared input field. Each Node sectio
     };
     const writeWorkflowDocumentResult = (runDir, result)=>{
         const { documentRunId: _documentRunId, ...persistedResult } = result;
-        writeJson((0, external_node_path_.join)(runDir, workflowDocumentResultPath(result)), persistedResult);
+        return writeJson((0, external_node_path_.join)(runDir, workflowDocumentResultPath(result)), persistedResult);
     };
     const writeCaseAttemptResult = (runDir, projectId, documentId, result)=>{
         const { runId: attemptId, ...persistedResult } = result;
-        writeJson((0, external_node_path_.join)(runDir, caseAttemptResultPath(projectId, documentId, result)), {
+        return writeJson((0, external_node_path_.join)(runDir, caseAttemptResultPath(projectId, documentId, result)), {
             ...persistedResult,
             attemptId
         });
     };
-    const writeCollectionError = (runDir, collectionError)=>{
-        writeJson((0, external_node_path_.join)(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
+    const writeCollectionError = (runDir, collectionError)=>writeJson((0, external_node_path_.join)(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
             kind: 'collection-error',
             ...collectionError
         });
-    };
     const relativeToSummary = (summaryPath, target)=>{
         const value = (0, external_node_path_.relative)((0, external_node_path_.dirname)(summaryPath), target);
         return toPosix(value || '.');
@@ -2130,7 +739,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
     const writeTestProjectRunResult = (options)=>{
         const { result } = options;
         const fact = (path)=>toPosix(path);
-        writeJson(result.summaryPath, {
+        return writeJson(result.summaryPath, {
             schemaVersion: result.schemaVersion,
             runId: result.runId,
             startedAt: result.startedAt,
@@ -2138,6 +747,9 @@ A Node may map a string step value to one declared input field. Each Node sectio
             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
@@ -2173,6 +785,9 @@ A Node may map a string step value to one declared input field. Each Node sectio
                         }
                     } : {},
                     cases: project.cases.map((outcome)=>({
+                            ...outcome.documentRunId ? {
+                                documentRunId: outcome.documentRunId
+                            } : {},
                             documentId: outcome.documentId,
                             caseId: outcome.caseId,
                             sourcePath: outcome.sourcePath,
@@ -2196,6 +811,10 @@ A Node may map a string step value to one declared input field. Each Node sectio
                         })),
                     documents: project.documents.map((document)=>({
                             documentId: document.documentId,
+                            ...void 0 === document.attemptIndex ? {} : {
+                                attemptIndex: document.attemptIndex,
+                                documentRunId: document.documentRunId
+                            },
                             sourcePath: document.sourcePath,
                             status: document.status,
                             resultFile: fact(workflowDocumentResultPath(document)),
@@ -2230,29 +849,28 @@ A Node may map a string step value to one declared input field. Each Node sectio
             '**/*.{yaml,yml}'
         ]
     };
-    const test_project_runner_toPosix = (value)=>value.split(external_node_path_.sep).join('/');
-    const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)=>{
+    const project_preparation_toPosix = (value)=>value.split(external_node_path_.sep).join('/');
+    const discoverResolvedTestFiles = (projectRoot, selection)=>{
         const root = (0, external_node_path_.resolve)(projectRoot);
-        const normalized = validateTestFileSelection(selection);
-        if (!normalized) throw new TypeError('Test file selection is required.');
-        const files = (0, external_tinyglobby_namespaceObject.globSync)(normalized.include, {
-            absolute: true,
-            caseSensitiveMatch: false,
-            cwd: root,
-            dot: true,
-            expandDirectories: false,
-            followSymbolicLinks: false,
-            ignore: [
-                ...ALWAYS_IGNORED_PATTERNS,
-                ...normalized.exclude ?? []
-            ],
-            onlyFiles: true
-        }).filter((file)=>/\.ya?ml$/i.test(file));
+        const match = (patterns)=>(0, external_tinyglobby_namespaceObject.globSync)(patterns, {
+                absolute: true,
+                caseSensitiveMatch: false,
+                cwd: root,
+                dot: true,
+                expandDirectories: false,
+                followSymbolicLinks: false,
+                ignore: [
+                    ...ALWAYS_IGNORED_PATTERNS,
+                    ...selection.exclude ?? []
+                ],
+                onlyFiles: true
+            }).filter((file)=>/\.ya?ml$/i.test(file));
+        const files = match(selection.include);
         return [
             ...new Set(files.map((file)=>(0, external_node_path_.resolve)(file)))
         ].sort((a, b)=>{
-            const relativeA = test_project_runner_toPosix((0, external_node_path_.relative)(root, a));
-            const relativeB = test_project_runner_toPosix((0, external_node_path_.relative)(root, b));
+            const relativeA = project_preparation_toPosix((0, external_node_path_.relative)(root, a));
+            const relativeB = project_preparation_toPosix((0, external_node_path_.relative)(root, b));
             return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
         });
     };
@@ -2273,27 +891,11 @@ A Node may map a string step value to one declared input field. Each Node sectio
         ].join('\n'));
         return supported[0] ? (0, external_node_path_.join)(root, supported[0]) : void 0;
     };
-    const defaultResultDir = (projectRoot)=>(0, external_node_path_.join)(projectRoot, '.midscene', 'test-results');
-    const padDatePart = (value)=>String(value).padStart(2, '0');
-    const createTestRunId = (date = new Date(), uuid = (0, external_node_crypto_namespaceObject.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 (!(0, external_node_fs_.existsSync)(path) || !(0, external_node_fs_.statSync)(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
-    };
     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)}`, {
+            error: error instanceof test_runner_namespaceObject.WorkflowError ? error : new test_runner_namespaceObject.WorkflowParseError(`Failed to collect workflow document "${sourcePath}": ${error instanceof Error ? error.message : String(error)}`, {
                 projectName,
                 sourcePath
             }, error)
@@ -2315,52 +917,6 @@ A Node may map a string step value to one declared input field. Each Node sectio
             filtered
         };
     };
-    const test_project_runner_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 cases = projects.flatMap((project)=>project.cases);
-        const documents = projects.flatMap((project)=>project.documents);
-        return {
-            total: cases.length,
-            passed: cases.filter((item)=>'success' === item.status).length,
-            failed: cases.filter((item)=>'failed' === item.status).length,
-            notRun: cases.filter((item)=>'not-run' === item.status).length,
-            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 stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
-    const test_project_runner_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 ? '      ' : '    ';
-        const symbol = 'success' === result.status ? '✓' : '✗';
-        const error = result.error ? ` — ${result.error.message}` : '';
-        const continuation = result.continuedAfterError ? '; continuing' : '';
-        return `${indent}${symbol} ${test_project_runner_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));
-    const documentHasFatalError = (result)=>[
-            ...result.beforeAll,
-            ...result.afterAll
-        ].some((step)=>step.error && isFatalDeviceError(step.error)) || (result.teardownErrors ?? []).some(isFatalDeviceError);
     const selectProjects = (projects, names)=>{
         if (!names || 0 === names.length) return projects;
         const requested = new Set(names);
@@ -2370,74 +926,316 @@ A Node may map a string step value to one declared input field. Each Node sectio
         if (unknown) throw new Error(`Unknown Midscene project: ${unknown}`);
         return projects.filter((project)=>requested.has(project.name));
     };
-    const prepareProject = (project, projectRoot, runDir)=>{
+    async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, options = {}) {
         const fileSelection = project.files ?? DEFAULT_TEST_FILE_SELECTION;
-        const files = discoverTestFiles(projectRoot, fileSelection);
-        const sources = files.map((absolutePath)=>({
+        const prerequisiteFile = options.prerequisiteFile ? (0, external_node_path_.resolve)(options.prerequisiteFile) : void 0;
+        const mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
+        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: test_project_runner_toPosix((0, external_node_path_.relative)(projectRoot, absolutePath)),
-                absolutePath
-            }));
+                sourcePath: project_preparation_toPosix((0, external_node_path_.relative)(projectRoot, absolutePath)),
+                absolutePath,
+                invocationIndex
+            };
+        });
         const collectionErrors = [];
-        const documents = [];
+        const invocations = [];
         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}.`, {
+            const error = asCollectionError(project.projectId, project.name, '<project>', new test_runner_namespaceObject.WorkflowParseError(`No workflow YAML files found for project "${project.name}" in ${projectRoot}.`, {
                 projectName: project.name,
                 projectRoot
             }));
             collectionErrors.push(error);
-            writeCollectionError(runDir, error);
+            await writeCollectionError(runDir, error);
         }
         for (const source of sources)try {
-            const collected = collectWorkflowDocument(source, {
+            const collected = await options.collectDocument?.(source, project);
+            if (collected) {
+                filteredCaseCount += collected.filteredCaseCount;
+                if (collected.invocation) invocations.push(collected.invocation);
+                continue;
+            }
+            const document = collectWorkflowDocument(source, {
                 resolveNode: project.nodes.get.bind(project.nodes),
                 variables: project.variables,
                 env: process.env
             });
-            const filtered = filterDocumentCases(collected, project);
+            const filtered = source.absolutePath === prerequisiteFile ? {
+                document,
+                filtered: 0
+            } : filterDocumentCases(document, project);
             filteredCaseCount += filtered.filtered;
-            if (filtered.document) documents.push(filtered.document);
+            if (filtered.document) invocations.push({
+                document: filtered.document,
+                retry: {
+                    scope: 'case',
+                    count: project.retry
+                },
+                defaultTimeoutMs,
+                reportEnabled: true,
+                bindings: {
+                    resolveNode: project.nodes.require.bind(project.nodes)
+                }
+            });
         } catch (error) {
             const collectionError = asCollectionError(project.projectId, project.name, source.sourcePath, error);
             collectionErrors.push(collectionError);
-            writeCollectionError(runDir, 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: options.platform ?? 'test',
+            documentConcurrency: options.documentConcurrency ?? 1,
+            ...prerequisiteDocument ? {
+                prerequisiteDocumentId: prerequisiteDocument.documentId
+            } : {},
             fileSelection,
             sources,
             documents,
+            invocations,
             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 = (0, external_node_crypto_namespaceObject.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 notRunSuite = (prepared, reason)=>prepared.documents.flatMap((document)=>document.cases.map((item)=>test_project_runner_asNotRun(document.documentId, item, prepared.project.name, reason)));
-    async function runTestProject(options = {}) {
-        const startedAt = new Date();
-        const runId = createTestRunId(startedAt);
+    const assertDirectory = (path, label)=>{
+        if (!(0, external_node_fs_.existsSync)(path) || !(0, external_node_fs_.statSync)(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
+    };
+    const resolveRunInput = (options)=>{
         const cwd = (0, external_node_path_.resolve)(options.cwd ?? process.cwd());
         assertDirectory(cwd, 'Test working directory');
-        const cliProjectRoot = options.projectRoot ? (0, external_node_path_.resolve)(cwd, options.projectRoot) : void 0;
+        const inputPath = options.projectRoot ? (0, external_node_path_.resolve)(cwd, options.projectRoot) : void 0;
+        const singleFile = inputPath && (0, external_node_fs_.existsSync)(inputPath) && (0, external_node_fs_.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 ? (0, external_node_path_.dirname)(singleFile) : inputPath;
         if (cliProjectRoot) assertDirectory(cliProjectRoot, 'Test project directory');
-        const configSearchRoot = cliProjectRoot ?? cwd;
-        const configPath = options.configPath ? (0, external_node_path_.resolve)(configSearchRoot, options.configPath) : discoverTestConfig(configSearchRoot);
-        if (options.configPath && (!configPath || !(0, external_node_fs_.existsSync)(configPath))) throw new Error(`Midscene config does not exist: ${configPath}`);
-        const definition = await loadTestProject(configPath);
         const projectRoot = cliProjectRoot ?? cwd;
-        const resultDir = options.resultDir ? (0, external_node_path_.resolve)(cwd, options.resultDir) : defaultResultDir(projectRoot);
+        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 ? (0, 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 && !(0, external_node_fs_.existsSync)(configPath)) throw new Error(`Midscene config does not exist: ${configPath}`);
+        const definition = await loadTestProject(configPath);
+        const resultDir = options.resultDir ? (0, external_node_path_.resolve)(input.cwd, options.resultDir) : (0, external_node_path_.join)(input.projectRoot, '.midscene', 'test-results');
         const runDir = (0, external_node_path_.join)(resultDir, runId);
         const summaryPath = (0, external_node_path_.join)(runDir, 'summary.json');
-        const reportDir = (0, external_node_path_.resolve)(projectRoot, definition.output.reportDir);
+        const reportDir = (0, external_node_path_.resolve)(input.projectRoot, definition.output.reportDir);
         (0, external_node_fs_.mkdirSync)(resultDir, {
             recursive: true
         });
         (0, external_node_fs_.mkdirSync)(runDir);
-        const selectedProjects = selectProjects(definition.projects, options.projectNames);
-        const preparedProjects = selectedProjects.map((project)=>prepareProject(project, projectRoot, runDir));
-        const progress = options.onProgress ?? (()=>{});
+        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
+            ]
+        } : void 0));
+        const hasFormatMismatch = projects.some((project)=>project.collectionErrors.some(({ error })=>error instanceof NativeWorkflowFormatError));
+        return {
+            startedAt,
+            runId,
+            projectRoot: input.projectRoot,
+            ...configPath ? {
+                configPath
+            } : {},
+            resultDir,
+            runDir,
+            summaryPath,
+            reportDir,
+            definition,
+            projects,
+            preflightScope: hasFormatMismatch ? 'run' : 'project',
+            reportEnabled: true,
+            publications: [],
+            onProgress: options.onProgress ?? (()=>{})
+        };
+    }
+    const external_node_events_namespaceObject = require("node:events");
+    const report_namespaceObject = require("@midscene/core/report");
+    const logger_namespaceObject = require("@midscene/shared/logger");
+    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 ? '      ' : '    ';
+        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 && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (attempt.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError));
+    const documentHasFatalError = (result)=>[
+            ...result.beforeAll,
+            ...result.afterAll
+        ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (result.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError);
+    async function executeDocumentInvocation(options) {
+        const { invocation, project, sinks } = options;
+        const { document } = invocation;
+        const documentRetry = 'document' === invocation.retry.scope;
+        const attempts = [];
+        await (0, test_runner_namespaceObject.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 (0, test_runner_namespaceObject.runWorkflowDocument)(document, {
+                documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
+                ...invocation.bindings,
+                project,
+                projectContext: options.projectContext,
+                retry: documentRetry ? 0 : invocation.retry.count,
+                signal: options.signal,
+                defaultTimeoutMs: invocation.defaultTimeoutMs,
+                shouldStop: ()=>options.rootSignal.aborted || options.shouldBail() || options.isProjectFatal(),
+                stopReason: ()=>options.rootSignal.aborted ? 'interrupted' : options.isProjectFatal() ? 'fatal-error' : 'bail',
+                isFatalError: (run)=>[
+                        ...run.beforeEach,
+                        ...run.steps,
+                        ...run.afterEach
+                    ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (run.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError),
+                onCaseStart: (collectedCase)=>{
+                    options.onProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
+                },
+                onStepStart: (info)=>{
+                    const indent = 'case' === info.scope ? '      ' : '    ';
+                    options.onProgress(`${indent}→ ${formatStep(info)}`);
+                },
+                onStepResult: async (info, result)=>{
+                    await invocation.bindings.onStepResult?.(info, result);
+                    options.onProgress(formatStepResult(info, result));
+                },
+                onCaseResult: async (attempt)=>{
+                    await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+                    options.onProgress(`    ${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${documentRetry ? 1 : invocation.retry.count + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
+                },
+                onCaseOutcome: (outcome)=>{
+                    if (caseHasFatalError(outcome)) options.markProjectFatal();
+                    if (!documentRetry && 'failed' === outcome.status) options.addFailedCases(1);
+                },
+                onDocumentResult: options.onDocumentResult
+            }).catch(async (error)=>{
+                if (error instanceof test_runner_namespaceObject.WorkflowExecutionFailure) {
+                    const partial = error.result;
+                    attempts.push(partial);
+                    sinks.documents.push(partial.document);
+                    sinks.cases.push(...partial.cases.map((outcome)=>({
+                            ...outcome,
+                            documentId: document.documentId,
+                            documentRunId: partial.document.documentRunId
+                        })));
+                    try {
+                        await writeWorkflowDocumentResult(options.runDir, partial.document);
+                    } catch (publicationError) {
+                        throw new test_runner_namespaceObject.WorkflowExecutionFailure(partial, [
+                            ...error.errors,
+                            publicationError
+                        ]);
+                    }
+                }
+                throw error;
+            });
+            attempts.push(execution);
+            sinks.cases.push(...execution.cases.map((outcome)=>({
+                    ...outcome,
+                    documentId: document.documentId,
+                    documentRunId: execution.document.documentRunId
+                })));
+            sinks.documents.push(execution.document);
+            await writeWorkflowDocumentResult(options.runDir, execution.document);
+            if (documentHasFatalError(execution.document)) options.markProjectFatal();
+            const cleanupErrors = [
+                ...execution.document.teardownErrors ?? [],
+                ...execution.cases.flatMap((outcome)=>(outcome.attempts ?? []).flatMap((attempt)=>attempt.teardownErrors ?? []))
+            ];
+            if (cleanupErrors.length) throw new test_runner_namespaceObject.WorkflowExecutionFailure(execution, cleanupErrors);
+            const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
+            return failed ? 'failed' : 'success';
+        });
+        const final = attempts.at(-1);
+        if (!final) return;
+        const failedCases = final.cases.filter((item)=>'failed' === item.status).length;
+        if (documentRetry && failedCases) options.addFailedCases(failedCases);
+        else if ('failed' === final.document.status && 0 === failedCases) options.addFailedCases(Math.max(1, failedCases));
+    }
+    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 cases = projects.flatMap((project)=>latestById(project.cases, (item)=>item.caseId));
+        const documents = projects.flatMap((project)=>latestById(project.documents, (item)=>item.documentId));
+        return {
+            total: cases.length,
+            passed: cases.filter((item)=>'success' === item.status).length,
+            failed: cases.filter((item)=>'failed' === item.status).length,
+            notRun: cases.filter((item)=>'not-run' === item.status).length,
+            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 { 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);
@@ -2455,11 +1253,13 @@ A Node may map a string step value to one declared input field. Each Node sectio
         let failedCaseCount = 0;
         const bailReached = ()=>definition.test.bail > 0 && failedCaseCount >= definition.test.bail;
         let hasInfrastructureError = false;
-        let firstInfrastructureError;
+        const infrastructureErrors = [];
         const recordInfrastructureError = (error)=>{
-            if (hasInfrastructureError) return;
+            const errors = error instanceof test_runner_namespaceObject.WorkflowExecutionFailure ? error.errors : [
+                error
+            ];
+            for (const item of errors)if (!infrastructureErrors.includes(item)) infrastructureErrors.push(item);
             hasInfrastructureError = true;
-            firstInfrastructureError = error;
             rootController.abort(error);
         };
         const runInfrastructureCallback = (callback)=>{
@@ -2476,10 +1276,11 @@ A Node may map a string step value to one declared input field. Each Node sectio
         };
         const buildProjectResult = (prepared, cases, documents, lifecycle)=>{
             const { project } = prepared;
-            const projectFailed = prepared.collectionErrors.length > 0 || cases.some((item)=>'success' !== item.status) || documents.some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
+            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,
+                platform: prepared.platform,
                 status: projectFailed ? 'failed' : 'success',
                 retry: project.retry,
                 fileSelection: prepared.fileSelection,
@@ -2507,106 +1308,111 @@ A Node may map a string step value to one declared input field. Each Node sectio
             const documents = [];
             let lifecycle;
             let projectFatal = false;
-            if (prepared.collectionErrors.length > 0) cases.push(...notRunSuite(prepared, 'project-preflight-failed'));
+            if (prepared.collectionErrors.length > 0 || 'run' === plan.preflightScope && totalErrors > 0) cases.push(...notRunSuite(prepared, 'project-preflight-failed'));
             else if (rootController.signal.aborted) cases.push(...notRunSuite(prepared, 'interrupted'));
             else if (bailReached()) cases.push(...notRunSuite(prepared, 'bail'));
             else {
-                const runtime = createProjectRuntime({
+                const runtime = (0, test_runner_namespaceObject.createProjectRuntime)({
                     project,
                     setup: project.setup,
                     signal: rootController.signal
                 });
                 let hasProjectExecutionError = false;
-                let projectExecutionError;
                 try {
                     await runtime.start();
-                    if (runtime.canRun) for (const [documentIndex, document] of prepared.documents.entries()){
-                        if (rootController.signal.aborted || bailReached() || projectFatal) {
-                            const reason = rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                            cases.push(...document.cases.map((item)=>test_project_runner_asNotRun(document.documentId, item, project.name, reason)));
-                            continue;
+                    if (runtime.canRun) {
+                        const runDocument = async (invocation, documentIndex)=>{
+                            const { document } = invocation;
+                            if (rootController.signal.aborted || bailReached() || projectFatal) {
+                                const reason = rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
+                                cases.push(...document.cases.map((item)=>asNotRun(document.documentId, item, project.name, reason)));
+                                return;
+                            }
+                            projectProgress(`  [document ${documentIndex + 1}/${prepared.documents.length}] ${document.sourcePath}`);
+                            await executeDocumentInvocation({
+                                invocation,
+                                project,
+                                projectContext: runtime.context,
+                                runDir,
+                                signal: runtime.signal,
+                                rootSignal: rootController.signal,
+                                shouldBail: bailReached,
+                                isProjectFatal: ()=>projectFatal,
+                                markProjectFatal: ()=>{
+                                    projectFatal = true;
+                                },
+                                addFailedCases: (count)=>{
+                                    failedCaseCount += count;
+                                },
+                                onProgress: projectProgress,
+                                sinks: {
+                                    cases,
+                                    documents
+                                }
+                            });
+                        };
+                        let prerequisiteFailed = false;
+                        const prerequisite = prepared.invocations.find((invocation)=>invocation.document.documentId === prepared.prerequisiteDocumentId);
+                        const prerequisiteCount = prerequisite ? 1 : 0;
+                        if (prerequisite) {
+                            await runDocument(prerequisite, 0);
+                            prerequisiteFailed = documents.at(-1)?.status === 'failed' || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status);
                         }
-                        projectProgress(`  [document ${documentIndex + 1}/${prepared.documents.length}] ${document.sourcePath}`);
-                        const execution = await runWorkflowDocument(document, {
-                            resolveNode: project.nodes.require.bind(project.nodes),
-                            project,
-                            projectContext: runtime.context,
-                            retry: project.retry,
-                            signal: runtime.signal,
-                            defaultTimeoutMs: definition.test.testTimeout,
-                            shouldStop: ()=>rootController.signal.aborted || bailReached() || projectFatal,
-                            stopReason: ()=>rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail',
-                            isFatalError: (run)=>[
-                                    ...run.beforeEach,
-                                    ...run.steps,
-                                    ...run.afterEach
-                                ].some((step)=>step.error && isFatalDeviceError(step.error)) || (run.teardownErrors ?? []).some(isFatalDeviceError),
-                            onCaseStart: (collectedCase)=>{
-                                projectProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
-                            },
-                            onStepStart: (info)=>{
-                                const indent = 'case' === info.scope ? '      ' : '    ';
-                                projectProgress(`${indent}→ ${test_project_runner_formatStep(info)}`);
-                            },
-                            onStepResult: (info, result)=>projectProgress(formatStepResult(info, result)),
-                            onCaseResult: (attempt)=>{
-                                runInfrastructureCallback(()=>writeCaseAttemptResult(runDir, project.projectId, document.documentId, attempt));
-                                projectProgress(`    ${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${project.retry + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
-                            },
-                            onCaseOutcome: (outcome)=>{
-                                if ('failed' === outcome.status) failedCaseCount += 1;
-                                if (caseHasFatalError(outcome)) projectFatal = true;
-                            },
-                            onDocumentResult: (documentResult)=>runInfrastructureCallback(()=>writeWorkflowDocumentResult(runDir, documentResult))
+                        if (!prerequisiteFailed) await (0, test_runner_namespaceObject.runConcurrentJobs)(prepared.invocations.filter((invocation)=>invocation !== prerequisite), {
+                            concurrency: prepared.documentConcurrency,
+                            shouldStop: ()=>rootController.signal.aborted || bailReached() || projectFatal
+                        }, async (invocation, index)=>{
+                            try {
+                                await runDocument(invocation, index + prerequisiteCount);
+                            } catch (error) {
+                                recordInfrastructureError(error);
+                                throw error;
+                            }
                         });
-                        cases.push(...execution.cases.map((outcome)=>({
-                                ...outcome,
-                                documentId: document.documentId
-                            })));
-                        if (documentHasFatalError(execution.document)) projectFatal = true;
-                        documents.push(execution.document);
-                    }
-                    else cases.push(...notRunSuite(prepared, rootController.signal.aborted ? 'interrupted' : 'project-setup-failed'));
+                        const completed = new Set(cases.map((item)=>item.caseId));
+                        const reason = prerequisiteFailed ? 'project-setup-failed' : rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
+                        cases.push(...notRunSuite(prepared, reason).filter((item)=>!completed.has(item.caseId)));
+                    } else cases.push(...notRunSuite(prepared, rootController.signal.aborted ? 'interrupted' : 'project-setup-failed'));
                 } catch (error) {
                     hasProjectExecutionError = true;
-                    projectExecutionError = error;
                     recordInfrastructureError(error);
                 } finally{
-                    const hasFailure = hasProjectExecutionError || cases.some((item)=>'success' !== item.status) || documents.some((item)=>'failed' === item.status) || projectFatal || rootController.signal.aborted;
+                    const hasFailure = hasProjectExecutionError || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || projectFatal || rootController.signal.aborted;
                     lifecycle = await runtime.finish(hasFailure ? 'failed' : 'success');
                 }
-                if (hasProjectExecutionError) throw projectExecutionError;
+                if (hasProjectExecutionError) {
+                    const completed = new Set(cases.map((item)=>item.caseId));
+                    cases.push(...notRunSuite(prepared, 'interrupted').filter((item)=>!completed.has(item.caseId)));
+                }
             }
+            const order = new Map(prepared.documents.map((document, index)=>[
+                    document.documentId,
+                    index
+                ]));
+            const documentOrder = (id)=>order.get(id) ?? Number.MAX_SAFE_INTEGER;
+            cases.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || a.caseIndex - b.caseIndex);
+            documents.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || (a.attemptIndex ?? 0) - (b.attemptIndex ?? 0));
             return buildProjectResult(prepared, cases, documents, lifecycle);
         };
         const projectResults = new Array(preparedProjects.length);
-        let nextProjectIndex = 0;
-        const claimNextProject = ()=>{
-            if (hasInfrastructureError || rootController.signal.aborted || bailReached() || nextProjectIndex >= preparedProjects.length) return;
-            const projectIndex = nextProjectIndex;
-            nextProjectIndex += 1;
-            return projectIndex;
-        };
-        const worker = async ()=>{
-            try {
-                while(true){
-                    const projectIndex = claimNextProject();
-                    if (void 0 === projectIndex) return;
-                    projectResults[projectIndex] = await runPreparedProject(preparedProjects[projectIndex], projectIndex);
-                }
-            } catch (error) {
-                recordInfrastructureError(error);
-            }
-        };
         try {
-            await Promise.allSettled(Array.from({
-                length: effectiveConcurrency
-            }, ()=>worker()));
+            await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
+                concurrency: effectiveConcurrency,
+                shouldStop: ()=>hasInfrastructureError || rootController.signal.aborted || bailReached()
+            }, async (prepared, index)=>{
+                try {
+                    projectResults[index] = await runPreparedProject(prepared, index);
+                } catch (error) {
+                    recordInfrastructureError(error);
+                    throw error;
+                }
+            });
+        } catch (error) {
+            recordInfrastructureError(error);
         } finally{
             process.off('SIGINT', sigint);
             process.off('SIGTERM', sigterm);
         }
-        if (hasInfrastructureError) throw firstInfrastructureError;
         const completedProjectResults = preparedProjects.map((prepared, projectIndex)=>{
             const result = projectResults[projectIndex];
             if (result) return result;
@@ -2615,7 +1421,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
             return buildSkippedProjectResult(prepared, projectIndex, reason);
         });
         const summary = summarize(completedProjectResults);
-        const failed = rootController.signal.aborted || summary.failed > 0 || summary.notRun > 0 || summary.collectionErrors > 0 || summary.documentFailures > 0 || summary.projectFailures > 0;
+        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,
@@ -2632,34 +1438,66 @@ A Node may map a string step value to one declared input field. Each Node sectio
             projects: completedProjectResults,
             cases: completedProjectResults.flatMap((project)=>project.cases),
             documents: completedProjectResults.flatMap((project)=>project.documents),
-            collectionErrors: completedProjectResults.flatMap((project)=>project.collectionErrors)
+            collectionErrors: completedProjectResults.flatMap((project)=>project.collectionErrors),
+            ...hasInfrastructureError ? {
+                errors: infrastructureErrors.map(test_runner_namespaceObject.asExecutionError)
+            } : {}
         };
-        writeTestProjectRunResult({
-            projectRoot,
-            ...configPath ? {
-                configPath
-            } : {},
-            result
-        });
-        const reportPath = new report_namespaceObject.TestRunReportAssembler().assemble({
-            outputDir: reportDir,
-            reportFileName: `test-run-${runId}`,
-            sources: collectTestRunReportSources(result),
-            buildRunnerDump: (index)=>buildTestRunReportDump(result, index)
-        });
-        const completedResult = {
-            ...result,
-            reportPath
+        let completedResult = result;
+        const publish = async (operation, path, callback)=>{
+            try {
+                await callback();
+                return true;
+            } catch (error) {
+                recordInfrastructureError(error instanceof test_runner_namespaceObject.WorkflowPublicationError || error instanceof test_runner_namespaceObject.WorkflowExecutionFailure ? error : new test_runner_namespaceObject.WorkflowPublicationError(operation, path, error));
+                completedResult = {
+                    ...completedResult,
+                    status: 'failed',
+                    exitCode: 1,
+                    errors: infrastructureErrors.map(test_runner_namespaceObject.asExecutionError)
+                };
+                return false;
+            }
         };
-        writeTestProjectRunResult({
-            projectRoot,
-            ...configPath ? {
-                configPath
-            } : {},
-            result: completedResult
+        const writeSummary = ()=>publish('write-result', summaryPath, ()=>writeTestProjectRunResult({
+                    projectRoot,
+                    ...configPath ? {
+                        configPath
+                    } : {},
+                    result: completedResult
+                }));
+        const writeReport = ()=>publish('write-report', reportDir, async ()=>{
+                if (!plan.reportEnabled) return;
+                const reportPath = await new report_namespaceObject.TestRunReportAssembler().assembleAsync({
+                    outputDir: reportDir,
+                    reportFileName: `midscene-e2e-${runId}`,
+                    overwrite: false,
+                    sources: (0, test_runner_namespaceObject.collectTestRunReportSources)(completedResult),
+                    buildRunnerDump: (index)=>{
+                        const dump = (0, test_runner_namespaceObject.buildTestRunReportDump)(completedResult, index);
+                        const warn = (0, logger_namespaceObject.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 writeSummary();
+        if (hasInfrastructureError) throw new test_runner_namespaceObject.WorkflowExecutionFailure(completedResult, infrastructureErrors);
         return completedResult;
     }
+    async function runTestProject(options = {}) {
+        return runPreparedTestProject(await prepareTestRun(options));
+    }
     const parseTestCliArgs = (args, cwd = process.cwd())=>{
         const command = 'nodes' === args[0] ? args[0] : void 0;
         const commandOffset = command ? 1 : 0;
@@ -2668,20 +1506,23 @@ A Node may map a string step value to one declared input field. Each Node sectio
         let resultDir;
         const projectNames = [];
         for(let index = commandOffset; index < args.length; index += 1){
-            const arg = args[index];
+            const token = args[index];
+            const equal = token.startsWith('-') ? token.indexOf('=') : -1;
+            const arg = equal < 0 ? token : token.slice(0, equal);
+            const inlineValue = equal < 0 ? void 0 : token.slice(equal + 1);
             if (!arg.startsWith('-')) {
                 if (projectRoot) throw new Error('Only one test project directory is allowed.');
                 projectRoot = (0, external_node_path_.resolve)(cwd, arg);
                 continue;
             }
             if ('--config' === arg || '--result-dir' === arg || '--project' === arg) {
-                const value = args[index + 1];
-                if (!value) throw new Error(`${arg} requires a value.`);
+                const value = inlineValue ?? args[index + 1];
+                if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value.`);
                 if ('--config' === arg) configPath = value;
                 else if ('--result-dir' === arg) resultDir = (0, external_node_path_.resolve)(cwd, value);
                 else projectNames.push(value);
-                index += 1;
-            } else throw new Error(`Unknown option: ${arg}`);
+                if (void 0 === inlineValue) index += 1;
+            } else throw new Error(`Unknown option: ${token}`);
         }
         if ('nodes' === command && resultDir) throw new Error('--result-dir is not supported by nodes.');
         if ('nodes' === command && projectNames.length > 1) throw new Error('nodes accepts only one --project name.');
@@ -2703,6 +1544,23 @@ A Node may map a string step value to one declared input field. Each Node sectio
         error: console.error,
         write: (message)=>process.stdout.write(message)
     };
+    const testCliHelp = `Midscene Test: run native cases/steps Test projects.
+
+Usage:
+  midscene-test [file.yaml | directory] [options]
+  midscene-test --config <midscene.config.ts> [options]
+  midscene-test nodes [directory] [--config midscene.config.ts]
+  midscene-test create --help
+
+Options:
+  --config <path>              Native TypeScript or JavaScript Test config
+  --project <name>             Select a native execution Project (repeatable)
+  --result-dir <path>          Store Test result files in this directory
+  --help, -h                  Show this help
+  --version                   Show the package version
+
+Legacy tasks/flow YAML and its CLI options belong to the midscene command.
+`;
     const test_command_assertDirectory = (path, label)=>{
         if (!(0, external_node_fs_.existsSync)(path) || !(0, external_node_fs_.statSync)(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
     };
@@ -2713,6 +1571,7 @@ A Node may map a string step value to one declared input field. Each Node sectio
         if (projectRoot) test_command_assertDirectory(projectRoot, 'Test project directory');
         const configSearchRoot = projectRoot ?? cwd;
         const configPath = options.configPath ? (0, external_node_path_.resolve)(configSearchRoot, options.configPath) : discoverTestConfig(configSearchRoot);
+        if (options.configPath && /\.ya?ml$/i.test(configPath)) throw new Error(`midscene-test nodes --config only accepts a native TypeScript or JavaScript project config: ${configPath}.`);
         if (options.configPath && (!configPath || !(0, external_node_fs_.existsSync)(configPath))) throw new Error(`Midscene config does not exist: ${configPath}`);
         const project = await loadTestProject(configPath);
         const projectName = options.projectNames?.[0];
@@ -2740,10 +1599,18 @@ A Node may map a string step value to one declared input field. Each Node sectio
     async function runTestCli(args, io = defaultCliIO) {
         try {
             if ('create' === args[0]) {
-                const { runCreateCommand } = await __webpack_require__.e("458").then(__webpack_require__.bind(__webpack_require__, "./src/cli/create-command.ts"));
+                const { runCreateCommand } = await __webpack_require__.e("160").then(__webpack_require__.bind(__webpack_require__, "./src/cli/create-command.ts"));
                 await runCreateCommand(args.slice(1), io);
                 return 0;
             }
+            if (args.includes('--help') || args.includes('-h')) {
+                io.log(testCliHelp);
+                return 0;
+            }
+            if (args.includes('--version')) {
+                io.log(package_0.rE);
+                return 0;
+            }
             const options = parseTestCliArgs(args);
             if ('nodes' === options.command) {
                 await runNodesCommand(options, io);
@@ -2753,6 +1620,25 @@ A Node may map a string step value to one declared input field. Each Node sectio
                 ...options,
                 onProgress: (message)=>io.log(message)
             });
+            for (const failure of result.collectionErrors)io.error(`midscene-test: ${failure.projectName}/${failure.sourcePath}: ${failure.error.message}`);
+            const finalCases = new Map(result.cases.map((outcome)=>[
+                    outcome.caseId,
+                    outcome
+                ]));
+            for (const outcome of finalCases.values()){
+                if ('failed' !== outcome.status || !outcome.run) continue;
+                const run = outcome.run;
+                const source = `${run.projectName}/${run.sourcePath} / ${run.name}`;
+                for (const step of [
+                    ...run.beforeEach,
+                    ...run.steps,
+                    ...run.afterEach
+                ])if (step.error) io.error(`midscene-test: ${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}: ${step.error.message}`);
+                for (const error of [
+                    ...run.executionErrors ?? [],
+                    ...run.teardownErrors ?? []
+                ])io.error(`midscene-test: ${source}: ${error.message}`);
+            }
             io.log(`midscene-test: ${result.summary.passed}/${result.summary.total} cases passed, ${result.summary.failed} failed, ${result.summary.notRun} not run`);
             io.log(`Results: ${result.resultDir}`);
             io.log(`Summary: ${result.summaryPath}`);