@midscene/test 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/lib/index.js

@@ -24,1147 +24,77 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    NodeInputValidationError: ()=>NodeInputValidationError,
+    NodeInputValidationError: ()=>test_runner_namespaceObject.NodeInputValidationError,
     createCaseRunner: ()=>createCaseRunner,
-    isFatalDeviceError: ()=>isFatalDeviceError,
+    isFatalDeviceError: ()=>test_runner_namespaceObject.isFatalDeviceError,
     normalizeSteps: ()=>normalizeSteps,
-    FatalDeviceError: ()=>FatalDeviceError,
+    FatalDeviceError: ()=>test_runner_namespaceObject.FatalDeviceError,
     runWorkflowDocument: ()=>runWorkflowDocument,
     defineNode: ()=>defineNode,
     z: ()=>v4_namespaceObject.z,
-    createProjectRuntime: ()=>createProjectRuntime,
-    sanitizeReportValue: ()=>sanitizeReportValue,
-    buildTestRunReportDump: ()=>buildTestRunReportDump,
-    sanitizeReportError: ()=>sanitizeReportError,
+    createProjectRuntime: ()=>test_runner_namespaceObject.createProjectRuntime,
+    sanitizeReportValue: ()=>test_runner_namespaceObject.sanitizeReportValue,
+    buildTestRunReportDump: ()=>test_runner_namespaceObject.buildTestRunReportDump,
+    sanitizeReportError: ()=>test_runner_namespaceObject.sanitizeReportError,
     createWorkflowDocumentId: ()=>createWorkflowDocumentId,
-    NodeDefinitionError: ()=>NodeDefinitionError,
-    normalizeNodeExecutionError: ()=>normalizeNodeExecutionError,
-    NodeExecutionError: ()=>NodeExecutionError,
-    CaseExecutionError: ()=>CaseExecutionError,
-    WorkflowLifecycleError: ()=>WorkflowLifecycleError,
-    NodeNotFoundError: ()=>NodeNotFoundError,
-    ProjectSetupError: ()=>ProjectSetupError,
-    WorkflowError: ()=>WorkflowError,
-    DuplicateNodeError: ()=>DuplicateNodeError,
+    NativeWorkflowFormatError: ()=>NativeWorkflowFormatError,
+    NodeDefinitionError: ()=>test_runner_namespaceObject.NodeDefinitionError,
+    normalizeNodeExecutionError: ()=>test_runner_namespaceObject.normalizeNodeExecutionError,
+    NodeExecutionError: ()=>test_runner_namespaceObject.NodeExecutionError,
+    CaseExecutionError: ()=>test_runner_namespaceObject.CaseExecutionError,
+    WorkflowLifecycleError: ()=>test_runner_namespaceObject.WorkflowLifecycleError,
+    NodeNotFoundError: ()=>test_runner_namespaceObject.NodeNotFoundError,
+    ProjectSetupError: ()=>test_runner_namespaceObject.ProjectSetupError,
+    WorkflowError: ()=>test_runner_namespaceObject.WorkflowError,
+    DuplicateNodeError: ()=>test_runner_namespaceObject.DuplicateNodeError,
     NodeRegistry: ()=>NodeRegistry,
     CaseRunner: ()=>CaseRunner,
-    StepTimeoutError: ()=>StepTimeoutError,
-    sanitizeReportText: ()=>sanitizeReportText,
-    WorkflowParseError: ()=>WorkflowParseError,
-    NodeScopeTeardownError: ()=>NodeScopeTeardownError,
-    WorkflowDocumentExecutionError: ()=>WorkflowDocumentExecutionError,
-    ProjectTeardownError: ()=>ProjectTeardownError,
-    collectTestRunReportSources: ()=>collectTestRunReportSources,
+    StepTimeoutError: ()=>test_runner_namespaceObject.StepTimeoutError,
+    sanitizeReportText: ()=>test_runner_namespaceObject.sanitizeReportText,
+    WorkflowParseError: ()=>test_runner_namespaceObject.WorkflowParseError,
+    NodeScopeTeardownError: ()=>test_runner_namespaceObject.NodeScopeTeardownError,
+    WorkflowDocumentExecutionError: ()=>test_runner_namespaceObject.WorkflowDocumentExecutionError,
+    ProjectTeardownError: ()=>test_runner_namespaceObject.ProjectTeardownError,
+    collectTestRunReportSources: ()=>test_runner_namespaceObject.collectTestRunReportSources,
     normalizeStep: ()=>normalizeStep,
     resolveWorkflowVariables: ()=>resolveWorkflowVariables,
     createCaseId: ()=>createCaseId,
     createDocumentRuntime: ()=>createDocumentRuntime,
     collectWorkflowDocument: ()=>collectWorkflowDocument
 });
-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;
-};
-class CaseExecutionError extends WorkflowError {
-    constructor(result){
-        super(`Case "${result.name}" failed.`, {
-            code: 'CASE_EXECUTION_FAILED',
-            details: {
-                caseId: result.caseId,
-                runId: result.runId
-            }
-        }), _define_property(this, "result", void 0);
-        this.result = result;
-    }
-}
-class WorkflowDocumentExecutionError extends WorkflowError {
-    constructor(result){
-        super(`Workflow document "${result.sourcePath}" failed.`, {
-            code: 'WORKFLOW_DOCUMENT_EXECUTION_FAILED',
-            details: {
-                documentId: result.documentId,
-                documentRunId: result.documentRunId
-            }
-        }), _define_property(this, "result", void 0);
-        this.result = result;
-    }
-}
-function normalizeNodeExecutionError(error, node) {
-    return error instanceof WorkflowError ? error : new NodeExecutionError(node, error);
-}
-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 v4_namespaceObject = require("zod/v4");
-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 external_node_crypto_namespaceObject = require("node:crypto");
-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);
-    }
-};
-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);
-    });
-    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
-        });
-    });
-    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);
-    });
-    const settledExecution = Promise.race([
-        execution,
-        abortedExecution,
-        ...void 0 === timeoutExecution ? [] : [
-            timeoutExecution
-        ]
-    ]);
-    try {
-        const output = validateNodeOutput(await settledExecution, step.node);
-        return {
-            ...createStepResultBase(step, startedAt, phase, stepIndex),
-            status: 'success',
-            continuedAfterError: false,
-            ...void 0 === output ? {} : {
-                output
-            }
-        };
-    } 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);
-    }
-}
-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);
-                }
-            };
-            return 'case' === target.scope ? node.execute({
-                ...common,
-                scope: 'case',
-                case: target.case
-            }) : node.execute({
-                ...common,
-                scope: 'document',
-                document: target.document
-            });
-        }, 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 external_node_path_namespaceObject = require("node:path");
-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_namespaceObject.isAbsolute)(path)) throw new TypeError(`Node teardown reportPaths[${index}] must be an absolute path.`);
-        return path;
-    });
-};
-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;
-}
-function case_runner_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 CaseRunner {
-    register(node) {
-        this.registry.register(node);
-        return this;
-    }
-    async run(input) {
-        const collectedCase = {
-            caseId: 'standalone-case',
-            projectId: 'standalone-project',
-            sourcePath: '',
-            caseIndex: 0,
-            definition: {
-                name: input.name ?? 'case',
-                tags: input.tags ?? [],
-                steps: normalizeSteps(input.steps, (name)=>this.registry.get(name))
-            }
-        };
-        const result = await runCollectedCase(collectedCase, {
-            resolveNode: (name)=>this.registry.require(name),
-            context: this.context,
-            createRunId: ()=>'standalone-case'
-        });
-        const fatalStepError = result.steps.find((step)=>'failed' === step.status && !step.continuedAfterError)?.error;
-        if (fatalStepError) throw fatalStepError;
-        return result;
-    }
-    constructor(options = {}){
-        case_runner_define_property(this, "registry", void 0);
-        case_runner_define_property(this, "context", void 0);
-        this.registry = new NodeRegistry(options.nodes);
-        this.context = options.context;
-    }
-}
-function createCaseRunner(options = {}) {
-    return new CaseRunner(options);
-}
-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;
-        }
-    };
-}
-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 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 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 test_runner_namespaceObject = require("@midscene/core/internal/test-runner");
+const CaseRunner = test_runner_namespaceObject.CaseRunner;
+const createCaseRunner = test_runner_namespaceObject.createCaseRunner;
+const createDocumentRuntime = test_runner_namespaceObject.createDocumentRuntime;
+const NodeRegistry = test_runner_namespaceObject.NodeRegistry;
+const runWorkflowDocument = test_runner_namespaceObject.runWorkflowDocument;
+const defineNode = test_runner_namespaceObject.defineNode;
 const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
 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 normalizeStep = test_runner_namespaceObject.normalizeStep;
+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 WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
+    throw new test_runner_namespaceObject.WorkflowParseError(`Undefined ${kind} variable "${name}" in ${options.location.sourcePath}.`, {
         ...options.location,
         variable: name,
         variableKind: kind
@@ -1180,7 +110,7 @@ const environmentVariable = (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.`, {
+    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'
@@ -1203,23 +133,36 @@ const resolveWorkflowVariables = (value, options)=>{
         ]));
     return value;
 };
-const collect_isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+class NativeWorkflowFormatError extends 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 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]}".`, {
+    if (unknown.length) throw new test_runner_namespaceObject.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');
+const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
+const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
 function collectWorkflowDocument(source, options) {
     let parsed;
     try {
@@ -1227,11 +170,13 @@ function collectWorkflowDocument(source, options) {
             schema: external_js_yaml_namespaceObject.JSON_SCHEMA
         });
     } catch (error) {
-        throw new WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
+        throw new test_runner_namespaceObject.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.');
+    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);
     rejectUnknownKeys(parsed, [
         'beforeAll',
         'beforeEach',
@@ -1239,7 +184,7 @@ function collectWorkflowDocument(source, options) {
         '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.');
+    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_namespaceObject.sep).join('/');
     const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
             ...step,
@@ -1260,12 +205,12 @@ function collectWorkflowDocument(source, options) {
     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.`, {
+        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 WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${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
@@ -1281,7 +226,7 @@ function collectWorkflowDocument(source, options) {
     };
     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
         });
         rejectUnknownKeys(definition, [
@@ -1289,18 +234,18 @@ function collectWorkflowDocument(source, options) {
             '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
@@ -1308,7 +253,7 @@ function collectWorkflowDocument(source, options) {
             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);
@@ -1332,423 +277,12 @@ function collectWorkflowDocument(source, options) {
         cases
     };
 }
-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 logger_namespaceObject = require("@midscene/shared/logger");
-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)
-            }))
-    };
-};
-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 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 v4_namespaceObject = require("zod/v4");
 exports.CaseExecutionError = __webpack_exports__.CaseExecutionError;
 exports.CaseRunner = __webpack_exports__.CaseRunner;
 exports.DuplicateNodeError = __webpack_exports__.DuplicateNodeError;
 exports.FatalDeviceError = __webpack_exports__.FatalDeviceError;
+exports.NativeWorkflowFormatError = __webpack_exports__.NativeWorkflowFormatError;
 exports.NodeDefinitionError = __webpack_exports__.NodeDefinitionError;
 exports.NodeExecutionError = __webpack_exports__.NodeExecutionError;
 exports.NodeInputValidationError = __webpack_exports__.NodeInputValidationError;
@@ -1786,6 +320,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CaseRunner",
     "DuplicateNodeError",
     "FatalDeviceError",
+    "NativeWorkflowFormatError",
     "NodeDefinitionError",
     "NodeExecutionError",
     "NodeInputValidationError",