@midscene/test 0.0.0 → 1.10.4-beta-20260715034325.0

package/dist/es/index.mjs

@@ -0,0 +1,843 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { sep } from "node:path";
+import { JSON_SCHEMA, load } from "js-yaml";
+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 {
+    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 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
+        });
+    }
+}
+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 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));
+}
+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);
+    }
+}
+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);
+}
+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?.() ?? 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;
+}
+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',
+                steps: normalizeSteps(input.steps)
+            }
+        };
+        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?.() ?? 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;
+        }
+    };
+}
+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 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)=>createHash('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath,
+        caseIndex
+    ])).digest('hex');
+const createWorkflowDocumentId = (projectId, sourcePath)=>createHash('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath
+    ])).digest('hex');
+function collectWorkflowDocument(source, options) {
+    let parsed;
+    try {
+        parsed = load(readFileSync(source.absolutePath, 'utf8'), {
+            schema: 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(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
+    };
+}
+export { CaseExecutionError, CaseRunner, DuplicateNodeError, NodeDefinitionError, NodeExecutionError, NodeInputValidationError, NodeNotFoundError, NodeRegistry, StepTimeoutError, WorkflowDocumentExecutionError, WorkflowDocumentSetupError, WorkflowDocumentTeardownError, WorkflowError, WorkflowLifecycleError, WorkflowParseError, collectWorkflowDocument, createCaseId, createCaseRunner, createDocumentRuntime, createWorkflowDocumentId, defineNode, normalizeNodeExecutionError, normalizeStep, normalizeSteps, runWorkflowDocument, validateCommonNodeInput };
+
+//# sourceMappingURL=index.mjs.map