@blokjs/runner 0.2.0

package/dist/testing/TestLogger.js

@@ -0,0 +1,153 @@
+import { GlobalLogger } from "@blokjs/shared";
+/**
+ * TestLogger - A logger that captures log output for testing.
+ *
+ * Extends GlobalLogger to be compatible with the Context.logger interface
+ * while storing all log entries in memory for assertion and inspection.
+ *
+ * @example
+ * ```typescript
+ * const logger = new TestLogger();
+ * logger.info("User created");
+ * logger.warn("Rate limit approaching");
+ *
+ * // Assert specific messages were logged
+ * logger.assertLogged("User created", "info");
+ * logger.assertLogged(/rate limit/i, "warn");
+ *
+ * // Inspect all logs
+ * const errors = logger.getLogsByLevel("error");
+ * ```
+ */
+export class TestLogger extends GlobalLogger {
+    entries;
+    constructor() {
+        super();
+        this.entries = [];
+    }
+    /**
+     * Log an info-level message.
+     */
+    info(message) {
+        this.addEntry("info", message);
+    }
+    /**
+     * Log a warning-level message.
+     */
+    warn(message) {
+        this.addEntry("warn", message);
+    }
+    /**
+     * Log a debug-level message.
+     */
+    debug(message) {
+        this.addEntry("debug", message);
+    }
+    /**
+     * Implementation of GlobalLogger.log - logs at info level.
+     */
+    log(message) {
+        this.addEntry("info", message);
+    }
+    /**
+     * Implementation of GlobalLogger.logLevel.
+     */
+    logLevel(level, message) {
+        this.addEntry(level, message);
+    }
+    /**
+     * Implementation of GlobalLogger.error.
+     */
+    error(message, _stack = "") {
+        this.addEntry("error", message);
+    }
+    /**
+     * Get all logged entries.
+     */
+    getLogs() {
+        return this.entries.map((entry) => entry.message);
+    }
+    /**
+     * Get all log entries with full metadata.
+     */
+    getEntries() {
+        return [...this.entries];
+    }
+    /**
+     * Get log entries filtered by level.
+     *
+     * @param level - The log level to filter by ("info", "warn", "error", "debug")
+     * @returns Array of matching log entries
+     */
+    getLogsByLevel(level) {
+        return this.entries.filter((entry) => entry.level === level);
+    }
+    /**
+     * Assert that a specific message was logged.
+     *
+     * @param message - String or RegExp to match against log messages
+     * @param level - Optional level to restrict the search to
+     * @throws Error if no matching log entry is found
+     */
+    assertLogged(message, level) {
+        const searchEntries = level ? this.getLogsByLevel(level) : this.entries;
+        const found = searchEntries.some((entry) => {
+            if (typeof message === "string") {
+                return entry.message.includes(message);
+            }
+            return message.test(entry.message);
+        });
+        if (!found) {
+            const levelInfo = level ? ` at level "${level}"` : "";
+            const loggedMessages = searchEntries.map((e) => `  [${e.level}] ${e.message}`).join("\n");
+            throw new Error(`Expected log message matching ${message}${levelInfo} but none was found.\n` +
+                `Logged messages:\n${loggedMessages || "  (none)"}`);
+        }
+    }
+    /**
+     * Assert that a specific message was NOT logged.
+     *
+     * @param message - String or RegExp to match against log messages
+     * @param level - Optional level to restrict the search to
+     * @throws Error if a matching log entry is found
+     */
+    assertNotLogged(message, level) {
+        const searchEntries = level ? this.getLogsByLevel(level) : this.entries;
+        const found = searchEntries.some((entry) => {
+            if (typeof message === "string") {
+                return entry.message.includes(message);
+            }
+            return message.test(entry.message);
+        });
+        if (found) {
+            const levelInfo = level ? ` at level "${level}"` : "";
+            throw new Error(`Expected log message matching ${message}${levelInfo} to NOT be present, but it was found.`);
+        }
+    }
+    /**
+     * Clear all captured log entries.
+     */
+    clear() {
+        this.entries = [];
+        this.logs = [];
+    }
+    /**
+     * Get the total number of log entries.
+     */
+    get count() {
+        return this.entries.length;
+    }
+    /**
+     * Internal helper to add a log entry.
+     */
+    addEntry(level, message) {
+        const entry = {
+            level,
+            message,
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        this.logs.push(message);
+    }
+}
+//# sourceMappingURL=TestLogger.js.map

package/dist/testing/TestLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestLogger.js","sourceRoot":"","sources":["../../src/testing/TestLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAc9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,UAAW,SAAQ,YAAY;IACnC,OAAO,CAAa;IAE5B;QACC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,OAAe;QACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,OAAe;QACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAe;QACpB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,OAAe;QAClB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,KAAa,EAAE,OAAe;QACtC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAe,EAAE,MAAM,GAAG,EAAE;QACjC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,OAAO;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,UAAU;QACT,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,KAAa;QAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CAAC,OAAwB,EAAE,KAAc;QACpD,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAExE,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAC1C,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACjC,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC;YACD,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,EAAE,CAAC;YACZ,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,cAAc,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACtD,MAAM,cAAc,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1F,MAAM,IAAI,KAAK,CACd,iCAAiC,OAAO,GAAG,SAAS,wBAAwB;gBAC3E,qBAAqB,cAAc,IAAI,UAAU,EAAE,CACpD,CAAC;QACH,CAAC;IACF,CAAC;IAED;;;;;;OAMG;IACH,eAAe,CAAC,OAAwB,EAAE,KAAc;QACvD,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAExE,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAC1C,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACjC,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACxC,CAAC;YACD,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QAEH,IAAI,KAAK,EAAE,CAAC;YACX,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,cAAc,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,iCAAiC,OAAO,GAAG,SAAS,uCAAuC,CAAC,CAAC;QAC9G,CAAC;IACF,CAAC;IAED;;OAEG;IACH,KAAK;QACJ,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED;;OAEG;IACK,QAAQ,CAAC,KAAa,EAAE,OAAe;QAC9C,MAAM,KAAK,GAAa;YACvB,KAAK;YACL,OAAO;YACP,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACrB,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;CACD"}

package/dist/testing/WorkflowTestRunner.d.ts

@@ -0,0 +1,172 @@
+import type { Context } from "@blokjs/shared";
+import BlokService from "../Blok";
+import type { FunctionNode } from "../defineNode";
+import type { TestContextOverrides, TestResult } from "./TestHarness";
+/**
+ * Configuration options for the WorkflowTestRunner.
+ */
+export interface WorkflowTestConfig {
+    /** Timeout in milliseconds for the entire workflow execution. Default: 30000 */
+    timeout?: number;
+    /** Whether to print execution details to the console. Default: false */
+    verbose?: boolean;
+    /** When true, all nodes without explicit implementations will be auto-mocked. Default: false */
+    mockAllNodes?: boolean;
+}
+/**
+ * Result of a workflow test execution.
+ */
+export interface WorkflowTestResult {
+    /** Whether the entire workflow executed successfully */
+    success: boolean;
+    /** Final output of the workflow */
+    output: any;
+    /** Ordered trace of node executions */
+    trace: ExecutionTrace[];
+    /** Total execution duration in milliseconds */
+    durationMs: number;
+    /** Per-node results keyed by node name */
+    nodeResults: Map<string, TestResult<any>>;
+}
+/**
+ * A record of a single node execution within a workflow.
+ */
+export interface ExecutionTrace {
+    /** Name of the node that was executed */
+    nodeName: string;
+    /** The index of this step in the workflow */
+    stepIndex: number;
+    /** Input data provided to the node */
+    input: any;
+    /** Output data returned by the node */
+    output: any;
+    /** Execution duration in milliseconds */
+    durationMs: number;
+    /** Whether this node executed successfully */
+    success: boolean;
+    /** Error message if the node failed */
+    error?: string;
+    /** Timestamp when this node started execution */
+    timestamp: number;
+}
+/**
+ * Options for a single workflow execution.
+ */
+export interface WorkflowExecuteOptions {
+    /** HTTP headers to populate in the context request */
+    headers?: Record<string, string>;
+    /** Query parameters to populate in the context request */
+    query?: Record<string, string>;
+    /** Path parameters to populate in the context request */
+    params?: Record<string, string>;
+    /** Additional context overrides */
+    contextOverrides?: TestContextOverrides;
+}
+/**
+ * WorkflowTestRunner - For testing complete workflows.
+ *
+ * Allows you to register real or mock node implementations and execute
+ * workflow definitions in a controlled test environment. Captures a full
+ * execution trace showing which nodes ran, in what order, with what data.
+ *
+ * @example
+ * ```typescript
+ * import { WorkflowTestRunner } from "@blokjs/runner";
+ * import { defineNode } from "@blokjs/runner";
+ * import { z } from "zod";
+ *
+ * const runner = new WorkflowTestRunner({ verbose: true });
+ *
+ * // Register a real node
+ * runner.registerNode("validate-input", ValidateInputNode);
+ *
+ * // Register a mock for an external API call
+ * runner.mockNode("fetch-user", async (input) => {
+ *   return { user: { id: input.userId, name: "Test User" } };
+ * });
+ *
+ * // Load and execute workflow
+ * runner.loadWorkflow({
+ *   name: "get-user",
+ *   steps: [
+ *     { name: "step1", node: "validate-input", inputs: { userId: "abc-123" } },
+ *     { name: "step2", node: "fetch-user", inputs: { userId: "${response.data.userId}" } },
+ *   ],
+ * });
+ *
+ * const result = await runner.execute({ userId: "abc-123" });
+ * console.log(result.trace); // See execution order and data flow
+ * ```
+ */
+export declare class WorkflowTestRunner {
+    private config;
+    private nodes;
+    private workflow;
+    private trace;
+    private nodeResults;
+    constructor(config?: WorkflowTestConfig);
+    /**
+     * Register a real node implementation for use in the workflow.
+     *
+     * @param name - The node name as referenced in the workflow steps
+     * @param node - A BlokService instance or a FunctionNode from defineNode()
+     */
+    registerNode(name: string, node: BlokService<any> | FunctionNode<any, any>): void;
+    /**
+     * Register a mock node that executes the provided handler function.
+     *
+     * Use this to simulate external API calls, database queries, or any
+     * node whose real implementation you want to skip during testing.
+     *
+     * @param name - The node name as referenced in the workflow steps
+     * @param handler - Async function that receives (input, ctx) and returns output
+     */
+    mockNode(name: string, handler: (input: any, ctx: Context) => Promise<any>): void;
+    /**
+     * Load a workflow definition from a JSON object or JSON string.
+     *
+     * The workflow should have a `steps` array where each step defines:
+     * - `name`: step identifier
+     * - `node`: the node type to execute
+     * - `inputs`: input data for the node (optional)
+     *
+     * @param workflow - Workflow definition object or JSON string
+     */
+    loadWorkflow(workflow: object | string): void;
+    /**
+     * Execute the loaded workflow with the given input.
+     *
+     * Each step in the workflow is executed sequentially. The output of each
+     * step is fed into the context for subsequent steps. A full execution
+     * trace is captured for inspection.
+     *
+     * @param input - Input data (populates request.body in the context)
+     * @param options - Optional execution configuration
+     * @returns WorkflowTestResult with output, trace, and per-node results
+     * @throws Error if no workflow is loaded or if a required node is not registered
+     */
+    execute(input: any, options?: WorkflowExecuteOptions): Promise<WorkflowTestResult>;
+    /**
+     * Get the execution trace from the most recent workflow run.
+     *
+     * @returns Array of ExecutionTrace entries in execution order
+     */
+    getTrace(): ExecutionTrace[];
+    /**
+     * Reset the runner state (clears trace, node results, and loaded workflow).
+     * Registered nodes and mocks are preserved.
+     */
+    reset(): void;
+    /**
+     * Fully reset the runner, including all registered nodes and mocks.
+     */
+    resetAll(): void;
+    /**
+     * Internal: Execute all workflow steps sequentially.
+     */
+    private executeSteps;
+    /**
+     * Internal: Execute a single workflow step.
+     */
+    private executeStep;
+}

package/dist/testing/WorkflowTestRunner.js

@@ -0,0 +1,355 @@
+import BlokService from "../Blok";
+import BlokResponse from "../BlokResponse";
+import { TestLogger } from "./TestLogger";
+/**
+ * A mock node implementation wrapping a user-provided handler function.
+ */
+class MockNode extends BlokService {
+    handler;
+    constructor(name, handler) {
+        super();
+        this.name = name;
+        this.handler = handler;
+    }
+    async handle(ctx, inputs) {
+        const response = new BlokResponse();
+        try {
+            const result = await this.handler(inputs, ctx);
+            response.setSuccess(result);
+        }
+        catch (error) {
+            const { GlobalError } = await import("@blokjs/shared");
+            const globalError = new GlobalError(error instanceof Error ? error.message : String(error));
+            globalError.setCode(500);
+            globalError.setName(this.name);
+            response.setError(globalError);
+        }
+        return response;
+    }
+}
+/**
+ * An auto-mock node that returns an empty object for any input.
+ */
+class AutoMockNode extends MockNode {
+    constructor(name) {
+        super(name, async () => ({}));
+    }
+}
+/**
+ * WorkflowTestRunner - For testing complete workflows.
+ *
+ * Allows you to register real or mock node implementations and execute
+ * workflow definitions in a controlled test environment. Captures a full
+ * execution trace showing which nodes ran, in what order, with what data.
+ *
+ * @example
+ * ```typescript
+ * import { WorkflowTestRunner } from "@blokjs/runner";
+ * import { defineNode } from "@blokjs/runner";
+ * import { z } from "zod";
+ *
+ * const runner = new WorkflowTestRunner({ verbose: true });
+ *
+ * // Register a real node
+ * runner.registerNode("validate-input", ValidateInputNode);
+ *
+ * // Register a mock for an external API call
+ * runner.mockNode("fetch-user", async (input) => {
+ *   return { user: { id: input.userId, name: "Test User" } };
+ * });
+ *
+ * // Load and execute workflow
+ * runner.loadWorkflow({
+ *   name: "get-user",
+ *   steps: [
+ *     { name: "step1", node: "validate-input", inputs: { userId: "abc-123" } },
+ *     { name: "step2", node: "fetch-user", inputs: { userId: "${response.data.userId}" } },
+ *   ],
+ * });
+ *
+ * const result = await runner.execute({ userId: "abc-123" });
+ * console.log(result.trace); // See execution order and data flow
+ * ```
+ */
+export class WorkflowTestRunner {
+    config;
+    nodes;
+    workflow;
+    trace;
+    nodeResults;
+    constructor(config) {
+        this.config = {
+            timeout: config?.timeout ?? 30000,
+            verbose: config?.verbose ?? false,
+            mockAllNodes: config?.mockAllNodes ?? false,
+        };
+        this.nodes = new Map();
+        this.workflow = null;
+        this.trace = [];
+        this.nodeResults = new Map();
+    }
+    /**
+     * Register a real node implementation for use in the workflow.
+     *
+     * @param name - The node name as referenced in the workflow steps
+     * @param node - A BlokService instance or a FunctionNode from defineNode()
+     */
+    registerNode(name, node) {
+        node.name = name;
+        this.nodes.set(name, node);
+        if (this.config.verbose) {
+            console.log(`[WorkflowTestRunner] Registered node: ${name}`);
+        }
+    }
+    /**
+     * Register a mock node that executes the provided handler function.
+     *
+     * Use this to simulate external API calls, database queries, or any
+     * node whose real implementation you want to skip during testing.
+     *
+     * @param name - The node name as referenced in the workflow steps
+     * @param handler - Async function that receives (input, ctx) and returns output
+     */
+    mockNode(name, handler) {
+        const mockNodeInstance = new MockNode(name, handler);
+        this.nodes.set(name, mockNodeInstance);
+        if (this.config.verbose) {
+            console.log(`[WorkflowTestRunner] Mocked node: ${name}`);
+        }
+    }
+    /**
+     * Load a workflow definition from a JSON object or JSON string.
+     *
+     * The workflow should have a `steps` array where each step defines:
+     * - `name`: step identifier
+     * - `node`: the node type to execute
+     * - `inputs`: input data for the node (optional)
+     *
+     * @param workflow - Workflow definition object or JSON string
+     */
+    loadWorkflow(workflow) {
+        if (typeof workflow === "string") {
+            this.workflow = JSON.parse(workflow);
+        }
+        else {
+            this.workflow = workflow;
+        }
+        if (!this.workflow.steps || !Array.isArray(this.workflow.steps)) {
+            throw new Error("Workflow must have a 'steps' array");
+        }
+        if (this.config.verbose) {
+            console.log(`[WorkflowTestRunner] Loaded workflow: ${this.workflow.name ?? "(unnamed)"} ` +
+                `with ${this.workflow.steps.length} steps`);
+        }
+    }
+    /**
+     * Execute the loaded workflow with the given input.
+     *
+     * Each step in the workflow is executed sequentially. The output of each
+     * step is fed into the context for subsequent steps. A full execution
+     * trace is captured for inspection.
+     *
+     * @param input - Input data (populates request.body in the context)
+     * @param options - Optional execution configuration
+     * @returns WorkflowTestResult with output, trace, and per-node results
+     * @throws Error if no workflow is loaded or if a required node is not registered
+     */
+    async execute(input, options) {
+        if (!this.workflow) {
+            throw new Error("No workflow loaded. Call loadWorkflow() first.");
+        }
+        // Reset trace for this execution
+        this.trace = [];
+        this.nodeResults = new Map();
+        const logger = options?.contextOverrides?.logger ?? new TestLogger();
+        const workflowStartTime = performance.now();
+        // Build the initial context
+        const ctx = {
+            id: options?.contextOverrides?.id ?? `test-workflow-${Date.now()}`,
+            workflow_name: this.workflow.name ?? "test-workflow",
+            workflow_path: options?.contextOverrides?.workflow_path ?? "/test",
+            request: {
+                body: input ?? {},
+                headers: options?.headers ?? options?.contextOverrides?.request?.headers ?? {},
+                query: options?.query ?? options?.contextOverrides?.request?.query ?? {},
+                params: options?.params ?? options?.contextOverrides?.request?.params ?? {},
+            },
+            response: {
+                data: {},
+                error: null,
+                success: true,
+                contentType: "application/json",
+            },
+            error: options?.contextOverrides?.error ?? { message: [] },
+            logger: logger,
+            config: options?.contextOverrides?.config ?? {},
+            vars: options?.contextOverrides?.vars ?? {},
+            env: options?.contextOverrides?.env ?? {},
+            eventLogger: logger,
+            _PRIVATE_: {},
+        };
+        let workflowSuccess = true;
+        let workflowError = null;
+        // Create a timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Workflow execution timed out after ${this.config.timeout}ms`));
+            }, this.config.timeout);
+        });
+        try {
+            await Promise.race([this.executeSteps(ctx, this.workflow.steps), timeoutPromise]);
+        }
+        catch (error) {
+            workflowSuccess = false;
+            workflowError = error;
+            if (this.config.verbose) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.log(`[WorkflowTestRunner] Workflow failed: ${errorMsg}`);
+            }
+        }
+        const workflowEndTime = performance.now();
+        return {
+            success: workflowSuccess,
+            output: workflowSuccess ? ctx.response?.data : workflowError,
+            trace: [...this.trace],
+            durationMs: workflowEndTime - workflowStartTime,
+            nodeResults: new Map(this.nodeResults),
+        };
+    }
+    /**
+     * Get the execution trace from the most recent workflow run.
+     *
+     * @returns Array of ExecutionTrace entries in execution order
+     */
+    getTrace() {
+        return [...this.trace];
+    }
+    /**
+     * Reset the runner state (clears trace, node results, and loaded workflow).
+     * Registered nodes and mocks are preserved.
+     */
+    reset() {
+        this.workflow = null;
+        this.trace = [];
+        this.nodeResults = new Map();
+    }
+    /**
+     * Fully reset the runner, including all registered nodes and mocks.
+     */
+    resetAll() {
+        this.reset();
+        this.nodes = new Map();
+    }
+    /**
+     * Internal: Execute all workflow steps sequentially.
+     */
+    async executeSteps(ctx, steps) {
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            await this.executeStep(ctx, step, i);
+        }
+    }
+    /**
+     * Internal: Execute a single workflow step.
+     */
+    async executeStep(ctx, step, stepIndex) {
+        const nodeName = step.node;
+        let node = this.nodes.get(nodeName);
+        // Auto-mock if configured
+        if (!node && this.config.mockAllNodes) {
+            node = new AutoMockNode(nodeName);
+            this.nodes.set(nodeName, node);
+            if (this.config.verbose) {
+                console.log(`[WorkflowTestRunner] Auto-mocked node: ${nodeName}`);
+            }
+        }
+        if (!node) {
+            throw new Error(`Node "${nodeName}" is not registered. ` +
+                `Call registerNode("${nodeName}", nodeImpl) or mockNode("${nodeName}", handler) before executing.`);
+        }
+        // Determine input: use step.inputs if defined, otherwise use current response data
+        const stepInput = step.inputs ?? ctx.response?.data ?? {};
+        if (this.config.verbose) {
+            console.log(`[WorkflowTestRunner] Step ${stepIndex}: executing "${step.name}" (node: ${nodeName})`);
+        }
+        const startTime = performance.now();
+        const traceEntry = {
+            nodeName: step.name,
+            stepIndex,
+            input: stepInput,
+            output: null,
+            durationMs: 0,
+            success: false,
+            timestamp: Date.now(),
+        };
+        try {
+            const response = (await node.handle(ctx, stepInput));
+            const endTime = performance.now();
+            traceEntry.durationMs = endTime - startTime;
+            if (response.success === false || response.error) {
+                traceEntry.success = false;
+                traceEntry.error = response.error?.toString() ?? "Unknown error";
+                traceEntry.output = null;
+                this.nodeResults.set(step.name, {
+                    success: false,
+                    data: null,
+                    error: response.error,
+                    context: ctx,
+                    durationMs: traceEntry.durationMs,
+                    logs: ctx.logger.getLogs?.() ?? [],
+                });
+                this.trace.push(traceEntry);
+                throw new Error(`Node "${step.name}" (${nodeName}) failed: ${response.error?.toString() ?? "Unknown error"}`);
+            }
+            // Update context response with node output
+            ctx.response = {
+                data: response.data,
+                error: null,
+                success: true,
+                contentType: response.contentType ?? "application/json",
+            };
+            // If step sets a var, store output in vars
+            if (step.set_var) {
+                if (!ctx.vars)
+                    ctx.vars = {};
+                ctx.vars[step.name] = response.data;
+            }
+            traceEntry.success = true;
+            traceEntry.output = response.data;
+            this.nodeResults.set(step.name, {
+                success: true,
+                data: response.data,
+                error: null,
+                context: ctx,
+                durationMs: traceEntry.durationMs,
+                logs: ctx.logger.getLogs?.() ?? [],
+            });
+        }
+        catch (error) {
+            const endTime = performance.now();
+            if (!traceEntry.durationMs) {
+                traceEntry.durationMs = endTime - startTime;
+            }
+            if (!traceEntry.error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                traceEntry.success = false;
+                traceEntry.error = errorMsg;
+                this.nodeResults.set(step.name, {
+                    success: false,
+                    data: null,
+                    error,
+                    context: ctx,
+                    durationMs: traceEntry.durationMs,
+                    logs: ctx.logger.getLogs?.() ?? [],
+                });
+            }
+            this.trace.push(traceEntry);
+            throw error;
+        }
+        this.trace.push(traceEntry);
+        if (this.config.verbose) {
+            console.log(`[WorkflowTestRunner] Step ${stepIndex}: "${step.name}" completed in ${traceEntry.durationMs.toFixed(2)}ms`);
+        }
+    }
+}
+//# sourceMappingURL=WorkflowTestRunner.js.map