flowcraft 2.8.0 → 2.8.1

package/dist/testing/index.d.mts

@@ -0,0 +1,172 @@
+import { Ct as WorkflowState, F as PersistentEventBusAdapter, K as NodeClass, N as IEventStore, P as InMemoryEventStore, R as FlowcraftEvent, V as IEventBus, X as NodeFunction, at as WorkflowBlueprint, ct as WorkflowResult, ht as GraphTraverser, ut as FlowRuntime } from "../index-D3dyjW2G.mjs";
+
+//#region src/testing/event-logger.d.ts
+/**
+ * A test utility that implements IEventBus to capture all workflow events
+ * in memory, acting as a "flight recorder" for behavioral testing.
+ *
+ * @example
+ * // In your test file (e.g., resiliency.test.ts)
+ * it('should retry a node on failure', async () => {
+ *   const eventLogger = new InMemoryEventLogger();
+ *   const runtime = new FlowRuntime({ eventBus: eventLogger });
+ *
+ *   const flow = createFlow('retry-flow')
+ *     .node('api-call', vi.fn().mockRejectedValueOnce(new Error('fail')), {
+ *       config: { maxRetries: 2 },
+ *     });
+ *
+ *   await runtime.run(flow.toBlueprint());
+ *
+ *   // Assert against the captured event history to prove behavior.
+ *   const retryEvents = eventLogger.filter('node:retry');
+ *   expect(retryEvents).toHaveLength(1); // The first attempt is not a "retry"
+ * });
+ */
+declare class InMemoryEventLogger implements IEventBus {
+  readonly events: FlowcraftEvent[];
+  /**
+   * Clears all captured events.
+   */
+  clear(): void;
+  /**
+   * The `emit` method required by the IEventBus interface.
+   * It simply pushes the received event into the internal events array.
+   * @param event The FlowcraftEvent to record.
+   */
+  emit(event: FlowcraftEvent): Promise<void>;
+  /**
+   * Finds the first event of a specific type.
+   * @param type The event type to find (e.g., 'node:error').
+   * @returns The first matching event, or undefined if not found.
+   */
+  find<T extends FlowcraftEvent['type']>(type: T): Extract<FlowcraftEvent, {
+    type: T;
+  }> | undefined;
+  /**
+   * Filters events to find all occurrences of a specific type.
+   * @param type The event type to filter by.
+   * @returns An array of matching events.
+   */
+  filter<T extends FlowcraftEvent['type']>(type: T): Extract<FlowcraftEvent, {
+    type: T;
+  }>[];
+  /**
+   * Prints a formatted log of all captured events to the console.
+   * Ideal for debugging failing tests.
+   * @param title A title for the log output.
+   */
+  printLog(title?: string): void;
+}
+//#endregion
+//#region src/testing/run-with-trace.d.ts
+/**
+ * A test helper that executes a workflow and automatically prints a detailed
+ * execution trace to the console if the workflow fails.
+ *
+ * @example
+ * // In your test file (e.g., my-workflow.test.ts)
+ * it('should process data correctly', async () => {
+ *   const flow = createFlow('my-flow')
+ *     .node('a', async () => ({ output: 1 }))
+ *     .node('b', async ({ input }) => ({ output: input + 1 })) // Bug: returns { output: 3 }
+ *     .edge('a', 'b')
+ *
+ *   const runtime = new FlowRuntime({})
+ *
+ *   // If this test fails, a full, human-readable trace of the execution
+ *   // (inputs, outputs, context changes) is printed to the console.
+ *   const result = await runWithTrace(runtime, flow.toBlueprint())
+ *
+ *   expect(result.context.b).toBe(2)
+ * })
+ *
+ * @param runtime The original FlowRuntime instance (its options will be used).
+ * @param blueprint The WorkflowBlueprint to execute.
+ * @param initialState The initial state for the workflow run.
+ * @param options Additional options for the run.
+ * @returns The WorkflowResult if successful.
+ */
+declare function runWithTrace<TContext extends Record<string, any>>(runtime: FlowRuntime<TContext, any>, blueprint: WorkflowBlueprint, initialState?: Partial<TContext> | string, options?: {
+  functionRegistry?: Map<string, any>;
+  strict?: boolean;
+  signal?: AbortSignal;
+}): Promise<WorkflowResult<Record<string, any>>>;
+//#endregion
+//#region src/testing/stepper.d.ts
+/**
+ * Represents the controlled, step-by-step execution of a workflow.
+ * Returned by the `createStepper` utility.
+ */
+interface IWorkflowStepper<TContext extends Record<string, any>> {
+  /** The current state of the workflow. Can be inspected after each step. */
+  readonly state: WorkflowState<TContext>;
+  /** The graph traverser instance. Can be used to inspect the frontier or completed nodes. */
+  readonly traverser: GraphTraverser;
+  /**
+   * Executes the next "turn" or batch of ready nodes in the workflow.
+   * @param options Optional configuration for this specific step, like a cancellation signal.
+   * @returns A `WorkflowResult` representing the state after the step, or `null` if the workflow has already completed.
+   */
+  next(options?: {
+    signal?: AbortSignal;
+    concurrency?: number;
+  }): Promise<WorkflowResult<TContext> | null>;
+  /**
+   * Reverts the workflow to its previous state.
+   * @returns The `WorkflowResult` of the previous state, or `null` if there is no history to revert to.
+   */
+  prev(): Promise<WorkflowResult<TContext> | null>;
+  /**
+   * Resets the stepper to its initial state, clearing all progress and history.
+   */
+  reset(): void;
+  /**
+   * A convenience method to check if the workflow has any more steps to run.
+   * @returns `true` if the workflow is complete or stalled, `false` otherwise.
+   */
+  isDone(): boolean;
+}
+/**
+ * A test utility that creates a stepper to execute a workflow one "turn" at a time.
+ * This is invaluable for debugging and writing fine-grained tests where you need to
+ * assert the state of the workflow after each logical step.
+ *
+ * @example
+ * // In your test file
+ * it('should correctly execute step-by-step', async () => {
+ *   const runtime = new FlowRuntime({ ... });
+ *   const flow = createFlow('test')
+ *     .node('a', async () => ({ output: 10 }))
+ *     .node('b', async ({ input }) => ({ output: input * 2 }))
+ *     .edge('a', 'b');
+ *
+ *   const stepper = await createStepper(runtime, flow.toBlueprint(), flow.getFunctionRegistry());
+ *
+ *   // First step (executes node 'a')
+ *   const result1 = await stepper.next();
+ *   expect(stepper.isDone()).toBe(false);
+ *   expect(result1.status).toBe('stalled');
+ *   expect(result1.context._outputs.a).toBe(10);
+ *
+ *   // Second step (executes node 'b')
+ *   const result2 = await stepper.next();
+ *   expect(stepper.isDone()).toBe(true);
+ *   expect(result2.status).toBe('completed');
+ *   expect(result2.context._outputs.b).toBe(20);
+ *
+ *   // Final step (no more work)
+ *   const result3 = await stepper.next();
+ *   expect(result3).toBeNull();
+ * });
+ *
+ * @param runtime The `FlowRuntime` instance, used for its configuration.
+ * @param blueprint The `WorkflowBlueprint` to execute.
+ * @param functionRegistry The function registry from createFlow, containing the node implementations.
+ * @param initialState The initial state for the workflow run.
+ * @returns A Promise that resolves to an `IWorkflowStepper` instance.
+ */
+declare function createStepper<TContext extends Record<string, any>, TDependencies extends Record<string, any>>(runtime: FlowRuntime<TContext, TDependencies>, blueprint: WorkflowBlueprint, functionRegistry: Map<string, NodeFunction | NodeClass>, initialState?: Partial<TContext>): Promise<IWorkflowStepper<TContext>>;
+//#endregion
+export { IEventStore, IWorkflowStepper, InMemoryEventLogger, InMemoryEventStore, PersistentEventBusAdapter, createStepper, runWithTrace };
+//# sourceMappingURL=index.d.mts.map

package/dist/testing/index.mjs

@@ -0,0 +1,277 @@
+import { A as PersistentEventBusAdapter, d as executeBatch, f as processResults, k as InMemoryEventStore, m as WorkflowState, o as GraphTraverser, p as ExecutionContext, t as FlowRuntime, v as FlowcraftError } from "../runtime-CmefIAu_.mjs";
+
+//#region src/testing/event-logger.ts
+/**
+* A test utility that implements IEventBus to capture all workflow events
+* in memory, acting as a "flight recorder" for behavioral testing.
+*
+* @example
+* // In your test file (e.g., resiliency.test.ts)
+* it('should retry a node on failure', async () => {
+*   const eventLogger = new InMemoryEventLogger();
+*   const runtime = new FlowRuntime({ eventBus: eventLogger });
+*
+*   const flow = createFlow('retry-flow')
+*     .node('api-call', vi.fn().mockRejectedValueOnce(new Error('fail')), {
+*       config: { maxRetries: 2 },
+*     });
+*
+*   await runtime.run(flow.toBlueprint());
+*
+*   // Assert against the captured event history to prove behavior.
+*   const retryEvents = eventLogger.filter('node:retry');
+*   expect(retryEvents).toHaveLength(1); // The first attempt is not a "retry"
+* });
+*/
+var InMemoryEventLogger = class {
+	events = [];
+	/**
+	* Clears all captured events.
+	*/
+	clear() {
+		this.events.length = 0;
+	}
+	/**
+	* The `emit` method required by the IEventBus interface.
+	* It simply pushes the received event into the internal events array.
+	* @param event The FlowcraftEvent to record.
+	*/
+	async emit(event) {
+		this.events.push(event);
+	}
+	/**
+	* Finds the first event of a specific type.
+	* @param type The event type to find (e.g., 'node:error').
+	* @returns The first matching event, or undefined if not found.
+	*/
+	find(type) {
+		return this.events.find((e) => e.type === type);
+	}
+	/**
+	* Filters events to find all occurrences of a specific type.
+	* @param type The event type to filter by.
+	* @returns An array of matching events.
+	*/
+	filter(type) {
+		return this.events.filter((e) => e.type === type);
+	}
+	/**
+	* Prints a formatted log of all captured events to the console.
+	* Ideal for debugging failing tests.
+	* @param title A title for the log output.
+	*/
+	printLog(title = "Workflow Execution Trace") {
+		console.log(`\n--- ${title} ---`);
+		if (this.events.length === 0) {
+			console.log("No events were captured.");
+			console.log("----------------------------------\n");
+			return;
+		}
+		this.events.forEach((event, index) => {
+			const { type, payload } = event;
+			console.log(`\n[${index + 1}] ${type}`);
+			switch (type) {
+				case "node:start":
+					console.log(`  - Node: "${payload.nodeId}" | Input: ${JSON.stringify(payload.input)}`);
+					break;
+				case "edge:evaluate":
+					console.log(`  - Edge: "${payload.source}" -> "${payload.target}"`);
+					console.log(`  - Condition: ${payload.condition || "N/A"} | Result: ${payload.result}`);
+					break;
+				case "context:change":
+					if (payload.op === "set") console.log(`  - Node "${payload.sourceNode}" wrote to context -> Key: "${payload.key}" | Value: ${JSON.stringify(payload.value)}`);
+					else if (payload.op === "delete") console.log(`  - Node "${payload.sourceNode}" deleted from context -> Key: "${payload.key}"`);
+					break;
+				case "node:finish":
+					console.log(`  - Node: "${payload.nodeId}" | Result: ${JSON.stringify(payload.result)}`);
+					break;
+				case "node:error":
+					console.log(`  - Node: "${payload.nodeId}"`);
+					console.error("  - Error:", payload.error);
+					break;
+				default: console.log(`  - Payload: ${JSON.stringify(payload, null, 2)}`);
+			}
+		});
+		console.log(`\n--- End of Trace ---`);
+	}
+};
+
+//#endregion
+//#region src/testing/run-with-trace.ts
+/**
+* A test helper that executes a workflow and automatically prints a detailed
+* execution trace to the console if the workflow fails.
+*
+* @example
+* // In your test file (e.g., my-workflow.test.ts)
+* it('should process data correctly', async () => {
+*   const flow = createFlow('my-flow')
+*     .node('a', async () => ({ output: 1 }))
+*     .node('b', async ({ input }) => ({ output: input + 1 })) // Bug: returns { output: 3 }
+*     .edge('a', 'b')
+*
+*   const runtime = new FlowRuntime({})
+*
+*   // If this test fails, a full, human-readable trace of the execution
+*   // (inputs, outputs, context changes) is printed to the console.
+*   const result = await runWithTrace(runtime, flow.toBlueprint())
+*
+*   expect(result.context.b).toBe(2)
+* })
+*
+* @param runtime The original FlowRuntime instance (its options will be used).
+* @param blueprint The WorkflowBlueprint to execute.
+* @param initialState The initial state for the workflow run.
+* @param options Additional options for the run.
+* @returns The WorkflowResult if successful.
+*/
+async function runWithTrace(runtime, blueprint, initialState = {}, options = {}) {
+	const eventLogger = new InMemoryEventLogger();
+	const testRuntime = new FlowRuntime({
+		...runtime.options,
+		eventBus: eventLogger
+	});
+	try {
+		const result = await testRuntime.run(blueprint, initialState, options);
+		if (process.env.DEBUG) eventLogger.printLog(`Successful Trace: ${blueprint.id}`);
+		return result;
+	} catch (error) {
+		eventLogger.printLog(`Failing Test Trace: ${blueprint.id}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/runtime/orchestrators/step-by-step.ts
+/**
+* An orchestrator that executes only one "tick" or "turn" of the workflow.
+* It processes a single batch of ready nodes from the frontier and then returns,
+* allowing the caller to inspect the intermediate state before proceeding.
+*
+* Useful for debugging, testing, or building interactive tools.
+*/
+var StepByStepOrchestrator = class {
+	async run(context, traverser) {
+		try {
+			context.signal?.throwIfAborted();
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+			throw error;
+		}
+		if (!traverser.hasMoreWork()) {
+			const isTraversalComplete = !traverser.hasMoreWork();
+			const status = context.state.getStatus(isTraversalComplete);
+			const result = await context.state.toResult(context.services.serializer, context.executionId);
+			result.status = status;
+			return result;
+		}
+		const allReadyNodes = traverser.getReadyNodes();
+		const nodesToExecute = context.concurrency ? allReadyNodes.slice(0, context.concurrency) : allReadyNodes;
+		const nodesToSkip = context.concurrency ? allReadyNodes.slice(context.concurrency) : [];
+		await processResults(await executeBatch(nodesToExecute, traverser.getDynamicBlueprint(), context.state, (nodeId) => context.runtime.getExecutorForNode(nodeId, context), context.runtime, context.concurrency), traverser, context.state, context.runtime, context.blueprint, context.executionId);
+		for (const { nodeId } of nodesToSkip) traverser.addToFrontier(nodeId);
+		const isTraversalComplete = !traverser.hasMoreWork();
+		const status = context.state.getStatus(isTraversalComplete);
+		const result = await context.state.toResult(context.services.serializer, context.executionId);
+		result.status = status;
+		return result;
+	}
+};
+
+//#endregion
+//#region src/testing/stepper.ts
+/**
+* A test utility that creates a stepper to execute a workflow one "turn" at a time.
+* This is invaluable for debugging and writing fine-grained tests where you need to
+* assert the state of the workflow after each logical step.
+*
+* @example
+* // In your test file
+* it('should correctly execute step-by-step', async () => {
+*   const runtime = new FlowRuntime({ ... });
+*   const flow = createFlow('test')
+*     .node('a', async () => ({ output: 10 }))
+*     .node('b', async ({ input }) => ({ output: input * 2 }))
+*     .edge('a', 'b');
+*
+*   const stepper = await createStepper(runtime, flow.toBlueprint(), flow.getFunctionRegistry());
+*
+*   // First step (executes node 'a')
+*   const result1 = await stepper.next();
+*   expect(stepper.isDone()).toBe(false);
+*   expect(result1.status).toBe('stalled');
+*   expect(result1.context._outputs.a).toBe(10);
+*
+*   // Second step (executes node 'b')
+*   const result2 = await stepper.next();
+*   expect(stepper.isDone()).toBe(true);
+*   expect(result2.status).toBe('completed');
+*   expect(result2.context._outputs.b).toBe(20);
+*
+*   // Final step (no more work)
+*   const result3 = await stepper.next();
+*   expect(result3).toBeNull();
+* });
+*
+* @param runtime The `FlowRuntime` instance, used for its configuration.
+* @param blueprint The `WorkflowBlueprint` to execute.
+* @param functionRegistry The function registry from createFlow, containing the node implementations.
+* @param initialState The initial state for the workflow run.
+* @returns A Promise that resolves to an `IWorkflowStepper` instance.
+*/
+async function createStepper(runtime, blueprint, functionRegistry, initialState = {}) {
+	const _initialBlueprint = structuredClone(blueprint);
+	const _initialState = structuredClone(initialState);
+	let state;
+	let traverser;
+	const history = [];
+	const orchestrator = new StepByStepOrchestrator();
+	const executionId = globalThis.crypto?.randomUUID();
+	const nodeRegistry = new Map([...runtime.registry, ...functionRegistry]);
+	const initialize = () => {
+		state = new WorkflowState(_initialState);
+		traverser = new GraphTraverser(_initialBlueprint);
+		history.length = 0;
+	};
+	initialize();
+	const stepper = {
+		get state() {
+			return state;
+		},
+		get traverser() {
+			return traverser;
+		},
+		isDone() {
+			return !traverser.hasMoreWork() && !state.isAwaiting();
+		},
+		reset() {
+			initialize();
+		},
+		async prev() {
+			const previousStateJson = history.pop();
+			if (!previousStateJson) return null;
+			state = new WorkflowState(runtime.serializer.deserialize(previousStateJson));
+			traverser = GraphTraverser.fromState(_initialBlueprint, state);
+			return state.toResult(runtime.serializer, void 0);
+		},
+		async next(options = {}) {
+			if (stepper.isDone()) return null;
+			const serializedContext = (await state.toResult(runtime.serializer, void 0)).serializedContext;
+			history.push(serializedContext);
+			const executionContext = new ExecutionContext(_initialBlueprint, state, nodeRegistry, executionId, runtime, {
+				logger: runtime.logger,
+				eventBus: runtime.eventBus,
+				serializer: runtime.serializer,
+				evaluator: runtime.evaluator,
+				middleware: runtime.middleware,
+				dependencies: runtime.dependencies
+			}, options.signal, options.concurrency);
+			return orchestrator.run(executionContext, traverser);
+		}
+	};
+	return stepper;
+}
+
+//#endregion
+export { InMemoryEventLogger, InMemoryEventStore, PersistentEventBusAdapter, createStepper, runWithTrace };
+//# sourceMappingURL=index.mjs.map

package/dist/testing/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/testing/event-logger.ts","../../src/testing/run-with-trace.ts","../../src/runtime/orchestrators/step-by-step.ts","../../src/testing/stepper.ts"],"sourcesContent":["import type { FlowcraftEvent, IEventBus } from '../types'\n\n/**\n * A test utility that implements IEventBus to capture all workflow events\n * in memory, acting as a \"flight recorder\" for behavioral testing.\n *\n * @example\n * // In your test file (e.g., resiliency.test.ts)\n * it('should retry a node on failure', async () => {\n *   const eventLogger = new InMemoryEventLogger();\n *   const runtime = new FlowRuntime({ eventBus: eventLogger });\n *\n *   const flow = createFlow('retry-flow')\n *     .node('api-call', vi.fn().mockRejectedValueOnce(new Error('fail')), {\n *       config: { maxRetries: 2 },\n *     });\n *\n *   await runtime.run(flow.toBlueprint());\n *\n *   // Assert against the captured event history to prove behavior.\n *   const retryEvents = eventLogger.filter('node:retry');\n *   expect(retryEvents).toHaveLength(1); // The first attempt is not a \"retry\"\n * });\n */\nexport class InMemoryEventLogger implements IEventBus {\n\tpublic readonly events: FlowcraftEvent[] = []\n\n\t/**\n\t * Clears all captured events.\n\t */\n\tpublic clear(): void {\n\t\tthis.events.length = 0\n\t}\n\n\t/**\n\t * The `emit` method required by the IEventBus interface.\n\t * It simply pushes the received event into the internal events array.\n\t * @param event The FlowcraftEvent to record.\n\t */\n\tpublic async emit(event: FlowcraftEvent): Promise<void> {\n\t\tthis.events.push(event)\n\t}\n\n\t/**\n\t * Finds the first event of a specific type.\n\t * @param type The event type to find (e.g., 'node:error').\n\t * @returns The first matching event, or undefined if not found.\n\t */\n\tpublic find<T extends FlowcraftEvent['type']>(type: T): Extract<FlowcraftEvent, { type: T }> | undefined {\n\t\treturn this.events.find((e) => e.type === type) as Extract<FlowcraftEvent, { type: T }> | undefined\n\t}\n\n\t/**\n\t * Filters events to find all occurrences of a specific type.\n\t * @param type The event type to filter by.\n\t * @returns An array of matching events.\n\t */\n\tpublic filter<T extends FlowcraftEvent['type']>(type: T): Extract<FlowcraftEvent, { type: T }>[] {\n\t\treturn this.events.filter((e) => e.type === type) as Extract<FlowcraftEvent, { type: T }>[]\n\t}\n\n\t/**\n\t * Prints a formatted log of all captured events to the console.\n\t * Ideal for debugging failing tests.\n\t * @param title A title for the log output.\n\t */\n\tpublic printLog(title = 'Workflow Execution Trace'): void {\n\t\tconsole.log(`\\n--- ${title} ---`)\n\t\tif (this.events.length === 0) {\n\t\t\tconsole.log('No events were captured.')\n\t\t\tconsole.log('----------------------------------\\n')\n\t\t\treturn\n\t\t}\n\n\t\tthis.events.forEach((event, index) => {\n\t\t\tconst { type, payload } = event\n\t\t\tconsole.log(`\\n[${index + 1}] ${type}`)\n\n\t\t\t// Custom formatting for a more intuitive trace\n\t\t\tswitch (type) {\n\t\t\t\tcase 'node:start':\n\t\t\t\t\tconsole.log(`  - Node: \"${payload.nodeId}\" | Input: ${JSON.stringify(payload.input)}`)\n\t\t\t\t\tbreak\n\t\t\t\tcase 'edge:evaluate':\n\t\t\t\t\tconsole.log(`  - Edge: \"${payload.source}\" -> \"${payload.target}\"`)\n\t\t\t\t\tconsole.log(`  - Condition: ${payload.condition || 'N/A'} | Result: ${payload.result}`)\n\t\t\t\t\tbreak\n\t\t\t\tcase 'context:change':\n\t\t\t\t\tif (payload.op === 'set') {\n\t\t\t\t\t\tconsole.log(\n\t\t\t\t\t\t\t`  - Node \"${payload.sourceNode}\" wrote to context -> Key: \"${payload.key}\" | Value: ${JSON.stringify(payload.value)}`,\n\t\t\t\t\t\t)\n\t\t\t\t\t} else if (payload.op === 'delete') {\n\t\t\t\t\t\tconsole.log(`  - Node \"${payload.sourceNode}\" deleted from context -> Key: \"${payload.key}\"`)\n\t\t\t\t\t}\n\t\t\t\t\tbreak\n\t\t\t\tcase 'node:finish':\n\t\t\t\t\tconsole.log(`  - Node: \"${payload.nodeId}\" | Result: ${JSON.stringify(payload.result)}`)\n\t\t\t\t\tbreak\n\t\t\t\tcase 'node:error':\n\t\t\t\t\tconsole.log(`  - Node: \"${payload.nodeId}\"`)\n\t\t\t\t\tconsole.error('  - Error:', payload.error)\n\t\t\t\t\tbreak\n\t\t\t\tdefault:\n\t\t\t\t\tconsole.log(`  - Payload: ${JSON.stringify(payload, null, 2)}`)\n\t\t\t}\n\t\t})\n\t\tconsole.log(`\\n--- End of Trace ---`)\n\t}\n}\n","import { FlowRuntime } from '../runtime'\nimport type { WorkflowBlueprint } from '../types'\nimport { InMemoryEventLogger } from './event-logger'\n\n/**\n * A test helper that executes a workflow and automatically prints a detailed\n * execution trace to the console if the workflow fails.\n *\n * @example\n * // In your test file (e.g., my-workflow.test.ts)\n * it('should process data correctly', async () => {\n *   const flow = createFlow('my-flow')\n *     .node('a', async () => ({ output: 1 }))\n *     .node('b', async ({ input }) => ({ output: input + 1 })) // Bug: returns { output: 3 }\n *     .edge('a', 'b')\n *\n *   const runtime = new FlowRuntime({})\n *\n *   // If this test fails, a full, human-readable trace of the execution\n *   // (inputs, outputs, context changes) is printed to the console.\n *   const result = await runWithTrace(runtime, flow.toBlueprint())\n *\n *   expect(result.context.b).toBe(2)\n * })\n *\n * @param runtime The original FlowRuntime instance (its options will be used).\n * @param blueprint The WorkflowBlueprint to execute.\n * @param initialState The initial state for the workflow run.\n * @param options Additional options for the run.\n * @returns The WorkflowResult if successful.\n */\nexport async function runWithTrace<TContext extends Record<string, any>>(\n\truntime: FlowRuntime<TContext, any>,\n\tblueprint: WorkflowBlueprint,\n\tinitialState: Partial<TContext> | string = {},\n\toptions: {\n\t\tfunctionRegistry?: Map<string, any>\n\t\tstrict?: boolean\n\t\tsignal?: AbortSignal\n\t} = {},\n) {\n\tconst eventLogger = new InMemoryEventLogger()\n\tconst testRuntime = new FlowRuntime({\n\t\t...runtime.options,\n\t\teventBus: eventLogger,\n\t})\n\n\ttry {\n\t\tconst result = await testRuntime.run(blueprint, initialState, options)\n\t\tif (process.env.DEBUG) {\n\t\t\teventLogger.printLog(`Successful Trace: ${blueprint.id}`)\n\t\t}\n\t\treturn result\n\t} catch (error) {\n\t\teventLogger.printLog(`Failing Test Trace: ${blueprint.id}`)\n\t\tthrow error\n\t}\n}\n","import { FlowcraftError } from '../../errors'\n\nimport type { WorkflowResult } from '../../types'\nimport type { ExecutionContext } from '../execution-context'\nimport type { GraphTraverser } from '../traverser'\nimport type { IOrchestrator } from '../types'\nimport { executeBatch, processResults } from './utils'\n\n/**\n * An orchestrator that executes only one \"tick\" or \"turn\" of the workflow.\n * It processes a single batch of ready nodes from the frontier and then returns,\n * allowing the caller to inspect the intermediate state before proceeding.\n *\n * Useful for debugging, testing, or building interactive tools.\n */\nexport class StepByStepOrchestrator implements IOrchestrator {\n\tpublic async run(context: ExecutionContext<any, any>, traverser: GraphTraverser): Promise<WorkflowResult<any>> {\n\t\ttry {\n\t\t\tcontext.signal?.throwIfAborted()\n\t\t} catch (error) {\n\t\t\tif (error instanceof DOMException && error.name === 'AbortError') {\n\t\t\t\tthrow new FlowcraftError('Workflow cancelled', { isFatal: false })\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\n\t\tif (!traverser.hasMoreWork()) {\n\t\t\tconst isTraversalComplete = !traverser.hasMoreWork()\n\t\t\tconst status = context.state.getStatus(isTraversalComplete)\n\t\t\tconst result = await context.state.toResult(context.services.serializer, context.executionId)\n\t\t\tresult.status = status\n\t\t\treturn result\n\t\t}\n\n\t\tconst allReadyNodes = traverser.getReadyNodes()\n\t\tconst nodesToExecute = context.concurrency ? allReadyNodes.slice(0, context.concurrency) : allReadyNodes\n\t\tconst nodesToSkip = context.concurrency ? allReadyNodes.slice(context.concurrency) : []\n\n\t\tconst settledResults = await executeBatch(\n\t\t\tnodesToExecute,\n\t\t\ttraverser.getDynamicBlueprint(),\n\t\t\tcontext.state,\n\t\t\t(nodeId: string) => context.runtime.getExecutorForNode(nodeId, context),\n\t\t\tcontext.runtime,\n\t\t\tcontext.concurrency,\n\t\t)\n\n\t\tawait processResults(\n\t\t\tsettledResults,\n\t\t\ttraverser,\n\t\t\tcontext.state,\n\t\t\tcontext.runtime,\n\t\t\tcontext.blueprint,\n\t\t\tcontext.executionId,\n\t\t)\n\n\t\tfor (const { nodeId } of nodesToSkip) {\n\t\t\ttraverser.addToFrontier(nodeId)\n\t\t}\n\n\t\tconst isTraversalComplete = !traverser.hasMoreWork()\n\t\tconst status = context.state.getStatus(isTraversalComplete)\n\t\tconst result = await context.state.toResult(context.services.serializer, context.executionId)\n\t\tresult.status = status\n\t\treturn result\n\t}\n}\n","import type { FlowRuntime } from '../runtime'\nimport { ExecutionContext } from '../runtime/execution-context'\nimport { StepByStepOrchestrator } from '../runtime/orchestrators/step-by-step'\nimport { WorkflowState } from '../runtime/state'\nimport { GraphTraverser } from '../runtime/traverser'\nimport type { NodeClass, NodeFunction, WorkflowBlueprint, WorkflowResult } from '../types'\n\n/**\n * Represents the controlled, step-by-step execution of a workflow.\n * Returned by the `createStepper` utility.\n */\nexport interface IWorkflowStepper<TContext extends Record<string, any>> {\n\t/** The current state of the workflow. Can be inspected after each step. */\n\treadonly state: WorkflowState<TContext>\n\n\t/** The graph traverser instance. Can be used to inspect the frontier or completed nodes. */\n\treadonly traverser: GraphTraverser\n\n\t/**\n\t * Executes the next \"turn\" or batch of ready nodes in the workflow.\n\t * @param options Optional configuration for this specific step, like a cancellation signal.\n\t * @returns A `WorkflowResult` representing the state after the step, or `null` if the workflow has already completed.\n\t */\n\tnext(options?: { signal?: AbortSignal; concurrency?: number }): Promise<WorkflowResult<TContext> | null>\n\n\t/**\n\t * Reverts the workflow to its previous state.\n\t * @returns The `WorkflowResult` of the previous state, or `null` if there is no history to revert to.\n\t */\n\tprev(): Promise<WorkflowResult<TContext> | null>\n\n\t/**\n\t * Resets the stepper to its initial state, clearing all progress and history.\n\t */\n\treset(): void\n\n\t/**\n\t * A convenience method to check if the workflow has any more steps to run.\n\t * @returns `true` if the workflow is complete or stalled, `false` otherwise.\n\t */\n\tisDone(): boolean\n}\n\n/**\n * A test utility that creates a stepper to execute a workflow one \"turn\" at a time.\n * This is invaluable for debugging and writing fine-grained tests where you need to\n * assert the state of the workflow after each logical step.\n *\n * @example\n * // In your test file\n * it('should correctly execute step-by-step', async () => {\n *   const runtime = new FlowRuntime({ ... });\n *   const flow = createFlow('test')\n *     .node('a', async () => ({ output: 10 }))\n *     .node('b', async ({ input }) => ({ output: input * 2 }))\n *     .edge('a', 'b');\n *\n *   const stepper = await createStepper(runtime, flow.toBlueprint(), flow.getFunctionRegistry());\n *\n *   // First step (executes node 'a')\n *   const result1 = await stepper.next();\n *   expect(stepper.isDone()).toBe(false);\n *   expect(result1.status).toBe('stalled');\n *   expect(result1.context._outputs.a).toBe(10);\n *\n *   // Second step (executes node 'b')\n *   const result2 = await stepper.next();\n *   expect(stepper.isDone()).toBe(true);\n *   expect(result2.status).toBe('completed');\n *   expect(result2.context._outputs.b).toBe(20);\n *\n *   // Final step (no more work)\n *   const result3 = await stepper.next();\n *   expect(result3).toBeNull();\n * });\n *\n * @param runtime The `FlowRuntime` instance, used for its configuration.\n * @param blueprint The `WorkflowBlueprint` to execute.\n * @param functionRegistry The function registry from createFlow, containing the node implementations.\n * @param initialState The initial state for the workflow run.\n * @returns A Promise that resolves to an `IWorkflowStepper` instance.\n */\nexport async function createStepper<TContext extends Record<string, any>, TDependencies extends Record<string, any>>(\n\truntime: FlowRuntime<TContext, TDependencies>,\n\tblueprint: WorkflowBlueprint,\n\tfunctionRegistry: Map<string, NodeFunction | NodeClass>,\n\tinitialState: Partial<TContext> = {},\n): Promise<IWorkflowStepper<TContext>> {\n\tconst _initialBlueprint = structuredClone(blueprint)\n\tconst _initialState = structuredClone(initialState)\n\n\tlet state: WorkflowState<TContext>\n\tlet traverser: GraphTraverser\n\tconst history: string[] = []\n\n\tconst orchestrator = new StepByStepOrchestrator()\n\tconst executionId = globalThis.crypto?.randomUUID()\n\tconst nodeRegistry = new Map([...runtime.registry, ...functionRegistry])\n\n\tconst initialize = () => {\n\t\tstate = new WorkflowState<TContext>(_initialState)\n\t\ttraverser = new GraphTraverser(_initialBlueprint)\n\t\thistory.length = 0\n\t}\n\n\tinitialize()\n\n\tconst stepper: IWorkflowStepper<TContext> = {\n\t\tget state() {\n\t\t\treturn state\n\t\t},\n\t\tget traverser() {\n\t\t\treturn traverser\n\t\t},\n\t\tisDone() {\n\t\t\treturn !traverser.hasMoreWork() && !state.isAwaiting()\n\t\t},\n\t\treset() {\n\t\t\tinitialize()\n\t\t},\n\t\tasync prev() {\n\t\t\tconst previousStateJson = history.pop()\n\t\t\tif (!previousStateJson) {\n\t\t\t\treturn null\n\t\t\t}\n\n\t\t\tconst previousStateData = runtime.serializer.deserialize(previousStateJson) as Partial<TContext>\n\n\t\t\tstate = new WorkflowState(previousStateData)\n\t\t\ttraverser = GraphTraverser.fromState(_initialBlueprint, state)\n\n\t\t\treturn state.toResult(runtime.serializer, undefined)\n\t\t},\n\t\tasync next(options: { signal?: AbortSignal; concurrency?: number } = {}) {\n\t\t\tif (stepper.isDone()) {\n\t\t\t\treturn null\n\t\t\t}\n\n\t\t\tconst serializedContext = (await state.toResult(runtime.serializer, undefined)).serializedContext\n\t\t\thistory.push(serializedContext)\n\n\t\t\tconst executionContext = new ExecutionContext(\n\t\t\t\t_initialBlueprint,\n\t\t\t\tstate,\n\t\t\t\tnodeRegistry,\n\t\t\t\texecutionId,\n\t\t\t\truntime,\n\t\t\t\t{\n\t\t\t\t\tlogger: runtime.logger,\n\t\t\t\t\teventBus: runtime.eventBus,\n\t\t\t\t\tserializer: runtime.serializer,\n\t\t\t\t\tevaluator: runtime.evaluator,\n\t\t\t\t\tmiddleware: runtime.middleware,\n\t\t\t\t\tdependencies: runtime.dependencies,\n\t\t\t\t},\n\t\t\t\toptions.signal,\n\t\t\t\toptions.concurrency,\n\t\t\t)\n\t\t\treturn orchestrator.run(executionContext, traverser)\n\t\t},\n\t}\n\n\treturn stepper\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "flowcraft",
 	"type": "module",
-	"version": "2.8.0",
+	"version": "2.8.1",
 	"description": "A lightweight workflow engine",
 	"license": "MIT",
 	"homepage": "https://flowcraft.js.org",
@@ -27,34 +27,34 @@
 	],
 	"exports": {
 		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
+			"types": "./dist/index.d.mts",
+			"import": "./dist/index.mjs"
 		},
 		"./sdk": {
-			"types": "./dist/sdk.d.ts",
-			"import": "./dist/sdk.js"
+			"types": "./dist/sdk.d.mts",
+			"import": "./dist/sdk.mjs"
 		},
 		"./testing": {
-			"types": "./dist/testing/index.d.ts",
-			"import": "./dist/testing/index.js"
+			"types": "./dist/testing/index.d.mts",
+			"import": "./dist/testing/index.mjs"
 		}
 	},
 	"files": [
 		"dist"
 	],
 	"scripts": {
-		"dev": "tsup --watch",
-		"build": "tsup",
+		"dev": "tsdown --watch",
+		"build": "tsdown",
 		"typecheck": "tsc --noEmit",
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"test:coverage": "vitest run --coverage"
 	},
 	"devDependencies": {
-		"@types/node": "^25.3.3",
+		"@types/node": "^25.5.0",
 		"@vitest/coverage-v8": "4.0.4",
-		"tsup": "^8.5.1",
-		"typescript": "^5.9.3",
-		"vitest": "^4.0.18"
+		"tsdown": "^0.21.7",
+		"typescript": "^6.0.2",
+		"vitest": "^4.1.2"
 	}
 }

package/dist/adapters/index.d.ts

@@ -1,4 +0,0 @@
-export { IEventStore, InMemoryEventStore, PersistentEventBusAdapter } from './persistent-event-bus.js';
-import '../types-Biip2gLh.js';
-import '../errors.js';
-import '../container.js';

package/dist/adapters/index.js

@@ -1,4 +0,0 @@
-import '../chunk-3Y5O5EGB.js';
-export { InMemoryEventStore, PersistentEventBusAdapter } from '../chunk-2TSADFQX.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/adapters/persistent-event-bus.d.ts

@@ -1,69 +0,0 @@
-import { z as FlowcraftEvent, A as IEventBus } from '../types-Biip2gLh.js';
-import '../errors.js';
-import '../container.js';
-
-/**
- * Interface for a persistent storage mechanism for events.
- * Implementations can store events in databases, log streams, files, etc.
- */
-interface IEventStore {
-    /**
-     * Store an event persistently.
-     * @param event The event to store
-     * @param executionId The execution ID for grouping events
-     */
-    store(event: FlowcraftEvent, executionId: string): Promise<void>;
-    /**
-     * Retrieve all events for a specific execution.
-     * @param executionId The execution ID
-     * @returns Array of events in chronological order
-     */
-    retrieve(executionId: string): Promise<FlowcraftEvent[]>;
-    /**
-     * Retrieve events for multiple executions.
-     * @param executionIds Array of execution IDs
-     * @returns Map of execution ID to array of events
-     */
-    retrieveMultiple(executionIds: string[]): Promise<Map<string, FlowcraftEvent[]>>;
-}
-/**
- * A pluggable event bus adapter that persists all workflow events
- * to a configurable storage backend, enabling time-travel debugging and replay.
- *
- * @example
- * ```typescript
- * // Using a database-backed store
- * const eventStore = new DatabaseEventStore(dbConnection)
- * const eventBus = new PersistentEventBusAdapter(eventStore)
- * const runtime = new FlowRuntime({ eventBus })
- *
- * // Later, replay the execution
- * const events = await eventStore.retrieve(executionId)
- * const finalState = await runtime.replay(blueprint, events)
- * ```
- */
-declare class PersistentEventBusAdapter implements IEventBus {
-    private store;
-    constructor(store: IEventStore);
-    /**
-     * Emit an event by storing it persistently.
-     * Also emits to console for debugging (can be made configurable).
-     */
-    emit(event: FlowcraftEvent): Promise<void>;
-}
-/**
- * Simple in-memory event store for testing and development.
- * Not suitable for production use.
- */
-declare class InMemoryEventStore implements IEventStore {
-    private events;
-    store(event: FlowcraftEvent, executionId: string): Promise<void>;
-    retrieve(executionId: string): Promise<FlowcraftEvent[]>;
-    retrieveMultiple(executionIds: string[]): Promise<Map<string, FlowcraftEvent[]>>;
-    /**
-     * Clear all stored events (useful for testing).
-     */
-    clear(): void;
-}
-
-export { type IEventStore, InMemoryEventStore, PersistentEventBusAdapter };

package/dist/adapters/persistent-event-bus.js

@@ -1,3 +0,0 @@
-export { InMemoryEventStore, PersistentEventBusAdapter } from '../chunk-2TSADFQX.js';
-//# sourceMappingURL=persistent-event-bus.js.map
-//# sourceMappingURL=persistent-event-bus.js.map

package/dist/adapters/persistent-event-bus.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"persistent-event-bus.js"}