flowcraft 2.9.3 → 2.10.1

package/dist/flow.mjs

@@ -0,0 +1,328 @@
+import { isNodeClass } from "./node.mjs";
+
+//#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
+export { FlowBuilder, createFlow };

package/dist/index-9iG2qHLe.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index-Bk0eNZmQ.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index-CNgSR_kt.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index-CW2WHUXP.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.mts

@@ -1,2 +1,25 @@
-import { $ as NodeConfig, A as TrackedAsyncContext, At as DIContainer, B as InMemoryEventStore, C as FlowBuilder, Ct as ClassNodeExecutor, D as createErrorMapper, Dt as NodeExecutor, E as UnsafeEvaluator, Et as NodeExecutionResult, F as analyzeBlueprint, Ft as FlowcraftError, G as IAsyncContext, H as ContextImplementation, I as checkForCycles, J as ILogger, K as IEvaluator, L as generateMermaid, M as createDefaultContainer, Mt as ServiceTokens, N as BlueprintAnalysis, Nt as BaseNode, O as AsyncContextView, Ot as NodeExecutorConfig, P as Cycles, Pt as isNodeClass, Q as NodeClass, R as generateMermaidForRun, S as lintBlueprint, St as ReadyNode, T as PropertyEvaluator, Tt as FunctionNodeExecutor, U as EdgeDefinition, V as PersistentEventBusAdapter, W as FlowcraftEvent, X as ISyncContext, Y as ISerializer, Z as Middleware, _ as ConsoleLogger, _t as ExecutionServices, a as ReplayOrchestrator, at as NodeResult, b as LinterIssueCode, bt as NodeExecutorFactory, c as BaseDistributedAdapter, ct as RuntimeOptions, d as WebhookNode, dt as WorkflowBlueprint, et as NodeContext, f as WaitNode, ft as WorkflowBlueprintMetadata, g as BatchGatherNode, gt as FlowRuntime, h as BatchScatterNode, ht as WorkflowStatus, i as processResults, it as NodeRegistry, j as ContainerOptions, jt as ServiceToken, k as Context, kt as WorkflowState, l as ICoordinationStore, lt as SourceLocation, m as SleepNode, mt as WorkflowResult, n as sanitizeBlueprint, nt as NodeFunction, o as DefaultOrchestrator, ot as PatchOperation, p as SubflowNode, pt as WorkflowError, q as IEventBus, r as executeBatch, rt as NodeImplementation, s as AdapterOptions, st as RuntimeDependencies, t as JsonSerializer, tt as NodeDefinition, u as JobPayload, ut as UIGraph, v as NullLogger, vt as IOrchestrator, w as createFlow, wt as ExecutionStrategy, x as LinterResult, xt as GraphTraverser, y as LinterIssue, yt as IRuntime, z as IEventStore } from "./index-DUPpyNvU.mjs";
+import { t as FlowcraftError } from "./errors-CyyIj3OO.mjs";
+import { A as FlowRuntime, B as NodeExecutionResult, C as UIGraph, D as WorkflowResult, E as WorkflowError, F as GraphTraverser, H as NodeExecutorConfig, I as ReadyNode, K as BaseNode, L as ClassNodeExecutor, M as IOrchestrator, N as IRuntime, O as WorkflowStatus, P as NodeExecutorFactory, R as ExecutionStrategy, S as SourceLocation, T as WorkflowBlueprintMetadata, U as WorkflowState, V as NodeExecutor, _ as NodeRegistry, a as IEvaluator, b as RuntimeDependencies, c as ISerializer, d as NodeClass, f as NodeConfig, g as NodeImplementation, h as NodeFunction, i as IAsyncContext, j as ExecutionServices, l as ISyncContext, m as NodeDefinition, n as EdgeDefinition, o as IEventBus, p as NodeContext, q as isNodeClass, r as FlowcraftEvent, s as ILogger, t as ContextImplementation, u as Middleware, v as NodeResult, w as WorkflowBlueprint, x as RuntimeOptions, y as PatchOperation, z as FunctionNodeExecutor } from "./types-BcrXJEPI.mjs";
+import { n as ServiceToken, r as ServiceTokens, t as DIContainer } from "./container-BKdd-9wf.mjs";
+import { n as InMemoryEventStore, r as PersistentEventBusAdapter, t as IEventStore } from "./persistent-event-bus-COiQOpWh.mjs";
+import { a as generateMermaid, i as checkForCycles, n as Cycles, o as generateMermaidForRun, r as analyzeBlueprint, t as BlueprintAnalysis } from "./analysis-B5Twr7sD.mjs";
+import { n as createDefaultContainer, t as ContainerOptions } from "./container-factory-fDY2kkxt.mjs";
+import { n as Context, r as TrackedAsyncContext, t as AsyncContextView } from "./context-ZVtzXuZu.mjs";
+import { t as createErrorMapper } from "./error-mapper-BAv_YQMQ.mjs";
+import { n as UnsafeEvaluator, t as PropertyEvaluator } from "./evaluator-Dnj5qJ92.mjs";
+import { n as createFlow, t as FlowBuilder } from "./flow-CZGpYpl-.mjs";
+import { i as lintBlueprint, n as LinterIssueCode, r as LinterResult, t as LinterIssue } from "./linter-B8KALEae.mjs";
+import { n as NullLogger, t as ConsoleLogger } from "./logger-BvDgvNHQ.mjs";
+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";
+import { i as JobPayload, n as BaseDistributedAdapter, r as ICoordinationStore, t as AdapterOptions } from "./adapter-DzeZVjSE.mjs";
+import { t as DefaultOrchestrator } from "./orchestrator-DwMIJRFI.mjs";
+import { t as ReplayOrchestrator } from "./replay-CVOy6d_L.mjs";
+import { n as processResults, t as executeBatch } from "./utils-BUEgr9V2.mjs";
+import { t as sanitizeBlueprint } from "./sanitizer-Bi00YjvO.mjs";
+import { t as JsonSerializer } from "./serializer-BnmJr13R.mjs";
 export { AdapterOptions, AsyncContextView, BaseDistributedAdapter, BaseNode, BatchGatherNode, BatchScatterNode, BlueprintAnalysis, ClassNodeExecutor, ConsoleLogger, ContainerOptions, Context, ContextImplementation, Cycles, DIContainer, DefaultOrchestrator, EdgeDefinition, ExecutionServices, ExecutionStrategy, FlowBuilder, FlowRuntime, FlowcraftError, FlowcraftEvent, FunctionNodeExecutor, GraphTraverser, IAsyncContext, ICoordinationStore, IEvaluator, IEventBus, IEventStore, ILogger, IOrchestrator, IRuntime, ISerializer, ISyncContext, InMemoryEventStore, JobPayload, JsonSerializer, LinterIssue, LinterIssueCode, LinterResult, Middleware, NodeClass, NodeConfig, NodeContext, NodeDefinition, NodeExecutionResult, NodeExecutor, NodeExecutorConfig, NodeExecutorFactory, NodeFunction, NodeImplementation, NodeRegistry, NodeResult, NullLogger, PatchOperation, PersistentEventBusAdapter, PropertyEvaluator, ReadyNode, ReplayOrchestrator, RuntimeDependencies, RuntimeOptions, ServiceToken, ServiceTokens, SleepNode, SourceLocation, SubflowNode, TrackedAsyncContext, UIGraph, UnsafeEvaluator, WaitNode, WebhookNode, WorkflowBlueprint, WorkflowBlueprintMetadata, WorkflowError, WorkflowResult, WorkflowState, WorkflowStatus, analyzeBlueprint, checkForCycles, createDefaultContainer, createErrorMapper, createFlow, executeBatch, generateMermaid, generateMermaidForRun, isNodeClass, lintBlueprint, processResults, sanitizeBlueprint };