flowcraft 2.10.0 → 2.10.1

package/dist/linter-B8KALEae.d.mts

@@ -0,0 +1,25 @@
+import { d as NodeClass, h as NodeFunction, w as WorkflowBlueprint } from "./types-BcrXJEPI.mjs";
+
+//#region src/linter.d.ts
+type LinterIssueCode = 'INVALID_EDGE_SOURCE' | 'INVALID_EDGE_TARGET' | 'MISSING_NODE_IMPLEMENTATION' | 'ORPHAN_NODE' | 'INVALID_BATCH_WORKER_KEY' | 'INVALID_SUBFLOW_BLUEPRINT_ID';
+interface LinterIssue {
+  code: LinterIssueCode;
+  message: string;
+  nodeId?: string;
+  relatedId?: string;
+}
+interface LinterResult {
+  isValid: boolean;
+  issues: LinterIssue[];
+}
+/**
+ * Statically analyzes a workflow blueprint against a registry of implementations
+ * to find common errors before runtime.
+ *
+ * @param blueprint The WorkflowBlueprint to analyze.
+ * @param registry A map of node implementations (functions or classes) to check against.
+ * @returns A LinterResult object containing any issues found.
+ */
+declare function lintBlueprint(blueprint: WorkflowBlueprint, registry: Map<string, NodeFunction | NodeClass> | Record<string, NodeFunction | NodeClass>, blueprints?: Record<string, WorkflowBlueprint>): LinterResult;
+//#endregion
+export { lintBlueprint as i, LinterIssueCode as n, LinterResult as r, LinterIssue as t };

package/dist/linter.d.mts

@@ -0,0 +1,2 @@
+import { i as lintBlueprint, n as LinterIssueCode, r as LinterResult, t as LinterIssue } from "./linter-B8KALEae.mjs";
+export { LinterIssue, LinterIssueCode, LinterResult, lintBlueprint };

package/dist/linter.mjs

@@ -0,0 +1,74 @@
+import { analyzeBlueprint } from "./analysis.mjs";
+
+//#region src/linter.ts
+/**
+* Statically analyzes a workflow blueprint against a registry of implementations
+* to find common errors before runtime.
+*
+* @param blueprint The WorkflowBlueprint to analyze.
+* @param registry A map of node implementations (functions or classes) to check against.
+* @returns A LinterResult object containing any issues found.
+*/
+function lintBlueprint(blueprint, registry, blueprints) {
+	const issues = [];
+	const nodeIds = new Set(blueprint.nodes.map((n) => n.id));
+	const registryKeys = registry instanceof Map ? new Set(registry.keys()) : new Set(Object.keys(registry));
+	for (const node of blueprint.nodes) if (!node.uses.startsWith("batch-") && !node.uses.startsWith("loop-") && !registryKeys.has(node.uses)) issues.push({
+		code: "MISSING_NODE_IMPLEMENTATION",
+		message: `Node implementation key '${node.uses}' is not found in the provided registry.`,
+		nodeId: node.id
+	});
+	for (const node of blueprint.nodes) {
+		if (node.uses.startsWith("batch-") && node.params?.workerUsesKey) {
+			if (!registryKeys.has(node.params.workerUsesKey)) issues.push({
+				code: "INVALID_BATCH_WORKER_KEY",
+				message: `Batch node '${node.id}' references workerUsesKey '${node.params.workerUsesKey}' which is not found in the registry.`,
+				nodeId: node.id
+			});
+		}
+		if (node.uses === "subflow" && node.params?.blueprintId) {
+			if (!blueprints?.[node.params.blueprintId]) issues.push({
+				code: "INVALID_SUBFLOW_BLUEPRINT_ID",
+				message: `Subflow node '${node.id}' references blueprintId '${node.params.blueprintId}' which is not found in the blueprints registry.`,
+				nodeId: node.id
+			});
+		}
+	}
+	for (const edge of blueprint.edges || []) {
+		if (!nodeIds.has(edge.source)) issues.push({
+			code: "INVALID_EDGE_SOURCE",
+			message: `Edge source '${edge.source}' does not correspond to a valid node ID.`,
+			relatedId: edge.target
+		});
+		if (!nodeIds.has(edge.target)) issues.push({
+			code: "INVALID_EDGE_TARGET",
+			message: `Edge target '${edge.target}' does not correspond to a valid node ID.`,
+			relatedId: edge.source
+		});
+	}
+	if (blueprint.nodes.length > 1) {
+		const analysis = analyzeBlueprint(blueprint);
+		const connectedNodes = /* @__PURE__ */ new Set();
+		const nodesToVisit = [...analysis.startNodeIds];
+		const visited = /* @__PURE__ */ new Set();
+		while (nodesToVisit.length > 0) {
+			const currentId = nodesToVisit.pop();
+			if (!currentId || visited.has(currentId)) continue;
+			visited.add(currentId);
+			connectedNodes.add(currentId);
+			for (const targetEdge of blueprint.edges.filter((e) => e.source === currentId)) nodesToVisit.push(targetEdge.target);
+		}
+		for (const nodeId of nodeIds) if (!connectedNodes.has(nodeId)) issues.push({
+			code: "ORPHAN_NODE",
+			message: `Node '${nodeId}' is not reachable from any start node.`,
+			nodeId
+		});
+	}
+	return {
+		isValid: issues.length === 0,
+		issues
+	};
+}
+
+//#endregion
+export { lintBlueprint };

package/dist/logger-BvDgvNHQ.d.mts

@@ -0,0 +1,19 @@
+import { s as ILogger } from "./types-BcrXJEPI.mjs";
+
+//#region src/logger.d.ts
+/** A logger implementation that outputs to the console. */
+declare class ConsoleLogger implements ILogger {
+  debug(message: string, meta?: Record<string, any>): void;
+  info(message: string, meta?: Record<string, any>): void;
+  warn(message: string, meta?: Record<string, any>): void;
+  error(message: string, meta?: Record<string, any>): void;
+}
+/** A logger implementation that does nothing (no-op). */
+declare class NullLogger implements ILogger {
+  debug(_message: string, _meta?: Record<string, any>): void;
+  info(_message: string, _meta?: Record<string, any>): void;
+  warn(_message: string, _meta?: Record<string, any>): void;
+  error(_message: string, _meta?: Record<string, any>): void;
+}
+//#endregion
+export { NullLogger as n, ConsoleLogger as t };

package/dist/logger.d.mts

@@ -0,0 +1,2 @@
+import { n as NullLogger, t as ConsoleLogger } from "./logger-BvDgvNHQ.mjs";
+export { ConsoleLogger, NullLogger };

package/dist/logger.mjs

@@ -0,0 +1,26 @@
+//#region src/logger.ts
+/** A logger implementation that outputs to the console. */
+var ConsoleLogger = class {
+	debug(message, meta) {
+		console.debug(`[DEBUG] ${message}`, meta || "");
+	}
+	info(message, meta) {
+		console.info(`[INFO] ${message}`, meta || "");
+	}
+	warn(message, meta) {
+		console.warn(`[WARN] ${message}`, meta || "");
+	}
+	error(message, meta) {
+		console.error(`[ERROR] ${message}`, meta || "");
+	}
+};
+/** A logger implementation that does nothing (no-op). */
+var NullLogger = class {
+	debug(_message, _meta) {}
+	info(_message, _meta) {}
+	warn(_message, _meta) {}
+	error(_message, _meta) {}
+};
+
+//#endregion
+export { ConsoleLogger, NullLogger };

package/dist/node.d.mts

@@ -0,0 +1,2 @@
+import { K as BaseNode, q as isNodeClass } from "./types-BcrXJEPI.mjs";
+export { BaseNode, isNodeClass };

package/dist/node.mjs

@@ -0,0 +1,55 @@
+//#region src/node.ts
+/** A type guard to reliably distinguish a NodeClass from a NodeFunction. */
+function isNodeClass(impl) {
+	return typeof impl === "function" && !!impl.prototype?.exec;
+}
+/**
+* A structured, class-based node for complex logic with a safe, granular lifecycle.
+* This class is generic, allowing implementations to specify the exact context
+* and dependency types they expect.
+*/
+var BaseNode = class {
+	/**
+	* @param params Static parameters for this node instance, passed from the blueprint.
+	* @param nodeId The ID of the node in the blueprint.
+	*/
+	constructor(params, nodeId) {
+		this.params = params;
+		this.nodeId = nodeId;
+	}
+	/**
+	* Phase 1: Gathers and prepares data for execution. This phase is NOT retried on failure.
+	* @param context The node's execution context.
+	* @returns The data needed for the `exec` phase.
+	*/
+	async prep(context) {
+		return context.input;
+	}
+	/**
+	* Phase 3: Processes the result and saves state. This phase is NOT retried.
+	* @param execResult The successful result from the `exec` or `fallback` phase.
+	* @param _context The node's execution context.
+	*/
+	async post(execResult, _context) {
+		return execResult;
+	}
+	/**
+	* An optional safety net that runs if all `exec` retries fail.
+	* @param error The final error from the last `exec` attempt.
+	* @param _context The node's execution context.
+	*/
+	async fallback(error, _context) {
+		throw error;
+	}
+	/**
+	* An optional cleanup phase for non-retriable errors that occur outside the main `exec` method.
+	* This method is invoked in a `finally` block or equivalent construct if a fatal, unhandled exception occurs in the `prep`, `exec`, or `post` phases.
+	* Allows nodes to perform crucial cleanup, such as closing database connections or releasing locks.
+	* @param _error The error that caused the failure.
+	* @param _context The node's execution context.
+	*/
+	async recover(_error, _context) {}
+};
+
+//#endregion
+export { BaseNode, isNodeClass };

package/dist/nodes/batch-gather.d.mts

@@ -0,0 +1,2 @@
+import { t as BatchGatherNode } from "../batch-gather-BhF-IzQR.mjs";
+export { BatchGatherNode };

package/dist/nodes/batch-gather.mjs

@@ -0,0 +1,47 @@
+import { BaseNode } from "../node.mjs";
+
+//#region src/nodes/batch-gather.ts
+var BatchGatherNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const { gatherNodeId, outputKey } = this.params || {};
+		const hasMore = await context.context.get(`${gatherNodeId}_hasMore`) || false;
+		const dynamicNodes = [];
+		let results = [];
+		if (hasMore) {
+			const newScatterId = `${gatherNodeId}_scatter_next`;
+			dynamicNodes.push({
+				id: newScatterId,
+				uses: "batch-scatter",
+				inputs: context.input,
+				params: {
+					...this.params,
+					gatherNodeId
+				}
+			});
+		} else {
+			const allWorkerIds = await context.context.get(`${gatherNodeId}_allWorkerIds`) || [];
+			results = [];
+			for (const workerId of allWorkerIds) {
+				const result = await context.context.get(`_outputs.${workerId}`);
+				if (result !== void 0) results.push(result);
+			}
+			await context.context.set(outputKey, results);
+			const parentBatchId = gatherNodeId.replace("_gather", "");
+			await context.dependencies.runtime.services.eventBus.emit({
+				type: "batch:finish",
+				payload: {
+					batchId: parentBatchId,
+					gatherNodeId,
+					results
+				}
+			});
+		}
+		return {
+			dynamicNodes,
+			output: results
+		};
+	}
+};
+
+//#endregion
+export { BatchGatherNode };

package/dist/nodes/batch-scatter.d.mts

@@ -0,0 +1,2 @@
+import { t as BatchScatterNode } from "../batch-scatter-DD8TU0Wm.mjs";
+export { BatchScatterNode };

package/dist/nodes/batch-scatter.mjs

@@ -0,0 +1,52 @@
+import { BaseNode } from "../node.mjs";
+
+//#region src/nodes/batch-scatter.ts
+var BatchScatterNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const inputArray = context.input || [];
+		if (!Array.isArray(inputArray)) throw new Error(`Input for batch-scatter node '${this.nodeId}' must be an array.`);
+		const { chunkSize = inputArray.length, workerUsesKey, gatherNodeId } = this.params || {};
+		if (!workerUsesKey || !gatherNodeId) throw new Error(`BatchScatterNode requires 'workerUsesKey' and 'gatherNodeId' parameters.`);
+		const batchId = globalThis.crypto.randomUUID();
+		const currentIndex = await context.context.get(`${this.nodeId}_currentIndex`) || 0;
+		const endIndex = Math.min(currentIndex + chunkSize, inputArray.length);
+		const dynamicNodes = [];
+		const workerIds = [];
+		for (let i = currentIndex; i < endIndex; i++) {
+			const item = inputArray[i];
+			const itemInputKey = `_batch.${this.nodeId}_${batchId}_item_${i}`;
+			await context.context.set(itemInputKey, item);
+			const workerId = `${workerUsesKey}_${batchId}_${i}`;
+			workerIds.push(workerId);
+			dynamicNodes.push({
+				id: workerId,
+				uses: workerUsesKey,
+				inputs: itemInputKey
+			});
+		}
+		const parentBatchId = this.nodeId?.replace("_scatter", "") || "";
+		await context.dependencies.runtime.services.eventBus.emit({
+			type: "batch:start",
+			payload: {
+				batchId: parentBatchId,
+				scatterNodeId: this.nodeId,
+				workerNodeIds: workerIds
+			}
+		});
+		await context.context.set(`${this.nodeId}_currentIndex`, endIndex);
+		const hasMore = endIndex < inputArray.length;
+		await context.context.set(`${gatherNodeId}_hasMore`, hasMore);
+		const allWorkerIds = [...await context.context.get(`${gatherNodeId}_allWorkerIds`) || [], ...workerIds];
+		await context.context.set(`${gatherNodeId}_allWorkerIds`, allWorkerIds);
+		return {
+			dynamicNodes,
+			output: {
+				gatherNodeId,
+				hasMore
+			}
+		};
+	}
+};
+
+//#endregion
+export { BatchScatterNode };

package/dist/nodes/index.d.mts

@@ -0,0 +1,7 @@
+import { t as BatchGatherNode } from "../batch-gather-BhF-IzQR.mjs";
+import { t as BatchScatterNode } from "../batch-scatter-DD8TU0Wm.mjs";
+import { t as SleepNode } from "../sleep-DpwYaY5b.mjs";
+import { t as SubflowNode } from "../subflow-n2IMsRe2.mjs";
+import { t as WaitNode } from "../wait-2Q-LA7V7.mjs";
+import { t as WebhookNode } from "../webhook-BiCm-HLx.mjs";
+export { BatchGatherNode, BatchScatterNode, SleepNode, SubflowNode, WaitNode, WebhookNode };

package/dist/nodes/index.mjs

@@ -0,0 +1,8 @@
+import { BatchGatherNode } from "./batch-gather.mjs";
+import { BatchScatterNode } from "./batch-scatter.mjs";
+import { SleepNode } from "./sleep.mjs";
+import { SubflowNode } from "./subflow.mjs";
+import { WaitNode } from "./wait.mjs";
+import { WebhookNode } from "./webhook.mjs";
+
+export { BatchGatherNode, BatchScatterNode, SleepNode, SubflowNode, WaitNode, WebhookNode };

package/dist/nodes/sleep.d.mts

@@ -0,0 +1,2 @@
+import { t as SleepNode } from "../sleep-DpwYaY5b.mjs";
+export { SleepNode };

package/dist/nodes/sleep.mjs

@@ -0,0 +1,41 @@
+import { BaseNode } from "../node.mjs";
+
+//#region src/nodes/sleep.ts
+var SleepNode = class extends BaseNode {
+	async exec(prepResult, context) {
+		const durationParam = this.params?.duration;
+		let durationMs;
+		if (typeof durationParam === "string") {
+			const match = durationParam.match(/^(\d+)([smhd])$/);
+			if (!match) throw new Error(`SleepNode '${this.nodeId}' received an invalid duration string: '${durationParam}'. Expected format: '5m', '10s', '1h', '2d'`);
+			const [, numStr, unit] = match;
+			const num = parseInt(numStr, 10);
+			switch (unit) {
+				case "s":
+					durationMs = num * 1e3;
+					break;
+				case "m":
+					durationMs = num * 60 * 1e3;
+					break;
+				case "h":
+					durationMs = num * 60 * 60 * 1e3;
+					break;
+				case "d":
+					durationMs = num * 24 * 60 * 60 * 1e3;
+					break;
+				default: throw new Error(`Invalid duration unit: ${unit}`);
+			}
+		} else if (typeof durationParam === "number") durationMs = durationParam;
+		else throw new Error(`SleepNode '${this.nodeId}' received an invalid duration type: ${typeof durationParam}`);
+		if (durationMs < 0) throw new Error(`SleepNode '${this.nodeId}' received a negative duration.`);
+		const wakeUpAt = new Date(Date.now() + durationMs).toISOString();
+		await context.dependencies.workflowState.markAsAwaiting(this.nodeId ?? "", {
+			reason: "timer",
+			wakeUpAt
+		});
+		return { output: prepResult };
+	}
+};
+
+//#endregion
+export { SleepNode };

package/dist/nodes/subflow.d.mts

@@ -0,0 +1,2 @@
+import { t as SubflowNode } from "../subflow-n2IMsRe2.mjs";
+export { SubflowNode };

package/dist/nodes/subflow.mjs

@@ -0,0 +1,64 @@
+import { analyzeBlueprint } from "../analysis.mjs";
+import { FlowcraftError } from "../errors.mjs";
+import { WorkflowState } from "../runtime/state.mjs";
+import { ExecutionContext } from "../runtime/execution-context.mjs";
+import { BaseNode } from "../node.mjs";
+import { GraphTraverser } from "../runtime/traverser.mjs";
+
+//#region src/nodes/subflow.ts
+var SubflowNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const { blueprintId, inputs, outputs } = this.params ?? {};
+		const { runtime, workflowState } = context.dependencies;
+		if (!blueprintId) throw new FlowcraftError(`Subflow node '${this.nodeId}' is missing 'blueprintId' parameter.`, { isFatal: true });
+		const subBlueprint = runtime.blueprints?.[blueprintId] || runtime.runtime?.blueprints?.[blueprintId];
+		if (!subBlueprint) throw new FlowcraftError(`Sub-blueprint '${blueprintId}' not found in runtime registry.`, { isFatal: true });
+		const subflowInitialContext = {};
+		if (inputs) for (const [targetKey, sourceKey] of Object.entries(inputs)) {
+			let value = await context.context.get(sourceKey);
+			if (value === void 0) value = await context.context.get(`_outputs.${sourceKey}`);
+			subflowInitialContext[targetKey] = value;
+		}
+		else if (context.input !== void 0) {
+			const subAnalysis = analyzeBlueprint(subBlueprint);
+			for (const startNodeId of subAnalysis.startNodeIds) {
+				const inputKey = `_inputs.${startNodeId}`;
+				subflowInitialContext[inputKey] = context.input;
+			}
+		}
+		const subflowExecContext = new ExecutionContext(subBlueprint, new WorkflowState(subflowInitialContext), runtime.nodeRegistry, runtime.executionId, runtime.runtime, runtime.services, runtime.signal, runtime.concurrency);
+		const subflowTraverser = new GraphTraverser(subBlueprint);
+		const subflowResult = await runtime.runtime.orchestrator.run(subflowExecContext, subflowTraverser);
+		if (subflowResult.status === "awaiting") {
+			await workflowState.markAsAwaiting(this.nodeId ?? "");
+			const subflowStateKey = `_subflowState.${this.nodeId}`;
+			await context.context.set(subflowStateKey, subflowResult.serializedContext);
+			return { output: void 0 };
+		}
+		if (subflowResult.status !== "completed") {
+			const firstError = subflowResult.errors?.[0];
+			const errorMessage = firstError?.message || "Unknown error";
+			throw new FlowcraftError(`Sub-workflow '${blueprintId}' did not complete successfully. Status: ${subflowResult.status}. Error: ${errorMessage}`, {
+				cause: firstError,
+				nodeId: this.nodeId,
+				blueprintId
+			});
+		}
+		const subflowFinalContext = subflowResult.context;
+		if (outputs) {
+			for (const [parentKey, subKey] of Object.entries(outputs)) {
+				const value = subflowFinalContext[`_outputs.${subKey}`] ?? subflowFinalContext[subKey];
+				await context.context.set(parentKey, value);
+			}
+			return { output: subflowFinalContext };
+		}
+		const subAnalysis = analyzeBlueprint(subBlueprint);
+		if (subAnalysis.terminalNodeIds.length === 1) return { output: subflowFinalContext[`_outputs.${subAnalysis.terminalNodeIds[0]}`] };
+		const terminalOutputs = {};
+		for (const terminalId of subAnalysis.terminalNodeIds) terminalOutputs[terminalId] = subflowFinalContext[`_outputs.${terminalId}`];
+		return { output: terminalOutputs };
+	}
+};
+
+//#endregion
+export { SubflowNode };

package/dist/nodes/wait.d.mts

@@ -0,0 +1,2 @@
+import { t as WaitNode } from "../wait-2Q-LA7V7.mjs";
+export { WaitNode };

package/dist/nodes/wait.mjs

@@ -0,0 +1,12 @@
+import { BaseNode } from "../node.mjs";
+
+//#region src/nodes/wait.ts
+var WaitNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		await context.dependencies.workflowState.markAsAwaiting(this.nodeId ?? "", { reason: "external_event" });
+		return { output: void 0 };
+	}
+};
+
+//#endregion
+export { WaitNode };

package/dist/nodes/webhook.d.mts

@@ -0,0 +1,2 @@
+import { t as WebhookNode } from "../webhook-BiCm-HLx.mjs";
+export { WebhookNode };

package/dist/nodes/webhook.mjs

@@ -0,0 +1,24 @@
+import { BaseNode } from "../node.mjs";
+
+//#region src/nodes/webhook.ts
+var WebhookNode = class extends BaseNode {
+	async prep(context) {
+		const runId = context.dependencies.runtime.executionId;
+		const nodeId = this.nodeId ?? "";
+		const { url, event } = await context.dependencies.adapter.registerWebhookEndpoint(runId, nodeId);
+		return {
+			url,
+			event
+		};
+	}
+	async exec(prepResult, _context) {
+		return { output: {
+			url: prepResult.url,
+			event: prepResult.event,
+			request: new Promise(() => {})
+		} };
+	}
+};
+
+//#endregion
+export { WebhookNode };

package/dist/orchestrator-DwMIJRFI.d.mts

@@ -0,0 +1,8 @@
+import { D as WorkflowResult, F as GraphTraverser, M as IOrchestrator, k as ExecutionContext } from "./types-BcrXJEPI.mjs";
+
+//#region src/runtime/orchestrator.d.ts
+declare class DefaultOrchestrator implements IOrchestrator {
+  run(context: ExecutionContext<any, any>, traverser: GraphTraverser): Promise<WorkflowResult<any>>;
+}
+//#endregion
+export { DefaultOrchestrator as t };

package/dist/persistent-event-bus-COiQOpWh.d.mts

@@ -0,0 +1,68 @@
+import { o as IEventBus, r as FlowcraftEvent } from "./types-BcrXJEPI.mjs";
+
+//#region src/adapters/persistent-event-bus.d.ts
+/**
+ * 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;
+}
+//#endregion
+export { InMemoryEventStore as n, PersistentEventBusAdapter as r, IEventStore as t };

package/dist/replay-CVOy6d_L.d.mts

@@ -0,0 +1,44 @@
+import { D as WorkflowResult, F as GraphTraverser, M as IOrchestrator, k as ExecutionContext, r as FlowcraftEvent } from "./types-BcrXJEPI.mjs";
+
+//#region src/runtime/orchestrators/replay.d.ts
+/**
+ * An orchestrator that replays a pre-recorded sequence of workflow events
+ * to reconstruct the workflow state without executing any node logic.
+ *
+ * This enables time-travel debugging by allowing developers to inspect
+ * the exact state of a workflow at any point in its execution history.
+ */
+declare class ReplayOrchestrator implements IOrchestrator {
+  private events;
+  /**
+   * Creates a new ReplayOrchestrator with a sequence of recorded workflow events.
+   *
+   * @param events - Array of FlowcraftEvent objects representing the recorded workflow execution
+   */
+  constructor(events: FlowcraftEvent[]);
+  /**
+   * Replays the recorded workflow events to reconstruct the workflow state.
+   *
+   * This method filters events for the specific execution, applies each event in sequence
+   * to rebuild the context state, and returns the final reconstructed workflow result.
+   * Replayed executions always have a "completed" status since they reconstruct the final state.
+   *
+   * @param context - The execution context containing state and services
+   * @param _traverser - Graph traverser (unused in replay mode)
+   * @returns Promise resolving to the reconstructed workflow result
+   */
+  run(context: ExecutionContext<any, any>, _traverser: GraphTraverser): Promise<WorkflowResult<any>>;
+  /**
+   * Applies a single workflow event to reconstruct the execution state.
+   *
+   * This method handles different event types by updating the workflow state accordingly,
+   * including node completions, context changes, errors, fallbacks, and workflow control events.
+   *
+   * @param event - The workflow event to apply
+   * @param context - The execution context to update
+   * @param fallbackMap - Map tracking fallback node relationships (fallbackNodeId -> originalNodeId)
+   */
+  private applyEvent;
+}
+//#endregion
+export { ReplayOrchestrator as t };

package/dist/runtime/adapter.d.mts

@@ -0,0 +1,2 @@
+import { i as JobPayload, n as BaseDistributedAdapter, r as ICoordinationStore, t as AdapterOptions } from "../adapter-DzeZVjSE.mjs";
+export { AdapterOptions, BaseDistributedAdapter, ICoordinationStore, JobPayload };