@midscene/test 0.0.0 → 1.10.4-beta-20260715034325.0

package/dist/lib/cli/index.js

@@ -0,0 +1,1170 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    defineWorkflowProject: ()=>defineWorkflowProject,
+    discoverWorkflowFiles: ()=>discoverWorkflowFiles,
+    runWorkflowProject: ()=>runWorkflowProject,
+    loadWorkflowProjectSync: ()=>loadWorkflowProjectSync,
+    validateWorkflowFileSelection: ()=>validateWorkflowFileSelection,
+    DEFAULT_WORKFLOW_FILE_SELECTION: ()=>DEFAULT_WORKFLOW_FILE_SELECTION,
+    discoverWorkflowConfig: ()=>discoverWorkflowConfig
+});
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+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 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 WorkflowDocumentSetupError extends WorkflowError {
+    constructor(cause, details){
+        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
+        super(`Workflow document setup failed: ${causeMessage}`, {
+            code: 'WORKFLOW_DOCUMENT_SETUP_ERROR',
+            details,
+            cause
+        });
+    }
+}
+class WorkflowDocumentTeardownError extends WorkflowError {
+    constructor(cause, details){
+        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
+        super(`Workflow document teardown failed: ${causeMessage}`, {
+            code: 'WORKFLOW_DOCUMENT_TEARDOWN_ERROR',
+            details,
+            cause
+        });
+    }
+}
+class WorkflowLifecycleError extends WorkflowError {
+    constructor(message, details){
+        super(message, {
+            code: 'WORKFLOW_LIFECYCLE_ERROR',
+            details
+        });
+    }
+}
+function normalizeNodeExecutionError(error, node) {
+    return error instanceof WorkflowError ? error : new NodeExecutionError(node, error);
+}
+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.');
+    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()
+        ];
+    }
+    constructor(nodes = []){
+        _class_private_field_init(this, _nodes, {
+            writable: true,
+            value: new Map()
+        });
+        for (const node of nodes)this.register(node);
+    }
+}
+const defineWorkflowProject = (definition)=>definition;
+const unwrapProjectDefinition = (loaded)=>{
+    if ('object' == typeof loaded && null !== loaded && 'default' in loaded) return loaded.default;
+    return loaded;
+};
+const isAbsolutePattern = (pattern)=>(0, external_node_path_namespaceObject.isAbsolute)(pattern) || /^[A-Za-z]:[\\/]/.test(pattern) || pattern.startsWith('\\\\');
+const validatePatterns = (value, field)=>{
+    if (!Array.isArray(value)) throw new TypeError(`Workflow config files.${field} must be an array.`);
+    if ('include' === field && 0 === value.length) throw new TypeError('Workflow config files.include must be a non-empty array.');
+    return value.map((pattern, index)=>{
+        if ('string' != typeof pattern || 0 === pattern.trim().length) throw new TypeError(`Workflow config files.${field}[${index}] must be a non-empty string.`);
+        if (isAbsolutePattern(pattern)) throw new TypeError(`Workflow config files.${field}[${index}] must be relative to the project root.`);
+        if (pattern.split(/[\\/]/).includes('..')) throw new TypeError(`Workflow config files.${field}[${index}] must not contain a ".." path segment.`);
+        if (pattern.includes('\\')) throw new TypeError(`Workflow config files.${field}[${index}] must use POSIX path separators (/).`);
+        if (pattern.startsWith('!')) {
+            if ('include' === field) throw new TypeError(`Workflow config files.include[${index}] must not be a negated pattern. Use files.exclude instead.`);
+            throw new TypeError(`Workflow config files.exclude[${index}] must not be a negated pattern.`);
+        }
+        return pattern;
+    });
+};
+const validateWorkflowFileSelection = (value)=>{
+    if (void 0 === value) return;
+    if ('object' != typeof value || null === value || Array.isArray(value)) throw new TypeError('Workflow config files must be an object.');
+    const files = value;
+    const include = validatePatterns(files.include, 'include');
+    const exclude = void 0 === files.exclude ? void 0 : validatePatterns(files.exclude, 'exclude');
+    return {
+        include,
+        ...exclude ? {
+            exclude
+        } : {}
+    };
+};
+function loadWorkflowProjectSync(configPath) {
+    let definition = {
+        nodes: []
+    };
+    if (configPath) {
+        const absolutePath = (0, external_node_path_namespaceObject.resolve)(configPath);
+        try {
+            definition = unwrapProjectDefinition((0, external_node_module_namespaceObject.createRequire)(absolutePath)(absolutePath));
+        } catch (error) {
+            throw new Error(`Failed to load workflow config "${absolutePath}". Use a CommonJS config (.cjs).`, {
+                cause: error
+            });
+        }
+    }
+    if ('object' != typeof definition || null === definition || !('nodes' in definition) || !Array.isArray(definition.nodes)) throw new TypeError('Workflow config must export an object with a nodes array.');
+    const projectDefinition = definition;
+    if ('setupWorkflow' in definition) throw new TypeError('Workflow config setupWorkflow is no longer supported. Use setupDocument instead.');
+    if (void 0 !== projectDefinition.root && ('string' != typeof projectDefinition.root || 0 === projectDefinition.root.trim().length)) throw new TypeError('Workflow config root must be a non-empty string.');
+    const files = validateWorkflowFileSelection(projectDefinition.files);
+    if (void 0 !== projectDefinition.setupDocument && 'function' != typeof projectDefinition.setupDocument) throw new TypeError('Workflow config setupDocument must be a function.');
+    const nodes = new NodeRegistry(projectDefinition.nodes);
+    return {
+        ...projectDefinition.root ? {
+            root: projectDefinition.root
+        } : {},
+        ...files ? {
+            files
+        } : {},
+        nodes,
+        ...projectDefinition.setupDocument ? {
+            setupDocument: projectDefinition.setupDocument
+        } : {},
+        resolveNode: (name)=>nodes.get(name)
+    };
+}
+const external_node_fs_namespaceObject = require("node:fs");
+const external_tinyglobby_namespaceObject = require("tinyglobby");
+const external_node_crypto_namespaceObject = require("node:crypto");
+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 validateCommonNodeInput(input, index) {
+    if (void 0 !== input.prompt && 'string' != typeof input.prompt) throw new WorkflowParseError(`${formatStep(index)} "prompt" must be a string.`, {
+        index,
+        prompt: input.prompt
+    });
+}
+function normalizeStep(value, index = 0) {
+    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) return {
+        node,
+        input: {
+            prompt: 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;
+    validateCommonNodeInput(input, index);
+    return {
+        node,
+        input,
+        meta: normalizeMeta(rawMeta, index)
+    };
+}
+function normalizeSteps(steps) {
+    if (!Array.isArray(steps)) throw new WorkflowParseError('Steps must be an array.');
+    return steps.map((step, index)=>normalizeStep(step, index));
+}
+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.'));
+    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) {
+    validateCommonNodeInput(step.input, stepIndex);
+    const startedAt = new Date();
+    const abortController = new AbortController();
+    const timeoutMs = step.meta.timeoutMs;
+    let timeout;
+    let timeoutError;
+    const execution = Promise.resolve().then(()=>execute(abortController.signal));
+    const timedExecution = void 0 === timeoutMs ? execution : Promise.race([
+        execution,
+        new Promise((_, reject)=>{
+            timeout = setTimeout(()=>{
+                timeoutError = new StepTimeoutError(timeoutMs, step.node);
+                abortController.abort(timeoutError);
+                reject(timeoutError);
+            }, timeoutMs);
+        })
+    ]);
+    try {
+        const output = validateNodeOutput(await timedExecution, 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(timeoutError ?? error, step.node)
+        };
+    } finally{
+        if (void 0 !== timeout) clearTimeout(timeout);
+    }
+}
+async function executeStep(step, node, target, context) {
+    const phase = 'case' === target.scope ? target.case.phase : target.document.phase;
+    const stepIndex = 'case' === target.scope ? target.case.stepIndex : target.document.stepIndex;
+    return executeNode(step, (signal)=>{
+        const common = {
+            input: step.input,
+            $: step.meta,
+            signal,
+            context
+        };
+        return 'case' === target.scope ? node.execute({
+            ...common,
+            scope: 'case',
+            case: target.case
+        }) : node.execute({
+            ...common,
+            scope: 'document',
+            document: target.document
+        });
+    }, phase, stepIndex);
+}
+function createDocumentRuntime(document, options) {
+    const documentRunId = options.createDocumentRunId?.() ?? (0, external_node_crypto_namespaceObject.randomUUID)();
+    const startedAt = new Date();
+    const beforeAll = [];
+    const afterAll = [];
+    const completedNodes = [];
+    const nodes = {
+        beforeAll: document.lifecycle.beforeAll.map((step)=>options.resolveNode(step.node)),
+        afterAll: document.lifecycle.afterAll.map((step)=>options.resolveNode(step.node))
+    };
+    const info = {
+        documentId: document.documentId,
+        documentRunId,
+        projectId: document.projectId,
+        sourcePath: document.sourcePath,
+        cases: document.cases.map((caseDefinition)=>caseDefinition.definition),
+        lifecycle: document.lifecycle,
+        env: Object.freeze({
+            ...process.env
+        })
+    };
+    const teardownStack = [];
+    let acceptingTeardowns = void 0 !== options.setupDocument;
+    let context;
+    let setupError;
+    let started = false;
+    let finishedResult;
+    const createResult = (teardownErrors = [])=>{
+        const endedAt = new Date();
+        return {
+            documentId: document.documentId,
+            documentRunId,
+            projectId: document.projectId,
+            sourcePath: document.sourcePath,
+            status: setupError || completedNodes.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
+            ],
+            ...setupError ? {
+                setupError
+            } : {},
+            ...teardownErrors.length > 0 ? {
+                teardownErrors
+            } : {}
+        };
+    };
+    const runPhase = async (phase, results)=>{
+        for (const [stepIndex, step] of document.lifecycle[phase].entries()){
+            const documentContext = {
+                documentId: document.documentId,
+                documentRunId,
+                projectId: document.projectId,
+                sourcePath: document.sourcePath,
+                phase,
+                stepIndex,
+                completedNodes: Object.freeze([
+                    ...completedNodes
+                ])
+            };
+            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);
+            await options.onStepResult?.(stepInfo, result);
+            results.push(result);
+            completedNodes.push(result);
+            if ('failed' === result.status && !result.continuedAfterError) break;
+        }
+    };
+    const onTeardown = (teardown)=>{
+        if (!acceptingTeardowns) throw new WorkflowLifecycleError('onTeardown() can only be called while setupDocument is running.', {
+            documentId: document.documentId,
+            documentRunId
+        });
+        if ('function' != typeof teardown) throw new WorkflowLifecycleError('onTeardown() requires a teardown function.', {
+            documentId: document.documentId,
+            documentRunId
+        });
+        teardownStack.push({
+            registrationIndex: teardownStack.length,
+            teardown
+        });
+    };
+    return {
+        get context () {
+            return context;
+        },
+        get canRunCases () {
+            return started && !setupError && !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 (options.setupDocument) try {
+                context = await options.setupDocument({
+                    ...info,
+                    onTeardown
+                });
+            } catch (error) {
+                setupError = new WorkflowDocumentSetupError(error, {
+                    documentId: document.documentId,
+                    documentRunId
+                });
+            } finally{
+                acceptingTeardowns = false;
+            }
+            if (!setupError) 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
+            });
+            if (!setupError) await runPhase('afterAll', afterAll);
+            const statusBeforeTeardown = createResult().status;
+            const teardownErrors = [];
+            for (const { registrationIndex, teardown } of teardownStack.reverse())try {
+                await teardown({
+                    ...info,
+                    beforeAll: Object.freeze([
+                        ...beforeAll
+                    ]),
+                    afterAll: Object.freeze([
+                        ...afterAll
+                    ]),
+                    status: statusBeforeTeardown,
+                    ...setupError ? {
+                        setupError
+                    } : {}
+                });
+            } catch (error) {
+                teardownErrors.push(new WorkflowDocumentTeardownError(error, {
+                    documentId: document.documentId,
+                    documentRunId,
+                    registrationIndex
+                }));
+            }
+            finishedResult = createResult(teardownErrors);
+            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 completedNodes = [];
+    const runPhase = async (phase, results)=>{
+        for (const [stepIndex, step] of phases[phase].entries()){
+            const caseContext = {
+                caseId: collectedCase.caseId,
+                runId,
+                name: collectedCase.definition.name,
+                sourcePath: collectedCase.sourcePath,
+                caseIndex: collectedCase.caseIndex,
+                phase,
+                stepIndex,
+                completedSteps: Object.freeze([
+                    ...steps
+                ]),
+                completedNodes: Object.freeze([
+                    ...completedNodes
+                ])
+            };
+            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);
+            await options.onStepResult?.(stepInfo, result);
+            results.push(result);
+            completedNodes.push(result);
+            if ('failed' === result.status && !result.continuedAfterError) break;
+        }
+    };
+    await runPhase('beforeEach', beforeEach);
+    if (!beforeEach.some((step)=>'failed' === step.status)) await runPhase('steps', steps);
+    await runPhase('afterEach', afterEach);
+    const endedAt = new Date();
+    const result = {
+        caseId: collectedCase.caseId,
+        runId,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        status: completedNodes.some((step)=>'failed' === step.status) ? 'failed' : 'success',
+        beforeEach,
+        steps,
+        afterEach,
+        startedAt: startedAt.toISOString(),
+        endedAt: endedAt.toISOString(),
+        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
+    };
+    await options.onResult?.(result);
+    return result;
+}
+const asNotRun = (collectedCase, reason)=>({
+        caseId: collectedCase.caseId,
+        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 runtime = createDocumentRuntime(document, {
+        resolveNode: options.resolveNode,
+        setupDocument: options.setupDocument,
+        onStepStart: options.onStepStart,
+        onStepResult: options.onStepResult,
+        onResult: options.onDocumentResult,
+        createDocumentRunId: createDocumentRunId ? ()=>createDocumentRunId(document) : void 0
+    });
+    const cases = [];
+    let runtimeStarted = false;
+    let documentResult;
+    let executionError;
+    try {
+        runtimeStarted = true;
+        await runtime.start();
+        if (runtime.canRunCases) for (const collectedCase of document.cases){
+            if (options.shouldStop?.()) {
+                cases.push(asNotRun(collectedCase, 'interrupted'));
+                continue;
+            }
+            await options.onCaseStart?.(collectedCase);
+            const run = await runCollectedCase(collectedCase, {
+                resolveNode: options.resolveNode,
+                beforeEach: document.lifecycle.beforeEach,
+                afterEach: document.lifecycle.afterEach,
+                context: runtime.context,
+                onStepStart: options.onStepStart,
+                onStepResult: options.onStepResult,
+                onResult: options.onCaseResult,
+                createRunId: createCaseRunId ? ()=>createCaseRunId(collectedCase) : void 0
+            });
+            cases.push({
+                caseId: collectedCase.caseId,
+                name: collectedCase.definition.name,
+                sourcePath: collectedCase.sourcePath,
+                caseIndex: collectedCase.caseIndex,
+                status: run.status,
+                run
+            });
+        }
+        else cases.push(...document.cases.map((collectedCase)=>asNotRun(collectedCase, 'document-start-failed')));
+    } 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 collect_isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+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]}".`, {
+        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_namespaceObject.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.');
+    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_namespaceObject.sep).join('/');
+    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).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 normalized;
+        });
+    };
+    const lifecycle = {
+        beforeAll: normalizeLifecycle('beforeAll'),
+        beforeEach: normalizeLifecycle('beforeEach'),
+        afterEach: normalizeLifecycle('afterEach'),
+        afterAll: normalizeLifecycle('afterAll')
+    };
+    const ids = new Set();
+    const cases = parsed.cases.map((definition, caseIndex)=>{
+        if (!collect_isMapping(definition)) throw new WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
+            caseIndex
+        });
+        rejectUnknownKeys(definition, [
+            'name',
+            'steps'
+        ], `Case ${caseIndex + 1}`);
+        if ('string' != typeof definition.name || 0 === definition.name.trim().length) throw new WorkflowParseError(`Case ${caseIndex + 1} name must be a non-empty string.`, {
+            caseIndex
+        });
+        if (!Array.isArray(definition.steps) || 0 === definition.steps.length) throw new WorkflowParseError(`Case ${caseIndex + 1} steps must be a non-empty array.`, {
+            caseIndex
+        });
+        const steps = normalizeSteps(definition.steps).map((normalized, stepIndex)=>{
+            if (!options.resolveNode(normalized.node)) throw new WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
+                caseIndex,
+                stepIndex,
+                node: normalized.node
+            });
+            return normalized;
+        });
+        const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
+        if (ids.has(caseId)) throw new WorkflowParseError(`Case id collision: ${caseId}.`, {
+            caseId
+        });
+        ids.add(caseId);
+        return {
+            caseId,
+            projectId: source.projectId,
+            sourcePath,
+            caseIndex,
+            definition: {
+                name: definition.name,
+                steps
+            }
+        };
+    });
+    return {
+        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
+        projectId: source.projectId,
+        sourcePath,
+        lifecycle,
+        cases
+    };
+}
+const writeJson = (path, value)=>{
+    (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(path), {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(path, JSON.stringify(value, null, 2));
+};
+const toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
+const caseRunResultPath = (result)=>toPosix((0, external_node_path_namespaceObject.join)('runs', result.caseId, `${result.runId}.json`));
+const workflowDocumentRunResultPath = (result)=>toPosix((0, external_node_path_namespaceObject.join)('documents', result.documentId, `${result.documentRunId}.json`));
+const collectionErrorPath = (sourcePath)=>{
+    const id = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(sourcePath).digest('hex');
+    return toPosix((0, external_node_path_namespaceObject.join)('collection-errors', `${id}.json`));
+};
+const writeWorkflowDocumentRunResult = (resultDir, result)=>{
+    writeJson((0, external_node_path_namespaceObject.join)(resultDir, workflowDocumentRunResultPath(result)), result);
+};
+const writeCaseRunResult = (resultDir, result)=>{
+    writeJson((0, external_node_path_namespaceObject.join)(resultDir, caseRunResultPath(result)), result);
+};
+const writeCollectionError = (resultDir, collectionError)=>{
+    writeJson((0, external_node_path_namespaceObject.join)(resultDir, collectionErrorPath(collectionError.sourcePath)), {
+        kind: 'collection-error',
+        ...collectionError
+    });
+};
+const writeWorkflowProjectRunResult = (resultDir, options)=>{
+    const { result } = options;
+    writeJson((0, external_node_path_namespaceObject.join)(resultDir, 'project.json'), {
+        version: 3,
+        projectId: options.projectId,
+        projectRoot: options.projectRoot,
+        ...options.configPath ? {
+            configPath: options.configPath
+        } : {},
+        fileSelection: {
+            include: [
+                ...options.fileSelection.include
+            ],
+            ...options.fileSelection.exclude ? {
+                exclude: [
+                    ...options.fileSelection.exclude
+                ]
+            } : {}
+        },
+        sources: options.sources,
+        status: result.status,
+        exitCode: result.exitCode,
+        resultDir: result.resultDir,
+        summary: result.summary,
+        cases: result.cases.map((caseResult)=>({
+                caseId: caseResult.caseId,
+                name: caseResult.name,
+                sourcePath: caseResult.sourcePath,
+                caseIndex: caseResult.caseIndex,
+                status: caseResult.status,
+                ...caseResult.run ? {
+                    resultFile: caseRunResultPath(caseResult.run)
+                } : {},
+                ...caseResult.notRunReason ? {
+                    notRunReason: caseResult.notRunReason
+                } : {}
+            })),
+        documents: result.documents.map((document)=>({
+                documentId: document.documentId,
+                sourcePath: document.sourcePath,
+                status: document.status,
+                resultFile: workflowDocumentRunResultPath(document)
+            })),
+        collectionErrors: result.collectionErrors.map((error)=>({
+                sourcePath: error.sourcePath,
+                errorFile: collectionErrorPath(error.sourcePath)
+            }))
+    });
+};
+const CONFIG_NAMES = [
+    'midscene.workflow.config.cjs',
+    'midscene.workflow.config.js'
+];
+const ALWAYS_IGNORED_PATTERNS = [
+    '.git/**',
+    '.midscene/**',
+    'node_modules/**',
+    '**/.git/**',
+    '**/.midscene/**',
+    '**/node_modules/**'
+];
+const DEFAULT_WORKFLOW_FILE_SELECTION = {
+    include: [
+        '**/*.{yaml,yml}'
+    ]
+};
+const workflow_runner_toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
+const discoverWorkflowFiles = (projectRoot, selection = DEFAULT_WORKFLOW_FILE_SELECTION)=>{
+    const root = (0, external_node_path_namespaceObject.resolve)(projectRoot);
+    const normalized = validateWorkflowFileSelection(selection);
+    if (!normalized) throw new TypeError('Workflow 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));
+    return [
+        ...new Set(files.map((file)=>(0, external_node_path_namespaceObject.resolve)(file)))
+    ].sort((a, b)=>{
+        const relativeA = workflow_runner_toPosix((0, external_node_path_namespaceObject.relative)(root, a));
+        const relativeB = workflow_runner_toPosix((0, external_node_path_namespaceObject.relative)(root, b));
+        return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
+    });
+};
+const discoverWorkflowConfig = (projectRoot)=>CONFIG_NAMES.map((name)=>(0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.resolve)(projectRoot), name)).find(external_node_fs_namespaceObject.existsSync);
+const defaultResultDir = (projectRoot)=>(0, external_node_path_namespaceObject.join)(projectRoot, '.midscene', 'workflow-results', `${Date.now()}-${process.pid}`);
+const assertDirectory = (path, label)=>{
+    if (!(0, external_node_fs_namespaceObject.existsSync)(path) || !(0, external_node_fs_namespaceObject.statSync)(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
+};
+const asCollectionError = (sourcePath, error)=>({
+        sourcePath,
+        error: error instanceof WorkflowError ? error : new WorkflowParseError(`Failed to collect workflow document "${sourcePath}": ${error instanceof Error ? error.message : String(error)}`, {
+            sourcePath
+        }, error)
+    });
+const workflow_runner_asNotRun = (collectedCase, reason)=>({
+        caseId: collectedCase.caseId,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        status: 'not-run',
+        notRunReason: reason
+    });
+const summarize = (cases, documents, collectionErrors)=>({
+        total: cases.length,
+        passed: cases.filter((caseResult)=>'success' === caseResult.status).length,
+        failed: cases.filter((caseResult)=>'failed' === caseResult.status).length,
+        notRun: cases.filter((caseResult)=>'not-run' === caseResult.status).length,
+        collectionErrors: collectionErrors.length,
+        documentFailures: documents.filter((document)=>'failed' === document.status).length
+    });
+const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
+const workflow_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} ${workflow_runner_formatStep(info)} (${result.durationMs} ms)${error}${continuation}`;
+};
+const formatNotRunReason = (reason)=>'document-start-failed' === reason ? 'document start failed' : 'run interrupted';
+async function runWorkflowProject(options = {}) {
+    const cwd = (0, external_node_path_namespaceObject.resolve)(options.cwd ?? process.cwd());
+    assertDirectory(cwd, 'Workflow working directory');
+    const cliProjectRoot = options.projectRoot ? (0, external_node_path_namespaceObject.resolve)(cwd, options.projectRoot) : void 0;
+    if (cliProjectRoot) assertDirectory(cliProjectRoot, 'Workflow project directory');
+    const configSearchRoot = cliProjectRoot ?? cwd;
+    const configPath = options.configPath ? (0, external_node_path_namespaceObject.resolve)(configSearchRoot, options.configPath) : discoverWorkflowConfig(configSearchRoot);
+    if (options.configPath && (!configPath || !(0, external_node_fs_namespaceObject.existsSync)(configPath))) throw new Error(`Workflow config does not exist: ${configPath}`);
+    const project = loadWorkflowProjectSync(configPath);
+    const projectRoot = cliProjectRoot ? cliProjectRoot : project.root ? (0, external_node_path_namespaceObject.resolve)(configPath ? (0, external_node_path_namespaceObject.dirname)(configPath) : configSearchRoot, project.root) : cwd;
+    assertDirectory(projectRoot, 'Workflow project root');
+    const fileSelection = project.files ?? DEFAULT_WORKFLOW_FILE_SELECTION;
+    const files = discoverWorkflowFiles(projectRoot, fileSelection);
+    if (0 === files.length) throw new Error(`No workflow YAML files found in ${projectRoot}.`);
+    const resultDir = options.resultDir ? (0, external_node_path_namespaceObject.resolve)(cwd, options.resultDir) : defaultResultDir(projectRoot);
+    (0, external_node_fs_namespaceObject.mkdirSync)(resultDir, {
+        recursive: true
+    });
+    const projectId = (0, external_node_path_namespaceObject.basename)(projectRoot);
+    const sources = files.map((absolutePath)=>({
+            projectId,
+            sourcePath: workflow_runner_toPosix((0, external_node_path_namespaceObject.relative)(projectRoot, absolutePath)),
+            absolutePath
+        }));
+    const collectedDocuments = [];
+    const collectionErrors = [];
+    const collectedCaseIds = new Set();
+    const progress = options.onProgress ?? (()=>{});
+    for (const source of sources)try {
+        const document = collectWorkflowDocument(source, {
+            resolveNode: project.resolveNode
+        });
+        const collided = document.cases.find((collectedCase)=>collectedCaseIds.has(collectedCase.caseId));
+        if (collided) throw new WorkflowParseError(`Case id collision: ${collided.caseId}.`, {
+            caseId: collided.caseId,
+            sourcePath: source.sourcePath
+        });
+        for (const collectedCase of document.cases)collectedCaseIds.add(collectedCase.caseId);
+        collectedDocuments.push({
+            document
+        });
+    } catch (error) {
+        const collectionError = asCollectionError(source.sourcePath, error);
+        collectionErrors.push(collectionError);
+        writeCollectionError(resultDir, collectionError);
+    }
+    const collectedCaseCount = collectedDocuments.reduce((total, { document })=>total + document.cases.length, 0);
+    progress(`midscene-workflow: collected ${collectedDocuments.length} documents, ${collectedCaseCount} cases, ${collectionErrors.length} collection errors`);
+    for (const collectionError of collectionErrors)progress(`✗ collection: ${collectionError.sourcePath} — ${collectionError.error.message}`);
+    const cases = [];
+    const documents = [];
+    let interrupted = false;
+    const handleSignal = ()=>{
+        interrupted = true;
+    };
+    process.on('SIGINT', handleSignal);
+    process.on('SIGTERM', handleSignal);
+    try {
+        for (const [documentIndex, { document }] of collectedDocuments.entries()){
+            if (interrupted) {
+                progress(`[document ${documentIndex + 1}/${collectedDocuments.length}] ${document.sourcePath}`);
+                const notRunCases = document.cases.map((collectedCase)=>workflow_runner_asNotRun(collectedCase, 'interrupted'));
+                for (const outcome of notRunCases)progress(`  - case ${outcome.caseIndex + 1}/${document.cases.length}: ${outcome.name} (not run: run interrupted)`);
+                progress(`- document ${documentIndex + 1}/${collectedDocuments.length}: ${document.sourcePath} (not run: run interrupted)`);
+                cases.push(...notRunCases);
+                continue;
+            }
+            progress(`[document ${documentIndex + 1}/${collectedDocuments.length}] ${document.sourcePath}`);
+            const execution = await runWorkflowDocument(document, {
+                resolveNode: project.nodes.require.bind(project.nodes),
+                setupDocument: project.setupDocument,
+                shouldStop: ()=>interrupted,
+                onCaseStart: (collectedCase)=>{
+                    progress(`  [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
+                },
+                onStepStart: (info)=>{
+                    const indent = 'case' === info.scope ? '    ' : '  ';
+                    progress(`${indent}→ ${workflow_runner_formatStep(info)}`);
+                },
+                onStepResult: (info, result)=>{
+                    progress(formatStepResult(info, result));
+                },
+                onCaseResult: (run)=>{
+                    writeCaseRunResult(resultDir, run);
+                    const symbol = 'success' === run.status ? '✓' : '✗';
+                    progress(`  ${symbol} case ${run.caseIndex + 1}/${document.cases.length}: ${run.name} (${run.durationMs} ms)`);
+                },
+                onDocumentResult: (documentResult)=>writeWorkflowDocumentRunResult(resultDir, documentResult)
+            });
+            for (const outcome of execution.cases)if ('not-run' === outcome.status && outcome.notRunReason) progress(`  - case ${outcome.caseIndex + 1}/${document.cases.length}: ${outcome.name} (not run: ${formatNotRunReason(outcome.notRunReason)})`);
+            const documentSymbol = 'success' === execution.document.status ? '✓' : '✗';
+            const documentError = execution.document.setupError ?? execution.document.teardownErrors?.[0];
+            progress(`${documentSymbol} document ${documentIndex + 1}/${collectedDocuments.length}: ${document.sourcePath} (${execution.document.durationMs} ms)${documentError ? ` — ${documentError.message}` : ''}`);
+            cases.push(...execution.cases);
+            documents.push(execution.document);
+        }
+    } finally{
+        process.off('SIGINT', handleSignal);
+        process.off('SIGTERM', handleSignal);
+    }
+    const summary = summarize(cases, documents, collectionErrors);
+    const failed = interrupted || summary.failed > 0 || summary.notRun > 0 || summary.collectionErrors > 0 || summary.documentFailures > 0;
+    const result = {
+        status: failed ? 'failed' : 'success',
+        exitCode: failed ? 1 : 0,
+        resultDir,
+        summary,
+        cases,
+        documents,
+        collectionErrors
+    };
+    writeWorkflowProjectRunResult(resultDir, {
+        projectId,
+        projectRoot,
+        ...configPath ? {
+            configPath
+        } : {},
+        fileSelection,
+        sources,
+        result
+    });
+    return result;
+}
+exports.DEFAULT_WORKFLOW_FILE_SELECTION = __webpack_exports__.DEFAULT_WORKFLOW_FILE_SELECTION;
+exports.defineWorkflowProject = __webpack_exports__.defineWorkflowProject;
+exports.discoverWorkflowConfig = __webpack_exports__.discoverWorkflowConfig;
+exports.discoverWorkflowFiles = __webpack_exports__.discoverWorkflowFiles;
+exports.loadWorkflowProjectSync = __webpack_exports__.loadWorkflowProjectSync;
+exports.runWorkflowProject = __webpack_exports__.runWorkflowProject;
+exports.validateWorkflowFileSelection = __webpack_exports__.validateWorkflowFileSelection;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_WORKFLOW_FILE_SELECTION",
+    "defineWorkflowProject",
+    "discoverWorkflowConfig",
+    "discoverWorkflowFiles",
+    "loadWorkflowProjectSync",
+    "runWorkflowProject",
+    "validateWorkflowFileSelection"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.js.map