@midscene/test 1.12.3 → 1.12.4-beta-20260902110647.0

package/dist/es/cli/index.mjs

@@ -829,30 +829,47 @@ async function executeNode(step, execute, phase, stepIndex, options) {
     const startedAt = new Date();
     const abortController = new AbortController();
     const parentSignal = options.parentSignal;
-    const abortFromParent = ()=>abortController.abort(parentSignal?.reason ?? new Error('Workflow execution aborted.'));
+    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 timeoutError;
+    let abortGraceTimeout;
     const execution = Promise.resolve().then(()=>{
-        if (abortController.signal.aborted) throw abortController.signal.reason ?? new Error('Workflow execution aborted.');
+        abortController.signal.throwIfAborted();
         return execute(abortController.signal);
     });
-    const timedExecution = void 0 === timeoutMs ? execution : Promise.race([
+    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,
-        new Promise((_, reject)=>{
-            timeout = setTimeout(()=>{
-                timeoutError = new StepTimeoutError(timeoutMs, step.node);
-                abortController.abort(timeoutError);
-                reject(timeoutError);
-            }, timeoutMs);
-        })
+        abortedExecution,
+        ...void 0 === timeoutExecution ? [] : [
+            timeoutExecution
+        ]
     ]);
     try {
-        const output = validateNodeOutput(await timedExecution, step.node);
+        const output = validateNodeOutput(await settledExecution, step.node);
         return {
             ...createStepResultBase(step, startedAt, phase, stepIndex),
             status: 'success',
@@ -866,10 +883,12 @@ async function executeNode(step, execute, phase, stepIndex, options) {
             ...createStepResultBase(step, startedAt, phase, stepIndex),
             status: 'failed',
             continuedAfterError: step.meta.continueOnError,
-            error: normalizeNodeExecutionError(timeoutError ?? error, step.node)
+            error: normalizeNodeExecutionError(error, step.node)
         };
     } finally{
         if (void 0 !== timeout) clearTimeout(timeout);
+        if (void 0 !== abortGraceTimeout) clearTimeout(abortGraceTimeout);
+        if (void 0 !== settleOnAbort) abortController.signal.removeEventListener('abort', settleOnAbort);
         parentSignal?.removeEventListener('abort', abortFromParent);
     }
 }
@@ -884,6 +903,7 @@ async function executeStep(step, node, target, context, execution = {}) {
     const stepIndex = 'case' === target.scope ? target.case.stepIndex : target.document.stepIndex;
     return executeNode(step, async (signal)=>{
         const input = await parseNodeInput(node, step.input);
+        signal.throwIfAborted();
         const common = {
             input,
             $: step.meta,