flowcraft 2.9.3 → 2.10.1

package/dist/runtime/index.d.mts

@@ -0,0 +1,6 @@
+import { A as FlowRuntime, B as NodeExecutionResult, F as GraphTraverser, H as NodeExecutorConfig, I as ReadyNode, L as ClassNodeExecutor, M as IOrchestrator, N as IRuntime, P as NodeExecutorFactory, R as ExecutionStrategy, U as WorkflowState, V as NodeExecutor, j as ExecutionServices, z as FunctionNodeExecutor } from "../types-BcrXJEPI.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";
+export { AdapterOptions, BaseDistributedAdapter, ClassNodeExecutor, DefaultOrchestrator, ExecutionServices, ExecutionStrategy, FlowRuntime, FunctionNodeExecutor, GraphTraverser, ICoordinationStore, IOrchestrator, IRuntime, JobPayload, NodeExecutionResult, NodeExecutor, NodeExecutorConfig, NodeExecutorFactory, ReadyNode, ReplayOrchestrator, WorkflowState, executeBatch, processResults };

package/dist/runtime/index.mjs

@@ -0,0 +1,10 @@
+import { WorkflowState } from "./state.mjs";
+import { executeBatch, processResults } from "./orchestrators/utils.mjs";
+import { DefaultOrchestrator } from "./orchestrator.mjs";
+import { GraphTraverser } from "./traverser.mjs";
+import { ClassNodeExecutor, FunctionNodeExecutor, NodeExecutor } from "./executors.mjs";
+import { FlowRuntime } from "./runtime.mjs";
+import { BaseDistributedAdapter } from "./adapter.mjs";
+import { ReplayOrchestrator } from "./orchestrators/replay.mjs";
+
+export { BaseDistributedAdapter, ClassNodeExecutor, DefaultOrchestrator, FlowRuntime, FunctionNodeExecutor, GraphTraverser, NodeExecutor, ReplayOrchestrator, WorkflowState, executeBatch, processResults };

package/dist/runtime/node-executor-factory.d.mts

@@ -0,0 +1,11 @@
+import { V as NodeExecutor, k as ExecutionContext, o as IEventBus } from "../types-BcrXJEPI.mjs";
+
+//#region src/runtime/node-executor-factory.d.ts
+declare class NodeExecutorFactory {
+  private readonly eventBus;
+  constructor(eventBus: IEventBus);
+  createExecutorForNode(nodeId: string, context: ExecutionContext<any, any>): NodeExecutor<any, any>;
+  private getExecutionStrategy;
+}
+//#endregion
+export { NodeExecutorFactory };

package/dist/runtime/node-executor-factory.mjs

@@ -0,0 +1,41 @@
+import { FlowcraftError } from "../errors.mjs";
+import { isNodeClass } from "../node.mjs";
+import { ClassNodeExecutor, FunctionNodeExecutor, NodeExecutor } from "./executors.mjs";
+
+//#region src/runtime/node-executor-factory.ts
+var NodeExecutorFactory = class {
+	constructor(eventBus) {
+		this.eventBus = eventBus;
+	}
+	createExecutorForNode(nodeId, context) {
+		const nodeDef = context.blueprint.nodes.find((n) => n.id === nodeId);
+		if (!nodeDef) throw new FlowcraftError(`Node '${nodeId}' not found in blueprint.`, {
+			nodeId,
+			blueprintId: context.blueprint.id,
+			executionId: context.executionId,
+			isFatal: false
+		});
+		return new NodeExecutor({
+			context,
+			nodeDef,
+			strategy: this.getExecutionStrategy(nodeDef, context)
+		});
+	}
+	getExecutionStrategy(nodeDef, context) {
+		const implementation = context.nodeRegistry.get(nodeDef.uses);
+		if (!implementation) throw new FlowcraftError(`Implementation for '${nodeDef.uses}' not found.`, {
+			nodeId: nodeDef.id,
+			blueprintId: "",
+			isFatal: true
+		});
+		let maxRetries = nodeDef.config?.maxRetries ?? 1;
+		const adapter = context.services.dependencies?.adapter;
+		if (adapter && typeof adapter.shouldRetryInProcess === "function") {
+			if (!adapter.shouldRetryInProcess(nodeDef)) maxRetries = 1;
+		}
+		return isNodeClass(implementation) ? new ClassNodeExecutor(implementation, maxRetries, this.eventBus) : new FunctionNodeExecutor(implementation, maxRetries, this.eventBus);
+	}
+};
+
+//#endregion
+export { NodeExecutorFactory };

package/dist/runtime/orchestrator.d.mts

@@ -0,0 +1,2 @@
+import { t as DefaultOrchestrator } from "../orchestrator-DwMIJRFI.mjs";
+export { DefaultOrchestrator };

package/dist/runtime/orchestrator.mjs

@@ -0,0 +1,41 @@
+import { FlowcraftError } from "../errors.mjs";
+import { ExecutionContext } from "./execution-context.mjs";
+import { executeBatch, processResults } from "./orchestrators/utils.mjs";
+
+//#region src/runtime/orchestrator.ts
+var DefaultOrchestrator = class {
+	async run(context, traverser) {
+		const hardwareConcurrency = globalThis.navigator?.hardwareConcurrency || 4;
+		const maxConcurrency = context.concurrency != null && context.concurrency > 0 ? context.concurrency : Math.min(hardwareConcurrency, 10);
+		try {
+			context.signal?.throwIfAborted();
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+			throw error;
+		}
+		let iterations = 0;
+		const maxIterations = 1e4;
+		while (traverser.hasMoreWork()) {
+			if (++iterations > maxIterations) throw new Error("Traversal exceeded maximum iterations, possible infinite loop");
+			try {
+				context.signal?.throwIfAborted();
+			} catch (error) {
+				if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+				throw error;
+			}
+			const readyNodes = traverser.getReadyNodes();
+			const dynamicBlueprint = traverser.getDynamicBlueprint();
+			const updatedContext = new ExecutionContext(dynamicBlueprint, context.state, context.nodeRegistry, context.executionId, context.runtime, context.services, context.signal, context.concurrency);
+			await processResults(await executeBatch(readyNodes, dynamicBlueprint, context.state, (nodeId) => context.runtime.getExecutorForNode(nodeId, updatedContext), context.runtime, maxConcurrency), traverser, context.state, context.runtime, context.blueprint, context.executionId);
+			if (context.state.isAwaiting()) break;
+		}
+		const isTraversalComplete = !traverser.hasMoreWork();
+		const status = context.state.getStatus(isTraversalComplete);
+		const result = await context.state.toResult(context.services.serializer, context.executionId);
+		result.status = status;
+		return result;
+	}
+};
+
+//#endregion
+export { DefaultOrchestrator };

package/dist/runtime/orchestrators/replay.d.mts

@@ -0,0 +1,2 @@
+import { t as ReplayOrchestrator } from "../../replay-CVOy6d_L.mjs";
+export { ReplayOrchestrator };

package/dist/{replay-BB11M6K1.mjs → runtime/orchestrators/replay.mjs}

@@ -1,22 +1,4 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
 //#region src/runtime/orchestrators/replay.ts
-var replay_exports = /* @__PURE__ */ __exportAll({ ReplayOrchestrator: () => ReplayOrchestrator });
 /**
 * An orchestrator that replays a pre-recorded sequence of workflow events
 * to reconstruct the workflow state without executing any node logic.
@@ -103,5 +85,4 @@ var ReplayOrchestrator = class {
 };
 
 //#endregion
-export { replay_exports as n, ReplayOrchestrator as t };
-//# sourceMappingURL=replay-BB11M6K1.mjs.map
+export { ReplayOrchestrator };

package/dist/runtime/orchestrators/step-by-step.d.mts

@@ -0,0 +1,15 @@
+import { D as WorkflowResult, F as GraphTraverser, M as IOrchestrator, k as ExecutionContext } from "../../types-BcrXJEPI.mjs";
+
+//#region src/runtime/orchestrators/step-by-step.d.ts
+/**
+ * An orchestrator that executes only one "tick" or "turn" of the workflow.
+ * It processes a single batch of ready nodes from the frontier and then returns,
+ * allowing the caller to inspect the intermediate state before proceeding.
+ *
+ * Useful for debugging, testing, or building interactive tools.
+ */
+declare class StepByStepOrchestrator implements IOrchestrator {
+  run(context: ExecutionContext<any, any>, traverser: GraphTraverser): Promise<WorkflowResult<any>>;
+}
+//#endregion
+export { StepByStepOrchestrator };

package/dist/runtime/orchestrators/step-by-step.mjs

@@ -0,0 +1,41 @@
+import { FlowcraftError } from "../../errors.mjs";
+import { executeBatch, processResults } from "./utils.mjs";
+
+//#region src/runtime/orchestrators/step-by-step.ts
+/**
+* An orchestrator that executes only one "tick" or "turn" of the workflow.
+* It processes a single batch of ready nodes from the frontier and then returns,
+* allowing the caller to inspect the intermediate state before proceeding.
+*
+* Useful for debugging, testing, or building interactive tools.
+*/
+var StepByStepOrchestrator = class {
+	async run(context, traverser) {
+		try {
+			context.signal?.throwIfAborted();
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+			throw error;
+		}
+		if (!traverser.hasMoreWork()) {
+			const isTraversalComplete = !traverser.hasMoreWork();
+			const status = context.state.getStatus(isTraversalComplete);
+			const result = await context.state.toResult(context.services.serializer, context.executionId);
+			result.status = status;
+			return result;
+		}
+		const allReadyNodes = traverser.getReadyNodes();
+		const nodesToExecute = context.concurrency ? allReadyNodes.slice(0, context.concurrency) : allReadyNodes;
+		const nodesToSkip = context.concurrency ? allReadyNodes.slice(context.concurrency) : [];
+		await processResults(await executeBatch(nodesToExecute, traverser.getDynamicBlueprint(), context.state, (nodeId) => context.runtime.getExecutorForNode(nodeId, context), context.runtime, context.concurrency), traverser, context.state, context.runtime, context.blueprint, context.executionId);
+		for (const { nodeId } of nodesToSkip) traverser.addToFrontier(nodeId);
+		const isTraversalComplete = !traverser.hasMoreWork();
+		const status = context.state.getStatus(isTraversalComplete);
+		const result = await context.state.toResult(context.services.serializer, context.executionId);
+		result.status = status;
+		return result;
+	}
+};
+
+//#endregion
+export { StepByStepOrchestrator };

package/dist/runtime/orchestrators/utils.d.mts

@@ -0,0 +1,2 @@
+import { n as processResults, t as executeBatch } from "../../utils-BUEgr9V2.mjs";
+export { executeBatch, processResults };

package/dist/runtime/orchestrators/utils.mjs

@@ -0,0 +1,79 @@
+import { FlowcraftError } from "../../errors.mjs";
+
+//#region src/runtime/orchestrators/utils.ts
+async function executeBatch(readyNodes, blueprint, state, executorFactory, runtime, maxConcurrency) {
+	const concurrency = maxConcurrency || readyNodes.length;
+	const results = [];
+	for (let i = 0; i < readyNodes.length; i += concurrency) {
+		const batchPromises = readyNodes.slice(i, i + concurrency).map(async ({ nodeId }) => {
+			try {
+				const executor = executorFactory(nodeId);
+				if (!executor) throw new Error(`No executor for node ${nodeId}`);
+				const executionResult = await executor.execute(await runtime.resolveNodeInput(nodeId, blueprint, state.getContext()));
+				results.push({
+					status: "fulfilled",
+					value: {
+						nodeId,
+						executionResult
+					}
+				});
+			} catch (error) {
+				results.push({
+					status: "rejected",
+					reason: {
+						nodeId,
+						error
+					}
+				});
+			}
+		});
+		await Promise.all(batchPromises);
+	}
+	return results;
+}
+async function processResults(settledResults, traverser, state, runtime, _blueprint, executionId) {
+	for (const promiseResult of settledResults) {
+		if (promiseResult.status === "rejected") {
+			const { nodeId, error } = promiseResult.reason;
+			if (error instanceof FlowcraftError && error.message.includes("cancelled")) throw error;
+			state.addError(nodeId, error);
+			continue;
+		}
+		const { nodeId, executionResult } = promiseResult.value;
+		if (executionResult.status === "success") {
+			const result = executionResult.result;
+			if (result) {
+				await state.addCompletedNode(nodeId, result.output);
+				if (result._fallbackExecuted) state.markFallbackExecuted();
+				if (result.dynamicNodes && result.dynamicNodes.length > 0) {
+					const gatherNodeId = result.output?.gatherNodeId;
+					for (const dynamicNode of result.dynamicNodes) traverser.addDynamicNode(dynamicNode.id, dynamicNode, nodeId, gatherNodeId);
+				}
+			}
+			const matched = await runtime.determineNextNodes(traverser.getDynamicBlueprint(), nodeId, result, state.getContext(), executionId);
+			for (const { node, edge } of matched) await runtime.applyEdgeTransform(edge, result, node, state.getContext(), traverser.getAllPredecessors(), executionId);
+			traverser.markNodeCompleted(nodeId, result, matched.map((m) => m.node));
+		} else if (executionResult.status === "failed_with_fallback") {
+			const { fallbackNodeId, error } = executionResult;
+			const fallbackNodeDef = traverser.getDynamicBlueprint().nodes.find((n) => n.id === fallbackNodeId);
+			if (!fallbackNodeDef) {
+				const notFoundError = new FlowcraftError(`Fallback node '${fallbackNodeId}' not found in blueprint.`, {
+					nodeId,
+					cause: error
+				});
+				state.addError(nodeId, notFoundError);
+			} else {
+				state.addCompletedNode(nodeId, null);
+				state.markFallbackExecuted();
+				traverser.markNodeCompleted(nodeId, {
+					action: "fallback",
+					output: null,
+					_fallbackExecuted: true
+				}, [fallbackNodeDef]);
+			}
+		} else state.addError(nodeId, executionResult.error);
+	}
+}
+
+//#endregion
+export { executeBatch, processResults };

package/dist/runtime/runtime.d.mts

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