callman-core 1.16.0 → 1.18.0

package/dist/scenario-runner/runScenario.js

@@ -1,7 +1,7 @@
 import { buildConditionOutputPayload, evaluateConditionConfig, evaluateConditionRule, resolveConditionRuntimeValue, validateConditionConfig, } from "./condition.js";
 import { applyExtract } from "./extraction.js";
 import { evaluateAssertionConfig, validateAssertionConfig, } from "./assertion.js";
-import { createSubScenarioStepId, buildRuntimeStepDescriptors, DEFAULT_END_LOOP_DELAY_MS, DEFAULT_END_LOOP_ITERATIONS, flattenScenarioNodesForContext, MAX_END_LOOP_ITERATIONS, } from "./graphTraversal.js";
+import { createSubScenarioStepId, buildRuntimeStepDescriptors, DEFAULT_END_LOOP_DELAY_MS, DEFAULT_END_LOOP_ITERATIONS, flattenScenarioNodesForContext, MAX_END_LOOP_ITERATIONS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_POLL_MAX_ATTEMPTS, MAX_POLL_ATTEMPTS, DEFAULT_FOREACH_MAX_ITERATIONS, MAX_FOREACH_ITERATIONS, } from "./graphTraversal.js";
 import { executeWithScenarioNodePolicy } from "./executionPolicyRunner.js";
 import { getLegacyScenarioNodeExecutionPolicy, getScenarioNodeExecutionPolicy, supportsScenarioNodeExecutionPolicy, } from "./nodePolicy.js";
 import { buildScenarioExecutionGraph, buildScenarioTemplateValues, collectExclusiveBranchNodeIds, evaluateScenarioExpression, resolveScenarioJsonTemplateString, resolveScenarioTemplateString, } from "./templateResolver.js";
@@ -33,9 +33,18 @@ const buildTitle = (node) => {
     return `${node.type[0]?.toUpperCase() ?? ""}${node.type.slice(1)}`;
 };
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-// `loop`/`loops` are the loop-iteration template roots (see the loop-frame
+// `loop`/`loops` are the loop-iteration template roots and `item`/`each`/
+// `eaches` the foreach-iteration ones (see the loop-frame and foreach
 // machinery in runScenario) — node labels must not shadow them.
-const RESERVED_WORKFLOW_ROOT_LABELS = new Set(["workflow", "__meta", "loop", "loops"]);
+const RESERVED_WORKFLOW_ROOT_LABELS = new Set([
+    "workflow",
+    "__meta",
+    "loop",
+    "loops",
+    "item",
+    "each",
+    "eaches",
+]);
 const cloneNodeExecutionMeta = (meta) => ({
     ...meta,
     ...(meta.error ? { error: { ...meta.error } } : {}),
@@ -400,6 +409,31 @@ const updateRecordFromEvent = (records, event) => {
         });
         return;
     }
+    if (event.type === "step:poll") {
+        // Tick progress only — the terminal success/fail event owns the rest.
+        records.set(event.stepId, {
+            ...current,
+            stepType: event.stepType,
+            title: event.title,
+            attempts: event.attempt,
+            currentAttempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            startedAt: current.startedAt ?? event.at,
+        });
+        return;
+    }
+    if (event.type === "step:iteration") {
+        // Iteration progress marker only — the terminal success/fail event owns
+        // the record. Without this early return the generic fallback below would
+        // stamp status:"failed" on the foreach step.
+        records.set(event.stepId, {
+            ...current,
+            stepType: event.stepType,
+            title: event.title,
+            startedAt: current.startedAt ?? event.at,
+        });
+        return;
+    }
     if (event.type === "step:condition") {
         records.set(event.stepId, {
             ...current,
@@ -492,6 +526,12 @@ const callHandler = async (handlers, event) => {
         case "step:retry":
             await handlers?.onNodeRetry?.(event);
             return;
+        case "step:poll":
+            await handlers?.onPollTick?.(event);
+            return;
+        case "step:iteration":
+            await handlers?.onForeachIteration?.(event);
+            return;
         case "step:success":
             await handlers?.onNodeSuccess?.(event);
             return;
@@ -802,9 +842,18 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
         localStatuses.set(stepId, "running");
         const title = buildTitle(node);
         const nodeLabel = node.data.label.trim();
-        const executionPolicy = supportsScenarioNodeExecutionPolicy(node)
+        let executionPolicy = supportsScenarioNodeExecutionPolicy(node)
             ? withNotificationFailurePolicyOverride(node, getScenarioNodeExecutionPolicy(node))
             : getLegacyScenarioNodeExecutionPolicy();
+        if (node.type === "poll" || node.type === "foreach") {
+            // The poll/item loop REPLACES per-node retry (nested retry loops would
+            // be unexplainable). onFailure — incl. error edges — still governs the
+            // final outcome.
+            executionPolicy = {
+                ...executionPolicy,
+                retry: { enabled: false, maxAttempts: 0, delayMs: 0 },
+            };
+        }
         const executionStartedAtMs = Date.now();
         let inputData = createInputSnapshot(runtimeContext);
         let statusCode = null;
@@ -1022,6 +1071,223 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                         throw new ScenarioNodeFailureError(redisResult.failureMessage);
                     }
                 }
+                if (node.type === "poll") {
+                    const pollConfig = node.data.config;
+                    const blockingPollIssue = validateConditionConfig(pollConfig.successCondition).find((issue) => issue.severity === "error");
+                    if (blockingPollIssue) {
+                        throw new ScenarioNodeFailureError(`Poll success condition is invalid: ${blockingPollIssue.message}`);
+                    }
+                    const pollStartedAtMs = Date.now();
+                    const pollMaxAttempts = Math.min(MAX_POLL_ATTEMPTS, Math.max(1, Math.round(pollConfig.maxAttempts ?? DEFAULT_POLL_MAX_ATTEMPTS)));
+                    const pollBaseIntervalMs = Math.max(0, Math.round(pollConfig.intervalMs ?? DEFAULT_POLL_INTERVAL_MS));
+                    const pollTimeoutMs = typeof pollConfig.timeoutMs === "number" && pollConfig.timeoutMs > 0
+                        ? Math.round(pollConfig.timeoutMs)
+                        : null;
+                    // Thinned emission keeps stored events bounded (~100 tick events).
+                    const pollEmitStride = Math.max(1, Math.ceil(pollMaxAttempts / 100));
+                    // One tick = the embedded action through the SAME host adapters real
+                    // nodes use (desktop IPC / backend drivers both covered), publishing
+                    // results into the runtime context exactly like the real node would,
+                    // so the success condition AND downstream nodes read the last
+                    // attempt's data. Returns the action's error message, or null.
+                    const runPollTick = async () => {
+                        const tickValues = buildScenarioTemplateValues({
+                            environment: runtimeContext.environment,
+                            globals: runtimeContext.globals,
+                            workflowContext: runtimeContext.workflowContext,
+                            nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
+                            responseRoot: runtimeContext.responseRoot,
+                            dbResult: runtimeContext.dbResult,
+                            kafkaEvent: runtimeContext.kafkaEvent,
+                            redisResult: runtimeContext.redisResult,
+                        });
+                        if (pollConfig.actionType === "request") {
+                            if (!pollConfig.request) {
+                                throw new ScenarioNodeFailureError("Poll node has no request configuration.");
+                            }
+                            const tickResult = await runtimeAdapters.requestExecutor({
+                                runId,
+                                stepId,
+                                node: {
+                                    id: node.id,
+                                    type: "request",
+                                    position: node.position,
+                                    data: { label: node.data.label, config: pollConfig.request },
+                                },
+                                context: createContextSnapshot(runtimeContext),
+                                kafkaCapturePlans: [],
+                                captureFromTimestampMs: startedAtMs,
+                                signal,
+                            });
+                            if (tickResult.cancelled) {
+                                throw new ScenarioStopError();
+                            }
+                            runtimeContext.environment = { ...tickResult.environment };
+                            runtimeContext.globals = { ...tickResult.globals };
+                            runtimeContext.lastResponse = tickResult.response;
+                            runtimeContext.responseRoot = tickResult.responseRoot;
+                            response = tickResult.response;
+                            statusCode = tickResult.response.status;
+                            testResults = tickResult.testResults;
+                            contractResults = tickResult.contractResults;
+                            contractSummary = tickResult.contractSummary;
+                            contractValidationError = tickResult.contractValidationError;
+                            dbAssertionResults = tickResult.dbAssertionResults;
+                            redisAssertionResults = tickResult.redisAssertionResults;
+                            return tickResult.failureMessage ?? null;
+                        }
+                        if (pollConfig.actionType === "db") {
+                            if (!pollConfig.db) {
+                                throw new ScenarioNodeFailureError("Poll node has no database configuration.");
+                            }
+                            const resolvedQuery = resolveScenarioTemplateString(pollConfig.db.query, tickValues);
+                            const resolvedParams = (pollConfig.db.params ?? []).map((param) => resolveScenarioTemplateString(param, tickValues));
+                            const tickResult = await runtimeAdapters.dbExecutor({
+                                runId,
+                                stepId,
+                                node: {
+                                    id: node.id,
+                                    type: "db",
+                                    position: node.position,
+                                    data: { label: node.data.label, config: pollConfig.db },
+                                },
+                                resolvedQuery,
+                                resolvedParams,
+                                context: createContextSnapshot(runtimeContext),
+                                signal,
+                            });
+                            runtimeContext.dbResult = tickResult.dbResult;
+                            return tickResult.failureMessage ?? null;
+                        }
+                        if (pollConfig.actionType === "redis") {
+                            if (!pollConfig.redis) {
+                                throw new ScenarioNodeFailureError("Poll node has no Redis configuration.");
+                            }
+                            const resolvedCommands = pollConfig.redis.commands
+                                .map((command) => resolveScenarioTemplateString(command, tickValues))
+                                .filter((command) => command.trim().length > 0);
+                            const tickResult = await runtimeAdapters.redisExecutor({
+                                runId,
+                                stepId,
+                                node: {
+                                    id: node.id,
+                                    type: "redis",
+                                    position: node.position,
+                                    data: { label: node.data.label, config: pollConfig.redis },
+                                },
+                                resolvedCommands,
+                                context: createContextSnapshot(runtimeContext),
+                                signal,
+                            });
+                            runtimeContext.redisResult = tickResult.redisResult;
+                            return tickResult.failureMessage ?? null;
+                        }
+                        if (!pollConfig.script) {
+                            throw new ScenarioNodeFailureError("Poll node has no script configuration.");
+                        }
+                        const tickResult = await runtimeAdapters.scriptExecutor({
+                            runId,
+                            stepId,
+                            node: {
+                                id: node.id,
+                                type: "script",
+                                position: node.position,
+                                data: { label: node.data.label, config: pollConfig.script },
+                            },
+                            context: createContextSnapshot(runtimeContext),
+                            signal,
+                        });
+                        scriptSource = tickResult.scriptSource;
+                        scriptTimeoutMs = tickResult.timeoutMs;
+                        scriptLogs = tickResult.logs;
+                        testResults = tickResult.testResults;
+                        applyVariableMutationsToContext(runtimeContext, tickResult.variableMutations);
+                        return tickResult.failureMessage ?? null;
+                    };
+                    let pollAttempt = 0;
+                    let pollPassed = false;
+                    let lastTickError = null;
+                    for (;;) {
+                        throwIfStopped(signal);
+                        pollAttempt += 1;
+                        lastTickError = await runPollTick();
+                        if (lastTickError === null) {
+                            const evaluation = evaluateConditionConfig(pollConfig.successCondition, {
+                                environment: runtimeContext.environment,
+                                globals: runtimeContext.globals,
+                                workflowContext: runtimeContext.workflowContext,
+                                nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
+                                responseRoot: runtimeContext.responseRoot,
+                                dbResult: runtimeContext.dbResult,
+                                kafkaEvent: runtimeContext.kafkaEvent,
+                                redisResult: runtimeContext.redisResult,
+                            });
+                            const conditionPayload = buildConditionOutputPayload(pollConfig.successCondition, evaluation);
+                            conditionResult = evaluation.result;
+                            conditionExpression = conditionPayload.expression;
+                            conditionPreview = conditionPayload.preview;
+                            conditionMode = conditionPayload.mode;
+                            conditionDebug = conditionPayload.debug;
+                            pollPassed = evaluation.result;
+                        }
+                        else {
+                            conditionResult = false;
+                        }
+                        const pollElapsedNow = Date.now() - pollStartedAtMs;
+                        const budgetExhausted = pollAttempt >= pollMaxAttempts ||
+                            (pollTimeoutMs !== null && pollElapsedNow >= pollTimeoutMs);
+                        const pollBackoff = pollConfig.backoffMultiplier && pollConfig.backoffMultiplier > 1
+                            ? Math.min(10, pollConfig.backoffMultiplier)
+                            : 1;
+                        const nextDelayMs = pollPassed || budgetExhausted
+                            ? null
+                            : Math.min(pollConfig.maxDelayMs && pollConfig.maxDelayMs > 0
+                                ? Math.round(pollConfig.maxDelayMs)
+                                : Number.MAX_SAFE_INTEGER, Math.round(pollBaseIntervalMs * Math.pow(pollBackoff, pollAttempt - 1)));
+                        if (pollPassed ||
+                            budgetExhausted ||
+                            pollAttempt === 1 ||
+                            pollAttempt % pollEmitStride === 0) {
+                            await emit({
+                                type: "step:poll",
+                                runId,
+                                scenarioId: scenario.id,
+                                stepId,
+                                stepType: node.type,
+                                title,
+                                at: new Date().toISOString(),
+                                attempt: pollAttempt,
+                                maxAttempts: pollMaxAttempts,
+                                elapsedMs: pollElapsedNow,
+                                timeoutMs: pollTimeoutMs,
+                                conditionResult: pollPassed,
+                                tickError: lastTickError,
+                                nextPollDelayMs: nextDelayMs,
+                            });
+                        }
+                        if (pollPassed || budgetExhausted) {
+                            break;
+                        }
+                        await waitForDuration(nextDelayMs ?? pollBaseIntervalMs);
+                    }
+                    const pollElapsedMs = Date.now() - pollStartedAtMs;
+                    outputData = {
+                        attempts: pollAttempt,
+                        maxAttempts: pollMaxAttempts,
+                        elapsedMs: pollElapsedMs,
+                        timedOut: !pollPassed,
+                        conditionResult: pollPassed,
+                        ...(lastTickError ? { lastTickError } : {}),
+                    };
+                    if (!pollPassed) {
+                        if ((pollConfig.onTimeout ?? "fail") === "continue") {
+                            shouldMarkPartialSuccess = true;
+                        }
+                        else {
+                            throw new ScenarioNodeFailureError(`Poll did not succeed within ${pollAttempt} attempt(s) (${pollElapsedMs}ms).${lastTickError ? ` Last error: ${lastTickError}` : ""}`);
+                        }
+                    }
+                }
                 if (node.type === "notification") {
                     const resolvedMessage = renderNotificationTemplate(node.data.config.messageTemplate, templateValues).trim();
                     const resolvedChannelOverride = node.data.config.channelOverride?.trim()
@@ -1291,6 +1557,228 @@ export const runScenario = async ({ scenario, environment = {}, globals = {}, ru
                     shouldMarkPartialSuccess = degradedStepIds.size > degradedCountBefore;
                     outputData = groupedOutput;
                 }
+                if (node.type === "foreach") {
+                    const foreachConfig = node.data.config;
+                    // ── Resolve the items array ──────────────────────────────────────
+                    let items;
+                    if (foreachConfig.sourceMode === "inline") {
+                        const rawInline = (foreachConfig.itemsInline ?? "").trim();
+                        if (!rawInline) {
+                            throw new ScenarioNodeFailureError("Foreach inline items are empty.");
+                        }
+                        const resolvedInline = resolveScenarioJsonTemplateString(rawInline, templateValues);
+                        let parsedInline;
+                        try {
+                            parsedInline = JSON.parse(resolvedInline);
+                        }
+                        catch {
+                            throw new ScenarioNodeFailureError("Foreach inline items are not valid JSON after template resolution.");
+                        }
+                        if (!Array.isArray(parsedInline)) {
+                            throw new ScenarioNodeFailureError("Foreach inline items must be a JSON array.");
+                        }
+                        items = parsedInline;
+                    }
+                    else {
+                        const itemsPath = (foreachConfig.itemsPath ?? "").trim();
+                        if (!itemsPath) {
+                            throw new ScenarioNodeFailureError("Foreach items path is required.");
+                        }
+                        const resolved = resolveConditionRuntimeValue({
+                            environment: runtimeContext.environment,
+                            globals: runtimeContext.globals,
+                            workflowContext: runtimeContext.workflowContext,
+                            nodeMetaByLabel: runtimeContext.nodeMetaByLabel,
+                            responseRoot: runtimeContext.responseRoot,
+                            dbResult: runtimeContext.dbResult,
+                            kafkaEvent: runtimeContext.kafkaEvent,
+                            redisResult: runtimeContext.redisResult,
+                        }, itemsPath);
+                        if (!resolved.exists || typeof resolved.value === "undefined") {
+                            throw new ScenarioNodeFailureError(`Foreach items path "${itemsPath}" resolved to nothing.`);
+                        }
+                        if (!Array.isArray(resolved.value)) {
+                            throw new ScenarioNodeFailureError(`Foreach items path "${itemsPath}" must resolve to an array (got ${typeof resolved.value}).`);
+                        }
+                        items = resolved.value;
+                    }
+                    const itemAlias = (foreachConfig.itemAlias ?? "").trim();
+                    if (itemAlias && RESERVED_WORKFLOW_ROOT_LABELS.has(itemAlias)) {
+                        throw new ScenarioNodeFailureError(`Foreach item alias "${itemAlias}" is a reserved name.`);
+                    }
+                    const maxIterations = Math.min(MAX_FOREACH_ITERATIONS, Math.max(1, Math.round(foreachConfig.maxIterations ?? DEFAULT_FOREACH_MAX_ITERATIONS)));
+                    const processLimit = Math.min(items.length, maxIterations);
+                    const iterationDelayMs = Math.max(0, Math.round(foreachConfig.delayMs ?? 0));
+                    const onItemFailure = foreachConfig.onItemFailure ?? "stop";
+                    const collectResults = foreachConfig.collectResults !== false;
+                    // Thinned emission keeps stored events bounded (~100 iteration markers).
+                    const iterationEmitStride = Math.max(1, Math.ceil(processLimit / 100));
+                    const internalGraph = buildScenarioExecutionGraph(foreachConfig.nodes, foreachConfig.edges);
+                    const internalScope = {
+                        graph: internalGraph,
+                        stepIdForNode: (childNodeId) => createSubScenarioStepId(stepId, childNodeId),
+                        stepIdForEdge: (edgeId) => createSubScenarioStepId(stepId, edgeId),
+                    };
+                    // ALL descendant step ids (nested containers included) — reset
+                    // targets between iterations.
+                    const internalStepIds = buildRuntimeStepDescriptors(foreachConfig.nodes, stepId).map((descriptor) => descriptor.stepId);
+                    const childLabels = flattenScenarioNodesForContext(foreachConfig.nodes)
+                        .map((childNode) => childNode.data.label.trim())
+                        .filter((childLabel) => childLabel.length > 0);
+                    const workflowRoots = runtimeContext.workflowContext;
+                    // Save the enclosing iteration roots so a NESTED foreach restores
+                    // its parent's {{item}}/{{each}} when it finishes mid-iteration.
+                    const hadItemRoot = Object.prototype.hasOwnProperty.call(workflowRoots, "item");
+                    const previousItemRoot = workflowRoots.item;
+                    const hadEachRoot = Object.prototype.hasOwnProperty.call(workflowRoots, "each");
+                    const previousEachRoot = workflowRoots.each;
+                    const hadAliasRoot = itemAlias
+                        ? Object.prototype.hasOwnProperty.call(workflowRoots, itemAlias)
+                        : false;
+                    const previousAliasRoot = itemAlias ? workflowRoots[itemAlias] : undefined;
+                    const nodeLabelKey = nodeLabel;
+                    const previousEaches = workflowRoots.eaches;
+                    const degradedCountBefore = degradedStepIds.size;
+                    const results = [];
+                    let failedItems = 0;
+                    try {
+                        for (let index = 0; index < processLimit; index += 1) {
+                            throwIfStopped(signal);
+                            if (index > 0) {
+                                // Fresh pass: every internal step back to idle (including the
+                                // "skipped" stamped on unreached nodes last pass), degraded
+                                // marks cleared, records reset via the bulk step:reset event.
+                                for (const internalStepId of internalStepIds) {
+                                    localStatuses.set(internalStepId, "idle");
+                                    degradedStepIds.delete(internalStepId);
+                                }
+                                await emit({
+                                    type: "step:reset",
+                                    runId,
+                                    scenarioId: scenario.id,
+                                    stepIds: internalStepIds,
+                                    at: new Date().toISOString(),
+                                    reason: `Item ${index + 1}/${processLimit}: reset foreach body`,
+                                });
+                                if (iterationDelayMs > 0) {
+                                    await waitForDuration(iterationDelayMs);
+                                }
+                            }
+                            // Fresh-pass isolation: a failed/short-circuited item must not
+                            // inherit the previous iteration's child outputs in its results
+                            // snapshot. The final iteration's children stay published after
+                            // the loop (last-iteration-wins for downstream reads).
+                            for (const childLabel of childLabels) {
+                                delete workflowRoots[childLabel];
+                            }
+                            const item = items[index];
+                            const frame = {
+                                index,
+                                iteration: index + 1,
+                                total: processLimit,
+                                remaining: processLimit - (index + 1),
+                            };
+                            workflowRoots.item = item;
+                            if (itemAlias) {
+                                workflowRoots[itemAlias] = item;
+                            }
+                            workflowRoots.each = frame;
+                            if (nodeLabelKey) {
+                                const eachesRoot = workflowRoots.eaches && typeof workflowRoots.eaches === "object"
+                                    ? workflowRoots.eaches
+                                    : {};
+                                workflowRoots.eaches = { ...eachesRoot, [nodeLabelKey]: frame };
+                            }
+                            if (index === 0 ||
+                                index === processLimit - 1 ||
+                                (index + 1) % iterationEmitStride === 0) {
+                                const itemPreview = (() => {
+                                    try {
+                                        const serialized = JSON.stringify(item);
+                                        if (typeof serialized !== "string")
+                                            return String(item);
+                                        return serialized.length > 2048 ? `${serialized.slice(0, 2048)}…` : serialized;
+                                    }
+                                    catch {
+                                        return null;
+                                    }
+                                })();
+                                await emit({
+                                    type: "step:iteration",
+                                    runId,
+                                    scenarioId: scenario.id,
+                                    stepId,
+                                    stepType: node.type,
+                                    title,
+                                    at: new Date().toISOString(),
+                                    index,
+                                    iteration: index + 1,
+                                    total: processLimit,
+                                    itemPreview,
+                                });
+                            }
+                            try {
+                                for (const startNodeId of internalGraph.startNodeIds) {
+                                    throwIfStopped(signal);
+                                    await executeNode(startNodeId, null, {}, internalScope);
+                                }
+                                await markScopeRemainingNodesSkipped(internalScope, `Internal node was not reached inside ${title} (item ${index + 1}).`);
+                            }
+                            catch (error) {
+                                if (error instanceof ScenarioStopError) {
+                                    throw error;
+                                }
+                                failedItems += 1;
+                                if (onItemFailure === "stop") {
+                                    const message = error instanceof Error ? error.message : String(error);
+                                    throw new ScenarioNodeFailureError(`Foreach item ${index + 1}/${processLimit} failed: ${message}`);
+                                }
+                                // continue: unreached internal nodes stay consistent for the
+                                // report, the run degrades to partial success below.
+                                await markScopeRemainingNodesSkipped(internalScope, `Internal node was not reached inside ${title} (item ${index + 1} failed).`);
+                            }
+                            if (collectResults) {
+                                const iterationOutput = {};
+                                for (const childLabel of childLabels) {
+                                    if (Object.prototype.hasOwnProperty.call(workflowRoots, childLabel)) {
+                                        iterationOutput[childLabel] = workflowRoots[childLabel];
+                                    }
+                                }
+                                results.push(iterationOutput);
+                            }
+                        }
+                    }
+                    finally {
+                        // Restore the enclosing iteration roots (or clear ours).
+                        if (hadItemRoot)
+                            workflowRoots.item = previousItemRoot;
+                        else
+                            delete workflowRoots.item;
+                        if (hadEachRoot)
+                            workflowRoots.each = previousEachRoot;
+                        else
+                            delete workflowRoots.each;
+                        if (itemAlias) {
+                            if (hadAliasRoot)
+                                workflowRoots[itemAlias] = previousAliasRoot;
+                            else
+                                delete workflowRoots[itemAlias];
+                        }
+                        if (typeof previousEaches === "undefined")
+                            delete workflowRoots.eaches;
+                        else
+                            workflowRoots.eaches = previousEaches;
+                    }
+                    shouldMarkPartialSuccess =
+                        degradedStepIds.size > degradedCountBefore || failedItems > 0;
+                    outputData = {
+                        ...(collectResults ? { results } : {}),
+                        itemCount: items.length,
+                        processedCount: processLimit,
+                        truncated: items.length > processLimit,
+                        failedItems,
+                    };
+                }
                 if (node.type === "end") {
                     if (node.data.config.loop && node.data.config.loopTargetNodeId) {
                         const loopTargetNode = scope.graph.nodeMap.get(node.data.config.loopTargetNodeId);