flowcraft 2.7.1 → 2.8.1

package/dist/runtime-CmefIAu_.mjs

@@ -0,0 +1,2216 @@
+//#region src/adapters/persistent-event-bus.ts
+/**
+* A pluggable event bus adapter that persists all workflow events
+* to a configurable storage backend, enabling time-travel debugging and replay.
+*
+* @example
+* ```typescript
+* // Using a database-backed store
+* const eventStore = new DatabaseEventStore(dbConnection)
+* const eventBus = new PersistentEventBusAdapter(eventStore)
+* const runtime = new FlowRuntime({ eventBus })
+*
+* // Later, replay the execution
+* const events = await eventStore.retrieve(executionId)
+* const finalState = await runtime.replay(blueprint, events)
+* ```
+*/
+var PersistentEventBusAdapter = class {
+	constructor(store) {
+		this.store = store;
+	}
+	/**
+	* Emit an event by storing it persistently.
+	* Also emits to console for debugging (can be made configurable).
+	*/
+	async emit(event) {
+		let executionId = "unknown";
+		if ("executionId" in event.payload) executionId = event.payload.executionId;
+		await this.store.store(event, executionId);
+	}
+};
+/**
+* Simple in-memory event store for testing and development.
+* Not suitable for production use.
+*/
+var InMemoryEventStore = class {
+	events = /* @__PURE__ */ new Map();
+	async store(event, executionId) {
+		if (!this.events.has(executionId)) this.events.set(executionId, []);
+		this.events.get(executionId)?.push(event);
+	}
+	async retrieve(executionId) {
+		return this.events.get(executionId) || [];
+	}
+	async retrieveMultiple(executionIds) {
+		const result = /* @__PURE__ */ new Map();
+		for (const id of executionIds) result.set(id, await this.retrieve(id));
+		return result;
+	}
+	/**
+	* Clear all stored events (useful for testing).
+	*/
+	clear() {
+		this.events.clear();
+	}
+};
+
+//#endregion
+//#region src/analysis.ts
+/**
+* Analyzes a workflow blueprint to detect cycles using an iterative DFS algorithm.
+* This avoids stack overflow issues for deep graphs compared to the recursive version.
+* @param blueprint The WorkflowBlueprint object containing nodes and edges.
+* @returns An array of cycles found. Each cycle is represented as an array of node IDs.
+*/
+function checkForCycles(blueprint) {
+	const cycles = [];
+	if (!blueprint?.nodes || blueprint.nodes.length === 0) return cycles;
+	const allNodeIds = blueprint.nodes.map((node) => node.id);
+	const adj = /* @__PURE__ */ new Map();
+	for (const id of allNodeIds) adj.set(id, []);
+	for (const edge of blueprint.edges) adj.get(edge.source)?.push(edge.target);
+	const state = /* @__PURE__ */ new Map();
+	for (const id of allNodeIds) state.set(id, 0);
+	for (const startNode of allNodeIds) {
+		if (state.get(startNode) !== 0) continue;
+		const stack = [{
+			node: startNode,
+			path: []
+		}];
+		const pathSet = /* @__PURE__ */ new Set();
+		while (stack.length > 0) {
+			const { node, path } = stack[stack.length - 1];
+			if (state.get(node) === 0) {
+				state.set(node, 1);
+				pathSet.add(node);
+				path.push(node);
+			}
+			const neighbors = adj.get(node) || [];
+			let foundUnvisited = false;
+			for (const neighbor of neighbors) if (state.get(neighbor) === 1) {
+				const cycleStartIndex = path.indexOf(neighbor);
+				const cycle = path.slice(cycleStartIndex);
+				cycles.push([...cycle, neighbor]);
+			} else if (state.get(neighbor) === 0) {
+				stack.push({
+					node: neighbor,
+					path: [...path]
+				});
+				foundUnvisited = true;
+				break;
+			}
+			if (!foundUnvisited) {
+				state.set(node, 2);
+				stack.pop();
+				pathSet.delete(node);
+			}
+		}
+	}
+	return cycles;
+}
+/**
+* Generates Mermaid diagram syntax from a WorkflowBlueprint
+* @param blueprint The WorkflowBlueprint object containing nodes and edges
+* @returns Mermaid syntax string for the flowchart
+*/
+function generateMermaid(blueprint) {
+	if (!blueprint?.nodes || blueprint.nodes.length === 0) return "flowchart TD\n    empty[Empty Blueprint]";
+	let mermaid = "flowchart TD\n";
+	for (const node of blueprint.nodes) {
+		const paramsString = node.params ? `<br/>params: ${JSON.stringify(node.params)}` : "";
+		const nodeLabel = `${node.id}${paramsString}`;
+		mermaid += `    ${node.id}["${nodeLabel}"]\n`;
+	}
+	for (const edge of blueprint.edges || []) {
+		const labelParts = [];
+		if (edge.action) labelParts.push(edge.action);
+		if (edge.condition) labelParts.push(edge.condition);
+		if (edge.transform) labelParts.push(edge.transform);
+		if (labelParts.length > 0) {
+			const edgeLabel = labelParts.join(" | ");
+			mermaid += `    ${edge.source} -- "${edgeLabel}" --> ${edge.target}\n`;
+		} else mermaid += `    ${edge.source} --> ${edge.target}\n`;
+	}
+	return mermaid;
+}
+/**
+* Generates Mermaid diagram syntax from a WorkflowBlueprint with execution history styling
+* @param blueprint The WorkflowBlueprint object containing nodes and edges
+* @param events Array of FlowcraftEvent objects from the workflow execution
+* @returns Mermaid syntax string for the flowchart with execution path highlighting
+*/
+function generateMermaidForRun(blueprint, events) {
+	if (!blueprint?.nodes || blueprint.nodes.length === 0) return "flowchart TD\n    empty[Empty Blueprint]";
+	let mermaid = "flowchart TD\n";
+	const successfulNodes = /* @__PURE__ */ new Set();
+	const failedNodes = /* @__PURE__ */ new Set();
+	const takenEdges = /* @__PURE__ */ new Set();
+	for (const event of events) switch (event.type) {
+		case "node:finish":
+			successfulNodes.add(event.payload.nodeId);
+			break;
+		case "node:error":
+			failedNodes.add(event.payload.nodeId);
+			break;
+		case "edge:evaluate":
+			if (event.payload.result) {
+				const edgeKey = `${event.payload.source}->${event.payload.target}`;
+				takenEdges.add(edgeKey);
+			}
+			break;
+	}
+	for (const node of blueprint.nodes) {
+		const paramsString = node.params ? `<br/>params: ${JSON.stringify(node.params)}` : "";
+		const nodeLabel = `${node.id}${paramsString}`;
+		mermaid += `    ${node.id}["${nodeLabel}"]\n`;
+	}
+	for (const node of blueprint.nodes) if (successfulNodes.has(node.id)) mermaid += `    style ${node.id} fill:#d4edda,stroke:#c3e6cb\n`;
+	else if (failedNodes.has(node.id)) mermaid += `    style ${node.id} fill:#f8d7da,stroke:#f5c6cb\n`;
+	let edgeIndex = 0;
+	for (const edge of blueprint.edges || []) {
+		const labelParts = [];
+		if (edge.action) labelParts.push(edge.action);
+		if (edge.condition) labelParts.push(edge.condition);
+		if (edge.transform) labelParts.push(edge.transform);
+		const edgeKey = `${edge.source}->${edge.target}`;
+		const isTaken = takenEdges.has(edgeKey);
+		let edgeLine;
+		if (labelParts.length > 0) {
+			const edgeLabel = labelParts.join(" | ");
+			edgeLine = `    ${edge.source} -- "${edgeLabel}" --> ${edge.target}\n`;
+		} else edgeLine = `    ${edge.source} --> ${edge.target}\n`;
+		mermaid += edgeLine;
+		if (isTaken) mermaid += `    linkStyle ${edgeIndex} stroke:#007bff,stroke-width:3px\n`;
+		edgeIndex++;
+	}
+	return mermaid;
+}
+/**
+* Analyzes a workflow blueprint and returns comprehensive analysis
+* @param blueprint The WorkflowBlueprint object containing nodes and edges
+* @returns Analysis result with cycles, start nodes, terminal nodes, and other metrics
+*/
+function analyzeBlueprint(blueprint) {
+	if (!blueprint?.nodes || blueprint.nodes.length === 0) return {
+		cycles: [],
+		startNodeIds: [],
+		terminalNodeIds: [],
+		nodeCount: 0,
+		edgeCount: 0,
+		isDag: true
+	};
+	const cycles = checkForCycles(blueprint);
+	const nodeCount = blueprint.nodes.length;
+	const edgeCount = blueprint.edges?.length || 0;
+	const nodesWithIncoming = /* @__PURE__ */ new Set();
+	for (const edge of blueprint.edges || []) nodesWithIncoming.add(edge.target);
+	const startNodeIds = blueprint.nodes.map((node) => node.id).filter((nodeId) => !nodesWithIncoming.has(nodeId));
+	const nodesWithOutgoing = /* @__PURE__ */ new Set();
+	for (const edge of blueprint.edges || []) nodesWithOutgoing.add(edge.source);
+	return {
+		cycles,
+		startNodeIds,
+		terminalNodeIds: blueprint.nodes.map((node) => node.id).filter((nodeId) => !nodesWithOutgoing.has(nodeId)),
+		nodeCount,
+		edgeCount,
+		isDag: cycles.length === 0
+	};
+}
+
+//#endregion
+//#region src/container.ts
+var DIContainer = class DIContainer {
+	services = /* @__PURE__ */ new Map();
+	factories = /* @__PURE__ */ new Map();
+	register(token, implementation) {
+		this.services.set(token, implementation);
+	}
+	registerFactory(token, factory) {
+		this.factories.set(token, factory);
+	}
+	resolve(token) {
+		if (this.services.has(token)) return this.services.get(token);
+		if (this.factories.has(token)) {
+			const instance = this.factories.get(token)?.(this);
+			this.services.set(token, instance);
+			return instance;
+		}
+		throw new Error(`Service not found for token: ${String(token)}`);
+	}
+	has(token) {
+		return this.services.has(token) || this.factories.has(token);
+	}
+	createChild() {
+		const child = new DIContainer();
+		child.services = new Map(this.services);
+		child.factories = new Map(this.factories);
+		return child;
+	}
+};
+const ServiceTokens = {
+	Logger: Symbol.for("flowcraft:logger"),
+	Serializer: Symbol.for("flowcraft:serializer"),
+	Evaluator: Symbol.for("flowcraft:evaluator"),
+	EventBus: Symbol.for("flowcraft:eventBus"),
+	Orchestrator: Symbol.for("flowcraft:orchestrator"),
+	Middleware: Symbol.for("flowcraft:middleware"),
+	NodeRegistry: Symbol.for("flowcraft:nodeRegistry"),
+	BlueprintRegistry: Symbol.for("flowcraft:blueprintRegistry"),
+	Dependencies: Symbol.for("flowcraft:dependencies")
+};
+
+//#endregion
+//#region src/evaluator.ts
+/**
+* A safe evaluator that only allows simple property access.
+* It cannot execute arbitrary code and is secure for untrusted inputs.
+*
+* Example expressions:
+* - "result.output.status"
+* - "context.user.isAdmin"
+* - "input.value"
+*/
+var PropertyEvaluator = class {
+	evaluate(expression, context) {
+		try {
+			if (!/^[a-zA-Z0-9_$.]+$/.test(expression)) {
+				console.error(`Error evaluating expression: "${expression}" contains invalid characters.`);
+				return;
+			}
+			const parts = expression.split(".");
+			const startKey = parts[0];
+			if (!Object.hasOwn(context, startKey)) return;
+			let current = context[startKey];
+			for (let i = 1; i < parts.length; i++) {
+				if (current === null || current === void 0) return;
+				current = current[parts[i]];
+			}
+			return current;
+		} catch (error) {
+			console.error(`Error evaluating property expression "${expression}":`, error);
+			return;
+		}
+	}
+};
+/**
+* @warning This evaluator uses `new Function()` and can execute arbitrary
+* JavaScript code. It poses a significant security risk if the expressions
+* are not from a trusted source (e.g., user input).
+*
+* It should only be used in controlled environments where all workflow
+* definitions are static and authored by trusted developers.
+*
+* For safer evaluation, use the default `PropertyEvaluator` or install a
+* sandboxed library like `jsep` to create a custom, secure evaluator.
+*/
+var UnsafeEvaluator = class {
+	evaluate(expression, context) {
+		try {
+			const validIdentifierRegex = /^[a-z_$][\w$]*$/i;
+			const validKeys = Object.keys(context).filter((key) => validIdentifierRegex.test(key));
+			const validContext = {};
+			for (const key of validKeys) validContext[key] = context[key];
+			return new Function(...validKeys, `return ${expression}`)(...validKeys.map((k) => validContext[k]));
+		} catch (error) {
+			console.error(`Error evaluating expression "${expression}":`, error);
+			return;
+		}
+	}
+};
+
+//#endregion
+//#region src/logger.ts
+/** A logger implementation that outputs to the console. */
+var ConsoleLogger = class {
+	debug(message, meta) {
+		console.debug(`[DEBUG] ${message}`, meta || "");
+	}
+	info(message, meta) {
+		console.info(`[INFO] ${message}`, meta || "");
+	}
+	warn(message, meta) {
+		console.warn(`[WARN] ${message}`, meta || "");
+	}
+	error(message, meta) {
+		console.error(`[ERROR] ${message}`, meta || "");
+	}
+};
+/** A logger implementation that does nothing (no-op). */
+var NullLogger = class {
+	debug(_message, _meta) {}
+	info(_message, _meta) {}
+	warn(_message, _meta) {}
+	error(_message, _meta) {}
+};
+
+//#endregion
+//#region src/errors.ts
+/**
+* A single, comprehensive error class for the framework.
+* Use this for all errors to ensure consistent structure and easy debugging.
+*/
+var FlowcraftError = class extends Error {
+	message;
+	nodeId;
+	blueprintId;
+	executionId;
+	isFatal;
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "FlowcraftError";
+		this.message = message;
+		this.nodeId = options.nodeId;
+		this.blueprintId = options.blueprintId;
+		this.executionId = options.executionId;
+		this.isFatal = options.isFatal ?? false;
+	}
+};
+
+//#endregion
+//#region src/context.ts
+/**
+* A default, high-performance, in-memory implementation of ISyncContext using a Map.
+*/
+var Context = class {
+	type = "sync";
+	data;
+	constructor(initialData = {}) {
+		this.data = new Map(Object.entries(initialData));
+	}
+	get(key) {
+		return this.data.get(key);
+	}
+	set(key, value) {
+		this.data.set(key, value);
+	}
+	has(key) {
+		return this.data.has(key);
+	}
+	delete(key) {
+		return this.data.delete(key);
+	}
+	toJSON() {
+		return Object.fromEntries(this.data);
+	}
+};
+/**
+* An adapter that provides a consistent, Promise-based view of a synchronous context.
+* This is created by the runtime and is transparent to the node author.
+*/
+var AsyncContextView = class {
+	type = "async";
+	constructor(syncContext) {
+		this.syncContext = syncContext;
+	}
+	get(key) {
+		return Promise.resolve(this.syncContext.get(key));
+	}
+	set(key, value) {
+		this.syncContext.set(key, value);
+		return Promise.resolve();
+	}
+	has(key) {
+		return Promise.resolve(this.syncContext.has(key));
+	}
+	delete(key) {
+		return Promise.resolve(this.syncContext.delete(key));
+	}
+	toJSON() {
+		return Promise.resolve(this.syncContext.toJSON());
+	}
+	async patch(_operations) {
+		throw new Error("Patch operations not supported by AsyncContextView");
+	}
+};
+/**
+* A proxy wrapper that tracks changes to an async context for delta-based persistence.
+* Records all mutations (set/delete operations) to enable efficient partial updates.
+*/
+var TrackedAsyncContext = class {
+	type = "async";
+	deltas = [];
+	innerContext;
+	eventBus;
+	executionId;
+	sourceNode;
+	constructor(innerContext, eventBus, executionId, sourceNode) {
+		this.innerContext = innerContext;
+		this.eventBus = eventBus;
+		this.executionId = executionId;
+		this.sourceNode = sourceNode;
+	}
+	async get(key) {
+		return this.innerContext.get(key);
+	}
+	async set(key, value) {
+		this.deltas.push({
+			op: "set",
+			key,
+			value
+		});
+		await this.innerContext.set(key, value);
+		if (this.eventBus && this.executionId) await this.eventBus.emit({
+			type: "context:change",
+			payload: {
+				sourceNode: this.sourceNode || "unknown",
+				key,
+				op: "set",
+				value,
+				executionId: this.executionId
+			}
+		});
+	}
+	async has(key) {
+		return this.innerContext.has(key);
+	}
+	async delete(key) {
+		this.deltas.push({
+			op: "delete",
+			key
+		});
+		const result = await this.innerContext.delete(key);
+		if (this.eventBus && this.executionId && result) await this.eventBus.emit({
+			type: "context:change",
+			payload: {
+				sourceNode: this.sourceNode || "unknown",
+				key,
+				op: "delete",
+				executionId: this.executionId
+			}
+		});
+		return result;
+	}
+	toJSON() {
+		return this.innerContext.toJSON();
+	}
+	async patch(operations) {
+		if (this.innerContext.patch) return this.innerContext.patch(operations);
+		for (const op of operations) if (op.op === "set") await this.innerContext.set(op.key, op.value);
+		else if (op.op === "delete") await this.innerContext.delete(op.key);
+	}
+	getDeltas() {
+		return [...this.deltas];
+	}
+	clearDeltas() {
+		this.deltas = [];
+	}
+	/**
+	* Configures the event emitter for tracking context changes.
+	* This enables the context to emit events when set/delete operations occur,
+	* allowing for external monitoring and persistence of context mutations.
+	*
+	* @param eventBus - The event bus instance to emit context change events
+	* @param executionId - The unique identifier for the current workflow execution
+	* @param sourceNode - Optional identifier for the node that triggered the context change
+	*/
+	configureEventEmitter(eventBus, executionId, sourceNode) {
+		this.eventBus = eventBus;
+		this.executionId = executionId;
+		this.sourceNode = sourceNode;
+	}
+};
+
+//#endregion
+//#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();
+	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);
+	}
+	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
+//#region src/runtime/execution-context.ts
+/**
+* A container for all state and dependencies of a single workflow execution.
+* This object is created once per `run` and passed through the execution stack.
+*/
+var ExecutionContext = class ExecutionContext {
+	constructor(blueprint, state, nodeRegistry, executionId, runtime, services, signal, concurrency) {
+		this.blueprint = blueprint;
+		this.state = state;
+		this.nodeRegistry = nodeRegistry;
+		this.executionId = executionId;
+		this.runtime = runtime;
+		this.services = services;
+		this.signal = signal;
+		this.concurrency = concurrency;
+		this.state.setEventEmitter(this.services.eventBus, this.executionId);
+	}
+	createForSubflow(subBlueprint, initialSubState) {
+		return new ExecutionContext(subBlueprint, new WorkflowState(initialSubState), this.nodeRegistry, this.executionId, this.runtime, this.services, this.signal, this.concurrency);
+	}
+};
+
+//#endregion
+//#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) {
+				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
+//#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
+//#region src/serializer.ts
+/**
+* A default serializer using standard JSON.
+*
+* @warning This implementation is lossy and does not handle complex data types
+* like `Date`, `Map`, `Set`, `undefined`, etc. It is recommended to provide a robust
+* serializer like `superjson` if working with complex data types.
+*/
+var JsonSerializer = class {
+	hasWarned = false;
+	serialize(data) {
+		for (const value of Object.values(data)) if (value instanceof Map || value instanceof Set || value instanceof Date) {
+			if (!this.hasWarned) {
+				console.warn("[Flowcraft] Warning: Default JsonSerializer does not support Map, Set, or Date types. Data may be lost. Consider providing a custom ISerializer (e.g., using superjson).");
+				this.hasWarned = true;
+			}
+		}
+		try {
+			return JSON.stringify(data);
+		} catch {
+			console.warn("[Flowcraft] Warning: Circular reference detected in context. Using safe serialization.");
+			return JSON.stringify({
+				_circularReference: true,
+				message: "Context contains circular references"
+			});
+		}
+	}
+	deserialize(text) {
+		return JSON.parse(text);
+	}
+};
+
+//#endregion
+//#region src/node.ts
+/** A type guard to reliably distinguish a NodeClass from a NodeFunction. */
+function isNodeClass(impl) {
+	return typeof impl === "function" && !!impl.prototype?.exec;
+}
+/**
+* A structured, class-based node for complex logic with a safe, granular lifecycle.
+* This class is generic, allowing implementations to specify the exact context
+* and dependency types they expect.
+*/
+var BaseNode = class {
+	/**
+	* @param params Static parameters for this node instance, passed from the blueprint.
+	* @param nodeId The ID of the node in the blueprint.
+	*/
+	constructor(params, nodeId) {
+		this.params = params;
+		this.nodeId = nodeId;
+	}
+	/**
+	* Phase 1: Gathers and prepares data for execution. This phase is NOT retried on failure.
+	* @param context The node's execution context.
+	* @returns The data needed for the `exec` phase.
+	*/
+	async prep(context) {
+		return context.input;
+	}
+	/**
+	* Phase 3: Processes the result and saves state. This phase is NOT retried.
+	* @param execResult The successful result from the `exec` or `fallback` phase.
+	* @param _context The node's execution context.
+	*/
+	async post(execResult, _context) {
+		return execResult;
+	}
+	/**
+	* An optional safety net that runs if all `exec` retries fail.
+	* @param error The final error from the last `exec` attempt.
+	* @param _context The node's execution context.
+	*/
+	async fallback(error, _context) {
+		throw error;
+	}
+	/**
+	* An optional cleanup phase for non-retriable errors that occur outside the main `exec` method.
+	* This method is invoked in a `finally` block or equivalent construct if a fatal, unhandled exception occurs in the `prep`, `exec`, or `post` phases.
+	* Allows nodes to perform crucial cleanup, such as closing database connections or releasing locks.
+	* @param _error The error that caused the failure.
+	* @param _context The node's execution context.
+	*/
+	async recover(_error, _context) {}
+};
+
+//#endregion
+//#region src/nodes/batch-gather.ts
+var BatchGatherNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const { gatherNodeId, outputKey } = this.params || {};
+		const hasMore = await context.context.get(`${gatherNodeId}_hasMore`) || false;
+		const dynamicNodes = [];
+		let results = [];
+		if (hasMore) {
+			const newScatterId = `${gatherNodeId}_scatter_next`;
+			dynamicNodes.push({
+				id: newScatterId,
+				uses: "batch-scatter",
+				inputs: context.input,
+				params: {
+					...this.params,
+					gatherNodeId
+				}
+			});
+		} else {
+			const allWorkerIds = await context.context.get(`${gatherNodeId}_allWorkerIds`) || [];
+			results = [];
+			for (const workerId of allWorkerIds) {
+				const result = await context.context.get(`_outputs.${workerId}`);
+				if (result !== void 0) results.push(result);
+			}
+			await context.context.set(outputKey, results);
+			const parentBatchId = gatherNodeId.replace("_gather", "");
+			await context.dependencies.runtime.services.eventBus.emit({
+				type: "batch:finish",
+				payload: {
+					batchId: parentBatchId,
+					gatherNodeId,
+					results
+				}
+			});
+		}
+		return {
+			dynamicNodes,
+			output: results
+		};
+	}
+};
+
+//#endregion
+//#region src/nodes/batch-scatter.ts
+var BatchScatterNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const inputArray = context.input || [];
+		if (!Array.isArray(inputArray)) throw new Error(`Input for batch-scatter node '${this.nodeId}' must be an array.`);
+		const { chunkSize = inputArray.length, workerUsesKey, gatherNodeId } = this.params || {};
+		if (!workerUsesKey || !gatherNodeId) throw new Error(`BatchScatterNode requires 'workerUsesKey' and 'gatherNodeId' parameters.`);
+		const batchId = globalThis.crypto.randomUUID();
+		const currentIndex = await context.context.get(`${this.nodeId}_currentIndex`) || 0;
+		const endIndex = Math.min(currentIndex + chunkSize, inputArray.length);
+		const dynamicNodes = [];
+		const workerIds = [];
+		for (let i = currentIndex; i < endIndex; i++) {
+			const item = inputArray[i];
+			const itemInputKey = `_batch.${this.nodeId}_${batchId}_item_${i}`;
+			await context.context.set(itemInputKey, item);
+			const workerId = `${workerUsesKey}_${batchId}_${i}`;
+			workerIds.push(workerId);
+			dynamicNodes.push({
+				id: workerId,
+				uses: workerUsesKey,
+				inputs: itemInputKey
+			});
+		}
+		const parentBatchId = this.nodeId?.replace("_scatter", "") || "";
+		await context.dependencies.runtime.services.eventBus.emit({
+			type: "batch:start",
+			payload: {
+				batchId: parentBatchId,
+				scatterNodeId: this.nodeId,
+				workerNodeIds: workerIds
+			}
+		});
+		await context.context.set(`${this.nodeId}_currentIndex`, endIndex);
+		const hasMore = endIndex < inputArray.length;
+		await context.context.set(`${gatherNodeId}_hasMore`, hasMore);
+		const allWorkerIds = [...await context.context.get(`${gatherNodeId}_allWorkerIds`) || [], ...workerIds];
+		await context.context.set(`${gatherNodeId}_allWorkerIds`, allWorkerIds);
+		return {
+			dynamicNodes,
+			output: {
+				gatherNodeId,
+				hasMore
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/nodes/sleep.ts
+var SleepNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const durationParam = this.params?.duration;
+		let durationMs;
+		if (typeof durationParam === "string") {
+			const match = durationParam.match(/^(\d+)([smhd])$/);
+			if (!match) throw new Error(`SleepNode '${this.nodeId}' received an invalid duration string: '${durationParam}'. Expected format: '5m', '10s', '1h', '2d'`);
+			const [, numStr, unit] = match;
+			const num = parseInt(numStr, 10);
+			switch (unit) {
+				case "s":
+					durationMs = num * 1e3;
+					break;
+				case "m":
+					durationMs = num * 60 * 1e3;
+					break;
+				case "h":
+					durationMs = num * 60 * 60 * 1e3;
+					break;
+				case "d":
+					durationMs = num * 24 * 60 * 60 * 1e3;
+					break;
+				default: throw new Error(`Invalid duration unit: ${unit}`);
+			}
+		} else if (typeof durationParam === "number") durationMs = durationParam;
+		else throw new Error(`SleepNode '${this.nodeId}' received an invalid duration type: ${typeof durationParam}`);
+		if (durationMs < 0) throw new Error(`SleepNode '${this.nodeId}' received a negative duration.`);
+		const wakeUpAt = new Date(Date.now() + durationMs).toISOString();
+		await context.dependencies.workflowState.markAsAwaiting(this.nodeId ?? "", {
+			reason: "timer",
+			wakeUpAt
+		});
+		return { output: void 0 };
+	}
+};
+
+//#endregion
+//#region src/runtime/traverser.ts
+var GraphTraverser = class GraphTraverser {
+	frontier = /* @__PURE__ */ new Set();
+	allPredecessors;
+	allSuccessors;
+	dynamicBlueprint;
+	completedNodes = /* @__PURE__ */ new Set();
+	nodesInLoops;
+	constructor(blueprint, isStrictMode = false) {
+		this.dynamicBlueprint = structuredClone(blueprint);
+		this.allPredecessors = /* @__PURE__ */ new Map();
+		this.allSuccessors = /* @__PURE__ */ new Map();
+		this.nodesInLoops = /* @__PURE__ */ new Map();
+		for (const node of this.dynamicBlueprint.nodes) {
+			this.allPredecessors.set(node.id, /* @__PURE__ */ new Set());
+			this.allSuccessors.set(node.id, /* @__PURE__ */ new Set());
+		}
+		for (const edge of this.dynamicBlueprint.edges) this.getPredecessors(edge.target).add(edge.source);
+		for (const edge of this.dynamicBlueprint.edges) this.getSuccessors(edge.source).add(edge.target);
+		const analysis = analyzeBlueprint(blueprint);
+		this.filterNodesInLoops(blueprint);
+		this.frontier = new Set(analysis.startNodeIds.filter((id) => !this.isFallbackNode(id)));
+		if (this.frontier.size === 0 && analysis.cycles.length > 0 && !isStrictMode) {
+			const uniqueStartNodes = /* @__PURE__ */ new Set();
+			const cycleEntryPoints = new Set(blueprint.metadata?.cycleEntryPoints || []);
+			for (const cycle of analysis.cycles) if (cycle.length > 0) {
+				const entryPoint = cycle.find((node) => cycleEntryPoints.has(node));
+				uniqueStartNodes.add(entryPoint || cycle[0]);
+			}
+			this.frontier = new Set(uniqueStartNodes);
+		}
+	}
+	/**
+	* Clears all nodes from the execution frontier.
+	*/
+	clearFrontier() {
+		this.frontier.clear();
+	}
+	/**
+	* Creates and initializes a GraphTraverser from a saved workflow state.
+	* This is the correct way to prepare a traverser for a `resume` operation.
+	* @param blueprint The workflow blueprint.
+	* @param state The workflow state being resumed.
+	* @returns A configured GraphTraverser instance.
+	*/
+	static fromState(blueprint, state) {
+		const traverser = new GraphTraverser(blueprint);
+		traverser.clearFrontier();
+		const completedNodes = state.getCompletedNodes();
+		traverser.completedNodes = new Set(completedNodes);
+		for (const node of traverser.dynamicBlueprint.nodes) {
+			if (traverser.completedNodes.has(node.id)) continue;
+			const requiredPredecessors = traverser.allPredecessors.get(node.id);
+			const joinStrategy = traverser.getJoinStrategy(node.id);
+			if (!requiredPredecessors || requiredPredecessors.size === 0) {
+				traverser.frontier.add(node.id);
+				continue;
+			}
+			const completedPredecessors = [...requiredPredecessors].filter((p) => traverser.completedNodes.has(p));
+			if (joinStrategy === "any" ? completedPredecessors.length > 0 : completedPredecessors.length === requiredPredecessors.size) traverser.frontier.add(node.id);
+		}
+		return traverser;
+	}
+	isFallbackNode(nodeId) {
+		return this.dynamicBlueprint.nodes.some((n) => n.config?.fallback === nodeId);
+	}
+	getJoinStrategy(nodeId) {
+		return this.dynamicBlueprint.nodes.find((n) => n.id === nodeId)?.config?.joinStrategy || "all";
+	}
+	filterNodesInLoops(blueprint) {
+		blueprint.nodes.forEach((node) => {
+			if (node.uses !== "loop-controller") return;
+			const nextInLoopId = blueprint.edges.find((e) => e.source === node.id && e.action === "continue")?.target;
+			if (!nextInLoopId) throw new FlowcraftError(`Loop '${node.id}' has no continue edge to start node. Ensure edges are wired inside the loop and incoming/breaking edges point to the loop controller.`, {
+				nodeId: node.id,
+				blueprintId: blueprint.id
+			});
+			const set = /* @__PURE__ */ new Set();
+			set.add(nextInLoopId);
+			this.nodesInLoops.set(node.id, this.getAllLoopSuccessors(nextInLoopId, blueprint, set));
+		});
+	}
+	getAllLoopSuccessors(nodeId, blueprint, set) {
+		this.getSuccessors(nodeId).forEach((successor) => {
+			if (set.has(successor)) return;
+			const node = this.getNode(successor, blueprint);
+			if (!node || node.uses === "loop-controller") return;
+			set.add(successor);
+			this.getAllLoopSuccessors(successor, blueprint, set);
+		});
+		return set;
+	}
+	getReadyNodes() {
+		const readyNodes = [];
+		for (const nodeId of this.frontier) {
+			const nodeDef = this.dynamicBlueprint.nodes.find((n) => n.id === nodeId);
+			if (nodeDef) readyNodes.push({
+				nodeId,
+				nodeDef
+			});
+		}
+		this.frontier.clear();
+		return readyNodes;
+	}
+	hasMoreWork() {
+		return this.frontier.size > 0;
+	}
+	markNodeCompleted(nodeId, result, nextNodes) {
+		this.completedNodes.add(nodeId);
+		if (result?.dynamicNodes && result.dynamicNodes.length > 0) {
+			const gatherNodeId = result.output?.gatherNodeId;
+			for (const dynamicNode of result.dynamicNodes) {
+				this.dynamicBlueprint.nodes.push(dynamicNode);
+				this.allPredecessors.set(dynamicNode.id, new Set([nodeId]));
+				if (gatherNodeId) this.getPredecessors(gatherNodeId).add(dynamicNode.id);
+				this.frontier.add(dynamicNode.id);
+			}
+		}
+		for (const node of nextNodes) {
+			const joinStrategy = this.getJoinStrategy(node.id);
+			if (joinStrategy !== "any" && this.completedNodes.has(node.id)) continue;
+			const requiredPredecessors = this.getPredecessors(node.id);
+			if (joinStrategy === "any" ? requiredPredecessors.has(nodeId) : [...requiredPredecessors].every((p) => this.completedNodes.has(p))) {
+				this.frontier.add(node.id);
+				if (node.uses === "loop-controller") this.getNodesInLoop(node.id).forEach((id) => {
+					this.resetNodeCompletion(id);
+				});
+			}
+		}
+		if (nextNodes.length === 0) {
+			for (const [potentialNextId, predecessors] of this.allPredecessors) if (predecessors.has(nodeId) && !this.completedNodes.has(potentialNextId)) {
+				if (this.getJoinStrategy(potentialNextId) === "any" ? predecessors.has(nodeId) : [...predecessors].every((p) => this.completedNodes.has(p))) {
+					this.frontier.add(potentialNextId);
+					const node = this.getNode(potentialNextId, this.dynamicBlueprint);
+					if (!node) continue;
+					if (node.uses === "loop-controller") this.getNodesInLoop(node.id).forEach((id) => {
+						this.resetNodeCompletion(id);
+					});
+				}
+			}
+		}
+	}
+	getAllNodeIds() {
+		return new Set(this.dynamicBlueprint.nodes.map((n) => n.id));
+	}
+	getFallbackNodeIds() {
+		const fallbackNodeIds = /* @__PURE__ */ new Set();
+		for (const node of this.dynamicBlueprint.nodes) if (node.config?.fallback) fallbackNodeIds.add(node.config.fallback);
+		return fallbackNodeIds;
+	}
+	getCompletedNodes() {
+		return new Set(this.completedNodes);
+	}
+	getDynamicBlueprint() {
+		return this.dynamicBlueprint;
+	}
+	getAllPredecessors() {
+		return this.allPredecessors;
+	}
+	getAllSuccessors() {
+		return this.allSuccessors;
+	}
+	getPredecessors(nodeId) {
+		const predecessors = this.allPredecessors.get(nodeId);
+		if (!predecessors) return /* @__PURE__ */ new Set();
+		return predecessors;
+	}
+	getSuccessors(nodeId) {
+		const successors = this.allSuccessors.get(nodeId);
+		if (!successors) return /* @__PURE__ */ new Set();
+		return successors;
+	}
+	getNodesInLoop(id) {
+		const loopNodes = this.nodesInLoops.get(id);
+		if (!loopNodes) return /* @__PURE__ */ new Set();
+		return loopNodes;
+	}
+	resetNodeCompletion(nodeId) {
+		this.completedNodes.delete(nodeId);
+	}
+	getNode(nodeId, blueprint) {
+		return blueprint.nodes.find((n) => n.id === nodeId);
+	}
+	addDynamicNode(_nodeId, dynamicNode, predecessorId, gatherNodeId) {
+		this.dynamicBlueprint.nodes.push(dynamicNode);
+		this.allPredecessors.set(dynamicNode.id, new Set([predecessorId]));
+		if (gatherNodeId) this.allPredecessors.get(gatherNodeId)?.add(dynamicNode.id);
+		this.frontier.add(dynamicNode.id);
+	}
+	/**
+	* Manually adds a node ID back to the execution frontier.
+	* Used by orchestrators that need fine-grained control over steps.
+	* @param nodeId The ID of the node to add to the frontier.
+	*/
+	addToFrontier(nodeId) {
+		this.frontier.add(nodeId);
+	}
+};
+
+//#endregion
+//#region src/nodes/subflow.ts
+var SubflowNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		const { blueprintId, inputs, outputs } = this.params ?? {};
+		const { runtime, workflowState } = context.dependencies;
+		if (!blueprintId) throw new FlowcraftError(`Subflow node '${this.nodeId}' is missing 'blueprintId' parameter.`, { isFatal: true });
+		const subBlueprint = runtime.blueprints?.[blueprintId] || runtime.runtime?.blueprints?.[blueprintId];
+		if (!subBlueprint) throw new FlowcraftError(`Sub-blueprint '${blueprintId}' not found in runtime registry.`, { isFatal: true });
+		const subflowInitialContext = {};
+		if (inputs) for (const [targetKey, sourceKey] of Object.entries(inputs)) {
+			let value = await context.context.get(sourceKey);
+			if (value === void 0) value = await context.context.get(`_outputs.${sourceKey}`);
+			subflowInitialContext[targetKey] = value;
+		}
+		else if (context.input !== void 0) {
+			const subAnalysis = analyzeBlueprint(subBlueprint);
+			for (const startNodeId of subAnalysis.startNodeIds) {
+				const inputKey = `_inputs.${startNodeId}`;
+				subflowInitialContext[inputKey] = context.input;
+			}
+		}
+		const subflowExecContext = new ExecutionContext(subBlueprint, new WorkflowState(subflowInitialContext), runtime.nodeRegistry, runtime.executionId, runtime.runtime, runtime.services, runtime.signal, runtime.concurrency);
+		const subflowTraverser = new GraphTraverser(subBlueprint);
+		const subflowResult = await runtime.runtime.orchestrator.run(subflowExecContext, subflowTraverser);
+		if (subflowResult.status === "awaiting") {
+			await workflowState.markAsAwaiting(this.nodeId ?? "");
+			const subflowStateKey = `_subflowState.${this.nodeId}`;
+			await context.context.set(subflowStateKey, subflowResult.serializedContext);
+			return { output: void 0 };
+		}
+		if (subflowResult.status !== "completed") {
+			const firstError = subflowResult.errors?.[0];
+			const errorMessage = firstError?.message || "Unknown error";
+			throw new FlowcraftError(`Sub-workflow '${blueprintId}' did not complete successfully. Status: ${subflowResult.status}. Error: ${errorMessage}`, {
+				cause: firstError,
+				nodeId: this.nodeId,
+				blueprintId
+			});
+		}
+		const subflowFinalContext = subflowResult.context;
+		if (outputs) {
+			for (const [parentKey, subKey] of Object.entries(outputs)) {
+				const value = subflowFinalContext[`_outputs.${subKey}`] ?? subflowFinalContext[subKey];
+				await context.context.set(parentKey, value);
+			}
+			return { output: subflowFinalContext };
+		}
+		const subAnalysis = analyzeBlueprint(subBlueprint);
+		if (subAnalysis.terminalNodeIds.length === 1) return { output: subflowFinalContext[`_outputs.${subAnalysis.terminalNodeIds[0]}`] };
+		const terminalOutputs = {};
+		for (const terminalId of subAnalysis.terminalNodeIds) terminalOutputs[terminalId] = subflowFinalContext[`_outputs.${terminalId}`];
+		return { output: terminalOutputs };
+	}
+};
+
+//#endregion
+//#region src/nodes/wait.ts
+var WaitNode = class extends BaseNode {
+	async exec(_prepResult, context) {
+		await context.dependencies.workflowState.markAsAwaiting(this.nodeId ?? "", { reason: "external_event" });
+		return { output: void 0 };
+	}
+};
+
+//#endregion
+//#region src/nodes/webhook.ts
+var WebhookNode = class extends BaseNode {
+	async prep(context) {
+		const runId = context.dependencies.runtime.executionId;
+		const nodeId = this.nodeId ?? "";
+		const { url, event } = await context.dependencies.adapter.registerWebhookEndpoint(runId, nodeId);
+		return {
+			url,
+			event
+		};
+	}
+	async exec(prepResult, _context) {
+		return { output: {
+			url: prepResult.url,
+			event: prepResult.event,
+			request: new Promise(() => {})
+		} };
+	}
+};
+
+//#endregion
+//#region src/sanitizer.ts
+/**
+* Sanitizes a raw workflow blueprint by removing extra properties
+* added by UI tools (e.g., position, style) and keeping only the
+* properties defined in NodeDefinition and EdgeDefinition.
+*/
+function sanitizeBlueprint(raw) {
+	let nodesArray = [];
+	if (Array.isArray(raw.nodes)) nodesArray = raw.nodes;
+	else if (typeof raw.nodes === "object" && raw.nodes !== null) nodesArray = Object.values(raw.nodes);
+	const nodes = nodesArray.map((node) => ({
+		id: node.id,
+		uses: node.uses,
+		params: node.params,
+		inputs: node.inputs,
+		config: node.config
+	}));
+	let edgesArray = [];
+	if (Array.isArray(raw.edges)) edgesArray = raw.edges;
+	else if (typeof raw.edges === "object" && raw.edges !== null) edgesArray = Object.values(raw.edges);
+	const edges = edgesArray.map((edge) => ({
+		source: edge.source,
+		target: edge.target,
+		action: edge.action,
+		condition: edge.condition,
+		transform: edge.transform
+	}));
+	return {
+		id: raw.id,
+		nodes,
+		edges,
+		metadata: raw.metadata
+	};
+}
+
+//#endregion
+//#region src/runtime/executors.ts
+async function withRetries(executor, maxRetries, nodeDef, context, executionId, signal, eventBus) {
+	let lastError;
+	for (let attempt = 1; attempt <= maxRetries; attempt++) try {
+		signal?.throwIfAborted();
+		const result = await executor();
+		if (attempt > 1) context.dependencies.logger.info(`Node execution succeeded after retry`, {
+			nodeId: nodeDef.id,
+			attempt,
+			executionId
+		});
+		return result;
+	} catch (error) {
+		lastError = error;
+		if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+		if (error instanceof FlowcraftError && error.isFatal) break;
+		if (attempt < maxRetries) {
+			context.dependencies.logger.warn(`Node execution failed, retrying`, {
+				nodeId: nodeDef.id,
+				attempt,
+				maxRetries,
+				error: error instanceof Error ? error.message : String(error),
+				executionId
+			});
+			if (eventBus) await eventBus.emit({
+				type: "node:retry",
+				payload: {
+					nodeId: nodeDef.id,
+					attempt,
+					executionId: executionId || "",
+					blueprintId: context.dependencies.blueprint?.id || ""
+				}
+			});
+		} else context.dependencies.logger.error(`Node execution failed after all retries`, {
+			nodeId: nodeDef.id,
+			attempts: maxRetries,
+			error: error instanceof Error ? error.message : String(error),
+			executionId
+		});
+	}
+	throw lastError;
+}
+var FunctionNodeExecutor = class {
+	constructor(implementation, maxRetries, eventBus) {
+		this.implementation = implementation;
+		this.maxRetries = maxRetries;
+		this.eventBus = eventBus;
+	}
+	async execute(nodeDef, context, executionId, signal) {
+		return withRetries(() => this.implementation(context), this.maxRetries, nodeDef, context, executionId, signal, this.eventBus);
+	}
+};
+var ClassNodeExecutor = class {
+	constructor(implementation, maxRetries, eventBus) {
+		this.implementation = implementation;
+		this.maxRetries = maxRetries;
+		this.eventBus = eventBus;
+	}
+	async execute(nodeDef, context, executionId, signal) {
+		const instance = new this.implementation(nodeDef.params || {}, nodeDef.id);
+		let lastError;
+		try {
+			signal?.throwIfAborted();
+			const prepResult = await instance.prep(context);
+			let execResult;
+			try {
+				execResult = await withRetries(() => instance.exec(prepResult, context), this.maxRetries, nodeDef, context, executionId, signal, this.eventBus);
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+				if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+				if (error instanceof FlowcraftError && error.isFatal) throw error;
+			}
+			if (lastError) {
+				signal?.throwIfAborted();
+				execResult = await instance.fallback(lastError, context);
+			}
+			signal?.throwIfAborted();
+			if (!execResult) throw new Error("Execution failed after all retries");
+			return await instance.post(execResult, context);
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", { isFatal: false });
+			throw error;
+		} finally {
+			if (lastError) try {
+				await instance.recover(lastError, context);
+			} catch (recoverError) {
+				context.dependencies.logger.warn(`Recover phase failed`, {
+					nodeId: nodeDef.id,
+					originalError: lastError.message,
+					recoverError: recoverError instanceof Error ? recoverError.message : String(recoverError),
+					executionId
+				});
+			}
+		}
+	}
+};
+var NodeExecutor = class {
+	context;
+	nodeDef;
+	strategy;
+	constructor(config) {
+		this.context = config.context;
+		this.nodeDef = config.nodeDef;
+		this.strategy = config.strategy;
+	}
+	async execute(input) {
+		const nodeContext = {
+			context: this.context.state.getContext(),
+			input,
+			params: this.nodeDef.params || {},
+			dependencies: {
+				...this.context.services.dependencies,
+				logger: this.context.services.logger,
+				runtime: this.context,
+				workflowState: this.context.state
+			},
+			signal: this.context.signal
+		};
+		const beforeHooks = this.context.services.middleware.map((m) => m.beforeNode).filter((hook) => !!hook);
+		const afterHooks = this.context.services.middleware.map((m) => m.afterNode).filter((hook) => !!hook);
+		const aroundHooks = this.context.services.middleware.map((m) => m.aroundNode).filter((hook) => !!hook);
+		const coreExecution = async () => {
+			let result;
+			let error;
+			try {
+				for (const hook of beforeHooks) await hook(nodeContext.context, this.nodeDef.id);
+				result = await this.strategy.execute(this.nodeDef, nodeContext, this.context.executionId, this.context.signal);
+				return {
+					status: "success",
+					result
+				};
+			} catch (e) {
+				error = e instanceof Error ? e : new Error(String(e));
+				const flowcraftError = error instanceof FlowcraftError ? error : new FlowcraftError(`Node '${this.nodeDef.id}' execution failed`, {
+					cause: error,
+					nodeId: this.nodeDef.id,
+					blueprintId: this.context.blueprint.id,
+					executionId: this.context.executionId,
+					isFatal: false
+				});
+				const fallbackNodeId = this.nodeDef.config?.fallback;
+				if (fallbackNodeId && !flowcraftError.isFatal) {
+					this.context.services.logger.warn(`Node failed, fallback required`, {
+						nodeId: this.nodeDef.id,
+						fallbackNodeId,
+						error: error.message,
+						executionId: this.context.executionId
+					});
+					await this.context.services.eventBus.emit({
+						type: "node:fallback",
+						payload: {
+							nodeId: this.nodeDef.id,
+							executionId: this.context.executionId || "",
+							fallback: fallbackNodeId,
+							blueprintId: this.context.blueprint.id
+						}
+					});
+					return {
+						status: "failed_with_fallback",
+						fallbackNodeId,
+						error: flowcraftError
+					};
+				}
+				return {
+					status: "failed",
+					error: flowcraftError
+				};
+			} finally {
+				for (const hook of afterHooks) await hook(nodeContext.context, this.nodeDef.id, result, error);
+			}
+		};
+		let executionChain = coreExecution;
+		for (let i = aroundHooks.length - 1; i >= 0; i--) {
+			const hook = aroundHooks[i];
+			const next = executionChain;
+			executionChain = async () => {
+				let capturedResult;
+				const middlewareResult = await hook(nodeContext.context, this.nodeDef.id, async () => {
+					capturedResult = await next();
+					if (capturedResult.status === "success") return capturedResult.result;
+					throw capturedResult.error;
+				});
+				if (!capturedResult && middlewareResult) return {
+					status: "success",
+					result: middlewareResult
+				};
+				if (!capturedResult) throw new Error("Middleware did not call next() and did not return a result");
+				return capturedResult;
+			};
+		}
+		try {
+			await this.context.services.eventBus.emit({
+				type: "node:start",
+				payload: {
+					nodeId: this.nodeDef.id,
+					executionId: this.context.executionId || "",
+					input: nodeContext.input,
+					blueprintId: this.context.blueprint.id
+				}
+			});
+			const executionResult = await executionChain();
+			if (executionResult.status === "success") await this.context.services.eventBus.emit({
+				type: "node:finish",
+				payload: {
+					nodeId: this.nodeDef.id,
+					result: executionResult.result,
+					executionId: this.context.executionId || "",
+					blueprintId: this.context.blueprint.id
+				}
+			});
+			else await this.context.services.eventBus.emit({
+				type: "node:error",
+				payload: {
+					nodeId: this.nodeDef.id,
+					error: executionResult.error,
+					executionId: this.context.executionId || "",
+					blueprintId: this.context.blueprint.id
+				}
+			});
+			return executionResult;
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			const flowcraftError = err instanceof FlowcraftError ? err : new FlowcraftError(`Node '${this.nodeDef.id}' failed execution.`, {
+				cause: err,
+				nodeId: this.nodeDef.id,
+				blueprintId: this.context.blueprint.id,
+				executionId: this.context.executionId,
+				isFatal: false
+			});
+			await this.context.services.eventBus.emit({
+				type: "node:error",
+				payload: {
+					nodeId: this.nodeDef.id,
+					error: flowcraftError,
+					executionId: this.context.executionId || "",
+					blueprintId: this.context.blueprint.id
+				}
+			});
+			if (error instanceof DOMException && error.name === "AbortError") throw new FlowcraftError("Workflow cancelled", {
+				executionId: this.context.executionId,
+				isFatal: false
+			});
+			throw error instanceof FlowcraftError && !error.isFatal ? error : new FlowcraftError(`Node '${this.nodeDef.id}' failed execution.`, {
+				cause: error,
+				nodeId: this.nodeDef.id,
+				blueprintId: this.context.blueprint.id,
+				executionId: this.context.executionId,
+				isFatal: false
+			});
+		}
+	}
+};
+
+//#endregion
+//#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.nodeRegistry)
+		});
+	}
+	getExecutionStrategy(nodeDef, nodeRegistry) {
+		const implementation = nodeRegistry.get(nodeDef.uses);
+		if (!implementation) throw new FlowcraftError(`Implementation for '${nodeDef.uses}' not found.`, {
+			nodeId: nodeDef.id,
+			blueprintId: "",
+			isFatal: true
+		});
+		const maxRetries = nodeDef.config?.maxRetries ?? 1;
+		return isNodeClass(implementation) ? new ClassNodeExecutor(implementation, maxRetries, this.eventBus) : new FunctionNodeExecutor(implementation, maxRetries, this.eventBus);
+	}
+};
+
+//#endregion
+//#region src/runtime/scheduler.ts
+var WorkflowScheduler = class {
+	runtime;
+	activeWorkflows = /* @__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) {
+		this.activeWorkflows.set(executionId, {
+			executionId,
+			blueprintId,
+			serializedContext,
+			awaitingNodeId,
+			wakeUpAt
+		});
+	}
+	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);
+			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());
+	}
+};
+
+//#endregion
+//#region src/runtime/workflow-logic-handler.ts
+var WorkflowLogicHandler = class {
+	constructor(evaluator, eventBus) {
+		this.evaluator = evaluator;
+		this.eventBus = eventBus;
+	}
+	async determineNextNodes(blueprint, completedNodeId, result, context, executionId) {
+		if (!result) return [];
+		const effectiveSourceNodeId = completedNodeId;
+		const directOutgoingEdges = blueprint.edges.filter((edge) => edge.source === effectiveSourceNodeId);
+		const inheritedOutgoingEdges = blueprint.nodes.filter((n) => n.config?.fallback === completedNodeId).flatMap((originalNode) => blueprint.edges.filter((edge) => edge.source === originalNode.id));
+		const allPossibleEdges = [...directOutgoingEdges, ...inheritedOutgoingEdges];
+		const outgoingEdges = [...new Map(allPossibleEdges.map((edge) => [`${edge.source}-${edge.target}-${edge.action || ""}-${edge.condition || ""}`, edge])).values()];
+		const matched = [];
+		const evaluateEdge = async (edge) => {
+			if (!edge.condition) return true;
+			const contextData = context.type === "sync" ? context.toJSON() : await context.toJSON();
+			const evaluationResult = !!this.evaluator.evaluate(edge.condition, {
+				...contextData,
+				result
+			});
+			await this.eventBus.emit({
+				type: "edge:evaluate",
+				payload: {
+					source: edge.source,
+					target: edge.target,
+					condition: edge.condition,
+					result: evaluationResult
+				}
+			});
+			return evaluationResult;
+		};
+		if (blueprint.nodes.find((n) => n.id === completedNodeId)?.uses === "loop-controller") {
+			const conditionalEdges = outgoingEdges.filter((edge) => edge.condition);
+			for (const edge of conditionalEdges) if (await evaluateEdge(edge)) {
+				const targetNode = blueprint.nodes.find((n) => n.id === edge.target);
+				if (targetNode) matched.push({
+					node: targetNode,
+					edge
+				});
+			} else await this.eventBus.emit({
+				type: "node:skipped",
+				payload: {
+					nodeId: completedNodeId,
+					edge,
+					executionId: executionId || "",
+					blueprintId: blueprint.id
+				}
+			});
+			if (matched.length > 0) return matched;
+		}
+		if (result.action) {
+			const actionEdges = outgoingEdges.filter((edge) => edge.action === result.action);
+			for (const edge of actionEdges) if (await evaluateEdge(edge)) {
+				const targetNode = blueprint.nodes.find((n) => n.id === edge.target);
+				if (targetNode) matched.push({
+					node: targetNode,
+					edge
+				});
+			} else await this.eventBus.emit({
+				type: "node:skipped",
+				payload: {
+					nodeId: completedNodeId,
+					edge,
+					executionId: executionId || "",
+					blueprintId: blueprint.id
+				}
+			});
+		}
+		if (matched.length === 0) {
+			const defaultEdges = outgoingEdges.filter((edge) => !edge.action);
+			for (const edge of defaultEdges) if (await evaluateEdge(edge)) {
+				const targetNode = blueprint.nodes.find((n) => n.id === edge.target);
+				if (targetNode) matched.push({
+					node: targetNode,
+					edge
+				});
+			} else await this.eventBus.emit({
+				type: "node:skipped",
+				payload: {
+					nodeId: completedNodeId,
+					edge,
+					executionId: executionId || "",
+					blueprintId: blueprint.id
+				}
+			});
+		}
+		return matched;
+	}
+	async applyEdgeTransform(edge, sourceResult, targetNode, context, allPredecessors, executionId) {
+		const asyncContext = context.type === "sync" ? new AsyncContextView(context) : context;
+		const predecessors = allPredecessors?.get(targetNode.id);
+		const hasSinglePredecessor = predecessors && predecessors.size === 1;
+		const hasExplicitInputs = targetNode.inputs !== void 0;
+		const hasEdgeTransform = edge.transform !== void 0;
+		if (!hasExplicitInputs && !hasSinglePredecessor && !hasEdgeTransform) return;
+		const finalInput = edge.transform ? this.evaluator.evaluate(edge.transform, {
+			input: sourceResult.output,
+			context: await asyncContext.toJSON()
+		}) : sourceResult.output;
+		const inputKey = `_inputs.${targetNode.id}`;
+		await asyncContext.set(inputKey, finalInput);
+		await this.eventBus.emit({
+			type: "context:change",
+			payload: {
+				sourceNode: edge.source,
+				key: inputKey,
+				op: "set",
+				value: finalInput,
+				executionId: executionId || "unknown"
+			}
+		});
+		if (!hasExplicitInputs) targetNode.inputs = inputKey;
+	}
+	async resolveNodeInput(nodeId, blueprint, context) {
+		const nodeDef = blueprint.nodes.find((n) => n.id === nodeId);
+		if (!nodeDef) throw new FlowcraftError(`Node '${nodeId}' not found in blueprint.`, {
+			nodeId,
+			blueprintId: blueprint.id,
+			isFatal: false
+		});
+		const asyncContext = context.type === "sync" ? new AsyncContextView(context) : context;
+		if (nodeDef.inputs) {
+			if (typeof nodeDef.inputs === "string") {
+				const key = nodeDef.inputs;
+				if (key.startsWith("_")) return await asyncContext.get(key);
+				const outputKey = `_outputs.${key}`;
+				if (await asyncContext.has(outputKey)) return await asyncContext.get(outputKey);
+				return await asyncContext.get(key);
+			}
+			if (typeof nodeDef.inputs === "object") {
+				const input = {};
+				for (const key in nodeDef.inputs) {
+					const contextKey = nodeDef.inputs[key];
+					if (contextKey.startsWith("_")) input[key] = await asyncContext.get(contextKey);
+					else {
+						const outputKey = `_outputs.${contextKey}`;
+						if (await asyncContext.has(outputKey)) input[key] = await asyncContext.get(outputKey);
+						else input[key] = await asyncContext.get(contextKey);
+					}
+				}
+				return input;
+			}
+		}
+		const inputKey = `_inputs.${nodeDef.id}`;
+		return await asyncContext.get(inputKey);
+	}
+};
+
+//#endregion
+//#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);
+				}
+			}
+			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);
+		}
+		workflowState.addCompletedNode(awaitingNodeId, resumeData.output);
+		const nextSteps = await this.determineNextNodes(blueprint, awaitingNodeId, resumeData, 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, resumeData, 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);
+	}
+	createForSubflow(subBlueprint, initialSubState, executionId, signal) {
+		return new ExecutionContext(subBlueprint, new WorkflowState(initialSubState), this.registry, executionId, this, {
+			logger: this.logger,
+			eventBus: this.eventBus,
+			serializer: this.serializer,
+			evaluator: this.evaluator,
+			middleware: this.middleware,
+			dependencies: this.dependencies
+		}, signal);
+	}
+	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("./replay-BB11M6K1.mjs").then((n) => n.n);
+		const replayOrchestrator = new ReplayOrchestrator(filteredEvents);
+		const traverser = new GraphTraverser(blueprint);
+		return await replayOrchestrator.run(executionContext, traverser);
+	}
+};
+
+//#endregion
+export { PersistentEventBusAdapter as A, DIContainer as C, generateMermaid as D, checkForCycles as E, generateMermaidForRun as O, UnsafeEvaluator as S, analyzeBlueprint as T, TrackedAsyncContext as _, sanitizeBlueprint as a, NullLogger as b, isNodeClass as c, executeBatch as d, processResults as f, Context as g, AsyncContextView as h, NodeExecutor as i, InMemoryEventStore as k, JsonSerializer as l, WorkflowState as m, ClassNodeExecutor as n, GraphTraverser as o, ExecutionContext as p, FunctionNodeExecutor as r, BaseNode as s, FlowRuntime as t, DefaultOrchestrator as u, FlowcraftError as v, ServiceTokens as w, PropertyEvaluator as x, ConsoleLogger as y };
+//# sourceMappingURL=runtime-CmefIAu_.mjs.map