flowcraft 2.9.3 → 2.10.1

package/dist/runtime/runtime.mjs

@@ -0,0 +1,425 @@
+import { analyzeBlueprint } from "../analysis.mjs";
+import { DIContainer, ServiceTokens } from "../container.mjs";
+import { PropertyEvaluator } from "../evaluator.mjs";
+import { NullLogger } from "../logger.mjs";
+import { FlowcraftError } from "../errors.mjs";
+import { WorkflowState } from "./state.mjs";
+import { ExecutionContext } from "./execution-context.mjs";
+import { DefaultOrchestrator } from "./orchestrator.mjs";
+import { JsonSerializer } from "../serializer.mjs";
+import { BatchGatherNode } from "../nodes/batch-gather.mjs";
+import { BatchScatterNode } from "../nodes/batch-scatter.mjs";
+import { SleepNode } from "../nodes/sleep.mjs";
+import { GraphTraverser } from "./traverser.mjs";
+import { SubflowNode } from "../nodes/subflow.mjs";
+import { WaitNode } from "../nodes/wait.mjs";
+import { WebhookNode } from "../nodes/webhook.mjs";
+import { sanitizeBlueprint } from "../sanitizer.mjs";
+import { NodeExecutorFactory } from "./node-executor-factory.mjs";
+import { WorkflowScheduler } from "./scheduler.mjs";
+import { WorkflowLogicHandler } from "./workflow-logic-handler.mjs";
+
+//#region src/runtime/runtime.ts
+var FlowRuntime = class {
+	container;
+	registry;
+	blueprints;
+	dependencies;
+	logger;
+	eventBus;
+	serializer;
+	middleware;
+	evaluator;
+	analysisCache;
+	orchestrator;
+	options;
+	logicHandler;
+	executorFactory;
+	scheduler;
+	getBlueprint(id) {
+		return this.blueprints[id];
+	}
+	constructor(containerOrOptions, legacyOptions) {
+		let userRegistry;
+		if (containerOrOptions instanceof DIContainer) {
+			this.container = containerOrOptions;
+			this.logger = this.container.resolve(ServiceTokens.Logger);
+			this.serializer = this.container.resolve(ServiceTokens.Serializer);
+			this.evaluator = this.container.resolve(ServiceTokens.Evaluator);
+			this.eventBus = this.container.resolve(ServiceTokens.EventBus) || { emit: async () => {} };
+			this.middleware = this.container.resolve(ServiceTokens.Middleware) || [];
+			userRegistry = this.container.resolve(ServiceTokens.NodeRegistry);
+			this.blueprints = this.container.resolve(ServiceTokens.BlueprintRegistry);
+			this.dependencies = this.container.resolve(ServiceTokens.Dependencies);
+			this.options = legacyOptions || {};
+			this.orchestrator = this.container.resolve(ServiceTokens.Orchestrator);
+			this.scheduler = new WorkflowScheduler(this);
+		} else {
+			const options = containerOrOptions || {};
+			this.logger = options.logger || new NullLogger();
+			this.serializer = options.serializer || new JsonSerializer();
+			this.evaluator = options.evaluator || new PropertyEvaluator();
+			this.eventBus = options.eventBus || { emit: async () => {} };
+			this.middleware = options.middleware || [];
+			userRegistry = options.registry || {};
+			this.blueprints = options.blueprints || {};
+			this.scheduler = new WorkflowScheduler(this);
+			this.dependencies = options.dependencies || {};
+			this.options = options;
+			this.container = null;
+		}
+		const loopControllerFunction = async (context) => {
+			const condition = context.params.condition;
+			const contextData = await context.context.toJSON();
+			if (this.evaluator.evaluate(condition, contextData)) return { action: "continue" };
+			else return {
+				action: "break",
+				output: null
+			};
+		};
+		this.registry = new Map(Object.entries({
+			wait: WaitNode,
+			sleep: SleepNode,
+			webhook: WebhookNode,
+			subflow: SubflowNode,
+			"batch-scatter": BatchScatterNode,
+			"batch-gather": BatchGatherNode,
+			"loop-controller": loopControllerFunction,
+			...userRegistry
+		}));
+		this.orchestrator = this.container?.has(ServiceTokens.Orchestrator) ? this.container.resolve(ServiceTokens.Orchestrator) : new DefaultOrchestrator();
+		this.analysisCache = /* @__PURE__ */ new WeakMap();
+		this.logicHandler = new WorkflowLogicHandler(this.evaluator, this.eventBus);
+		this.executorFactory = new NodeExecutorFactory(this.eventBus);
+	}
+	_setupExecutionContext(blueprint, initialState, options) {
+		const executionId = globalThis.crypto?.randomUUID();
+		const contextData = typeof initialState === "string" ? this.serializer.deserialize(initialState) : initialState;
+		blueprint = sanitizeBlueprint(blueprint);
+		const state = new WorkflowState(contextData);
+		const nodeRegistry = this._createExecutionRegistry(options?.functionRegistry);
+		return new ExecutionContext(blueprint, state, nodeRegistry, executionId, this, {
+			logger: this.logger,
+			eventBus: this.eventBus,
+			serializer: this.serializer,
+			evaluator: this.evaluator,
+			middleware: this.middleware,
+			dependencies: this.dependencies
+		}, options?.signal, options?.concurrency);
+	}
+	async run(blueprint, initialState = {}, options) {
+		const startTime = Date.now();
+		const executionContext = this._setupExecutionContext(blueprint, initialState, options);
+		this.logger.info(`Starting workflow execution`, {
+			blueprintId: executionContext.blueprint.id,
+			executionId: executionContext.executionId
+		});
+		try {
+			await this.eventBus.emit({
+				type: "workflow:start",
+				payload: {
+					blueprintId: executionContext.blueprint.id,
+					executionId: executionContext.executionId
+				}
+			});
+			await this.eventBus.emit({
+				type: "workflow:resume",
+				payload: {
+					blueprintId: executionContext.blueprint.id,
+					executionId: executionContext.executionId
+				}
+			});
+			const analysis = this.analysisCache.get(executionContext.blueprint) ?? (() => {
+				const computed = analyzeBlueprint(executionContext.blueprint);
+				this.analysisCache.set(executionContext.blueprint, computed);
+				return computed;
+			})();
+			if (options?.strict && !analysis.isDag) throw new Error(`Workflow '${executionContext.blueprint.id}' failed strictness check: Cycles are not allowed.`);
+			if (!analysis.isDag) this.logger.warn(`Workflow contains cycles`, { blueprintId: executionContext.blueprint.id });
+			const traverser = new GraphTraverser(executionContext.blueprint, options?.strict === true);
+			const result = await this.orchestrator.run(executionContext, traverser);
+			const duration = Date.now() - startTime;
+			if (result.status === "stalled") {
+				await this.eventBus.emit({
+					type: "workflow:stall",
+					payload: {
+						blueprintId: executionContext.blueprint.id,
+						executionId: executionContext.executionId,
+						remainingNodes: traverser.getAllNodeIds().size - executionContext.state.getCompletedNodes().size
+					}
+				});
+				await this.eventBus.emit({
+					type: "workflow:pause",
+					payload: {
+						blueprintId: executionContext.blueprint.id,
+						executionId: executionContext.executionId
+					}
+				});
+			}
+			this.logger.info(`Workflow execution completed`, {
+				blueprintId: executionContext.blueprint.id,
+				executionId: executionContext.executionId,
+				status: result.status,
+				duration,
+				errors: result.errors?.length || 0
+			});
+			await this.eventBus.emit({
+				type: "workflow:finish",
+				payload: {
+					blueprintId: executionContext.blueprint.id,
+					executionId: executionContext.executionId,
+					status: result.status,
+					errors: result.errors
+				}
+			});
+			if (result.status === "awaiting") {
+				const awaitingNodeIds = executionContext.state.getAwaitingNodeIds();
+				for (const nodeId of awaitingNodeIds) {
+					const details = executionContext.state.getAwaitingDetails(nodeId);
+					if (details?.reason === "timer") this.scheduler.registerAwaitingWorkflow(executionContext.executionId, executionContext.blueprint.id, result.serializedContext, nodeId, details.wakeUpAt, options?.functionRegistry);
+				}
+			}
+			return result;
+		} catch (error) {
+			const duration = Date.now() - startTime;
+			const workflowError = {
+				message: error instanceof Error ? error.message : String(error),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				isFatal: false,
+				name: "WorkflowError"
+			};
+			await this.eventBus.emit({
+				type: "workflow:finish",
+				payload: {
+					blueprintId: executionContext.blueprint.id,
+					executionId: executionContext.executionId,
+					status: "cancelled",
+					errors: [workflowError]
+				}
+			});
+			if (error instanceof DOMException ? error.name === "AbortError" : error instanceof FlowcraftError && error.message.includes("cancelled")) {
+				this.logger.info(`Workflow execution cancelled`, {
+					blueprintId: executionContext.blueprint.id,
+					executionId: executionContext.executionId,
+					duration
+				});
+				await this.eventBus.emit({
+					type: "workflow:pause",
+					payload: {
+						blueprintId: executionContext.blueprint.id,
+						executionId: executionContext.executionId
+					}
+				});
+				await this.eventBus.emit({
+					type: "workflow:finish",
+					payload: {
+						blueprintId: executionContext.blueprint.id,
+						executionId: executionContext.executionId,
+						status: "cancelled",
+						errors: [workflowError]
+					}
+				});
+				return {
+					context: {},
+					serializedContext: "{}",
+					status: "cancelled"
+				};
+			}
+			this.logger.error(`Workflow execution failed`, {
+				blueprintId: executionContext.blueprint.id,
+				executionId: executionContext.executionId,
+				duration,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	startScheduler(checkIntervalMs) {
+		if (checkIntervalMs !== void 0) this.scheduler = new WorkflowScheduler(this, checkIntervalMs);
+		this.scheduler.start();
+	}
+	stopScheduler() {
+		this.scheduler.stop();
+	}
+	_setupResumedExecutionContext(blueprint, workflowState, options) {
+		const executionId = globalThis.crypto?.randomUUID();
+		return new ExecutionContext(blueprint, workflowState, this._createExecutionRegistry(options?.functionRegistry), executionId, this, {
+			logger: this.logger,
+			eventBus: this.eventBus,
+			serializer: this.serializer,
+			evaluator: this.evaluator,
+			middleware: this.middleware,
+			dependencies: this.dependencies
+		}, options?.signal);
+	}
+	async resume(blueprint, serializedContext, resumeData, nodeId, options) {
+		const executionId = globalThis.crypto?.randomUUID();
+		const workflowState = new WorkflowState(this.serializer.deserialize(serializedContext));
+		const awaitingNodeIds = workflowState.getAwaitingNodeIds();
+		if (awaitingNodeIds.length === 0) throw new FlowcraftError("Cannot resume: The provided context is not in an awaiting state.", { isFatal: true });
+		const awaitingNodeId = nodeId || awaitingNodeIds[0];
+		if (!awaitingNodeIds.includes(awaitingNodeId)) throw new FlowcraftError(`Cannot resume: Node '${awaitingNodeId}' is not in an awaiting state.`, { isFatal: true });
+		const awaitingNodeDef = blueprint.nodes.find((n) => n.id === awaitingNodeId);
+		if (!awaitingNodeDef) throw new FlowcraftError(`Awaiting node '${awaitingNodeId}' not found in blueprint.`, {
+			nodeId: awaitingNodeId,
+			blueprintId: blueprint.id,
+			isFatal: true
+		});
+		const contextImpl = workflowState.getContext();
+		if (awaitingNodeDef.uses === "SubflowNode") {
+			const subflowStateKey = `_subflowState.${awaitingNodeId}`;
+			const subflowContext = await contextImpl.get(subflowStateKey);
+			if (!subflowContext) throw new FlowcraftError(`Cannot resume: Subflow state for node '${awaitingNodeId}' not found.`, {
+				nodeId: awaitingNodeId,
+				blueprintId: blueprint.id,
+				isFatal: true
+			});
+			const blueprintId = awaitingNodeDef.params?.blueprintId;
+			if (!blueprintId) throw new FlowcraftError(`Subflow node '${awaitingNodeId}' is missing the 'blueprintId' parameter.`, {
+				nodeId: awaitingNodeId,
+				blueprintId: blueprint.id,
+				isFatal: true
+			});
+			const subBlueprint = this.blueprints[blueprintId];
+			if (!subBlueprint) throw new FlowcraftError(`Sub-blueprint with ID '${blueprintId}' not found in runtime registry.`, {
+				nodeId: awaitingNodeId,
+				blueprintId: blueprint.id,
+				isFatal: true
+			});
+			const subflowResumeResult = await this.resume(subBlueprint, subflowContext, resumeData, void 0, options);
+			if (subflowResumeResult.status !== "completed") throw new FlowcraftError(`Resumed subflow '${subBlueprint.id}' did not complete. Status: ${subflowResumeResult.status}`, {
+				nodeId: awaitingNodeId,
+				blueprintId: blueprint.id,
+				isFatal: false
+			});
+			const subflowFinalContext = subflowResumeResult.context;
+			let finalSubflowOutput;
+			const subAnalysis = analyzeBlueprint(subBlueprint);
+			if (awaitingNodeDef.params?.outputs) finalSubflowOutput = subflowFinalContext;
+			else if (subAnalysis.terminalNodeIds.length === 1) finalSubflowOutput = subflowFinalContext[`_outputs.${subAnalysis.terminalNodeIds[0]}`];
+			else {
+				const terminalOutputs = {};
+				for (const terminalId of subAnalysis.terminalNodeIds) terminalOutputs[terminalId] = subflowFinalContext[`_outputs.${terminalId}`];
+				finalSubflowOutput = terminalOutputs;
+			}
+			resumeData = { output: finalSubflowOutput };
+			await contextImpl.delete(subflowStateKey);
+		}
+		const existingOutput = await workflowState.getContext().get(`_outputs.${awaitingNodeId}`);
+		const nodeOutput = resumeData.output !== void 0 ? resumeData.output : existingOutput;
+		workflowState.addCompletedNode(awaitingNodeId, nodeOutput);
+		const nodeResult = { output: nodeOutput };
+		const nextSteps = await this.determineNextNodes(blueprint, awaitingNodeId, nodeResult, contextImpl, executionId);
+		if (nextSteps.length === 0) {
+			workflowState.clearAwaiting(awaitingNodeId);
+			const result = await workflowState.toResult(this.serializer, executionId);
+			result.status = "completed";
+			return result;
+		}
+		const allPredecessors = new GraphTraverser(blueprint).getAllPredecessors();
+		for (const { node, edge } of nextSteps) await this.applyEdgeTransform(edge, nodeResult, node, contextImpl, allPredecessors, executionId);
+		const traverser = GraphTraverser.fromState(blueprint, workflowState);
+		const nextNodeDefs = nextSteps.map((s) => s.node);
+		for (const nodeDef of nextNodeDefs) traverser.addToFrontier(nodeDef.id);
+		workflowState.clearAwaiting(awaitingNodeId);
+		const executionContext = this._setupResumedExecutionContext(blueprint, workflowState, options);
+		return await this.orchestrator.run(executionContext, traverser);
+	}
+	_createExecutionRegistry(dynamicRegistry) {
+		const executionRegistry = new Map(this.registry);
+		if (dynamicRegistry) for (const [key, func] of dynamicRegistry.entries()) executionRegistry.set(key, func);
+		return executionRegistry;
+	}
+	async executeNode(blueprint, nodeId, state, _allPredecessors, functionRegistry, executionId, signal) {
+		const nodeDef = blueprint.nodes.find((n) => n.id === nodeId);
+		if (!nodeDef) throw new FlowcraftError(`Node '${nodeId}' not found in blueprint.`, {
+			nodeId,
+			blueprintId: blueprint.id,
+			executionId,
+			isFatal: false
+		});
+		const asyncContext = state.getContext();
+		const input = await this.resolveNodeInput(nodeDef.id, blueprint, asyncContext);
+		const nodeRegistry = new Map([...this.registry, ...functionRegistry || /* @__PURE__ */ new Map()]);
+		const services = {
+			logger: this.logger,
+			eventBus: this.eventBus,
+			serializer: this.serializer,
+			evaluator: this.evaluator,
+			middleware: this.middleware,
+			dependencies: this.dependencies
+		};
+		const context = new ExecutionContext(blueprint, state, nodeRegistry, executionId || "", this, services, signal);
+		const executionResult = await this.executorFactory.createExecutorForNode(nodeId, context).execute(input);
+		if (executionResult.status === "success") return executionResult.result;
+		if (executionResult.status === "failed_with_fallback") {
+			const fallbackNode = blueprint.nodes.find((n) => n.id === executionResult.fallbackNodeId);
+			if (!fallbackNode) throw new FlowcraftError(`Fallback node '${executionResult.fallbackNodeId}' not found in blueprint.`, {
+				nodeId: nodeDef.id,
+				blueprintId: blueprint.id,
+				executionId,
+				isFatal: false
+			});
+			const fallbackInput = await this.resolveNodeInput(fallbackNode.id, blueprint, asyncContext);
+			const fallbackResult = await this.executorFactory.createExecutorForNode(fallbackNode.id, context).execute(fallbackInput);
+			if (fallbackResult.status === "success") {
+				state.markFallbackExecuted();
+				state.addCompletedNode(executionResult.fallbackNodeId, fallbackResult.result.output);
+				this.logger.info(`Fallback execution completed`, {
+					nodeId: nodeDef.id,
+					fallbackNodeId: executionResult.fallbackNodeId,
+					executionId
+				});
+				return {
+					...fallbackResult.result,
+					_fallbackExecuted: true
+				};
+			}
+			throw fallbackResult.error;
+		}
+		throw executionResult.error;
+	}
+	getExecutorForNode(nodeId, context) {
+		return this.executorFactory.createExecutorForNode(nodeId, context);
+	}
+	async determineNextNodes(blueprint, nodeId, result, context, executionId) {
+		return this.logicHandler.determineNextNodes(blueprint, nodeId, result, context, executionId);
+	}
+	async applyEdgeTransform(edge, sourceResult, targetNode, context, allPredecessors, executionId) {
+		return this.logicHandler.applyEdgeTransform(edge, sourceResult, targetNode, context, allPredecessors, executionId);
+	}
+	async resolveNodeInput(nodeId, blueprint, context) {
+		return this.logicHandler.resolveNodeInput(nodeId, blueprint, context);
+	}
+	/**
+	* Replay a workflow execution from a pre-recorded event history.
+	* This reconstructs the final workflow state without executing any node logic,
+	* enabling time-travel debugging and post-mortem analysis.
+	*
+	* @param blueprint The workflow blueprint
+	* @param events The recorded event history for the execution
+	* @param executionId Optional execution ID to filter events (if events contain multiple executions)
+	* @returns The reconstructed workflow result
+	*/
+	async replay(blueprint, events, executionId) {
+		let filteredEvents = events;
+		if (executionId) filteredEvents = events.filter((event) => {
+			if ("executionId" in event.payload) return event.payload.executionId === executionId;
+			return false;
+		});
+		if (!executionId) {
+			const workflowStartEvent = filteredEvents.find((e) => e.type === "workflow:start");
+			if (workflowStartEvent && "executionId" in workflowStartEvent.payload) executionId = workflowStartEvent.payload.executionId;
+			else throw new FlowcraftError("Cannot determine execution ID from events", { isFatal: true });
+		}
+		const tempContext = this._setupExecutionContext(blueprint, {}, { strict: false });
+		const executionContext = new ExecutionContext(blueprint, tempContext.state, tempContext.nodeRegistry, executionId, this, tempContext.services, tempContext.signal, tempContext.concurrency);
+		const { ReplayOrchestrator } = await import("./orchestrators/replay.mjs");
+		const replayOrchestrator = new ReplayOrchestrator(filteredEvents);
+		const traverser = new GraphTraverser(blueprint);
+		return await replayOrchestrator.run(executionContext, traverser);
+	}
+};
+
+//#endregion
+export { FlowRuntime };

package/dist/runtime/scheduler.d.mts

@@ -0,0 +1,2 @@
+import { G as WorkflowScheduler, W as AwaitingWorkflow } from "../types-BcrXJEPI.mjs";
+export { AwaitingWorkflow, WorkflowScheduler };

package/dist/runtime/scheduler.mjs

@@ -0,0 +1,64 @@
+//#region src/runtime/scheduler.ts
+var WorkflowScheduler = class {
+	runtime;
+	activeWorkflows = /* @__PURE__ */ new Map();
+	resumeResults = /* @__PURE__ */ new Map();
+	intervalId;
+	checkIntervalMs;
+	constructor(runtime, checkIntervalMs = 1e3) {
+		this.runtime = runtime;
+		this.checkIntervalMs = checkIntervalMs;
+	}
+	start() {
+		if (this.intervalId) return;
+		this.intervalId = setInterval(() => {
+			this.checkAndResumeWorkflows();
+		}, this.checkIntervalMs);
+	}
+	stop() {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = void 0;
+		}
+	}
+	registerAwaitingWorkflow(executionId, blueprintId, serializedContext, awaitingNodeId, wakeUpAt, functionRegistry) {
+		this.activeWorkflows.set(executionId, {
+			executionId,
+			blueprintId,
+			serializedContext,
+			awaitingNodeId,
+			wakeUpAt,
+			functionRegistry
+		});
+	}
+	unregisterWorkflow(executionId) {
+		this.activeWorkflows.delete(executionId);
+	}
+	async checkAndResumeWorkflows() {
+		const now = /* @__PURE__ */ new Date();
+		const toResume = [];
+		for (const [_executionId, workflow] of this.activeWorkflows) if (new Date(workflow.wakeUpAt) <= now) toResume.push(workflow);
+		for (const workflow of toResume) try {
+			const blueprint = this.runtime.getBlueprint(workflow.blueprintId);
+			if (!blueprint) {
+				console.warn(`Blueprint ${workflow.blueprintId} not found, skipping resumption`);
+				continue;
+			}
+			const result = await this.runtime.resume(blueprint, workflow.serializedContext, { output: void 0 }, workflow.awaitingNodeId, { functionRegistry: workflow.functionRegistry });
+			this.resumeResults.set(workflow.executionId, result);
+			if (result.status === "completed" || result.status === "failed") this.unregisterWorkflow(workflow.executionId);
+		} catch (error) {
+			console.error(`Failed to resume workflow ${workflow.executionId}:`, error);
+			this.unregisterWorkflow(workflow.executionId);
+		}
+	}
+	getActiveWorkflows() {
+		return Array.from(this.activeWorkflows.values());
+	}
+	getResumeResult(executionId) {
+		return this.resumeResults.get(executionId);
+	}
+};
+
+//#endregion
+export { WorkflowScheduler };

package/dist/runtime/state.d.mts

@@ -0,0 +1,2 @@
+import { U as WorkflowState } from "../types-BcrXJEPI.mjs";
+export { WorkflowState };

package/dist/runtime/state.mjs

@@ -0,0 +1,127 @@
+import { FlowcraftError } from "../errors.mjs";
+import { AsyncContextView, Context, TrackedAsyncContext } from "../context.mjs";
+
+//#region src/runtime/state.ts
+var WorkflowState = class {
+	_completedNodes = /* @__PURE__ */ new Set();
+	errors = [];
+	anyFallbackExecuted = false;
+	context;
+	_isAwaiting = false;
+	_awaitingNodeIds = /* @__PURE__ */ new Set();
+	_awaitingDetails = /* @__PURE__ */ new Map();
+	isLastAttempt;
+	constructor(initialData, context) {
+		if (context) this.context = context instanceof TrackedAsyncContext ? context : new TrackedAsyncContext(context);
+		else this.context = new TrackedAsyncContext(new AsyncContextView(new Context(initialData)));
+		if (initialData._awaitingNodeIds) {
+			this._isAwaiting = true;
+			const awaitingIds = initialData._awaitingNodeIds;
+			if (Array.isArray(awaitingIds)) for (const id of awaitingIds) this._awaitingNodeIds.add(id);
+		}
+		if (initialData._awaitingDetails) this._awaitingDetails = new Map(Object.entries(initialData._awaitingDetails));
+		for (const key of Object.keys(initialData)) if (key.startsWith("_outputs.")) {
+			const nodeId = key.substring(9);
+			this._completedNodes.add(nodeId);
+		}
+	}
+	/**
+	* Configure the context to emit events when modified.
+	* This is called after the ExecutionContext is created.
+	*/
+	setEventEmitter(eventBus, executionId, sourceNode) {
+		if (this.context instanceof TrackedAsyncContext) this.context.configureEventEmitter(eventBus, executionId, sourceNode);
+	}
+	async addCompletedNode(nodeId, output) {
+		this._completedNodes.add(nodeId);
+		await this.context.set(`_outputs.${nodeId}`, output);
+		await this.context.set(nodeId, output);
+	}
+	addError(nodeId, error) {
+		const flowcraftError = new FlowcraftError(error.message, {
+			cause: error,
+			nodeId,
+			isFatal: false
+		});
+		this.errors.push({
+			...flowcraftError,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			originalError: error
+		});
+	}
+	clearError(nodeId) {
+		this.errors = this.errors.filter((err) => err.nodeId !== nodeId);
+	}
+	markFallbackExecuted() {
+		this.anyFallbackExecuted = true;
+	}
+	getContext() {
+		return this.context;
+	}
+	getCompletedNodes() {
+		return new Set(this._completedNodes);
+	}
+	getErrors() {
+		return this.errors;
+	}
+	getAnyFallbackExecuted() {
+		return this.anyFallbackExecuted;
+	}
+	async markAsAwaiting(nodeId, details) {
+		this._isAwaiting = true;
+		this._awaitingNodeIds.add(nodeId);
+		if (details) this._awaitingDetails.set(nodeId, details);
+		await this.context.set("_awaitingNodeIds", Array.from(this._awaitingNodeIds));
+		await this.context.set("_awaitingDetails", Object.fromEntries(this._awaitingDetails));
+	}
+	isAwaiting() {
+		return this._isAwaiting && this._awaitingNodeIds.size > 0;
+	}
+	getAwaitingNodeIds() {
+		return Array.from(this._awaitingNodeIds);
+	}
+	getAwaitingDetails(nodeId) {
+		return this._awaitingDetails.get(nodeId);
+	}
+	clearAwaiting(nodeId) {
+		if (nodeId) {
+			this._awaitingNodeIds.delete(nodeId);
+			this._awaitingDetails.delete(nodeId);
+		} else {
+			this._awaitingNodeIds.clear();
+			this._awaitingDetails.clear();
+		}
+		this._isAwaiting = this._awaitingNodeIds.size > 0;
+		if (this._awaitingNodeIds.size > 0) {
+			this.context.set("_awaitingNodeIds", Array.from(this._awaitingNodeIds));
+			this.context.set("_awaitingDetails", Object.fromEntries(this._awaitingDetails));
+		} else {
+			this.context.delete("_awaitingNodeIds");
+			this.context.delete("_awaitingDetails");
+		}
+	}
+	getStatus(isTraversalComplete = false) {
+		if (this._isAwaiting) return "awaiting";
+		if (this.anyFallbackExecuted) return "completed";
+		if (this.errors.length > 0) return "failed";
+		if (isTraversalComplete) return "completed";
+		return "stalled";
+	}
+	async toResult(serializer, executionId) {
+		const contextJSON = await this.context.toJSON();
+		if (!this._isAwaiting && contextJSON._awaitingNodeIds) {
+			delete contextJSON._awaitingNodeIds;
+			delete contextJSON._awaitingDetails;
+		}
+		if (executionId) contextJSON._executionId = executionId;
+		return {
+			context: contextJSON,
+			serializedContext: serializer.serialize(contextJSON),
+			status: this.getStatus(),
+			errors: this.errors.length > 0 ? this.errors : void 0
+		};
+	}
+};
+
+//#endregion
+export { WorkflowState };

package/dist/runtime/traverser.d.mts

@@ -0,0 +1,2 @@
+import { F as GraphTraverser, I as ReadyNode } from "../types-BcrXJEPI.mjs";
+export { GraphTraverser, ReadyNode };