flowcraft 2.10.0 → 2.10.1

package/dist/index.mjs

@@ -1,792 +1,32 @@
-import { t as ReplayOrchestrator } from "./replay-BB11M6K1.mjs";
-import { A as ServiceTokens, C as TrackedAsyncContext, D as PropertyEvaluator, E as NullLogger, F as InMemoryEventStore, I as PersistentEventBusAdapter, M as checkForCycles, N as generateMermaid, O as UnsafeEvaluator, P as generateMermaidForRun, S as Context, T as ConsoleLogger, _ as executeBatch, a as sanitizeBlueprint, b as WorkflowState, c as SubflowNode, d as BatchScatterNode, f as BatchGatherNode, g as DefaultOrchestrator, h as JsonSerializer, i as NodeExecutor, j as analyzeBlueprint, k as DIContainer, l as GraphTraverser, m as isNodeClass, n as ClassNodeExecutor, o as WebhookNode, p as BaseNode, r as FunctionNodeExecutor, s as WaitNode, t as FlowRuntime, u as SleepNode, v as processResults, w as FlowcraftError, x as AsyncContextView } from "./runtime-ChsWirQN.mjs";
+import { analyzeBlueprint, checkForCycles, generateMermaid, generateMermaidForRun } from "./analysis.mjs";
+import { DIContainer, ServiceTokens } from "./container.mjs";
+import { PropertyEvaluator, UnsafeEvaluator } from "./evaluator.mjs";
+import { ConsoleLogger, NullLogger } from "./logger.mjs";
+import { FlowcraftError } from "./errors.mjs";
+import { AsyncContextView, Context, TrackedAsyncContext } from "./context.mjs";
+import { WorkflowState } from "./runtime/state.mjs";
+import { executeBatch, processResults } from "./runtime/orchestrators/utils.mjs";
+import { DefaultOrchestrator } from "./runtime/orchestrator.mjs";
+import { JsonSerializer } from "./serializer.mjs";
+import { createDefaultContainer } from "./container-factory.mjs";
+import { createErrorMapper } from "./error-mapper.mjs";
+import { BaseNode, isNodeClass } from "./node.mjs";
+import { FlowBuilder, createFlow } from "./flow.mjs";
+import { InMemoryEventStore, PersistentEventBusAdapter } from "./adapters/persistent-event-bus.mjs";
+import "./adapters/index.mjs";
+import { lintBlueprint } from "./linter.mjs";
+import { BatchGatherNode } from "./nodes/batch-gather.mjs";
+import { BatchScatterNode } from "./nodes/batch-scatter.mjs";
+import { SleepNode } from "./nodes/sleep.mjs";
+import { GraphTraverser } from "./runtime/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 { ClassNodeExecutor, FunctionNodeExecutor, NodeExecutor } from "./runtime/executors.mjs";
+import { FlowRuntime } from "./runtime/runtime.mjs";
+import { BaseDistributedAdapter } from "./runtime/adapter.mjs";
+import { ReplayOrchestrator } from "./runtime/orchestrators/replay.mjs";
+import "./types.mjs";
 
-//#region src/container-factory.ts
-function createDefaultContainer(options = {}) {
-	const container = new DIContainer();
-	container.register(ServiceTokens.Logger, options.logger || new NullLogger());
-	container.register(ServiceTokens.Serializer, options.serializer || new JsonSerializer());
-	container.register(ServiceTokens.Evaluator, options.evaluator || new PropertyEvaluator());
-	container.register(ServiceTokens.EventBus, options.eventBus || { emit: async () => {} });
-	container.register(ServiceTokens.Middleware, options.middleware || []);
-	container.register(ServiceTokens.NodeRegistry, options.registry || {});
-	container.register(ServiceTokens.BlueprintRegistry, options.blueprints || {});
-	container.register(ServiceTokens.Dependencies, options.dependencies || {});
-	container.registerFactory(ServiceTokens.Orchestrator, () => new DefaultOrchestrator());
-	return container;
-}
-
-//#endregion
-//#region src/error-mapper.ts
-/**
-* Creates an error mapper function that enhances runtime errors with source location information.
-* The mapper looks up node IDs in the provided manifest blueprints and returns enhanced errors
-* that point to the original TypeScript source code.
-*
-* @param manifestBlueprints - The compiled blueprint manifest containing source location data
-* @returns A function that maps errors to enhanced errors with source location information
-*/
-function createErrorMapper(manifestBlueprints) {
-	const locationMap = /* @__PURE__ */ new Map();
-	for (const blueprint of Object.values(manifestBlueprints)) {
-		for (const node of blueprint.nodes) if (node._sourceLocation) locationMap.set(node.id, node._sourceLocation);
-		for (const edge of blueprint.edges) if (edge._sourceLocation) {
-			const edgeKey = `${edge.source}-${edge.target}`;
-			locationMap.set(edgeKey, edge._sourceLocation);
-		}
-	}
-	return function mapError(error) {
-		if (error instanceof FlowcraftError && error.nodeId) {
-			const location = locationMap.get(error.nodeId);
-			if (location) return /* @__PURE__ */ new Error(`Workflow error at ${location.file}:${location.line}:${location.column}. Original error: ${error.message}`);
-		}
-		const nodeIdMatch = error.message.match(/nodeId[:\s]+([^\s,]+)/i);
-		if (nodeIdMatch) {
-			const nodeId = nodeIdMatch[1];
-			const location = locationMap.get(nodeId);
-			if (location) return /* @__PURE__ */ new Error(`Workflow error at ${location.file}:${location.line}:${location.column}. Original error: ${error.message}`);
-		}
-		return error;
-	};
-}
-
-//#endregion
-//#region src/flow.ts
-/**
-* Generates a deterministic hash for a function based on its source code and a unique counter.
-*/
-let hashCounter = 0;
-function _hashFunction(fn) {
-	const source = fn.toString();
-	let hash = 0;
-	for (let i = 0; i < source.length; i++) {
-		const char = source.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
-	}
-	return (Math.abs(hash) + hashCounter++).toString(16);
-}
-/**
-* A fluent API for programmatically constructing a WorkflowBlueprint.
-*/
-var FlowBuilder = class {
-	blueprint;
-	functionRegistry;
-	loopDefinitions;
-	batchDefinitions;
-	cycleEntryPoints;
-	constructor(id) {
-		this.blueprint = {
-			id,
-			nodes: [],
-			edges: []
-		};
-		this.functionRegistry = /* @__PURE__ */ new Map();
-		this.loopDefinitions = [];
-		this.batchDefinitions = [];
-		this.cycleEntryPoints = /* @__PURE__ */ new Map();
-	}
-	node(id, implementation, options) {
-		let usesKey;
-		if (isNodeClass(implementation)) {
-			usesKey = implementation.name && implementation.name !== "BaseNode" ? implementation.name : `class_${_hashFunction(implementation)}`;
-			this.functionRegistry.set(usesKey, implementation);
-		} else {
-			usesKey = `fn_${_hashFunction(implementation)}`;
-			this.functionRegistry.set(usesKey, implementation);
-		}
-		const nodeDef = {
-			id,
-			uses: usesKey,
-			...options
-		};
-		this.blueprint.nodes?.push(nodeDef);
-		return this;
-	}
-	edge(source, target, options) {
-		const edgeDef = {
-			source,
-			target,
-			...options
-		};
-		this.blueprint.edges?.push(edgeDef);
-		return this;
-	}
-	/**
-	* Creates a batch processing pattern.
-	* It takes an input array, runs a worker node on each item in parallel, and gathers the results.
-	* This method augments the Flow's TContext with a new key for the output array.
-	*
-	* @param id The base ID for this batch operation.
-	* @param worker The node implementation to run on each item.
-	* @param options Configuration for the batch operation.
-	* @returns The Flow instance with an updated context type for chaining.
-	*/
-	batch(id, worker, options) {
-		const { inputKey, outputKey } = options;
-		const scatterId = `${id}_scatter`;
-		const gatherId = `${id}_gather`;
-		this.batchDefinitions.push({
-			id,
-			scatterId,
-			gatherId
-		});
-		let workerUsesKey;
-		if (isNodeClass(worker)) {
-			workerUsesKey = worker.name && worker.name !== "BaseNode" ? worker.name : `class_batch_worker_${_hashFunction(worker)}`;
-			this.functionRegistry.set(workerUsesKey, worker);
-		} else {
-			workerUsesKey = `fn_batch_worker_${_hashFunction(worker)}`;
-			this.functionRegistry.set(workerUsesKey, worker);
-		}
-		this.blueprint.nodes?.push({
-			id: scatterId,
-			uses: "batch-scatter",
-			inputs: inputKey,
-			params: {
-				workerUsesKey,
-				outputKey,
-				gatherNodeId: gatherId,
-				chunkSize: options.chunkSize
-			}
-		});
-		this.blueprint.nodes?.push({
-			id: gatherId,
-			uses: "batch-gather",
-			params: {
-				outputKey,
-				gatherNodeId: gatherId
-			},
-			config: { joinStrategy: "all" }
-		});
-		this.edge(scatterId, gatherId);
-		return this;
-	}
-	/**
-	* Creates a sleep node that pauses workflow execution for a specified duration.
-	* @param id A unique identifier for the sleep node.
-	* @param options Configuration for the sleep duration.
-	*/
-	sleep(id, options) {
-		const nodeDef = {
-			id,
-			uses: "sleep",
-			params: { duration: options.duration }
-		};
-		this.blueprint.nodes?.push(nodeDef);
-		return this;
-	}
-	/**
-	* Creates a wait node that pauses workflow execution for external input.
-	* @param id A unique identifier for the wait node.
-	* @param options Optional configuration for the wait node.
-	*/
-	wait(id, options) {
-		const nodeDef = {
-			id,
-			uses: "wait",
-			...options
-		};
-		this.blueprint.nodes?.push(nodeDef);
-		return this;
-	}
-	/**
-	* Creates a loop pattern in the workflow graph.
-	* @param id A unique identifier for the loop construct.
-	* @param options Defines the start, end, and continuation condition of the loop.
-	* @param options.startNodeId The ID of the first node inside the loop body.
-	* @param options.endNodeId The ID of the last node inside the loop body.
-	* @param options.condition An expression that, if true, causes the loop to run again.
-	*/
-	loop(id, options) {
-		const { startNodeId, endNodeId, condition } = options;
-		this.loopDefinitions.push({
-			id,
-			startNodeId,
-			endNodeId,
-			condition
-		});
-		this.blueprint.nodes?.push({
-			id,
-			uses: "loop-controller",
-			params: { condition },
-			config: { joinStrategy: "any" }
-		});
-		this.edge(endNodeId, id);
-		this.edge(id, startNodeId, {
-			action: "continue",
-			transform: `context["${endNodeId}"]`
-		});
-		return this;
-	}
-	/**
-	* Sets the preferred entry point for a cycle in non-DAG workflows.
-	* This helps remove ambiguity when the runtime needs to choose a starting node for cycles.
-	* @param nodeId The ID of the node to use as the entry point for cycles containing this node.
-	*/
-	setCycleEntryPoint(nodeId) {
-		this.cycleEntryPoints.set(nodeId, nodeId);
-		return this;
-	}
-	toBlueprint() {
-		if (!this.blueprint.nodes || this.blueprint.nodes.length === 0) throw new Error("Cannot build a blueprint with no nodes.");
-		const finalEdges = [];
-		const processedOriginalEdges = /* @__PURE__ */ new Set();
-		const allOriginalEdges = this.blueprint.edges || [];
-		for (const loopDef of this.loopDefinitions) {
-			const edgesToRewire = allOriginalEdges.filter((e) => e.source === loopDef.id && e.target !== loopDef.startNodeId);
-			for (const edge of edgesToRewire) {
-				finalEdges.push({
-					...edge,
-					action: edge.action || "break",
-					transform: `context["${loopDef.endNodeId}"]`
-				});
-				processedOriginalEdges.add(edge);
-			}
-		}
-		for (const batchDef of this.batchDefinitions) {
-			const incomingEdges = allOriginalEdges.filter((e) => e.target === batchDef.id);
-			for (const edge of incomingEdges) {
-				finalEdges.push({
-					...edge,
-					target: batchDef.scatterId
-				});
-				processedOriginalEdges.add(edge);
-			}
-			const outgoingEdges = allOriginalEdges.filter((e) => e.source === batchDef.id);
-			for (const edge of outgoingEdges) {
-				finalEdges.push({
-					...edge,
-					source: batchDef.gatherId
-				});
-				processedOriginalEdges.add(edge);
-			}
-		}
-		for (const edge of allOriginalEdges) if (!processedOriginalEdges.has(edge)) finalEdges.push(edge);
-		this.blueprint.edges = finalEdges;
-		for (const loopDef of this.loopDefinitions) {
-			const startNode = this.blueprint.nodes?.find((n) => n.id === loopDef.startNodeId);
-			const endNode = this.blueprint.nodes?.find((n) => n.id === loopDef.endNodeId);
-			if (!startNode) throw new Error(`Loop '${loopDef.id}' references non-existent start node '${loopDef.startNodeId}'.`);
-			if (!endNode) throw new Error(`Loop '${loopDef.id}' references non-existent end node '${loopDef.endNodeId}'.`);
-		}
-		if (this.cycleEntryPoints.size > 0) this.blueprint.metadata = {
-			...this.blueprint.metadata,
-			cycleEntryPoints: Array.from(this.cycleEntryPoints.keys())
-		};
-		return this.blueprint;
-	}
-	getFunctionRegistry() {
-		return this.functionRegistry;
-	}
-	/**
-	* Runs this flow on the given runtime, automatically passing the function registry.
-	* Convenience wrapper around `runtime.run(blueprint, initialState, { functionRegistry })`.
-	*/
-	async run(runtime, initialState = {}, options) {
-		return runtime.run(this.toBlueprint(), initialState, {
-			...options,
-			functionRegistry: this.functionRegistry
-		});
-	}
-	/**
-	* Resumes this flow on the given runtime, automatically passing the function registry.
-	* Convenience wrapper around `runtime.resume(blueprint, ...)`.
-	*/
-	async resume(runtime, serializedContext, resumeData, nodeId, options) {
-		return runtime.resume(this.toBlueprint(), serializedContext, resumeData, nodeId, {
-			...options,
-			functionRegistry: this.functionRegistry
-		});
-	}
-	toGraphRepresentation() {
-		const blueprint = this.toBlueprint();
-		const uiNodes = [];
-		const uiEdges = [];
-		const ignoredNodeIds = /* @__PURE__ */ new Set();
-		for (const loopDef of this.loopDefinitions) {
-			const id = loopDef.id;
-			ignoredNodeIds.add(id);
-			uiEdges.push({
-				source: loopDef.endNodeId,
-				target: loopDef.startNodeId,
-				data: {
-					isLoopback: true,
-					condition: loopDef.condition,
-					label: `continue if: ${loopDef.condition}`
-				}
-			});
-			const breakEdges = blueprint.edges.filter((edge) => edge.source === id && edge.action === "break");
-			for (const breakEdge of breakEdges) uiEdges.push({
-				...breakEdge,
-				source: loopDef.endNodeId
-			});
-			const incomingEdges = blueprint.edges.filter((edge) => edge.target === id && edge.source !== loopDef.endNodeId);
-			for (const incomingEdge of incomingEdges) uiEdges.push({
-				...incomingEdge,
-				target: loopDef.startNodeId
-			});
-		}
-		const scatterNodes = blueprint.nodes.filter((n) => n.uses === "batch-scatter");
-		for (const scatterNode of scatterNodes) {
-			const gatherNodeId = scatterNode.params?.gatherNodeId;
-			if (!gatherNodeId) continue;
-			ignoredNodeIds.add(scatterNode.id);
-			ignoredNodeIds.add(gatherNodeId);
-			const batchId = scatterNode.id.replace("_scatter", "");
-			const gatherNode = blueprint.nodes.find((n) => n.id === gatherNodeId);
-			uiNodes.push({
-				id: batchId,
-				uses: scatterNode.params?.workerUsesKey,
-				type: "batch-worker",
-				data: {
-					label: `Batch: ${batchId}`,
-					isBatchPlaceholder: true,
-					workerUsesKey: scatterNode.params?.workerUsesKey,
-					inputKey: scatterNode.inputs,
-					outputKey: gatherNode?.params?.outputKey
-				}
-			});
-			const incomingEdges = blueprint.edges.filter((e) => e.target === scatterNode.id);
-			for (const edge of incomingEdges) uiEdges.push({
-				...edge,
-				target: batchId
-			});
-			const outgoingEdges = blueprint.edges.filter((e) => e.source === gatherNodeId);
-			for (const edge of outgoingEdges) uiEdges.push({
-				...edge,
-				source: batchId
-			});
-		}
-		for (const node of blueprint.nodes) if (!ignoredNodeIds.has(node.id)) uiNodes.push(node);
-		for (const edge of blueprint.edges) if (!ignoredNodeIds.has(edge.source) && !ignoredNodeIds.has(edge.target)) {
-			if (!uiEdges.some((e) => e.source === edge.source && e.target === edge.target && e.action === edge.action)) uiEdges.push(edge);
-		}
-		return {
-			nodes: uiNodes,
-			edges: uiEdges
-		};
-	}
-};
-/**
-* Helper function to create a new Flow builder instance.
-*/
-function createFlow(id) {
-	return new FlowBuilder(id);
-}
-
-//#endregion
-//#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
-//#region src/runtime/adapter.ts
-/**
-* The base class for all distributed adapters. It handles the technology-agnostic
-* orchestration logic and leaves queue-specific implementation to subclasses.
-*/
-var BaseDistributedAdapter = class {
-	runtime;
-	store;
-	serializer;
-	logger;
-	eventBus;
-	constructor(options) {
-		this.runtime = new FlowRuntime({
-			...options.runtimeOptions,
-			dependencies: {
-				...options.runtimeOptions.dependencies,
-				adapter: this
-			}
-		});
-		this.store = options.coordinationStore;
-		this.serializer = options.runtimeOptions.serializer || new JsonSerializer();
-		this.logger = options.runtimeOptions.logger || new ConsoleLogger();
-		this.eventBus = options.eventBus;
-		this.logger.info("[Adapter] BaseDistributedAdapter initialized.");
-	}
-	/**
-	* Starts the worker, which begins listening for and processing jobs from the queue.
-	*/
-	start() {
-		this.logger.info("[Adapter] Starting worker...");
-		this.processJobs(this.handleJob.bind(this));
-	}
-	/**
-	* Hook called by the execution factory to determine if a node's automatic
-	* retries should be executed synchronously in-process (true) or delegated
-	* to the Queue backoff behavior configured by the adapter (false).
-	*/
-	shouldRetryInProcess(_nodeDef) {
-		return true;
-	}
-	/**
-	* Returns queue-level retry options for enqueuing successor jobs.
-	* Only used when shouldRetryInProcess() returns false.
-	*/
-	getQueueRetryOptions(_nodeDef) {}
-	/**
-	* Hook called at the start of job processing. Subclasses can override this
-	* to perform additional setup (e.g., timestamp tracking for reconciliation).
-	*/
-	async onJobStart(_runId, _blueprintId, _nodeId) {}
-	/**
-	* The main handler for processing a single job from the queue.
-	*/
-	async handleJob(job) {
-		const { runId, blueprintId, nodeId } = job;
-		const startTime = Date.now();
-		await this.onJobStart(runId, blueprintId, nodeId);
-		const blueprint = this.runtime.options.blueprints?.[blueprintId];
-		if (!blueprint) {
-			const reason = `Blueprint with ID '${blueprintId}' not found in the worker's runtime registry.`;
-			this.logger.error(`[Adapter] FATAL: ${reason}`);
-			await this.publishFinalResult(runId, {
-				status: "failed",
-				reason
-			});
-			return;
-		}
-		const context = this.createContext(runId);
-		const storedVersion = await context.get("blueprintVersion");
-		const currentVersion = blueprint.metadata?.version || null;
-		if (storedVersion !== currentVersion) {
-			const reason = `Blueprint version mismatch: stored version '${storedVersion}', current version '${currentVersion}'. Rejecting job to prevent state corruption.`;
-			this.logger.warn(`[Adapter] Version mismatch for run ${runId}, node ${nodeId}: ${reason}`);
-			return;
-		}
-		if (!await context.has("blueprintId")) {
-			await context.set("blueprintId", blueprintId);
-			await context.set("blueprintVersion", blueprint.metadata?.version || null);
-			const blueprintKey = `flowcraft:blueprint:${runId}`;
-			await this.store.setIfNotExist(blueprintKey, blueprintId, 3600);
-		}
-		const joinLockKey = `flowcraft:joinlock:${runId}:${nodeId}`;
-		const fanInKey = `flowcraft:fanin:${runId}:${nodeId}`;
-		const blueprintKey = `flowcraft:blueprint:${runId}`;
-		const heartbeatInterval = setInterval(async () => {
-			await this.store.extendTTL(joinLockKey, 3600);
-			await this.store.extendTTL(fanInKey, 3600);
-			await this.store.extendTTL(blueprintKey, 3600);
-			this.logger.debug(`[Adapter] Extended TTLs for run ${runId}, node ${nodeId}`);
-		}, 18e5);
-		try {
-			const state = new WorkflowState(await context.toJSON(), context);
-			state.isLastAttempt = job.isLastAttempt !== false;
-			let result;
-			if (await context.has(`_outputs.${nodeId}`)) {
-				this.logger.info(`[Adapter] Node '${nodeId}' already completed, skipping re-execution.`);
-				result = { output: await context.get(`_outputs.${nodeId}`) };
-			} else {
-				const nodeDef = blueprint.nodes.find((n) => n.id === nodeId);
-				if (nodeDef && !this.shouldRetryInProcess(nodeDef)) {
-					if (nodeDef.config?.maxRetries && nodeDef.config.maxRetries > 1) nodeDef.config.maxRetries = 1;
-				}
-				result = await this.runtime.executeNode(blueprint, nodeId, state);
-				await context.set(`_outputs.${nodeId}`, result.output);
-				const stateContext = state.getContext();
-				if (stateContext instanceof TrackedAsyncContext) {
-					const deltas = stateContext.getDeltas();
-					if (deltas.length > 0) {
-						await stateContext.patch(deltas);
-						stateContext.clearDeltas();
-					}
-				}
-			}
-			await this.handleNodeCompletion({
-				runId,
-				blueprintId,
-				nodeId,
-				blueprint,
-				result,
-				context,
-				startTime,
-				heartbeatInterval
-			});
-		} catch (error) {
-			const reason = error.message || "Unknown execution error";
-			this.logger.error(`[Adapter] FATAL: Job for node '${nodeId}' failed for Run ID '${runId}': ${reason}`);
-			if (this.eventBus) await this.eventBus.emit({
-				type: "job:failed",
-				payload: {
-					runId,
-					blueprintId,
-					nodeId,
-					error
-				}
-			});
-			if (job.isLastAttempt === false) {
-				this.logger.warn(`[Adapter] Job for node '${nodeId}' failed (queue attempt ${job.attempt || 1}), delegating retry to queue.`);
-				return;
-			}
-			await this.publishFinalResult(runId, {
-				status: "failed",
-				reason
-			});
-			await this.writePoisonPillForSuccessors(runId, blueprint, nodeId);
-		} finally {
-			clearInterval(heartbeatInterval);
-		}
-	}
-	/**
-	* Handles post-execution logic: terminal node checks, successor determination,
-	* and enqueueing of ready nodes. Extracted to support the idempotency guard.
-	*/
-	async handleNodeCompletion(params) {
-		const { runId, blueprintId, nodeId, blueprint, result, context, startTime, heartbeatInterval } = params;
-		const analysis = analyzeBlueprint(blueprint);
-		const isTerminalNode = analysis.terminalNodeIds.includes(nodeId);
-		if (isTerminalNode) {
-			const allContextKeys = Object.keys(await context.toJSON());
-			const completedNodes = /* @__PURE__ */ new Set();
-			for (const key of allContextKeys) if (key.startsWith("_outputs.")) completedNodes.add(key.substring(9));
-			if (analysis.terminalNodeIds.every((terminalId) => completedNodes.has(terminalId))) {
-				this.logger.info(`[Adapter] All terminal nodes completed for Run ID: ${runId}. Declaring workflow complete.`);
-				const finalContext = await context.toJSON();
-				const finalResult = {
-					context: finalContext,
-					serializedContext: this.serializer.serialize(finalContext),
-					status: "completed"
-				};
-				await this.publishFinalResult(runId, {
-					status: "completed",
-					payload: finalResult
-				});
-				clearInterval(heartbeatInterval);
-				return;
-			} else this.logger.info(`[Adapter] Terminal node '${nodeId}' completed for Run ID '${runId}', but other terminal nodes are still running.`);
-		}
-		const nextNodes = await this.runtime.determineNextNodes(blueprint, nodeId, result, context, runId);
-		if (nextNodes.length === 0 && !isTerminalNode) {
-			this.logger.info(`[Adapter] Non-terminal node '${nodeId}' reached end of branch for Run ID '${runId}'. This branch will now terminate.`);
-			clearInterval(heartbeatInterval);
-			return;
-		}
-		for (const { node: nextNodeDef, edge } of nextNodes) {
-			await this.runtime.applyEdgeTransform(edge, result, nextNodeDef, context, void 0, runId);
-			if (await this.isReadyForFanIn(runId, blueprint, nextNodeDef.id)) {
-				this.logger.info(`[Adapter] Node '${nextNodeDef.id}' is ready. Enqueuing job.`);
-				await this.enqueueJob({
-					runId,
-					blueprintId,
-					nodeId: nextNodeDef.id
-				});
-				if (this.eventBus) await this.eventBus.emit({
-					type: "job:enqueued",
-					payload: {
-						runId,
-						blueprintId,
-						nodeId: nextNodeDef.id
-					}
-				});
-			} else this.logger.info(`[Adapter] Node '${nextNodeDef.id}' is waiting for other predecessors to complete.`);
-		}
-		const duration = Date.now() - startTime;
-		if (this.eventBus) await this.eventBus.emit({
-			type: "job:processed",
-			payload: {
-				runId,
-				blueprintId,
-				nodeId,
-				duration,
-				success: true
-			}
-		});
-	}
-	/**
-	* Encapsulates the fan-in join logic using the coordination store.
-	*/
-	async isReadyForFanIn(runId, blueprint, targetNodeId) {
-		const targetNode = blueprint.nodes.find((n) => n.id === targetNodeId);
-		if (!targetNode) throw new Error(`Node '${targetNodeId}' not found in blueprint`);
-		const joinStrategy = targetNode.config?.joinStrategy || "all";
-		const predecessors = blueprint.edges.filter((e) => e.target === targetNodeId);
-		if (predecessors.length <= 1) return true;
-		const poisonKey = `flowcraft:fanin:poison:${runId}:${targetNodeId}`;
-		if (await this.store.get(poisonKey)) {
-			this.logger.info(`[Adapter] Node '${targetNodeId}' is poisoned due to failed predecessor. Failing immediately.`);
-			throw new Error(`Node '${targetNodeId}' failed due to poisoned predecessor in run '${runId}'`);
-		}
-		if (joinStrategy === "any") {
-			const lockKey = `flowcraft:joinlock:${runId}:${targetNodeId}`;
-			if (!await this.store.setIfNotExist(lockKey, "locked", 3600)) {
-				const cancelKey = `flowcraft:fanin:cancel:${runId}:${targetNodeId}`;
-				if (!await this.store.setIfNotExist(cancelKey, "cancelled", 3600)) {
-					this.logger.info(`[Adapter] Node '${targetNodeId}' is cancelled due to failed predecessor. Failing immediately.`);
-					throw new Error(`Node '${targetNodeId}' failed due to cancelled predecessor in run '${runId}'`);
-				}
-				return false;
-			}
-			return true;
-		} else {
-			const fanInKey = `flowcraft:fanin:${runId}:${targetNodeId}`;
-			if (await this.store.increment(fanInKey, 3600) >= predecessors.length) {
-				await this.store.delete(fanInKey);
-				return true;
-			}
-			return false;
-		}
-	}
-	/**
-	* Reconciles the state of a workflow run. It inspects the persisted
-	* context to find completed nodes, determines the next set of executable
-	* nodes (the frontier), and enqueues jobs for them if they aren't
-	* already running. This is the core of the resume functionality.
-	*
-	* @param runId The unique ID of the workflow execution to reconcile.
-	* @returns The set of node IDs that were enqueued for execution.
-	*/
-	async reconcile(runId) {
-		const context = this.createContext(runId);
-		let blueprintId = await context.get("blueprintId");
-		if (!blueprintId) {
-			const blueprintKey = `flowcraft:blueprint:${runId}`;
-			blueprintId = await this.store.get(blueprintKey);
-			if (blueprintId) await context.set("blueprintId", blueprintId);
-			else throw new Error(`Cannot reconcile runId '${runId}': blueprintId not found in context or coordination store.`);
-		}
-		const blueprint = this.runtime.options.blueprints?.[blueprintId];
-		if (blueprint && !await context.has("blueprintVersion")) await context.set("blueprintVersion", blueprint.metadata?.version || null);
-		if (!blueprint) throw new Error(`Cannot reconcile runId '${runId}': Blueprint with ID '${blueprintId}' not found.`);
-		const state = await context.toJSON();
-		const completedNodes = /* @__PURE__ */ new Set();
-		for (const key of Object.keys(state)) if (key.startsWith("_outputs.")) completedNodes.add(key.substring(9));
-		const frontier = this.calculateResumedFrontier(blueprint, completedNodes);
-		const enqueuedNodes = /* @__PURE__ */ new Set();
-		for (const nodeId of frontier) {
-			const joinStrategy = blueprint.nodes.find((n) => n.id === nodeId)?.config?.joinStrategy || "all";
-			const poisonKey = `flowcraft:fanin:poison:${runId}:${nodeId}`;
-			if (await this.store.get(poisonKey)) {
-				this.logger.info(`[Adapter] Reconciling: Node '${nodeId}' is poisoned, skipping.`, { runId });
-				continue;
-			}
-			let shouldEnqueue = false;
-			if (joinStrategy === "any") {
-				const lockKey = `flowcraft:joinlock:${runId}:${nodeId}`;
-				if (await this.store.setIfNotExist(lockKey, "locked-by-reconcile", 3600)) shouldEnqueue = true;
-				else this.logger.info(`[Adapter] Reconciling: Node '${nodeId}' is an 'any' join and is already locked.`, { runId });
-			} else {
-				const lockKey = `flowcraft:nodelock:${runId}:${nodeId}`;
-				if (await this.store.setIfNotExist(lockKey, "locked", 120)) shouldEnqueue = true;
-				else this.logger.info(`[Adapter] Reconciling: Node '${nodeId}' is already locked.`, { runId });
-			}
-			if (shouldEnqueue) {
-				this.logger.info(`[Adapter] Reconciling: Enqueuing ready job for node '${nodeId}'`, { runId });
-				await this.enqueueJob({
-					runId,
-					blueprintId: blueprint.id,
-					nodeId
-				});
-				enqueuedNodes.add(nodeId);
-			}
-		}
-		return enqueuedNodes;
-	}
-	calculateResumedFrontier(blueprint, completedNodes) {
-		const newFrontier = /* @__PURE__ */ new Set();
-		const allPredecessors = /* @__PURE__ */ new Map();
-		for (const node of blueprint.nodes) allPredecessors.set(node.id, /* @__PURE__ */ new Set());
-		for (const edge of blueprint.edges) allPredecessors.get(edge.target)?.add(edge.source);
-		for (const node of blueprint.nodes) {
-			if (completedNodes.has(node.id)) continue;
-			const predecessors = allPredecessors.get(node.id) ?? /* @__PURE__ */ new Set();
-			if (predecessors.size === 0 && !completedNodes.has(node.id)) {
-				newFrontier.add(node.id);
-				continue;
-			}
-			const joinStrategy = node.config?.joinStrategy || "all";
-			const completedPredecessors = [...predecessors].filter((p) => completedNodes.has(p));
-			if (joinStrategy === "any" ? completedPredecessors.length > 0 : completedPredecessors.length === predecessors.size) newFrontier.add(node.id);
-		}
-		return newFrontier;
-	}
-	/**
-	* Writes a poison pill for 'all' join successors and a cancellation pill for 'any' join successors of a failed node to prevent stalling or ambiguous states.
-	*/
-	async writePoisonPillForSuccessors(runId, blueprint, failedNodeId) {
-		const successors = blueprint.edges.filter((edge) => edge.source === failedNodeId).map((edge) => edge.target).map((targetId) => blueprint.nodes.find((node) => node.id === targetId)).filter((node) => node);
-		for (const successor of successors) if (successor) {
-			const joinStrategy = successor.config?.joinStrategy || "all";
-			if (joinStrategy === "all") {
-				const poisonKey = `flowcraft:fanin:poison:${runId}:${successor.id}`;
-				await this.store.setIfNotExist(poisonKey, "poisoned", 3600);
-				this.logger.info(`[Adapter] Wrote poison pill for 'all' join node '${successor.id}' due to failed predecessor '${failedNodeId}'`);
-			} else if (joinStrategy === "any") {
-				const cancelKey = `flowcraft:fanin:cancel:${runId}:${successor.id}`;
-				await this.store.setIfNotExist(cancelKey, "cancelled", 3600);
-				this.logger.info(`[Adapter] Wrote cancellation pill for 'any' join node '${successor.id}' due to failed predecessor '${failedNodeId}'`);
-			}
-		}
-	}
-};
-
-//#endregion
-export { AsyncContextView, BaseDistributedAdapter, BaseNode, BatchGatherNode, BatchScatterNode, ClassNodeExecutor, ConsoleLogger, Context, DIContainer, DefaultOrchestrator, FlowBuilder, FlowRuntime, FlowcraftError, FunctionNodeExecutor, GraphTraverser, InMemoryEventStore, JsonSerializer, NodeExecutor, NullLogger, PersistentEventBusAdapter, PropertyEvaluator, ReplayOrchestrator, ServiceTokens, SleepNode, SubflowNode, TrackedAsyncContext, UnsafeEvaluator, WaitNode, WebhookNode, WorkflowState, analyzeBlueprint, checkForCycles, createDefaultContainer, createErrorMapper, createFlow, executeBatch, generateMermaid, generateMermaidForRun, isNodeClass, lintBlueprint, processResults, sanitizeBlueprint };
-//# sourceMappingURL=index.mjs.map
+export { AsyncContextView, BaseDistributedAdapter, BaseNode, BatchGatherNode, BatchScatterNode, ClassNodeExecutor, ConsoleLogger, Context, DIContainer, DefaultOrchestrator, FlowBuilder, FlowRuntime, FlowcraftError, FunctionNodeExecutor, GraphTraverser, InMemoryEventStore, JsonSerializer, NodeExecutor, NullLogger, PersistentEventBusAdapter, PropertyEvaluator, ReplayOrchestrator, ServiceTokens, SleepNode, SubflowNode, TrackedAsyncContext, UnsafeEvaluator, WaitNode, WebhookNode, WorkflowState, analyzeBlueprint, checkForCycles, createDefaultContainer, createErrorMapper, createFlow, executeBatch, generateMermaid, generateMermaidForRun, isNodeClass, lintBlueprint, processResults, sanitizeBlueprint };