callman-core 1.0.2 → 1.0.3

package/dist/scenario-runner/runScenario.js

@@ -0,0 +1,1133 @@
+import { buildConditionOutputPayload, evaluateConditionConfig, validateConditionConfig, } from "./condition.js";
+import { createSubScenarioStepId, buildRuntimeStepDescriptors, DEFAULT_END_LOOP_DELAY_MS, DEFAULT_END_LOOP_ITERATIONS, flattenScenarioNodesForContext, MAX_END_LOOP_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";
+class ScenarioStopError extends Error {
+    constructor() {
+        super("Scenario execution stopped");
+        this.name = "ScenarioStopError";
+    }
+}
+class ScenarioNodeFailureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ScenarioNodeFailureError";
+    }
+}
+const DEFAULT_MIN_NODE_VISUAL_STATE_MS = 180;
+const createId = (prefix) => {
+    const randomUuid = globalThis.crypto?.randomUUID?.();
+    return randomUuid ?? `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+};
+const createRunId = () => createId("scenario-run");
+const buildTitle = (node) => {
+    const label = node.data.label.trim();
+    if (label) {
+        return label;
+    }
+    return `${node.type[0]?.toUpperCase() ?? ""}${node.type.slice(1)}`;
+};
+const isKafkaNode = (node) => node?.type === "kafka";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const createInputSnapshot = (context) => ({
+    env: context.environment,
+    global: context.globals,
+    workflow: context.workflowContext,
+    response: context.responseRoot,
+    db: {
+        result: context.dbResult ?? null,
+    },
+    kafkaEvent: context.kafkaEvent ?? null,
+    redis: {
+        result: context.redisResult ?? null,
+    },
+});
+const createContextSnapshot = (context) => ({
+    environment: { ...context.environment },
+    globals: { ...context.globals },
+    workflowContext: { ...context.workflowContext },
+    responseRoot: context.responseRoot ? { ...context.responseRoot } : null,
+    lastResponse: context.lastResponse,
+    dbResult: context.dbResult,
+    kafkaEvent: context.kafkaEvent,
+    kafkaCapture: context.kafkaCapture,
+    redisResult: context.redisResult,
+});
+const buildKafkaEventValue = (message) => {
+    const fallbackValue = {
+        value: message.valueJson ?? message.valueText,
+        text: message.valueText,
+        key: message.key,
+        partition: message.partition,
+        offset: message.offset,
+        timestamp: message.timestamp,
+        headers: Object.fromEntries(message.headers.map((header) => [header.key, header.value])),
+    };
+    if (isRecord(message.valueJson)) {
+        return {
+            ...message.valueJson,
+            meta: fallbackValue,
+        };
+    }
+    return fallbackValue;
+};
+const buildKafkaFailureMessage = (result, usedMatch) => {
+    if (result.errorMessage?.trim()) {
+        return result.errorMessage;
+    }
+    if (result.timedOut) {
+        return usedMatch
+            ? "Kafka node timed out without a matching event."
+            : "Kafka node timed out without receiving any events.";
+    }
+    return usedMatch
+        ? "No Kafka event matched the configured rule."
+        : "Kafka node did not receive any events.";
+};
+const safeStringifyKafkaMessage = (message) => {
+    try {
+        return JSON.stringify(message);
+    }
+    catch {
+        return message.valueText;
+    }
+};
+const buildScenarioRegex = (pattern) => {
+    const trimmedPattern = pattern.trim();
+    const literalMatch = trimmedPattern.match(/^\/(.+)\/([a-z]*)$/i);
+    if (literalMatch) {
+        return new RegExp(literalMatch[1] ?? "", literalMatch[2] ?? "");
+    }
+    return new RegExp(trimmedPattern);
+};
+const applyVariableMutationsToContext = (context, mutations) => {
+    for (const mutation of mutations) {
+        if (mutation.type === "set") {
+            if (mutation.scope === "environment") {
+                context.environment[mutation.key] = mutation.value ?? "";
+            }
+            else {
+                context.globals[mutation.key] = mutation.value ?? "";
+            }
+            continue;
+        }
+        if (mutation.scope === "environment") {
+            delete context.environment[mutation.key];
+        }
+        else {
+            delete context.globals[mutation.key];
+        }
+    }
+};
+const throwIfStopped = (signal) => {
+    if (signal?.aborted) {
+        throw new ScenarioStopError();
+    }
+};
+const createStepExecutionRecord = ({ stepId, stepType, title, }) => ({
+    stepId,
+    stepType,
+    title,
+    status: "idle",
+    attempts: 0,
+    currentAttempt: null,
+    maxAttempts: 1,
+    retryCount: 0,
+    retryEnabled: false,
+    retryDelayMs: 0,
+    failurePolicy: null,
+    continuedAfterFailure: false,
+    errors: [],
+    durationMs: null,
+    statusCode: null,
+    errorMessage: null,
+    response: null,
+    testResults: [],
+    contractResults: [],
+    contractSummary: null,
+    contractValidationError: null,
+    dbAssertionResults: [],
+    redisAssertionResults: [],
+    scriptSource: null,
+    scriptTimeoutMs: null,
+    scriptLogs: [],
+    conditionExpression: null,
+    conditionPreview: null,
+    conditionMode: null,
+    conditionResult: null,
+    conditionDebug: null,
+    activeBranch: null,
+    inputData: null,
+    outputData: null,
+    incomingEdgeId: null,
+    startedAt: null,
+    completedAt: null,
+});
+const isTerminalStatus = (status) => status !== "idle" && status !== "running" && status !== "retrying";
+const updateRecordFromEvent = (records, event) => {
+    if (event.type === "scenario:start" ||
+        event.type === "scenario:end" ||
+        event.type === "step:reset") {
+        if (event.type !== "step:reset") {
+            return;
+        }
+        for (const stepId of event.stepIds) {
+            const current = records.get(stepId);
+            if (!current) {
+                continue;
+            }
+            records.set(stepId, {
+                ...current,
+                status: "idle",
+                currentAttempt: null,
+                errorMessage: null,
+                startedAt: null,
+                completedAt: null,
+            });
+        }
+        return;
+    }
+    const current = records.get(event.stepId) ??
+        createStepExecutionRecord({
+            stepId: event.stepId,
+            stepType: "stepType" in event ? event.stepType : "condition",
+            title: event.title,
+        });
+    if (event.type === "step:start") {
+        records.set(event.stepId, {
+            ...current,
+            stepType: event.stepType,
+            title: event.title,
+            status: "running",
+            attempts: event.attempt ?? 1,
+            currentAttempt: event.attempt ?? 1,
+            maxAttempts: event.maxAttempts ?? 1,
+            retryCount: Math.max(0, (event.attempt ?? 1) - 1),
+            retryEnabled: event.retryEnabled ?? false,
+            retryDelayMs: event.retryDelayMs ?? 0,
+            failurePolicy: event.failurePolicy ?? null,
+            errors: (event.attempt ?? 1) > 1 ? current.errors : [],
+            inputData: event.inputData ?? null,
+            incomingEdgeId: event.incomingEdgeId ?? null,
+            errorMessage: null,
+            startedAt: current.startedAt ?? event.at,
+            completedAt: null,
+        });
+        return;
+    }
+    if (event.type === "step:retry") {
+        records.set(event.stepId, {
+            ...current,
+            stepType: event.stepType,
+            title: event.title,
+            status: "retrying",
+            attempts: event.attempt,
+            currentAttempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            retryCount: Math.max(0, event.attempt - 1),
+            retryEnabled: true,
+            retryDelayMs: event.retryDelayMs,
+            failurePolicy: event.failurePolicy,
+            errors: event.errors,
+            errorMessage: event.errorMessage,
+            inputData: event.inputData ?? current.inputData,
+            incomingEdgeId: event.incomingEdgeId ?? current.incomingEdgeId,
+            startedAt: current.startedAt ?? event.at,
+        });
+        return;
+    }
+    if (event.type === "step:condition") {
+        records.set(event.stepId, {
+            ...current,
+            title: event.title,
+            conditionExpression: event.conditionExpression,
+            conditionPreview: event.conditionPreview,
+            conditionMode: event.conditionMode,
+            conditionResult: event.result,
+            conditionDebug: event.conditionDebug,
+            activeBranch: event.activeBranch,
+        });
+        return;
+    }
+    if (event.type === "step:skip") {
+        records.set(event.stepId, {
+            ...current,
+            stepType: event.stepType,
+            title: event.title,
+            status: "skipped",
+            inputData: event.inputData ?? current.inputData,
+            incomingEdgeId: event.incomingEdgeId ?? current.incomingEdgeId,
+            startedAt: current.startedAt ?? event.at,
+            completedAt: event.at,
+        });
+        return;
+    }
+    const isSuccess = event.type === "step:success";
+    records.set(event.stepId, {
+        ...current,
+        stepType: event.stepType,
+        title: event.title,
+        status: event.status ?? (isSuccess ? "success" : "failed"),
+        attempts: event.attempts ?? current.attempts,
+        currentAttempt: event.currentAttempt ?? current.currentAttempt,
+        maxAttempts: event.maxAttempts ?? current.maxAttempts,
+        retryCount: event.retryCount ?? current.retryCount,
+        retryEnabled: event.retryEnabled ?? current.retryEnabled,
+        retryDelayMs: event.retryDelayMs ?? current.retryDelayMs,
+        failurePolicy: event.failurePolicy ?? current.failurePolicy,
+        continuedAfterFailure: event.continuedAfterFailure ?? current.continuedAfterFailure,
+        errors: event.errors ?? current.errors,
+        durationMs: event.durationMs ?? current.durationMs,
+        statusCode: event.statusCode ?? current.statusCode,
+        errorMessage: event.type === "step:fail"
+            ? event.errorMessage
+            : current.errorMessage,
+        response: event.response ?? current.response,
+        testResults: event.testResults ?? current.testResults,
+        contractResults: event.contractResults ?? current.contractResults,
+        contractSummary: event.contractSummary ?? current.contractSummary,
+        contractValidationError: event.contractValidationError ?? current.contractValidationError,
+        dbAssertionResults: event.dbAssertionResults ?? current.dbAssertionResults,
+        redisAssertionResults: event.redisAssertionResults ?? current.redisAssertionResults,
+        scriptSource: event.scriptSource ?? current.scriptSource,
+        scriptTimeoutMs: event.scriptTimeoutMs ?? current.scriptTimeoutMs,
+        scriptLogs: event.scriptLogs ?? current.scriptLogs,
+        conditionExpression: event.conditionExpression ?? current.conditionExpression,
+        conditionPreview: event.conditionPreview ?? current.conditionPreview,
+        conditionMode: event.conditionMode ?? current.conditionMode,
+        conditionResult: event.conditionResult ?? current.conditionResult,
+        conditionDebug: event.conditionDebug ?? current.conditionDebug,
+        activeBranch: event.activeBranch ?? current.activeBranch,
+        inputData: event.inputData ?? current.inputData,
+        outputData: event.outputData ?? current.outputData,
+        incomingEdgeId: event.incomingEdgeId ?? current.incomingEdgeId,
+        startedAt: current.startedAt ?? event.at,
+        completedAt: event.at,
+    });
+};
+const callHandler = async (handlers, event) => {
+    await handlers?.onEvent?.(event);
+    switch (event.type) {
+        case "scenario:start":
+            await handlers?.onScenarioStart?.(event);
+            return;
+        case "scenario:end":
+            return;
+        case "step:start":
+            await handlers?.onNodeStart?.(event);
+            return;
+        case "step:retry":
+            await handlers?.onNodeRetry?.(event);
+            return;
+        case "step:success":
+            await handlers?.onNodeSuccess?.(event);
+            return;
+        case "step:fail":
+            await handlers?.onNodeFail?.(event);
+            return;
+        case "step:skip":
+            await handlers?.onNodeSkip?.(event);
+            return;
+        case "step:reset":
+            await handlers?.onNodeReset?.(event);
+            return;
+        case "step:condition":
+            await handlers?.onConditionEvaluated?.(event);
+            return;
+        default:
+            return;
+    }
+};
+export const runScenario = async ({ scenario, environment = {}, globals = {}, runtimeAdapters, eventHandlers, signal, minNodeVisualStateMs = DEFAULT_MIN_NODE_VISUAL_STATE_MS, }) => {
+    const runId = createRunId();
+    const startedAtMs = Date.now();
+    const startedAt = new Date(startedAtMs).toISOString();
+    const graph = buildScenarioExecutionGraph(scenario.nodes, scenario.edges);
+    const orderedStartNodeIds = graph.startNodeIds;
+    const runtimeStepDescriptors = buildRuntimeStepDescriptors(scenario.nodes);
+    const runtimeStepIds = runtimeStepDescriptors.map((entry) => entry.stepId);
+    const localStatuses = new Map(runtimeStepIds.map((stepId) => [stepId, "idle"]));
+    const records = new Map();
+    const events = [];
+    const runtimeContext = {
+        environment: { ...environment },
+        globals: { ...globals },
+        workflowContext: {},
+        responseRoot: null,
+        lastResponse: null,
+        dbResult: null,
+        kafkaEvent: null,
+        kafkaCapture: null,
+        redisResult: null,
+    };
+    const prefetchedKafkaResults = new Map();
+    const degradedStepIds = new Set();
+    const loopIterationCounts = new Map();
+    const rootScope = {
+        graph,
+        stepIdForNode: (nodeId) => nodeId,
+        stepIdForEdge: (edgeId) => edgeId,
+    };
+    const emit = async (event) => {
+        events.push(event);
+        updateRecordFromEvent(records, event);
+        await callHandler(eventHandlers, event);
+    };
+    const waitForDuration = async (delayMs) => {
+        const normalizedDelayMs = Math.max(0, Math.round(delayMs));
+        if (normalizedDelayMs === 0) {
+            throwIfStopped(signal);
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const timeoutId = globalThis.setTimeout(() => {
+                signal?.removeEventListener?.("abort", onAbort);
+                resolve();
+            }, normalizedDelayMs);
+            const onAbort = () => {
+                globalThis.clearTimeout(timeoutId);
+                signal?.removeEventListener?.("abort", onAbort);
+                reject(new ScenarioStopError());
+            };
+            if (signal?.aborted) {
+                onAbort();
+                return;
+            }
+            signal?.addEventListener?.("abort", onAbort, { once: true });
+        });
+    };
+    const ensureMinimumVisualDuration = async (attemptStartedAtMs) => {
+        const elapsedMs = Date.now() - attemptStartedAtMs;
+        if (elapsedMs >= minNodeVisualStateMs) {
+            return;
+        }
+        await waitForDuration(minNodeVisualStateMs - elapsedMs);
+    };
+    const markNodeIdsSkipped = async (scope, nodeIds, reason) => {
+        for (const skippedNodeId of nodeIds) {
+            const skippedNode = scope.graph.nodeMap.get(skippedNodeId);
+            if (!skippedNode) {
+                continue;
+            }
+            const stepId = scope.stepIdForNode(skippedNodeId);
+            const currentStatus = localStatuses.get(stepId) ?? "idle";
+            if (currentStatus !== "idle") {
+                continue;
+            }
+            localStatuses.set(stepId, "skipped");
+            await emit({
+                type: "step:skip",
+                runId,
+                scenarioId: scenario.id,
+                stepId,
+                stepType: skippedNode.type,
+                title: buildTitle(skippedNode),
+                at: new Date().toISOString(),
+                reason,
+                inputData: createInputSnapshot(runtimeContext),
+            });
+        }
+    };
+    const markRemainingNodesSkipped = async (reason) => {
+        await markNodeIdsSkipped(rootScope, rootScope.graph.nodeMap.keys(), reason);
+    };
+    const markScopeRemainingNodesSkipped = async (scope, reason) => {
+        await markNodeIdsSkipped(scope, scope.graph.nodeMap.keys(), reason);
+    };
+    const isNodeReady = (scope, nodeId) => {
+        const incomingEdges = scope.graph.incomingMap.get(nodeId) ?? [];
+        if (incomingEdges.length === 0) {
+            return true;
+        }
+        return incomingEdges.every((edge) => {
+            const sourceStatus = localStatuses.get(scope.stepIdForNode(edge.source)) ?? "idle";
+            return (sourceStatus === "success" ||
+                sourceStatus === "skipped" ||
+                sourceStatus === "failed_continued" ||
+                sourceStatus === "partial_success");
+        });
+    };
+    const resetReachableNodesForLoop = (scope, targetNodeId) => {
+        const stack = [targetNodeId];
+        const visited = new Set();
+        while (stack.length > 0) {
+            const currentNodeId = stack.pop();
+            if (!currentNodeId || visited.has(currentNodeId)) {
+                continue;
+            }
+            visited.add(currentNodeId);
+            if (scope.graph.nodeMap.has(currentNodeId)) {
+                localStatuses.set(scope.stepIdForNode(currentNodeId), "idle");
+            }
+            for (const edge of scope.graph.outgoingMap.get(currentNodeId) ?? []) {
+                stack.push(edge.target);
+            }
+        }
+        return Array.from(visited).map((nodeId) => scope.stepIdForNode(nodeId));
+    };
+    const executeNode = async (nodeId, incomingEdgeId, options = {}, scope = rootScope) => {
+        throwIfStopped(signal);
+        const stepId = scope.stepIdForNode(nodeId);
+        const currentStatus = localStatuses.get(stepId) ?? "idle";
+        if (currentStatus !== "idle") {
+            return;
+        }
+        if (!options.force && !isNodeReady(scope, nodeId)) {
+            return;
+        }
+        const node = scope.graph.nodeMap.get(nodeId);
+        if (!node) {
+            return;
+        }
+        const title = buildTitle(node);
+        const executionPolicy = supportsScenarioNodeExecutionPolicy(node)
+            ? getScenarioNodeExecutionPolicy(node)
+            : getLegacyScenarioNodeExecutionPolicy();
+        const executionStartedAtMs = Date.now();
+        let inputData = createInputSnapshot(runtimeContext);
+        let statusCode = null;
+        let response = null;
+        let outputData = null;
+        let testResults = [];
+        let contractResults = [];
+        let contractSummary = null;
+        let contractValidationError = null;
+        let dbAssertionResults = [];
+        let redisAssertionResults = [];
+        let scriptSource = null;
+        let scriptTimeoutMs = null;
+        let scriptLogs = [];
+        let scriptHasReturnValue = false;
+        let scriptReturnValue = null;
+        let conditionResult = null;
+        let activeBranch = null;
+        let conditionExpression = null;
+        let conditionPreview = null;
+        let conditionMode = null;
+        let conditionDebug = null;
+        let shouldMarkPartialSuccess = false;
+        const resetAttemptArtifacts = () => {
+            statusCode = null;
+            response = null;
+            outputData = null;
+            testResults = [];
+            contractResults = [];
+            contractSummary = null;
+            contractValidationError = null;
+            dbAssertionResults = [];
+            redisAssertionResults = [];
+            scriptSource = null;
+            scriptTimeoutMs = null;
+            scriptLogs = [];
+            scriptHasReturnValue = false;
+            scriptReturnValue = null;
+            conditionResult = null;
+            activeBranch = null;
+            conditionExpression = null;
+            conditionPreview = null;
+            conditionMode = null;
+            conditionDebug = null;
+            shouldMarkPartialSuccess = false;
+        };
+        const executeNodeAttempt = async (attempt, maxAttempts) => {
+            throwIfStopped(signal);
+            resetAttemptArtifacts();
+            const attemptStartedAtMs = Date.now();
+            inputData = createInputSnapshot(runtimeContext);
+            localStatuses.set(stepId, "running");
+            await emit({
+                type: "step:start",
+                runId,
+                scenarioId: scenario.id,
+                stepId,
+                stepType: node.type,
+                title,
+                at: new Date().toISOString(),
+                attempt,
+                maxAttempts,
+                retryEnabled: executionPolicy.retry.enabled,
+                retryDelayMs: executionPolicy.retry.delayMs,
+                failurePolicy: executionPolicy.onFailure,
+                inputData,
+                incomingEdgeId: incomingEdgeId ?? null,
+            });
+            const templateValues = buildScenarioTemplateValues({
+                environment: runtimeContext.environment,
+                globals: runtimeContext.globals,
+                workflowContext: runtimeContext.workflowContext,
+                responseRoot: runtimeContext.responseRoot,
+                dbResult: runtimeContext.dbResult,
+                kafkaEvent: runtimeContext.kafkaEvent,
+                redisResult: runtimeContext.redisResult,
+            });
+            try {
+                if (node.type === "request") {
+                    const kafkaCapturePlans = (scope.graph.outgoingMap.get(nodeId) ?? [])
+                        .map((edge) => scope.graph.nodeMap.get(edge.target))
+                        .filter(isKafkaNode)
+                        .map((kafkaNode) => {
+                        const refreshedTemplateValues = buildScenarioTemplateValues({
+                            environment: runtimeContext.environment,
+                            globals: runtimeContext.globals,
+                            workflowContext: runtimeContext.workflowContext,
+                            responseRoot: runtimeContext.responseRoot,
+                            dbResult: runtimeContext.dbResult,
+                            kafkaEvent: runtimeContext.kafkaEvent,
+                            redisResult: runtimeContext.redisResult,
+                        });
+                        return {
+                            stepId: scope.stepIdForNode(kafkaNode.id),
+                            connectionId: kafkaNode.data.config.connectionId || null,
+                            topic: resolveScenarioTemplateString(kafkaNode.data.config.topic, refreshedTemplateValues).trim(),
+                        };
+                    })
+                        .filter((entry) => entry.connectionId && entry.topic);
+                    const requestResult = await runtimeAdapters.requestExecutor({
+                        runId,
+                        stepId,
+                        node,
+                        context: createContextSnapshot(runtimeContext),
+                        kafkaCapturePlans,
+                        signal,
+                    });
+                    if (requestResult.cancelled) {
+                        throw new ScenarioStopError();
+                    }
+                    runtimeContext.environment = { ...requestResult.environment };
+                    runtimeContext.globals = { ...requestResult.globals };
+                    runtimeContext.lastResponse = requestResult.response;
+                    runtimeContext.responseRoot = requestResult.responseRoot;
+                    response = requestResult.response;
+                    statusCode = requestResult.response.status;
+                    outputData = requestResult.outputData;
+                    testResults = requestResult.testResults;
+                    contractResults = requestResult.contractResults;
+                    contractSummary = requestResult.contractSummary;
+                    contractValidationError = requestResult.contractValidationError;
+                    dbAssertionResults = requestResult.dbAssertionResults;
+                    redisAssertionResults = requestResult.redisAssertionResults;
+                    for (const entry of requestResult.prefetchedKafkaResults ?? []) {
+                        prefetchedKafkaResults.set(entry.stepId, entry.result);
+                    }
+                    if (requestResult.failureMessage) {
+                        throw new ScenarioNodeFailureError(requestResult.failureMessage);
+                    }
+                }
+                if (node.type === "db") {
+                    const resolvedQuery = resolveScenarioTemplateString(node.data.config.query, templateValues);
+                    const dbResult = await runtimeAdapters.dbExecutor({
+                        runId,
+                        stepId,
+                        node,
+                        resolvedQuery,
+                        context: createContextSnapshot(runtimeContext),
+                        signal,
+                    });
+                    runtimeContext.dbResult = dbResult.dbResult;
+                    outputData = dbResult.outputData;
+                    if (dbResult.failureMessage) {
+                        throw new ScenarioNodeFailureError(dbResult.failureMessage);
+                    }
+                }
+                if (node.type === "script") {
+                    const scriptResult = await runtimeAdapters.scriptExecutor({
+                        runId,
+                        stepId,
+                        node,
+                        context: createContextSnapshot(runtimeContext),
+                        signal,
+                    });
+                    scriptSource = scriptResult.scriptSource;
+                    scriptTimeoutMs = scriptResult.timeoutMs;
+                    scriptLogs = scriptResult.logs;
+                    testResults = scriptResult.testResults;
+                    scriptHasReturnValue = scriptResult.hasReturnValue;
+                    scriptReturnValue = scriptResult.returnValue;
+                    outputData = scriptResult.outputData;
+                    applyVariableMutationsToContext(runtimeContext, scriptResult.variableMutations);
+                    if (scriptResult.failureMessage) {
+                        throw new ScenarioNodeFailureError(scriptResult.failureMessage);
+                    }
+                }
+                if (node.type === "redis") {
+                    const resolvedCommands = node.data.config.commands
+                        .map((command) => resolveScenarioTemplateString(command, templateValues))
+                        .filter((command) => command.trim().length > 0);
+                    const redisResult = await runtimeAdapters.redisExecutor({
+                        runId,
+                        stepId,
+                        node,
+                        resolvedCommands,
+                        context: createContextSnapshot(runtimeContext),
+                        signal,
+                    });
+                    runtimeContext.redisResult = redisResult.redisResult;
+                    outputData = redisResult.outputData;
+                    if (redisResult.failureMessage) {
+                        throw new ScenarioNodeFailureError(redisResult.failureMessage);
+                    }
+                }
+                if (node.type === "kafka") {
+                    const resolvedTopic = resolveScenarioTemplateString(node.data.config.topic, templateValues);
+                    const rules = node.data.config.rules?.filter((rule) => rule.trim()) ?? [];
+                    const prefetchedCaptureResult = prefetchedKafkaResults.get(stepId);
+                    const captureResult = prefetchedCaptureResult ??
+                        (await runtimeAdapters.kafkaExecutor({
+                            runId,
+                            stepId,
+                            node,
+                            resolvedTopic,
+                            matcher: rules.length > 0
+                                ? {
+                                    mode: node.data.config.matchMode,
+                                    rules,
+                                    templateValues,
+                                }
+                                : null,
+                            signal,
+                        })).captureResult;
+                    throwIfStopped(signal);
+                    let matchedMessage = captureResult.messages[0] ?? null;
+                    if (node.data.config.matchMode === "regex" && rules[0]) {
+                        const regex = buildScenarioRegex(rules[0]);
+                        matchedMessage =
+                            captureResult.messages.find((message) => {
+                                regex.lastIndex = 0;
+                                return regex.test(safeStringifyKafkaMessage(message));
+                            }) ?? null;
+                    }
+                    if (node.data.config.matchMode === "rules" && rules.length > 0) {
+                        matchedMessage =
+                            captureResult.messages.find((message) => {
+                                const kafkaEventValue = buildKafkaEventValue(message);
+                                const scopedValues = buildScenarioTemplateValues({
+                                    environment: runtimeContext.environment,
+                                    globals: runtimeContext.globals,
+                                    workflowContext: runtimeContext.workflowContext,
+                                    responseRoot: runtimeContext.responseRoot,
+                                    dbResult: runtimeContext.dbResult,
+                                    kafkaEvent: kafkaEventValue,
+                                    redisResult: runtimeContext.redisResult,
+                                });
+                                return rules.every((rule) => evaluateScenarioExpression(rule, scopedValues).result);
+                            }) ?? null;
+                    }
+                    if (!matchedMessage) {
+                        outputData = captureResult;
+                        throw new ScenarioNodeFailureError(buildKafkaFailureMessage(captureResult, Boolean(rules.length)));
+                    }
+                    runtimeContext.kafkaCapture = captureResult;
+                    runtimeContext.kafkaEvent = buildKafkaEventValue(matchedMessage);
+                    outputData = runtimeContext.kafkaEvent;
+                }
+                if (node.type === "condition") {
+                    const conditionIssues = validateConditionConfig(node.data.config);
+                    const blockingConditionIssue = conditionIssues.find((issue) => issue.severity === "error");
+                    if (blockingConditionIssue) {
+                        throw new ScenarioNodeFailureError(blockingConditionIssue.message);
+                    }
+                    const evaluation = evaluateConditionConfig(node.data.config, {
+                        environment: runtimeContext.environment,
+                        globals: runtimeContext.globals,
+                        workflowContext: runtimeContext.workflowContext,
+                        responseRoot: runtimeContext.responseRoot,
+                        dbResult: runtimeContext.dbResult,
+                        kafkaEvent: runtimeContext.kafkaEvent,
+                        redisResult: runtimeContext.redisResult,
+                    });
+                    const conditionPayload = buildConditionOutputPayload(node.data.config, evaluation);
+                    conditionResult = evaluation.result;
+                    activeBranch = evaluation.result ? "if" : "else";
+                    conditionExpression = conditionPayload.expression;
+                    conditionPreview = conditionPayload.preview;
+                    conditionMode = conditionPayload.mode;
+                    conditionDebug = conditionPayload.debug;
+                    outputData = conditionPayload;
+                    await emit({
+                        type: "step:condition",
+                        runId,
+                        scenarioId: scenario.id,
+                        stepId,
+                        title,
+                        at: new Date().toISOString(),
+                        conditionExpression: conditionPayload.expression,
+                        conditionPreview: conditionPayload.preview,
+                        conditionMode: conditionPayload.mode,
+                        conditionDebug: conditionPayload.debug,
+                        result: evaluation.result,
+                        activeBranch,
+                    });
+                    const inactiveBranch = evaluation.result ? "no" : "yes";
+                    const inactiveBranchNodeIds = collectExclusiveBranchNodeIds({
+                        graph: scope.graph,
+                        conditionNodeId: node.id,
+                        inactiveBranch,
+                    });
+                    await markNodeIdsSkipped(scope, inactiveBranchNodeIds, `Skipped because condition evaluated ${evaluation.result ? "TRUE" : "FALSE"}.`);
+                }
+                if (node.type === "subscenario") {
+                    const degradedCountBefore = degradedStepIds.size;
+                    const internalGraph = buildScenarioExecutionGraph(node.data.config.nodes, node.data.config.edges);
+                    const internalScope = {
+                        graph: internalGraph,
+                        stepIdForNode: (childNodeId) => createSubScenarioStepId(stepId, childNodeId),
+                        stepIdForEdge: (edgeId) => createSubScenarioStepId(stepId, edgeId),
+                    };
+                    for (const startNodeId of internalGraph.startNodeIds) {
+                        throwIfStopped(signal);
+                        await executeNode(startNodeId, null, {}, internalScope);
+                    }
+                    await markScopeRemainingNodesSkipped(internalScope, `Internal node was not reached inside ${title}.`);
+                    const groupedOutput = {};
+                    for (const childNode of flattenScenarioNodesForContext(node.data.config.nodes)) {
+                        const childLabel = childNode.data.label.trim();
+                        if (childLabel &&
+                            Object.prototype.hasOwnProperty.call(runtimeContext.workflowContext, childLabel)) {
+                            groupedOutput[childLabel] = runtimeContext.workflowContext[childLabel];
+                        }
+                    }
+                    shouldMarkPartialSuccess = degradedStepIds.size > degradedCountBefore;
+                    outputData = groupedOutput;
+                }
+                if (node.type === "end") {
+                    if (node.data.config.loop && node.data.config.loopTargetNodeId) {
+                        const loopTargetNode = scope.graph.nodeMap.get(node.data.config.loopTargetNodeId);
+                        if (!loopTargetNode) {
+                            throw new ScenarioNodeFailureError("Loop target node could not be found.");
+                        }
+                    }
+                    outputData = { ...runtimeContext.workflowContext };
+                }
+                if (node.type === "aggregator") {
+                    const resolvedTemplate = resolveScenarioJsonTemplateString(node.data.config.template, templateValues);
+                    try {
+                        outputData = JSON.parse(resolvedTemplate);
+                    }
+                    catch {
+                        throw new ScenarioNodeFailureError(`Aggregator "${node.data.label}" produced invalid JSON after template resolution.`);
+                    }
+                }
+                throwIfStopped(signal);
+                const nodeLabel = node.data.label.trim();
+                const workflowOutput = node.type === "script"
+                    ? scriptHasReturnValue
+                        ? scriptReturnValue
+                        : undefined
+                    : outputData;
+                if (nodeLabel &&
+                    typeof workflowOutput !== "undefined" &&
+                    (node.type === "script" || workflowOutput !== null)) {
+                    runtimeContext.workflowContext[nodeLabel] = workflowOutput;
+                }
+                await ensureMinimumVisualDuration(attemptStartedAtMs);
+            }
+            catch (error) {
+                if (error instanceof ScenarioStopError) {
+                    throw error;
+                }
+                await ensureMinimumVisualDuration(attemptStartedAtMs);
+                throw error instanceof ScenarioNodeFailureError
+                    ? error
+                    : new ScenarioNodeFailureError(error instanceof Error ? error.message : "Scenario node failed");
+            }
+        };
+        try {
+            const policyResult = await executeWithScenarioNodePolicy({
+                policy: executionPolicy,
+                execute: executeNodeAttempt,
+                wait: waitForDuration,
+                onRetry: async (event) => {
+                    localStatuses.set(stepId, "retrying");
+                    await emit({
+                        type: "step:retry",
+                        runId,
+                        scenarioId: scenario.id,
+                        stepId,
+                        stepType: node.type,
+                        title,
+                        at: new Date().toISOString(),
+                        attempt: event.nextAttempt,
+                        maxAttempts: event.maxAttempts,
+                        retryDelayMs: event.delayMs,
+                        retryAt: event.retryAt,
+                        failurePolicy: event.failurePolicy,
+                        errorMessage: event.errorMessage,
+                        errors: event.errors,
+                        inputData,
+                        incomingEdgeId: incomingEdgeId ?? null,
+                    });
+                },
+            });
+            const durationMs = Math.round(Date.now() - executionStartedAtMs);
+            if (policyResult.outcome === "failed") {
+                localStatuses.set(stepId, "failed");
+                await emit({
+                    type: "step:fail",
+                    runId,
+                    scenarioId: scenario.id,
+                    stepId,
+                    stepType: node.type,
+                    title,
+                    status: "failed",
+                    at: new Date().toISOString(),
+                    attempts: policyResult.attempts,
+                    currentAttempt: policyResult.attempts,
+                    maxAttempts: policyResult.maxAttempts,
+                    retryCount: policyResult.retryCount,
+                    retryEnabled: executionPolicy.retry.enabled,
+                    retryDelayMs: executionPolicy.retry.delayMs,
+                    failurePolicy: executionPolicy.onFailure,
+                    continuedAfterFailure: false,
+                    errors: policyResult.errors,
+                    errorMessage: policyResult.finalErrorMessage ?? "Scenario node failed",
+                    durationMs,
+                    statusCode,
+                    response,
+                    testResults,
+                    contractResults,
+                    contractSummary,
+                    contractValidationError,
+                    dbAssertionResults,
+                    redisAssertionResults,
+                    scriptSource,
+                    scriptTimeoutMs,
+                    scriptLogs,
+                    conditionExpression,
+                    conditionPreview,
+                    conditionMode,
+                    conditionResult,
+                    conditionDebug,
+                    activeBranch,
+                    inputData,
+                    outputData,
+                    incomingEdgeId: incomingEdgeId ?? null,
+                });
+                throw new ScenarioNodeFailureError(policyResult.finalErrorMessage ?? "Scenario node failed");
+            }
+            if (policyResult.outcome === "continued") {
+                degradedStepIds.add(stepId);
+                localStatuses.set(stepId, "failed_continued");
+                await emit({
+                    type: "step:fail",
+                    runId,
+                    scenarioId: scenario.id,
+                    stepId,
+                    stepType: node.type,
+                    title,
+                    status: "failed_continued",
+                    at: new Date().toISOString(),
+                    attempts: policyResult.attempts,
+                    currentAttempt: policyResult.attempts,
+                    maxAttempts: policyResult.maxAttempts,
+                    retryCount: policyResult.retryCount,
+                    retryEnabled: executionPolicy.retry.enabled,
+                    retryDelayMs: executionPolicy.retry.delayMs,
+                    failurePolicy: executionPolicy.onFailure,
+                    continuedAfterFailure: true,
+                    errors: policyResult.errors,
+                    errorMessage: policyResult.finalErrorMessage ??
+                        "Scenario node failed but execution continued.",
+                    durationMs,
+                    statusCode,
+                    response,
+                    testResults,
+                    contractResults,
+                    contractSummary,
+                    contractValidationError,
+                    dbAssertionResults,
+                    redisAssertionResults,
+                    scriptSource,
+                    scriptTimeoutMs,
+                    scriptLogs,
+                    conditionExpression,
+                    conditionPreview,
+                    conditionMode,
+                    conditionResult,
+                    conditionDebug,
+                    activeBranch,
+                    inputData,
+                    outputData,
+                    incomingEdgeId: incomingEdgeId ?? null,
+                });
+            }
+            else {
+                const successStatus = shouldMarkPartialSuccess ? "partial_success" : "success";
+                if (successStatus === "partial_success") {
+                    degradedStepIds.add(stepId);
+                }
+                else {
+                    degradedStepIds.delete(stepId);
+                }
+                localStatuses.set(stepId, successStatus);
+                await emit({
+                    type: "step:success",
+                    runId,
+                    scenarioId: scenario.id,
+                    stepId,
+                    stepType: node.type,
+                    title,
+                    status: successStatus,
+                    at: new Date().toISOString(),
+                    attempts: policyResult.attempts,
+                    currentAttempt: policyResult.attempts,
+                    maxAttempts: policyResult.maxAttempts,
+                    retryCount: policyResult.retryCount,
+                    retryEnabled: executionPolicy.retry.enabled,
+                    retryDelayMs: executionPolicy.retry.delayMs,
+                    failurePolicy: executionPolicy.onFailure,
+                    continuedAfterFailure: false,
+                    errors: policyResult.errors,
+                    durationMs,
+                    statusCode,
+                    response,
+                    testResults,
+                    contractResults,
+                    contractSummary,
+                    contractValidationError,
+                    dbAssertionResults,
+                    redisAssertionResults,
+                    scriptSource,
+                    scriptTimeoutMs,
+                    scriptLogs,
+                    conditionExpression,
+                    conditionPreview,
+                    conditionMode,
+                    conditionResult,
+                    conditionDebug,
+                    activeBranch,
+                    inputData,
+                    outputData,
+                    incomingEdgeId: incomingEdgeId ?? null,
+                });
+                if (node.type === "end" && node.data.config.loop && node.data.config.loopTargetNodeId) {
+                    const loopTargetNode = scope.graph.nodeMap.get(node.data.config.loopTargetNodeId);
+                    if (!loopTargetNode) {
+                        throw new ScenarioNodeFailureError("Loop target node could not be found.");
+                    }
+                    const configuredLoopIterations = Math.min(MAX_END_LOOP_ITERATIONS, Math.max(0, Math.round(node.data.config.loopIterations ?? DEFAULT_END_LOOP_ITERATIONS)));
+                    const currentLoopIteration = loopIterationCounts.get(node.id) ?? 0;
+                    if (currentLoopIteration < configuredLoopIterations) {
+                        const nextLoopIteration = currentLoopIteration + 1;
+                        loopIterationCounts.set(node.id, nextLoopIteration);
+                        if (nextLoopIteration > MAX_END_LOOP_ITERATIONS) {
+                            throw new ScenarioNodeFailureError(`Loop safety limit reached (${MAX_END_LOOP_ITERATIONS} iterations). Stop the run or choose a narrower loop target.`);
+                        }
+                        const resetStepIds = resetReachableNodesForLoop(scope, loopTargetNode.id);
+                        for (const resetStepId of resetStepIds) {
+                            degradedStepIds.delete(resetStepId);
+                        }
+                        await emit({
+                            type: "step:reset",
+                            runId,
+                            scenarioId: scenario.id,
+                            stepIds: resetStepIds,
+                            at: new Date().toISOString(),
+                            reason: `Loop ${nextLoopIteration}/${configuredLoopIterations}: reset workflow branch`,
+                        });
+                        await waitForDuration(node.data.config.loopDelayMs ?? DEFAULT_END_LOOP_DELAY_MS);
+                        await executeNode(loopTargetNode.id, null, { force: true }, scope);
+                    }
+                    return;
+                }
+            }
+            const outgoingEdges = scope.graph.outgoingMap.get(nodeId) ?? [];
+            const nextEdges = node.type === "condition"
+                ? outgoingEdges.filter((edge) => (conditionResult ? "yes" : "no") === (edge.type ?? "default"))
+                : outgoingEdges;
+            for (const edge of nextEdges) {
+                throwIfStopped(signal);
+                await executeNode(edge.target, scope.stepIdForEdge(edge.id), {}, scope);
+            }
+        }
+        catch (error) {
+            if (error instanceof ScenarioStopError) {
+                const stepState = localStatuses.get(stepId);
+                if (stepState === "running" || stepState === "retrying") {
+                    localStatuses.set(stepId, "skipped");
+                    await emit({
+                        type: "step:skip",
+                        runId,
+                        scenarioId: scenario.id,
+                        stepId,
+                        stepType: node.type,
+                        title,
+                        at: new Date().toISOString(),
+                        reason: "Execution stopped",
+                        inputData,
+                        incomingEdgeId: incomingEdgeId ?? null,
+                    });
+                }
+                throw error;
+            }
+            throw error instanceof ScenarioNodeFailureError
+                ? error
+                : new ScenarioNodeFailureError(error instanceof Error ? error.message : "Scenario node failed");
+        }
+    };
+    await emit({
+        type: "scenario:start",
+        runId,
+        scenarioId: scenario.id,
+        scenarioName: scenario.name,
+        totalSteps: runtimeStepIds.length,
+        stepIds: runtimeStepIds,
+        at: startedAt,
+    });
+    let finalStatus = "success";
+    try {
+        for (const startNodeId of orderedStartNodeIds) {
+            throwIfStopped(signal);
+            await executeNode(startNodeId, null);
+        }
+        await markRemainingNodesSkipped("Node was not reached during this run.");
+        finalStatus = degradedStepIds.size > 0 ? "completed_with_failures" : "success";
+        await emit({
+            type: "scenario:end",
+            runId,
+            scenarioId: scenario.id,
+            status: finalStatus,
+            at: new Date().toISOString(),
+            durationMs: Date.now() - startedAtMs,
+        });
+    }
+    catch (error) {
+        const isStopped = error instanceof ScenarioStopError || Boolean(signal?.aborted);
+        await markRemainingNodesSkipped(isStopped ? "Skipped because execution was stopped." : "Skipped after failure.");
+        finalStatus = isStopped ? "stopped" : "failed";
+        await emit({
+            type: "scenario:end",
+            runId,
+            scenarioId: scenario.id,
+            status: finalStatus,
+            at: new Date().toISOString(),
+            durationMs: Date.now() - startedAtMs,
+        });
+    }
+    const endedAt = new Date().toISOString();
+    const report = {
+        runId,
+        scenarioId: scenario.id,
+        scenarioName: scenario.name,
+        scenarioStatus: finalStatus,
+        startedAt,
+        endedAt,
+        durationMs: Date.now() - startedAtMs,
+        totalSteps: runtimeStepIds.length,
+        completedSteps: Array.from(localStatuses.values()).filter(isTerminalStatus).length,
+        context: createContextSnapshot(runtimeContext),
+        nodeExecutions: runtimeStepIds.map((stepId) => {
+            const descriptor = runtimeStepDescriptors.find((entry) => entry.stepId === stepId);
+            return (records.get(stepId) ??
+                createStepExecutionRecord({
+                    stepId,
+                    stepType: descriptor?.node.type ?? "script",
+                    title: descriptor ? buildTitle(descriptor.node) : stepId,
+                }));
+        }),
+        events,
+    };
+    await eventHandlers?.onScenarioComplete?.(report);
+    return report;
+};
+//# sourceMappingURL=runScenario.js.map