@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/test-runner/engine/document-runtime.mjs

@@ -0,0 +1,273 @@
+import { getDebug } from "@midscene/shared/logger";
+import { uuid } from "@midscene/shared/utils";
+import { NodeScopeTeardownError, WorkflowLifecycleError } from "../errors.mjs";
+import { executeStep } from "./execute-step.mjs";
+import { WorkflowExecutionFailure, asExecutionError } from "./execution-failure.mjs";
+import { ResourceCleanupDeferredError, cleanupScopeResources, createResourceScope } from "./resource-operations.mjs";
+import { reportPathsFromTeardown } from "./scope-teardown.mjs";
+function createDocumentRuntime(document, options) {
+    const documentRunId = options.createDocumentRunId?.() ?? uuid();
+    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,
+        retry: 0
+    });
+    let context = options.projectContext;
+    const resourceScope = createResourceScope(options.signal);
+    const signal = resourceScope.signal;
+    const nodeTeardownStack = [];
+    let acceptingNodeTeardowns = true;
+    let started = false;
+    let finishedResult;
+    let finishPromise;
+    const reportPaths = new Set();
+    const reportSources = [];
+    const executionErrors = [];
+    const hostErrors = [];
+    let acceptingSetupTeardowns = false;
+    const createResult = (teardownErrors = [])=>{
+        const endedAt = new Date();
+        return {
+            documentId: document.documentId,
+            documentRunId,
+            ...void 0 === options.documentAttemptIndex ? {} : {
+                attemptIndex: options.documentAttemptIndex
+            },
+            projectId: document.projectId,
+            projectName: project.name,
+            sourcePath: document.sourcePath,
+            status: executionErrors.length > 0 || hostErrors.length > 0 || 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
+            ],
+            ...executionErrors.length ? {
+                executionErrors: executionErrors.map(asExecutionError)
+            } : {},
+            ...hostErrors.length ? {
+                hostErrors: [
+                    ...hostErrors
+                ]
+            } : {},
+            ...teardownErrors.length > 0 ? {
+                teardownErrors: [
+                    ...teardownErrors
+                ]
+            } : {},
+            ...reportPaths.size > 0 ? {
+                reportPaths: [
+                    ...reportPaths
+                ]
+            } : {},
+            ...reportSources.length ? {
+                reportSources: [
+                    ...reportSources
+                ]
+            } : {}
+        };
+    };
+    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
+                    });
+                }
+            });
+            results.push(result);
+            await options.onStepResult?.(stepInfo, result);
+            if ('failed' === result.status && !result.continuedAfterError) break;
+        }
+    };
+    return {
+        signal,
+        get context () {
+            return context;
+        },
+        get canRunCases () {
+            return started && 0 === executionErrors.length && 0 === hostErrors.length && !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 && options.documentSetup) {
+                acceptingSetupTeardowns = true;
+                try {
+                    context = await options.documentSetup.setup({
+                        project,
+                        projectContext: options.projectContext,
+                        document: {
+                            documentId: document.documentId,
+                            documentRunId,
+                            sourcePath: document.sourcePath,
+                            attemptIndex: options.documentAttemptIndex ?? 0
+                        },
+                        signal,
+                        onTeardown (teardown) {
+                            if (!acceptingSetupTeardowns || 'function' != typeof teardown) throw new WorkflowLifecycleError('Document setup onTeardown() requires a function registered during setup.', {
+                                documentId: document.documentId,
+                                documentRunId
+                            });
+                            nodeTeardownStack.push({
+                                registrationIndex: nodeTeardownStack.length,
+                                node: options.documentSetup.name,
+                                teardown,
+                                host: true
+                            });
+                        }
+                    });
+                } catch (error) {
+                    hostErrors.push({
+                        phase: 'setup',
+                        error: asExecutionError(error)
+                    });
+                } finally{
+                    acceptingSetupTeardowns = false;
+                }
+            }
+            try {
+                if (!signal.aborted && !hostErrors.length) await runPhase('beforeAll', beforeAll);
+            } catch (error) {
+                executionErrors.push(error);
+                throw new WorkflowExecutionFailure(createResult(), [
+                    ...executionErrors
+                ]);
+            }
+            return createResult();
+        },
+        async finish () {
+            if (finishPromise) return finishPromise;
+            if (!started) throw new WorkflowLifecycleError('Workflow document runtime must start before it can finish.', {
+                documentId: document.documentId,
+                documentRunId
+            });
+            finishPromise = (async ()=>{
+                const teardownErrors = [];
+                const cleanupExecutionErrors = [];
+                let deferredCleanup = false;
+                const cleanup = async ()=>{
+                    const priorTeardownErrors = teardownErrors.length;
+                    acceptingNodeTeardowns = false;
+                    for (const { registrationIndex, node, teardown, host } of nodeTeardownStack.reverse())try {
+                        const released = await teardown();
+                        reportSources.push(...released?.reportSources ?? []);
+                        for (const path of reportPathsFromTeardown(released))reportPaths.add(path);
+                    } catch (error) {
+                        if (host) {
+                            hostErrors.push({
+                                phase: 'cleanup',
+                                error: asExecutionError(error)
+                            });
+                            executionErrors.push(error);
+                            cleanupExecutionErrors.push(error);
+                            continue;
+                        }
+                        teardownErrors.push(new NodeScopeTeardownError(error, {
+                            scope: 'document',
+                            scopeId: documentRunId,
+                            node,
+                            registrationIndex
+                        }));
+                    }
+                    if (deferredCleanup) {
+                        const errors = [
+                            ...cleanupExecutionErrors,
+                            ...teardownErrors.slice(priorTeardownErrors)
+                        ];
+                        if (errors.length) throw new AggregateError(errors, 'Deferred document cleanup failed');
+                    }
+                };
+                try {
+                    if (document.lifecycle.afterAll.length || nodeTeardownStack.length) await cleanupScopeResources(signal, cleanup, {
+                        beforeCleanup: async (cleanupSignal)=>{
+                            try {
+                                if (!hostErrors.some((error)=>'setup' === error.phase)) await runPhase('afterAll', afterAll, cleanupSignal);
+                            } catch (error) {
+                                executionErrors.push(error);
+                                cleanupExecutionErrors.push(error);
+                            }
+                        },
+                        onDeferredError: (error)=>getDebug('runner:cleanup', {
+                                console: true
+                            })(`Deferred document cleanup failed: ${String(error)}`)
+                    });
+                    else acceptingNodeTeardowns = false;
+                } catch (error) {
+                    deferredCleanup = error instanceof ResourceCleanupDeferredError;
+                    if (!deferredCleanup) acceptingNodeTeardowns = false;
+                    teardownErrors.push(new NodeScopeTeardownError(error, {
+                        scope: 'document',
+                        scopeId: documentRunId,
+                        node: 'resource-drain',
+                        registrationIndex: -1
+                    }));
+                }
+                finishedResult = createResult(teardownErrors);
+                try {
+                    await options.onResult?.(finishedResult);
+                } catch (error) {
+                    executionErrors.push(error);
+                    finishedResult = createResult(teardownErrors);
+                }
+                resourceScope.dispose();
+                if (executionErrors.length) throw new WorkflowExecutionFailure(finishedResult, [
+                    ...executionErrors
+                ]);
+                return finishedResult;
+            })();
+            return finishPromise;
+        }
+    };
+}
+export { createDocumentRuntime };
+
+//# sourceMappingURL=document-runtime.mjs.map

package/dist/es/test-runner/engine/document-runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/document-runtime.mjs","sources":["../../../../src/test-runner/engine/document-runtime.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport { uuid as randomUUID } from '@midscene/shared/utils';\nimport {\n  NodeScopeTeardownError,\n  type WorkflowError,\n  WorkflowLifecycleError,\n} from '../errors';\nimport type { CollectedWorkflowDocument } from '../parser/types';\nimport { executeStep } from './execute-step';\nimport {\n  WorkflowExecutionFailure,\n  asExecutionError,\n} from './execution-failure';\nimport {\n  ResourceCleanupDeferredError,\n  cleanupScopeResources,\n  createResourceScope,\n} from './resource-operations';\nimport { reportPathsFromTeardown } from './scope-teardown';\nimport type {\n  CreateDocumentRuntimeOptions,\n  DocumentNodePhase,\n  NodeDocumentContext,\n  NodeScopeTeardown,\n  StepRunResult,\n  WorkflowDocumentRunResult,\n  WorkflowDocumentRuntime,\n  WorkflowHostError,\n} from './types';\n\nexport function createDocumentRuntime<TContext = undefined>(\n  document: CollectedWorkflowDocument,\n  options: CreateDocumentRuntimeOptions<TContext>,\n): WorkflowDocumentRuntime<TContext> {\n  const documentRunId = options.createDocumentRunId?.() ?? randomUUID();\n  const startedAt = new Date();\n  const beforeAll: StepRunResult[] = [];\n  const afterAll: StepRunResult[] = [];\n  const nodes = {\n    beforeAll: document.lifecycle.beforeAll.map((step) =>\n      options.resolveNode(step.node),\n    ),\n    afterAll: document.lifecycle.afterAll.map((step) =>\n      options.resolveNode(step.node),\n    ),\n  };\n  const project =\n    options.project ??\n    Object.freeze({\n      projectId: document.projectId,\n      name: document.projectId,\n      retry: 0,\n    });\n  let context = options.projectContext as TContext;\n  const resourceScope = createResourceScope(options.signal);\n  const signal = resourceScope.signal;\n  const nodeTeardownStack: Array<{\n    registrationIndex: number;\n    node: string;\n    teardown: NodeScopeTeardown;\n    host?: boolean;\n  }> = [];\n  let acceptingNodeTeardowns = true;\n  let started = false;\n  let finishedResult: WorkflowDocumentRunResult | undefined;\n  let finishPromise: Promise<WorkflowDocumentRunResult> | undefined;\n  const reportPaths = new Set<string>();\n  const reportSources: import('./types').WorkflowReportSource[] = [];\n  const executionErrors: unknown[] = [];\n  const hostErrors: WorkflowHostError[] = [];\n  let acceptingSetupTeardowns = false;\n\n  const createResult = (\n    teardownErrors: WorkflowError[] = [],\n  ): WorkflowDocumentRunResult => {\n    const endedAt = new Date();\n    return {\n      documentId: document.documentId,\n      documentRunId,\n      ...(options.documentAttemptIndex === undefined\n        ? {}\n        : { attemptIndex: options.documentAttemptIndex }),\n      projectId: document.projectId,\n      projectName: project.name,\n      sourcePath: document.sourcePath,\n      status:\n        executionErrors.length > 0 ||\n        hostErrors.length > 0 ||\n        beforeAll.some((step) => step.status === 'failed') ||\n        afterAll.some((step) => step.status === 'failed') ||\n        teardownErrors.length > 0\n          ? 'failed'\n          : 'success',\n      startedAt: startedAt.toISOString(),\n      endedAt: endedAt.toISOString(),\n      durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),\n      beforeAll: [...beforeAll],\n      afterAll: [...afterAll],\n      ...(executionErrors.length\n        ? { executionErrors: executionErrors.map(asExecutionError) }\n        : {}),\n      ...(hostErrors.length ? { hostErrors: [...hostErrors] } : {}),\n      ...(teardownErrors.length > 0\n        ? { teardownErrors: [...teardownErrors] }\n        : {}),\n      ...(reportPaths.size > 0 ? { reportPaths: [...reportPaths] } : {}),\n      ...(reportSources.length ? { reportSources: [...reportSources] } : {}),\n    };\n  };\n\n  const runPhase = async (\n    phase: DocumentNodePhase,\n    results: StepRunResult[],\n    executionSignal = signal,\n  ): Promise<void> => {\n    for (const [stepIndex, step] of document.lifecycle[phase].entries()) {\n      const documentContext: NodeDocumentContext = {\n        documentId: document.documentId,\n        documentRunId,\n        projectId: document.projectId,\n        projectName: project.name,\n        sourcePath: document.sourcePath,\n        phase,\n        stepIndex,\n      };\n      const stepInfo = {\n        scope: 'document' as const,\n        node: step.node,\n        stepCount: document.lifecycle[phase].length,\n        document: documentContext,\n      };\n      await options.onStepStart?.(stepInfo);\n      const result = await executeStep(\n        step,\n        nodes[phase][stepIndex],\n        { scope: 'document', document: documentContext },\n        context,\n        {\n          signal: executionSignal,\n          defaultTimeoutMs: options.defaultTimeoutMs,\n          onTeardown(node, teardown) {\n            if (!acceptingNodeTeardowns) {\n              throw new WorkflowLifecycleError(\n                'Node teardown can only be registered while a workflow document is running.',\n                { documentId: document.documentId, documentRunId, node },\n              );\n            }\n            if (typeof teardown !== 'function') {\n              throw new WorkflowLifecycleError(\n                'Node onTeardown() requires a teardown function.',\n                { documentId: document.documentId, documentRunId, node },\n              );\n            }\n            nodeTeardownStack.push({\n              registrationIndex: nodeTeardownStack.length,\n              node,\n              teardown,\n            });\n          },\n        },\n      );\n      results.push(result);\n      await options.onStepResult?.(stepInfo, result);\n      if (result.status === 'failed' && !result.continuedAfterError) break;\n    }\n  };\n\n  return {\n    signal,\n    get context() {\n      return context;\n    },\n    get canRunCases() {\n      return (\n        started &&\n        executionErrors.length === 0 &&\n        hostErrors.length === 0 &&\n        !signal.aborted &&\n        !beforeAll.some((step) => step.status === 'failed')\n      );\n    },\n    async start() {\n      if (started) {\n        throw new WorkflowLifecycleError(\n          'Workflow document runtime has already started.',\n          { documentId: document.documentId, documentRunId },\n        );\n      }\n      started = true;\n      if (!signal.aborted && options.documentSetup) {\n        acceptingSetupTeardowns = true;\n        try {\n          context = await options.documentSetup.setup({\n            project,\n            projectContext: options.projectContext,\n            document: {\n              documentId: document.documentId,\n              documentRunId,\n              sourcePath: document.sourcePath,\n              attemptIndex: options.documentAttemptIndex ?? 0,\n            },\n            signal,\n            onTeardown(teardown) {\n              if (!acceptingSetupTeardowns || typeof teardown !== 'function')\n                throw new WorkflowLifecycleError(\n                  'Document setup onTeardown() requires a function registered during setup.',\n                  { documentId: document.documentId, documentRunId },\n                );\n              nodeTeardownStack.push({\n                registrationIndex: nodeTeardownStack.length,\n                node: options.documentSetup!.name,\n                teardown,\n                host: true,\n              });\n            },\n          });\n        } catch (error) {\n          hostErrors.push({ phase: 'setup', error: asExecutionError(error) });\n        } finally {\n          acceptingSetupTeardowns = false;\n        }\n      }\n      try {\n        if (!signal.aborted && !hostErrors.length)\n          await runPhase('beforeAll', beforeAll);\n      } catch (error) {\n        executionErrors.push(error);\n        throw new WorkflowExecutionFailure(createResult(), [\n          ...executionErrors,\n        ]);\n      }\n      return createResult();\n    },\n    async finish() {\n      if (finishPromise) return finishPromise;\n      if (!started) {\n        throw new WorkflowLifecycleError(\n          'Workflow document runtime must start before it can finish.',\n          { documentId: document.documentId, documentRunId },\n        );\n      }\n      finishPromise = (async () => {\n        const teardownErrors: WorkflowError[] = [];\n        const cleanupExecutionErrors: unknown[] = [];\n        let deferredCleanup = false;\n        const cleanup = async () => {\n          const priorTeardownErrors = teardownErrors.length;\n          acceptingNodeTeardowns = false;\n          for (const {\n            registrationIndex,\n            node,\n            teardown,\n            host,\n          } of nodeTeardownStack.reverse()) {\n            try {\n              const released = await teardown();\n              reportSources.push(...(released?.reportSources ?? []));\n              for (const path of reportPathsFromTeardown(released)) {\n                reportPaths.add(path);\n              }\n            } catch (error) {\n              if (host) {\n                hostErrors.push({\n                  phase: 'cleanup',\n                  error: asExecutionError(error),\n                });\n                executionErrors.push(error);\n                cleanupExecutionErrors.push(error);\n                continue;\n              }\n              teardownErrors.push(\n                new NodeScopeTeardownError(error, {\n                  scope: 'document',\n                  scopeId: documentRunId,\n                  node,\n                  registrationIndex,\n                }),\n              );\n            }\n          }\n          if (deferredCleanup) {\n            const errors = [\n              ...cleanupExecutionErrors,\n              ...teardownErrors.slice(priorTeardownErrors),\n            ];\n            if (errors.length)\n              throw new AggregateError(\n                errors,\n                'Deferred document cleanup failed',\n              );\n          }\n        };\n        try {\n          if (document.lifecycle.afterAll.length || nodeTeardownStack.length)\n            await cleanupScopeResources(signal, cleanup, {\n              beforeCleanup: async (cleanupSignal) => {\n                try {\n                  if (!hostErrors.some((error) => error.phase === 'setup'))\n                    await runPhase('afterAll', afterAll, cleanupSignal);\n                } catch (error) {\n                  executionErrors.push(error);\n                  cleanupExecutionErrors.push(error);\n                }\n              },\n              onDeferredError: (error) =>\n                getDebug('runner:cleanup', { console: true })(\n                  `Deferred document cleanup failed: ${String(error)}`,\n                ),\n            });\n          else acceptingNodeTeardowns = false;\n        } catch (error) {\n          deferredCleanup = error instanceof ResourceCleanupDeferredError;\n          if (!deferredCleanup) acceptingNodeTeardowns = false;\n          teardownErrors.push(\n            new NodeScopeTeardownError(error, {\n              scope: 'document',\n              scopeId: documentRunId,\n              node: 'resource-drain',\n              registrationIndex: -1,\n            }),\n          );\n        }\n        finishedResult = createResult(teardownErrors);\n        try {\n          await options.onResult?.(finishedResult);\n        } catch (error) {\n          executionErrors.push(error);\n          finishedResult = createResult(teardownErrors);\n        }\n        resourceScope.dispose();\n        if (executionErrors.length)\n          throw new WorkflowExecutionFailure(finishedResult, [\n            ...executionErrors,\n          ]);\n        return finishedResult;\n      })();\n      return finishPromise;\n    },\n  };\n}\n"],"names":["createDocumentRuntime","document","options","documentRunId","randomUUID","startedAt","Date","beforeAll","afterAll","nodes","step","project","Object","context","resourceScope","createResourceScope","signal","nodeTeardownStack","acceptingNodeTeardowns","started","finishedResult","finishPromise","reportPaths","Set","reportSources","executionErrors","hostErrors","acceptingSetupTeardowns","createResult","teardownErrors","endedAt","undefined","Math","asExecutionError","runPhase","phase","results","executionSignal","stepIndex","documentContext","stepInfo","result","executeStep","node","teardown","WorkflowLifecycleError","error","WorkflowExecutionFailure","cleanupExecutionErrors","deferredCleanup","cleanup","priorTeardownErrors","registrationIndex","host","released","path","reportPathsFromTeardown","NodeScopeTeardownError","errors","AggregateError","cleanupScopeResources","cleanupSignal","getDebug","String","ResourceCleanupDeferredError"],"mappings":"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"}

package/dist/es/test-runner/engine/execute-step.mjs

@@ -0,0 +1,177 @@
+import { NodeExecutionError, NodeInputValidationError, StepTimeoutError, normalizeNodeExecutionError } from "../errors.mjs";
+import { linkResourceSignal } from "./resource-operations.mjs";
+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, options) {
+    const startedAt = new Date();
+    const abortController = new AbortController();
+    const parentSignal = options.parentSignal;
+    linkResourceSignal(abortController.signal, 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) {
+        let output;
+        let failure = error;
+        if (error instanceof NodeExecutionError && void 0 !== error.output) try {
+            output = validateNodeOutput(error.output, step.node);
+        } catch (validationError) {
+            failure = validationError;
+        }
+        return {
+            ...createStepResultBase(step, startedAt, phase, stepIndex),
+            status: 'failed',
+            continuedAfterError: step.meta.continueOnError,
+            error: normalizeNodeExecutionError(failure, step.node),
+            ...void 0 === output ? {} : {
+                output
+            }
+        };
+    } 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;
+}
+export { executeStep };
+
+//# sourceMappingURL=execute-step.mjs.map

package/dist/es/test-runner/engine/execute-step.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/execute-step.mjs","sources":["../../../../src/test-runner/engine/execute-step.ts"],"sourcesContent":["import {\n  NodeExecutionError,\n  NodeInputValidationError,\n  StepTimeoutError,\n  normalizeNodeExecutionError,\n} from '../errors';\nimport type {\n  NodeDefinition,\n  NodeReportCollector,\n  NodeReportTrace,\n  NodeResult,\n} from '../node/types';\nimport type { NormalizedStep } from '../parser/types';\nimport { linkResourceSignal } from './resource-operations';\nimport type {\n  NodeCaseContext,\n  NodeDocumentContext,\n  NodeExecutionPhase,\n  NodeScopeTeardown,\n  StepRunResult,\n} from './types';\n\nfunction validateNodeOutput<TData>(\n  output: unknown,\n  node: string,\n): NodeResult<TData> | undefined {\n  if (output === undefined) {\n    return undefined;\n  }\n\n  if (typeof output !== 'object' || output === null || Array.isArray(output)) {\n    throw new NodeExecutionError(\n      node,\n      new TypeError('Node output must be an object or undefined.'),\n    );\n  }\n\n  if (\n    'summary' in output &&\n    output.summary !== undefined &&\n    typeof output.summary !== 'string'\n  ) {\n    throw new NodeExecutionError(\n      node,\n      new TypeError('Node output summary must be a string.'),\n    );\n  }\n\n  // Node data is an API value. JSON serialization belongs to the publisher;\n  // serialization failure must not turn completed actions into retryable work.\n\n  return output as NodeResult<TData>;\n}\n\nfunction createStepResultBase(\n  step: NormalizedStep,\n  startedAt: Date,\n  phase: NodeExecutionPhase,\n  stepIndex: number,\n) {\n  const endedAt = new Date();\n  return {\n    node: step.node,\n    phase,\n    stepIndex,\n    input: step.input,\n    meta: step.meta,\n    startedAt: startedAt.toISOString(),\n    endedAt: endedAt.toISOString(),\n    durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),\n  };\n}\n\nasync function executeNode<TOutputData>(\n  step: NormalizedStep,\n  execute: (signal: AbortSignal) => unknown,\n  phase: NodeExecutionPhase,\n  stepIndex: number,\n  options: { parentSignal?: AbortSignal; defaultTimeoutMs?: number },\n): Promise<StepRunResult<TOutputData>> {\n  const startedAt = new Date();\n  const abortController = new AbortController();\n  const parentSignal = options.parentSignal;\n  linkResourceSignal(abortController.signal, parentSignal);\n  const abortFromParent = () => abortController.abort(parentSignal?.reason);\n  if (parentSignal?.aborted) abortFromParent();\n  else parentSignal?.addEventListener('abort', abortFromParent, { once: true });\n  const timeoutMs = step.meta.timeoutMs ?? options.defaultTimeoutMs;\n  let timeout: ReturnType<typeof setTimeout> | undefined;\n  let abortGraceTimeout: ReturnType<typeof setTimeout> | undefined;\n  const execution = Promise.resolve().then(() => {\n    abortController.signal.throwIfAborted();\n    return execute(abortController.signal);\n  });\n  let settleOnAbort: (() => void) | undefined;\n  const abortedExecution = new Promise<never>((_, reject) => {\n    settleOnAbort = () => {\n      // Abort listeners run synchronously. Wait one task before rejecting so a\n      // cooperative node can settle in response to the forwarded abort first.\n      abortGraceTimeout = setTimeout(() => {\n        reject(abortController.signal.reason);\n      }, 0);\n    };\n    if (abortController.signal.aborted) settleOnAbort();\n    else\n      abortController.signal.addEventListener('abort', settleOnAbort, {\n        once: true,\n      });\n  });\n  const timeoutExecution =\n    timeoutMs === undefined\n      ? undefined\n      : new Promise<never>((_, reject) => {\n          timeout = setTimeout(() => {\n            if (abortController.signal.aborted) {\n              reject(abortController.signal.reason);\n              return;\n            }\n            const timeoutError = new StepTimeoutError(timeoutMs, step.node);\n            abortController.abort(timeoutError);\n            reject(timeoutError);\n          }, timeoutMs);\n        });\n  const settledExecution = Promise.race([\n    execution,\n    abortedExecution,\n    ...(timeoutExecution === undefined ? [] : [timeoutExecution]),\n  ]);\n\n  try {\n    const output = validateNodeOutput<TOutputData>(\n      await settledExecution,\n      step.node,\n    );\n    return {\n      ...createStepResultBase(step, startedAt, phase, stepIndex),\n      status: 'success',\n      continuedAfterError: false,\n      ...(output === undefined ? {} : { output }),\n    };\n  } catch (error) {\n    let output: NodeResult<TOutputData> | undefined;\n    let failure = error;\n    if (error instanceof NodeExecutionError && error.output !== undefined) {\n      try {\n        output = validateNodeOutput<TOutputData>(error.output, step.node);\n      } catch (validationError) {\n        failure = validationError;\n      }\n    }\n    return {\n      ...createStepResultBase(step, startedAt, phase, stepIndex),\n      status: 'failed',\n      continuedAfterError: step.meta.continueOnError,\n      error: normalizeNodeExecutionError(failure, step.node),\n      ...(output === undefined ? {} : { output }),\n    };\n  } finally {\n    if (timeout !== undefined) clearTimeout(timeout);\n    if (abortGraceTimeout !== undefined) clearTimeout(abortGraceTimeout);\n    if (settleOnAbort !== undefined) {\n      abortController.signal.removeEventListener('abort', settleOnAbort);\n    }\n    parentSignal?.removeEventListener('abort', abortFromParent);\n  }\n}\n\ntype StepExecutionTarget =\n  | { scope: 'case'; case: NodeCaseContext }\n  | { scope: 'document'; document: NodeDocumentContext };\n\nfunction createNodeReportCollector(node: string): {\n  collector: NodeReportCollector;\n  close(): readonly NodeReportTrace[];\n} {\n  const traces = new Map<string, NodeReportTrace>();\n  let accepting = true;\n\n  return {\n    collector: Object.freeze({\n      addTrace(trace: NodeReportTrace): void {\n        if (!accepting) {\n          throw new NodeExecutionError(\n            node,\n            new Error(\n              'Report traces can only be added while the current Step is running.',\n            ),\n          );\n        }\n        if (\n          !trace ||\n          typeof trace !== 'object' ||\n          (trace as { type?: unknown }).type !== 'midscene-execution'\n        ) {\n          throw new NodeExecutionError(\n            node,\n            new TypeError('Report trace type must be \"midscene-execution\".'),\n          );\n        }\n        if (\n          typeof trace.executionId !== 'string' ||\n          trace.executionId.trim().length === 0\n        ) {\n          throw new NodeExecutionError(\n            node,\n            new TypeError('Report trace executionId must be non-empty.'),\n          );\n        }\n        const normalized = Object.freeze({\n          type: 'midscene-execution' as const,\n          executionId: trace.executionId,\n        });\n        traces.set(`${normalized.type}:${normalized.executionId}`, normalized);\n      },\n    }),\n    close(): readonly NodeReportTrace[] {\n      accepting = false;\n      return Object.freeze([...traces.values()]);\n    },\n  };\n}\n\nasync function parseNodeInput<TInput, TData, TContext>(\n  node: NodeDefinition<TInput, TData, TContext>,\n  input: Record<string, unknown>,\n): Promise<TInput> {\n  if (!node.inputSchema) {\n    return input as TInput;\n  }\n\n  const parsed = await node.inputSchema.safeParseAsync(input);\n  if (!parsed.success) {\n    throw NodeInputValidationError.fromZod(node.name, parsed.error);\n  }\n  return parsed.data as TInput;\n}\n\nexport async function executeStep<\n  TInput = unknown,\n  TOutputData = unknown,\n  TContext = unknown,\n>(\n  step: NormalizedStep,\n  node: NodeDefinition<TInput, TOutputData, TContext>,\n  target: StepExecutionTarget,\n  context: TContext,\n  execution: {\n    signal?: AbortSignal;\n    defaultTimeoutMs?: number;\n    onTeardown?(node: string, teardown: NodeScopeTeardown): void;\n  } = {},\n): Promise<StepRunResult<TOutputData>> {\n  const phase =\n    target.scope === 'case' ? target.case.phase : target.document.phase;\n  const stepIndex =\n    target.scope === 'case' ? target.case.stepIndex : target.document.stepIndex;\n\n  const reportCollector = createNodeReportCollector(step.node);\n  let result: StepRunResult<TOutputData> | undefined;\n\n  try {\n    result = await executeNode<TOutputData>(\n      step,\n      async (signal) => {\n        const input = await parseNodeInput(node, step.input);\n        signal.throwIfAborted();\n        const common = {\n          input,\n          $: step.meta,\n          signal,\n          context,\n          report: reportCollector.collector,\n          onTeardown: (teardown: NodeScopeTeardown) => {\n            if (!execution.onTeardown) {\n              throw new NodeExecutionError(\n                step.node,\n                new Error(\n                  'The current execution scope cannot register teardown.',\n                ),\n              );\n            }\n            execution.onTeardown(step.node, teardown);\n          },\n        };\n        return target.scope === 'case'\n          ? node.execute({ ...common, scope: 'case', case: target.case })\n          : node.execute({\n              ...common,\n              scope: 'document',\n              document: target.document,\n            });\n      },\n      phase,\n      stepIndex,\n      {\n        parentSignal: execution.signal,\n        defaultTimeoutMs: execution.defaultTimeoutMs,\n      },\n    );\n  } finally {\n    const traces = reportCollector.close();\n    if (traces.length > 0 && result) {\n      result = { ...result, report: { traces } };\n    }\n  }\n\n  if (!result) {\n    throw new NodeExecutionError(\n      step.node,\n      new Error('Step execution completed without a result.'),\n    );\n  }\n  return result;\n}\n"],"names":["validateNodeOutput","output","node","undefined","Array","NodeExecutionError","TypeError","createStepResultBase","step","startedAt","phase","stepIndex","endedAt","Date","Math","executeNode","execute","options","abortController","AbortController","parentSignal","linkResourceSignal","abortFromParent","timeoutMs","timeout","abortGraceTimeout","execution","Promise","settleOnAbort","abortedExecution","_","reject","setTimeout","timeoutExecution","timeoutError","StepTimeoutError","settledExecution","error","failure","validationError","normalizeNodeExecutionError","clearTimeout","createNodeReportCollector","traces","Map","accepting","Object","trace","Error","normalized","parseNodeInput","input","parsed","NodeInputValidationError","executeStep","target","context","reportCollector","result","signal","common","teardown"],"mappings":"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"}

package/dist/es/test-runner/engine/execution-failure.mjs

@@ -0,0 +1,39 @@
+import { WorkflowError } from "../errors.mjs";
+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 errorMessage = (error)=>error && 'object' == typeof error && 'message' in error && 'string' == typeof error.message ? error.message : String(error);
+class WorkflowExecutionFailure extends WorkflowError {
+    constructor(result, errors){
+        super(errors.map(errorMessage).join('; '), {
+            code: 'WORKFLOW_EXECUTION_FAILURE',
+            cause: errors[0]
+        }), _define_property(this, "result", void 0), _define_property(this, "errors", void 0), this.result = result, this.errors = errors;
+    }
+}
+class WorkflowPublicationError extends WorkflowError {
+    constructor(operation, path, cause){
+        super(`Failed to ${operation} at ${path}: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            code: 'WORKFLOW_PUBLICATION_FAILED',
+            details: {
+                operation,
+                path
+            },
+            cause
+        });
+    }
+}
+const asExecutionError = (error)=>error instanceof WorkflowError ? error : new WorkflowError(errorMessage(error), {
+        code: 'WORKFLOW_EXECUTION_FAILURE',
+        cause: error
+    });
+export { WorkflowExecutionFailure, WorkflowPublicationError, asExecutionError };
+
+//# sourceMappingURL=execution-failure.mjs.map

package/dist/es/test-runner/engine/execution-failure.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/execution-failure.mjs","sources":["../../../../src/test-runner/engine/execution-failure.ts"],"sourcesContent":["import { WorkflowError } from '../errors';\n\nconst errorMessage = (error: unknown): string =>\n  error &&\n  typeof error === 'object' &&\n  'message' in error &&\n  typeof error.message === 'string'\n    ? error.message\n    : String(error);\n\n/** An infrastructure failure still carries all execution facts collected so far. */\nexport class WorkflowExecutionFailure<T> extends WorkflowError {\n  constructor(\n    readonly result: T,\n    readonly errors: readonly unknown[],\n  ) {\n    super(errors.map(errorMessage).join('; '), {\n      code: 'WORKFLOW_EXECUTION_FAILURE',\n      cause: errors[0],\n    });\n  }\n}\n\n/** Publication is an infrastructure failure, not a failed test action. */\nexport class WorkflowPublicationError extends WorkflowError {\n  constructor(\n    operation: 'write-result' | 'write-report' | 'preserve-report',\n    path: string,\n    cause: unknown,\n  ) {\n    super(\n      `Failed to ${operation} at ${path}: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        code: 'WORKFLOW_PUBLICATION_FAILED',\n        details: { operation, path },\n        cause,\n      },\n    );\n  }\n}\n\nexport const asExecutionError = (error: unknown): WorkflowError =>\n  error instanceof WorkflowError\n    ? error\n    : new WorkflowError(errorMessage(error), {\n        code: 'WORKFLOW_EXECUTION_FAILURE',\n        cause: error,\n      });\n"],"names":["errorMessage","error","String","WorkflowExecutionFailure","WorkflowError","result","errors","WorkflowPublicationError","operation","path","cause","Error","asExecutionError"],"mappings":";;;;;;;;;;;AAEA,MAAMA,eAAe,CAACC,QACpBA,SACA,AAAiB,YAAjB,OAAOA,SACP,aAAaA,SACb,AAAyB,YAAzB,OAAOA,MAAM,OAAO,GAChBA,MAAM,OAAO,GACbC,OAAOD;AAGN,MAAME,iCAAoCC;IAC/C,YACWC,MAAS,EACTC,MAA0B,CACnC;QACA,KAAK,CAACA,OAAO,GAAG,CAACN,cAAc,IAAI,CAAC,OAAO;YACzC,MAAM;YACN,OAAOM,MAAM,CAAC,EAAE;QAClB,6FANSD,MAAM,GAANA,QAAAA,IAAAA,CACAC,MAAM,GAANA;IAMX;AACF;AAGO,MAAMC,iCAAiCH;IAC5C,YACEI,SAA8D,EAC9DC,IAAY,EACZC,KAAc,CACd;QACA,KAAK,CACH,CAAC,UAAU,EAAEF,UAAU,IAAI,EAAEC,KAAK,EAAE,EAAEC,iBAAiBC,QAAQD,MAAM,OAAO,GAAGR,OAAOQ,QAAQ,EAC9F;YACE,MAAM;YACN,SAAS;gBAAEF;gBAAWC;YAAK;YAC3BC;QACF;IAEJ;AACF;AAEO,MAAME,mBAAmB,CAACX,QAC/BA,iBAAiBG,gBACbH,QACA,IAAIG,cAAcJ,aAAaC,QAAQ;QACrC,MAAM;QACN,OAAOA;IACT"}

package/dist/es/test-runner/engine/index.mjs

@@ -0,0 +1,12 @@
+export * from "./case-runner.mjs";
+export * from "./document-runtime.mjs";
+export * from "./registry.mjs";
+export * from "./run-collected-case.mjs";
+export * from "./run-workflow-document.mjs";
+export * from "./types.mjs";
+export * from "./project-runtime.mjs";
+export * from "./execute-step.mjs";
+export * from "./scope-teardown.mjs";
+export * from "./execution-failure.mjs";
+export * from "./resource-operations.mjs";
+export * from "./scheduler.mjs";