@codemation/core 0.2.1 → 0.3.0

package/dist/{RunIntentService-BFA48UpH.js → runtime-Cy-3FTI_.js}

@@ -1,5 +1,6 @@
 import "reflect-metadata";
 import { container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { ZodError, z } from "zod";
 import { createHash } from "node:crypto";
 import { ReadableStream } from "node:stream/web";
 
@@ -487,10 +488,11 @@ var NodeInputsByPortFactory = class {
 //#endregion
 //#region src/execution/ActivationEnqueueService.ts
 var ActivationEnqueueService = class {
-	constructor(activationScheduler, workflowExecutionRepository, nodeEventPublisher) {
+	constructor(activationScheduler, workflowExecutionRepository, nodeEventPublisher, nodeActivationRequestInputPreparer) {
 		this.activationScheduler = activationScheduler;
 		this.workflowExecutionRepository = workflowExecutionRepository;
 		this.nodeEventPublisher = nodeEventPublisher;
+		this.nodeActivationRequestInputPreparer = nodeActivationRequestInputPreparer;
 	}
 	async enqueueActivation(args) {
 		const { result, queuedSnapshot } = await this.enqueueActivationWithSnapshot(args);
@@ -498,9 +500,10 @@ var ActivationEnqueueService = class {
 		return result;
 	}
 	async enqueueActivationWithSnapshot(args) {
-		const preparedDispatch = await this.activationScheduler.prepareDispatch(args.request);
-		const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
-		const itemsIn = args.request.kind === "multi" ? args.planner.sumItemsByPort(args.request.inputsByPort) : args.request.input.length;
+		const preparedRequest = await this.nodeActivationRequestInputPreparer.prepare(args.request);
+		const preparedDispatch = await this.activationScheduler.prepareDispatch(preparedRequest);
+		const inputsByPort = NodeInputsByPortFactory.fromRequest(preparedRequest);
+		const itemsIn = preparedRequest.kind === "multi" ? args.planner.sumItemsByPort(preparedRequest.inputsByPort) : preparedRequest.input.length;
 		const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const pending = {
 			runId: args.runId,
@@ -561,6 +564,75 @@ var ActivationEnqueueService = class {
 	}
 };
 
+//#endregion
+//#region src/execution/NodeInputContractError.ts
+var NodeInputContractError = class extends Error {
+	constructor(message, nodeId, activationId, cause) {
+		super(message);
+		this.nodeId = nodeId;
+		this.activationId = activationId;
+		this.cause = cause;
+		this.name = "NodeInputContractError";
+	}
+};
+
+//#endregion
+//#region src/execution/NodeActivationRequestInputPreparer.ts
+/**
+* Maps and validates per-item inputs for {@link ItemNode} before enqueue persistence.
+*/
+var NodeActivationRequestInputPreparer = class {
+	constructor(workflowNodeInstanceFactory) {
+		this.workflowNodeInstanceFactory = workflowNodeInstanceFactory;
+	}
+	async prepare(request) {
+		if (request.kind !== "single") return request;
+		const nodeInstance = this.workflowNodeInstanceFactory.createByType(request.ctx.config.type);
+		if (!this.hasExecuteOne(nodeInstance)) return request;
+		const inputSchema = this.resolveInputSchema(nodeInstance, request.ctx.config);
+		const config = request.ctx.config;
+		const mappedItems = [];
+		for (let i = 0; i < request.input.length; i++) {
+			const item = request.input[i];
+			try {
+				const mappedRaw = config.mapInput ? await Promise.resolve(config.mapInput({
+					item,
+					itemIndex: i,
+					items: request.input,
+					ctx: request.ctx
+				})) : item.json;
+				const parsed = inputSchema.parse(mappedRaw);
+				mappedItems.push({
+					...item,
+					json: parsed
+				});
+			} catch (cause) {
+				const message = this.formatContractFailure(cause);
+				throw new NodeInputContractError(`Node ${request.nodeId} activation ${request.activationId}: input contract failed: ${message}`, request.nodeId, request.activationId, cause);
+			}
+		}
+		return {
+			...request,
+			input: mappedItems
+		};
+	}
+	hasExecuteOne(nodeInstance) {
+		return typeof nodeInstance === "object" && nodeInstance !== null && typeof nodeInstance.executeOne === "function";
+	}
+	resolveInputSchema(nodeInstance, config) {
+		const fromInstance = nodeInstance.inputSchema;
+		if (fromInstance && typeof fromInstance.parse === "function") return fromInstance;
+		const fromConfig = config.inputSchema;
+		if (fromConfig && typeof fromConfig.parse === "function") return fromConfig;
+		return z.unknown();
+	}
+	formatContractFailure(cause) {
+		if (cause instanceof ZodError) return cause.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+		if (cause instanceof Error) return cause.message;
+		return String(cause);
+	}
+};
+
 //#endregion
 //#region src/execution/CredentialResolverFactory.ts
 var CredentialResolverFactory = class {
@@ -806,10 +878,32 @@ var NodeExecutor = class {
 		return await multiInputNode.executeMulti(request.inputsByPort, request.ctx);
 	}
 	async executeSingleInputNode(request, node$1) {
+		if (this.hasExecuteOne(node$1)) return await this.executeItemNode(request, node$1);
 		const singleInputNode = node$1;
 		if (typeof singleInputNode.execute !== "function") throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
 		return await singleInputNode.execute(request.input, request.ctx);
 	}
+	hasExecuteOne(node$1) {
+		return typeof node$1 === "object" && node$1 !== null && typeof node$1.executeOne === "function";
+	}
+	async executeItemNode(request, node$1) {
+		const out = [];
+		for (let i = 0; i < request.input.length; i++) {
+			const item = request.input[i];
+			const outputJson = await Promise.resolve(node$1.executeOne({
+				input: item.json,
+				item,
+				itemIndex: i,
+				items: request.input,
+				ctx: request.ctx
+			}));
+			out.push({
+				...item,
+				json: outputJson
+			});
+		}
+		return { main: out };
+	}
 };
 
 //#endregion
@@ -1624,15 +1718,15 @@ var RunContinuationService = class {
 				finalStatus: "completed",
 				finishedAt: completedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: state.runId,
 				workflowId: state.workflowId,
 				startedAt: state.startedAt,
 				status: "completed",
 				outputs: this.semantics.resolveResultOutputs(wf, state.control?.stopCondition, data.dump())
 			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		const batchId = pendingExecution.batchId ?? "batch_1";
 		const queue = (schedulingState?.queue ?? []).map((q) => ({
@@ -1691,15 +1785,15 @@ var RunContinuationService = class {
 				finalStatus: "completed",
 				finishedAt: completedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: state.runId,
 				workflowId: state.workflowId,
 				startedAt: state.startedAt,
 				status: "completed",
 				outputs
 			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		if (completedActivations >= maxNodeActivations) {
 			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
@@ -1720,15 +1814,15 @@ var RunContinuationService = class {
 				finalStatus: "failed",
 				finishedAt: completedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: state.runId,
 				workflowId: state.workflowId,
 				startedAt: state.startedAt,
 				status: "failed",
 				error: { message }
 			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		const def = topology.defsById.get(next.nodeId);
 		if (!def || def.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
@@ -1742,26 +1836,43 @@ var RunContinuationService = class {
 			executionOptions: state.executionOptions,
 			nodeDefinition: def
 		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			parent: state.parent,
-			executionOptions: state.executionOptions,
-			control: state.control,
-			workflowSnapshot: state.workflowSnapshot,
-			mutableState: state.mutableState,
-			policySnapshot: state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-			planner,
-			engineCounters,
-			connectionInvocations: state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		return result;
+		try {
+			const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+				runId: state.runId,
+				workflowId: state.workflowId,
+				startedAt: state.startedAt,
+				parent: state.parent,
+				executionOptions: state.executionOptions,
+				control: state.control,
+				workflowSnapshot: state.workflowSnapshot,
+				mutableState: state.mutableState,
+				policySnapshot: state.policySnapshot,
+				pendingQueue: queue,
+				request,
+				previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+				planner,
+				engineCounters,
+				connectionInvocations: state.connectionInvocations ?? []
+			});
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+			return result;
+		} catch (cause) {
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			return await this.terminateRunAfterActivationEnqueueRejected({
+				wf,
+				state,
+				queue,
+				nextNodeId: next.nodeId,
+				request,
+				completedSnapshot,
+				nextNodeSnapshotsByNodeId,
+				outputsByNode: data.dump(),
+				engineCounters,
+				error,
+				completedAt
+			});
+		}
 	}
 	async resumeFromNodeError(args) {
 		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(args.runId), this.workflowExecutionRepository.loadSchedulingState(args.runId)]);
@@ -1938,15 +2049,15 @@ var RunContinuationService = class {
 				runStatus: "completed",
 				response: args.signal.responseItems
 			});
-			const result$1 = {
+			const result = {
 				runId: args.state.runId,
 				workflowId: args.state.workflowId,
 				startedAt: args.state.startedAt,
 				status: "completed",
 				outputs: this.semantics.resolveResultOutputs(args.workflow, args.state.control?.stopCondition, data.dump())
 			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		if (args.signal.kind === "respondNow") {
 			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
@@ -1969,7 +2080,7 @@ var RunContinuationService = class {
 				finalStatus: "completed",
 				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: args.state.runId,
 				workflowId: args.state.workflowId,
 				startedAt: args.state.startedAt,
@@ -1983,8 +2094,8 @@ var RunContinuationService = class {
 				runStatus: "completed",
 				response: args.signal.responseItems
 			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		const batchId = args.pendingExecution.batchId ?? "batch_1";
 		const queue = (args.schedulingState?.queue ?? []).map((entry) => ({
@@ -2020,7 +2131,7 @@ var RunContinuationService = class {
 				finalStatus: "completed",
 				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: args.state.runId,
 				workflowId: args.state.workflowId,
 				startedAt: args.state.startedAt,
@@ -2034,8 +2145,8 @@ var RunContinuationService = class {
 				runStatus: "completed",
 				response: args.signal.responseItems
 			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		if (completedActivations >= maxNodeActivations) {
 			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
@@ -2059,7 +2170,7 @@ var RunContinuationService = class {
 				finalStatus: "failed",
 				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
-			const result$1 = {
+			const result = {
 				runId: args.state.runId,
 				workflowId: args.state.workflowId,
 				startedAt: args.state.startedAt,
@@ -2073,8 +2184,8 @@ var RunContinuationService = class {
 				runStatus: "pending",
 				response: args.signal.responseItems
 			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
+			this.waiters.resolveRunCompletion(result);
+			return result;
 		}
 		const nextDefinition = topology.defsById.get(next.nodeId);
 		if (!nextDefinition || nextDefinition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
@@ -2100,36 +2211,63 @@ var RunContinuationService = class {
 			executionOptions: args.state.executionOptions,
 			nodeDefinition: nextDefinition
 		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			parent: args.state.parent,
-			executionOptions: args.state.executionOptions,
-			control: args.state.control,
-			workflowSnapshot: args.state.workflowSnapshot,
-			mutableState: args.state.mutableState,
-			policySnapshot: args.state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: {
-				...args.state.nodeSnapshotsByNodeId ?? {},
-				[args.args.nodeId]: completedSnapshot
-			},
-			planner,
-			engineCounters,
-			connectionInvocations: args.state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		this.waiters.resolveWebhookResponse({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			runStatus: "pending",
-			response: args.signal.responseItems
-		});
-		return result;
+		const mergedSnapshots = {
+			...args.state.nodeSnapshotsByNodeId ?? {},
+			[args.args.nodeId]: completedSnapshot
+		};
+		try {
+			const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				parent: args.state.parent,
+				executionOptions: args.state.executionOptions,
+				control: args.state.control,
+				workflowSnapshot: args.state.workflowSnapshot,
+				mutableState: args.state.mutableState,
+				policySnapshot: args.state.policySnapshot,
+				pendingQueue: queue,
+				request,
+				previousNodeSnapshotsByNodeId: mergedSnapshots,
+				planner,
+				engineCounters,
+				connectionInvocations: args.state.connectionInvocations ?? []
+			});
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "pending",
+				response: args.signal.responseItems
+			});
+			return result;
+		} catch (cause) {
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
+			const result = await this.terminateRunAfterActivationEnqueueRejected({
+				wf: args.workflow,
+				state: args.state,
+				queue,
+				nextNodeId: next.nodeId,
+				request,
+				completedSnapshot,
+				nextNodeSnapshotsByNodeId: mergedSnapshots,
+				outputsByNode: data.dump(),
+				engineCounters,
+				error,
+				completedAt: finishedAt
+			});
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "pending",
+				response: args.signal.responseItems
+			});
+			return result;
+		}
 	}
 	asWebhookControlSignal(error) {
 		const candidate = error;
@@ -2187,6 +2325,66 @@ var RunContinuationService = class {
 			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fb.maxSubworkflowDepth
 		};
 	}
+	/**
+	* Next activation could not be enqueued (e.g. input contract / mapping failed in the preparer).
+	* Marks the target node failed and terminates the run.
+	*/
+	async terminateRunAfterActivationEnqueueRejected(args) {
+		const finishedAt = args.completedAt;
+		const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
+		const failedSnapshot = NodeExecutionSnapshotFactory.failed({
+			previous: void 0,
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			nodeId: args.nextNodeId,
+			activationId: args.request.activationId,
+			parent: args.state.parent,
+			finishedAt,
+			inputsByPort,
+			error: args.error
+		});
+		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+			state: args.state,
+			engineCounters: args.engineCounters,
+			status: "failed",
+			queue: args.queue.map((q) => ({ ...q })),
+			outputsByNode: args.outputsByNode,
+			nodeSnapshotsByNodeId: {
+				...args.nextNodeSnapshotsByNodeId,
+				[args.nextNodeId]: failedSnapshot
+			},
+			finishedAtIso: finishedAt
+		});
+		await this.workflowExecutionRepository.save(failedState);
+		await this.nodeEventPublisher.publish("nodeCompleted", args.completedSnapshot);
+		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
+		const wfErr = this.policyErrorServices.resolveWorkflowErrorHandler(args.wf.workflowErrorHandler);
+		if (wfErr) await Promise.resolve(wfErr.onError({
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			workflow: args.wf,
+			failedNodeId: args.nextNodeId,
+			error: args.error,
+			startedAt: args.state.startedAt,
+			finishedAt
+		}));
+		await this.terminalPersistence.maybeDeleteAfterTerminalState({
+			workflow: args.wf,
+			state: failedState,
+			finalStatus: "failed",
+			finishedAt
+		});
+		const message = args.error.message ?? String(args.error);
+		const result = {
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			startedAt: args.state.startedAt,
+			status: "failed",
+			error: { message }
+		};
+		this.waiters.resolveRunCompletion(result);
+		return result;
+	}
 	formatNodeLabel(args) {
 		const tokenName = typeof args.definition?.type === "function" ? args.definition.type.name : "Node";
 		return args.definition?.name ? `"${args.definition.name}" (${tokenName}:${args.nodeId})` : `${tokenName}:${args.nodeId}`;
@@ -2361,7 +2559,7 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
 		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
 			const received = {};
-			for (const input$1 of expectedInputs) received[input$1] = this.resolveInput(currentState, nodeId, input$1);
+			for (const input$2 of expectedInputs) received[input$2] = this.resolveInput(currentState, nodeId, input$2);
 			return [{
 				nodeId,
 				input: [],
@@ -2372,12 +2570,12 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 				}
 			}];
 		}
-		const input = expectedInputs[0] ?? "in";
-		const incomingEdge = incomingEdges.find((edge) => edge.input === input);
+		const input$1 = expectedInputs[0] ?? "in";
+		const incomingEdge = incomingEdges.find((edge) => edge.input === input$1);
 		return [{
 			nodeId,
-			input: this.resolveInput(currentState, nodeId, input),
-			toInput: input,
+			input: this.resolveInput(currentState, nodeId, input$1),
+			toInput: input$1,
 			batchId: "batch_1",
 			from: incomingEdge?.from
 		}];
@@ -2393,16 +2591,16 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	isNodeSatisfiedByOutputsOnly(currentState, nodeId) {
 		return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
 	}
-	isEdgeSatisfied(currentState, nodeId, input) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+	isEdgeSatisfied(currentState, nodeId, input$1) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input$1);
 		if (!incomingEdge) return false;
 		if (!this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output)) return false;
 		if (this.usesCollect(nodeId)) return true;
 		if (this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output).length > 0) return true;
 		return this.shouldContinueAfterEmptyOutputFromSource(incomingEdge.from.nodeId);
 	}
-	resolveInput(currentState, nodeId, input) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+	resolveInput(currentState, nodeId, input$1) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input$1);
 		if (!incomingEdge) return [];
 		return this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
 	}
@@ -2413,13 +2611,13 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		const snapshot = currentState.nodeSnapshotsByNodeId[nodeId];
 		return snapshot?.status === "completed" || snapshot?.status === "skipped";
 	}
-	hasOutputPort(currentState, nodeId, output) {
+	hasOutputPort(currentState, nodeId, output$1) {
 		const outputs = currentState.outputsByNode[nodeId];
 		if (!outputs) return false;
-		return Object.prototype.hasOwnProperty.call(outputs, output);
+		return Object.prototype.hasOwnProperty.call(outputs, output$1);
 	}
-	resolveOutputItems(currentState, nodeId, output) {
-		return currentState.outputsByNode[nodeId]?.[output] ?? [];
+	resolveOutputItems(currentState, nodeId, output$1) {
+		return currentState.outputsByNode[nodeId]?.[output$1] ?? [];
 	}
 	usesCollect(nodeId) {
 		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
@@ -3077,6 +3275,67 @@ var EngineExecutionLimitsPolicy = class {
 	}
 };
 
+//#endregion
+//#region src/policies/storage/RunTerminalPersistenceCoordinator.ts
+var RunTerminalPersistenceCoordinator = class {
+	constructor(runRepository, storageEvaluator) {
+		this.runRepository = runRepository;
+		this.storageEvaluator = storageEvaluator;
+	}
+	async maybeDeleteAfterTerminalState(args) {
+		if (await this.storageEvaluator.shouldPersist(args.workflow, args.state.policySnapshot, {
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			workflow: args.workflow,
+			finalStatus: args.finalStatus,
+			startedAt: args.state.startedAt,
+			finishedAt: args.finishedAt
+		})) return;
+		if (!this.runRepository.deleteRun) return;
+		await this.runRepository.deleteRun(args.state.runId);
+	}
+};
+
+//#endregion
+//#region src/policies/WorkflowPolicyErrorServices.ts
+var WorkflowPolicyErrorServices = class {
+	constructor(nodeResolver) {
+		this.nodeResolver = nodeResolver;
+	}
+	resolveNodeErrorHandler(spec) {
+		if (!spec) return void 0;
+		if (typeof spec === "object" && spec !== null && "handle" in spec && typeof spec.handle === "function") return spec;
+		return this.nodeResolver.resolve(spec);
+	}
+	resolveWorkflowErrorHandler(spec) {
+		if (!spec) return void 0;
+		if (typeof spec === "object" && spec !== null && "onError" in spec && typeof spec.onError === "function") return spec;
+		return this.nodeResolver.resolve(spec);
+	}
+};
+
+//#endregion
+//#region src/policies/storage/WorkflowStoragePolicyEvaluator.ts
+var WorkflowStoragePolicyEvaluator = class {
+	constructor(nodeResolver) {
+		this.nodeResolver = nodeResolver;
+	}
+	async shouldPersist(workflow, snapshot, args) {
+		const spec = workflow.storagePolicy;
+		if (spec === void 0) return this.modeMatches(snapshot?.storagePolicy ?? "ALL", args);
+		if (typeof spec === "string") return this.modeMatches(spec, args);
+		const resolver = this.nodeResolver.resolve(spec);
+		return Boolean(await resolver.shouldPersist(args));
+	}
+	modeMatches(mode, args) {
+		if (mode === "ALL") return true;
+		if (mode === "NEVER") return false;
+		if (mode === "SUCCESS") return args.finalStatus === "completed";
+		if (mode === "ERROR") return args.finalStatus === "failed";
+		return true;
+	}
+};
+
 //#endregion
 //#region src/runStorage/BinaryBodyBufferReader.ts
 var BinaryBodyBufferReader = class {
@@ -3191,11 +3450,11 @@ var InMemoryRunData = class {
 	getOutputs(nodeId) {
 		return this.byNode.get(nodeId);
 	}
-	getOutputItems(nodeId, output = "main") {
-		return this.byNode.get(nodeId)?.[output] ?? [];
+	getOutputItems(nodeId, output$1 = "main") {
+		return this.byNode.get(nodeId)?.[output$1] ?? [];
 	}
-	getOutputItem(nodeId, itemIndex, output = "main") {
-		return this.getOutputItems(nodeId, output)[itemIndex];
+	getOutputItem(nodeId, itemIndex, output$1 = "main") {
+		return this.getOutputItems(nodeId, output$1)[itemIndex];
 	}
 	dump() {
 		const out = {};
@@ -3225,6 +3484,775 @@ var RunFinishedAtFactory = class {
 	}
 };
 
+//#endregion
+//#region src/orchestration/NodeExecutionRequestHandlerService.ts
+var NodeExecutionRequestHandlerService = class {
+	constructor(workflowExecutionRepository, workflowSnapshotResolver, runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, nodeExecutor, continuation, executionLimitsPolicy) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.workflowSnapshotResolver = workflowSnapshotResolver;
+		this.runDataFactory = runDataFactory;
+		this.runExecutionContextFactory = runExecutionContextFactory;
+		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
+		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
+		this.nodeExecutor = nodeExecutor;
+		this.continuation = continuation;
+		this.executionLimitsPolicy = executionLimitsPolicy;
+	}
+	async handleNodeExecutionRequest(request) {
+		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(request.runId), this.workflowExecutionRepository.loadSchedulingState(request.runId)]);
+		if (!state) throw new Error(`Unknown runId: ${request.runId}`);
+		if (state.workflowId !== request.workflowId) throw new Error(`workflowId mismatch for run ${request.runId}: ${state.workflowId} vs ${request.workflowId}`);
+		const pendingExecution = schedulingState?.pending;
+		if (state.status !== "pending" || !pendingExecution) return;
+		if (pendingExecution.activationId !== request.activationId || pendingExecution.nodeId !== request.nodeId) return;
+		const workflow = this.resolvePersistedWorkflow(state);
+		if (!workflow) throw new Error(`Unknown workflowId: ${state.workflowId}`);
+		const definition = workflow.nodes.find((node$1) => node$1.id === request.nodeId);
+		if (!definition) throw new Error(`Unknown nodeId: ${request.nodeId}`);
+		if (definition.kind !== "node") throw new Error(`Node ${request.nodeId} is not runnable`);
+		const resolvedParent = request.parent ?? state.parent;
+		const data = this.runDataFactory.create(state.outputsByNode);
+		const limits = this.resolveEngineLimitsFromState(state);
+		const persistedInput = pendingExecution.inputsByPort.in ?? request.input;
+		const base = this.runExecutionContextFactory.create({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: request.nodeId,
+			parent: resolvedParent,
+			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: limits.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent)
+		});
+		const activationRequest = this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
+			activationId: request.activationId,
+			runId: request.runId,
+			workflowId: request.workflowId,
+			parent: resolvedParent,
+			executionOptions: request.executionOptions ?? state.executionOptions,
+			base,
+			data,
+			definition: {
+				id: definition.id,
+				config: definition.config
+			},
+			batchId: pendingExecution.batchId ?? "batch_1",
+			input: persistedInput
+		});
+		await this.continuation.markNodeRunning({
+			runId: activationRequest.runId,
+			activationId: activationRequest.activationId,
+			nodeId: activationRequest.nodeId,
+			inputsByPort: pendingExecution.inputsByPort
+		});
+		let outputs;
+		try {
+			outputs = await this.nodeExecutor.execute(activationRequest);
+		} catch (error) {
+			await this.resumeAfterExecutionError(activationRequest, this.asError(error));
+			return;
+		}
+		await this.resumeAfterExecutionResult(activationRequest, outputs ?? {});
+	}
+	resolvePersistedWorkflow(state) {
+		return this.workflowSnapshotResolver.resolve({
+			workflowId: state.workflowId,
+			workflowSnapshot: state.workflowSnapshot
+		});
+	}
+	resolveEngineLimitsFromState(state) {
+		const fallback = this.executionLimitsPolicy.createRootExecutionOptions();
+		return {
+			engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fallback.maxNodeActivations,
+			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fallback.maxSubworkflowDepth
+		};
+	}
+	async resumeAfterExecutionResult(request, outputs) {
+		try {
+			await this.continuation.resumeFromNodeResult({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				outputs
+			});
+		} catch (error) {
+			this.rethrowUnlessIgnorableContinuationError(error);
+		}
+	}
+	async resumeAfterExecutionError(request, error) {
+		try {
+			await this.continuation.resumeFromNodeError({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				error
+			});
+		} catch (continuationError) {
+			this.rethrowUnlessIgnorableContinuationError(continuationError);
+		}
+	}
+	asError(error) {
+		return error instanceof Error ? error : new Error(String(error));
+	}
+	rethrowUnlessIgnorableContinuationError(error) {
+		if (this.isIgnorableContinuationError(error)) return;
+		throw this.asError(error);
+	}
+	isIgnorableContinuationError(error) {
+		const message = this.asError(error).message;
+		return message.includes(" is not pending") || message.includes("activationId mismatch") || message.includes("nodeId mismatch");
+	}
+};
+
+//#endregion
+//#region src/planning/RunQueuePlanner.ts
+var RunQueuePlanner = class {
+	constructor(topology, nodeInstances) {
+		this.topology = topology;
+		this.nodeInstances = nodeInstances;
+	}
+	validateNodeKinds() {
+		for (const [toNodeId, inputs] of this.topology.expectedInputsByNode.entries()) {
+			if (inputs.length <= 1) {
+				const only = inputs[0];
+				if (only && only !== "in") {
+					const inst$1 = this.nodeInstances.get(toNodeId);
+					if (!this.isMultiInputNode(inst$1)) throw new Error(`Node ${toNodeId} only supports input 'in' (got '${only}').`);
+				}
+				continue;
+			}
+			const inst = this.nodeInstances.get(toNodeId);
+			if (!this.isMultiInputNode(inst)) throw new Error(`Node ${toNodeId} has ${inputs.length} inbound edges. Insert a Merge node to combine branches.`);
+		}
+	}
+	seedFromTrigger(args) {
+		const queue = [];
+		for (const e of this.topology.outgoingByNode.get(args.startNodeId) ?? []) {
+			if (e.output !== "main") continue;
+			this.enqueueEdge(queue, {
+				batchId: args.batchId,
+				to: e.to,
+				from: {
+					nodeId: args.startNodeId,
+					output: "main"
+				},
+				items: args.items
+			});
+		}
+		return queue;
+	}
+	applyOutputs(queue, args) {
+		for (const e of this.topology.outgoingByNode.get(args.fromNodeId) ?? []) {
+			const outItems = args.outputs[e.output] ?? [];
+			this.enqueueEdge(queue, {
+				batchId: args.batchId,
+				to: e.to,
+				from: {
+					nodeId: args.fromNodeId,
+					output: e.output
+				},
+				items: outItems
+			});
+		}
+	}
+	nextActivation(queue) {
+		const readyCollect = this.resolveReadyCollect(queue);
+		if (readyCollect) return readyCollect;
+		const jobIdx = queue.findIndex((q) => !q.collect);
+		if (jobIdx === -1) {
+			if (queue.length === 0) return null;
+			const sealedCollect = this.resolveSealedCollect(queue);
+			if (sealedCollect) return sealedCollect;
+			const stuck = queue[0];
+			throw new Error(this.describeUnsatisfiedCollect(stuck));
+		}
+		const job = queue.splice(jobIdx, 1)[0];
+		const def = this.topology.defsById.get(job.nodeId);
+		if (!def || def.kind !== "node") return this.nextActivation(queue);
+		return {
+			kind: "single",
+			nodeId: job.nodeId,
+			input: job.input,
+			batchId: job.batchId ?? "batch_1"
+		};
+	}
+	sumItemsByPort(inputsByPort) {
+		let n = 0;
+		for (const v of Object.values(inputsByPort)) n += v?.length ?? 0;
+		return n;
+	}
+	resolveReadyCollect(queue) {
+		for (let i = 0; i < queue.length; i++) {
+			const ready = this.tryDequeueCollect(queue, i);
+			if (ready) return ready;
+		}
+		return null;
+	}
+	resolveSealedCollect(queue) {
+		for (let i = 0; i < queue.length; i++) {
+			const queueEntry = queue[i];
+			if (!queueEntry.collect) continue;
+			const received = queueEntry.collect.received;
+			if (Object.keys(received).length === 0) continue;
+			this.fillMissingCollectInputs(queueEntry);
+			const ready = this.tryDequeueCollect(queue, i);
+			if (ready) return ready;
+		}
+		return null;
+	}
+	tryDequeueCollect(queue, index) {
+		const queueEntry = queue[index];
+		if (!queueEntry.collect) return null;
+		const batchId = queueEntry.batchId ?? "batch_1";
+		const expected = queueEntry.collect.expectedInputs ?? [];
+		const received = queueEntry.collect.received;
+		for (const input$1 of expected) if (!(input$1 in received)) return null;
+		queue.splice(index, 1);
+		return {
+			kind: "multi",
+			nodeId: queueEntry.nodeId,
+			inputsByPort: received,
+			batchId
+		};
+	}
+	fillMissingCollectInputs(queueEntry) {
+		if (!queueEntry.collect) return;
+		const received = queueEntry.collect.received;
+		for (const input$1 of queueEntry.collect.expectedInputs ?? []) if (!(input$1 in received)) received[input$1] = [];
+	}
+	/**
+	* Matches `CurrentStateFrontierPlanner.buildFrontierQueue`: anything that is not exactly one input
+	* port named `in` participates in multi-port collect (Merge after `If` branches, etc.). Routing must
+	* not depend solely on `nodeInstances.get(toNodeId)?.executeMulti`, or a Merge can be enqueued as a
+	* single-input job and `NodeExecutor` will call `execute` on a multi-input-only implementation.
+	*/
+	usesTopologyCollectMerge(toNodeId) {
+		const expectedInputs = this.topology.expectedInputsByNode.get(toNodeId) ?? [];
+		return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+	}
+	enqueueEdge(queue, args) {
+		const target = this.nodeInstances.get(args.to.nodeId);
+		if (!(this.usesTopologyCollectMerge(args.to.nodeId) || this.isMultiInputNode(target))) {
+			if (args.items.length === 0) {
+				if (this.shouldContinueAfterEmptyOutputFromSource(args.from.nodeId)) {
+					queue.push({
+						nodeId: args.to.nodeId,
+						input: args.items,
+						toInput: args.to.input,
+						batchId: args.batchId,
+						from: args.from
+					});
+					return;
+				}
+				this.propagateEmptyPath(queue, args.to.nodeId, args.batchId);
+				return;
+			}
+			queue.push({
+				nodeId: args.to.nodeId,
+				input: args.items,
+				toInput: args.to.input,
+				batchId: args.batchId,
+				from: args.from
+			});
+			return;
+		}
+		const expected = this.topology.expectedInputsByNode.get(args.to.nodeId) ?? [];
+		let collect = queue.find((q) => q.nodeId === args.to.nodeId && (q.batchId ?? "batch_1") === args.batchId && !!q.collect);
+		if (!collect) {
+			collect = {
+				nodeId: args.to.nodeId,
+				input: [],
+				batchId: args.batchId,
+				collect: {
+					expectedInputs: expected,
+					received: {}
+				}
+			};
+			queue.push(collect);
+		}
+		const received = collect.collect.received;
+		received[args.to.input] = args.items;
+	}
+	shouldContinueAfterEmptyOutputFromSource(fromNodeId) {
+		const def = this.topology.defsById.get(fromNodeId);
+		if (!def) return false;
+		return def.config.continueWhenEmptyOutput === true;
+	}
+	propagateEmptyPath(queue, nodeId, batchId) {
+		for (const edge of this.topology.outgoingByNode.get(nodeId) ?? []) this.enqueueEdge(queue, {
+			batchId,
+			to: edge.to,
+			from: {
+				nodeId,
+				output: edge.output
+			},
+			items: []
+		});
+	}
+	isMultiInputNode(n) {
+		return typeof n?.executeMulti === "function";
+	}
+	describeUnsatisfiedCollect(queueEntry) {
+		const batchId = queueEntry.batchId ?? "batch_1";
+		const expectedInputs = queueEntry.collect?.expectedInputs ?? [];
+		const receivedInputs = Object.keys(queueEntry.collect?.received ?? {});
+		const missingInputs = expectedInputs.filter((input$1) => !receivedInputs.includes(input$1));
+		const mergeNodeLabel = this.formatNodeLabel(queueEntry.nodeId);
+		const receivedSummary = this.describeReceivedInputs(queueEntry);
+		const missingSummary = this.describeMissingInputs(queueEntry.nodeId, missingInputs);
+		return [
+			`Multi-input collect is stuck at ${mergeNodeLabel} (batchId=${batchId}).`,
+			`Expected inputs: ${this.formatInputList(expectedInputs)}.`,
+			`Received inputs: ${receivedSummary}.`,
+			`Missing inputs: ${missingSummary}.`
+		].join(" ");
+	}
+	describeReceivedInputs(queueEntry) {
+		const received = queueEntry.collect?.received ?? {};
+		const receivedEntries = Object.entries(received);
+		if (receivedEntries.length === 0) return "none";
+		return receivedEntries.map(([input$1, items]) => `${input$1} (${items.length} item${items.length === 1 ? "" : "s"})`).join(", ");
+	}
+	describeMissingInputs(nodeId, missingInputs) {
+		if (missingInputs.length === 0) return "none";
+		return missingInputs.map((input$1) => {
+			const sources = this.findSources(nodeId, input$1);
+			if (sources.length === 0) return input$1;
+			return `${input$1} from ${sources.join(" or ")}`;
+		}).join(", ");
+	}
+	findSources(nodeId, input$1) {
+		const matches = [];
+		for (const [sourceNodeId, edges] of this.topology.outgoingByNode.entries()) for (const edge of edges) if (edge.to.nodeId === nodeId && edge.to.input === input$1) matches.push(this.formatNodeLabel(sourceNodeId));
+		return matches;
+	}
+	formatInputList(inputs) {
+		return inputs.length > 0 ? `[${inputs.join(", ")}]` : "[]";
+	}
+	formatNodeLabel(nodeId) {
+		const definition = this.topology.defsById.get(nodeId);
+		const instance = this.nodeInstances.get(nodeId);
+		const typeName = definition?.type && typeof definition.type === "function" ? definition.type.name : instance && typeof instance === "object" && "constructor" in instance ? instance.constructor.name ?? "Node" : "Node";
+		return definition?.name ? `"${definition.name}" (${typeName}:${nodeId})` : `${typeName}:${nodeId}`;
+	}
+};
+
+//#endregion
+//#region src/planning/EngineWorkflowPlanningFactory.ts
+var EngineWorkflowPlanningFactory = class {
+	constructor(workflowNodeInstanceFactory) {
+		this.workflowNodeInstanceFactory = workflowNodeInstanceFactory;
+	}
+	create(workflow) {
+		this.validateAcyclic(workflow);
+		const topology = WorkflowTopology.fromWorkflow(workflow);
+		const planner = new RunQueuePlanner(topology, this.workflowNodeInstanceFactory.createNodes(workflow));
+		planner.validateNodeKinds();
+		return {
+			topology,
+			planner
+		};
+	}
+	validateAcyclic(workflow) {
+		const classifier = WorkflowExecutableNodeClassifierFactory.create(workflow);
+		const outgoing = /* @__PURE__ */ new Map();
+		const visitState = /* @__PURE__ */ new Map();
+		for (const node$1 of workflow.nodes) if (classifier.isExecutableNodeId(node$1.id)) visitState.set(node$1.id, "unvisited");
+		for (const edge of workflow.edges) {
+			if (!classifier.isExecutableNodeId(edge.from.nodeId) || !classifier.isExecutableNodeId(edge.to.nodeId)) continue;
+			const destinations = outgoing.get(edge.from.nodeId) ?? [];
+			destinations.push(edge.to.nodeId);
+			outgoing.set(edge.from.nodeId, destinations);
+		}
+		for (const node$1 of workflow.nodes) if (classifier.isExecutableNodeId(node$1.id) && visitState.get(node$1.id) === "unvisited") this.depthFirstSearch(node$1.id, outgoing, visitState);
+	}
+	depthFirstSearch(nodeId, outgoing, visitState) {
+		visitState.set(nodeId, "visiting");
+		for (const toNodeId of outgoing.get(nodeId) ?? []) {
+			const state = visitState.get(toNodeId);
+			if (state === "visiting") throw new Error(`Workflow graph contains a directed cycle (edge ${nodeId} -> ${toNodeId}).`);
+			if (state === "unvisited") this.depthFirstSearch(toNodeId, outgoing, visitState);
+		}
+		visitState.set(nodeId, "done");
+	}
+};
+
+//#endregion
+//#region src/orchestration/TriggerRuntimeService.ts
+var TriggerRuntimeService = class {
+	credentialResolverFactory;
+	triggerCleanupHandlesByKey = /* @__PURE__ */ new Map();
+	constructor(workflowRepository, workflowActivationPolicy, runIdFactory, runDataFactory, executionContextFactory, credentialResolverFactory, nodeExecutionStatePublisherFactory, nodeResolver, triggerSetupStateRepository, emitHandler, executionLimitsPolicy, diagnostics) {
+		this.workflowRepository = workflowRepository;
+		this.workflowActivationPolicy = workflowActivationPolicy;
+		this.runIdFactory = runIdFactory;
+		this.runDataFactory = runDataFactory;
+		this.executionContextFactory = executionContextFactory;
+		this.nodeExecutionStatePublisherFactory = nodeExecutionStatePublisherFactory;
+		this.nodeResolver = nodeResolver;
+		this.triggerSetupStateRepository = triggerSetupStateRepository;
+		this.emitHandler = emitHandler;
+		this.executionLimitsPolicy = executionLimitsPolicy;
+		this.diagnostics = diagnostics;
+		this.credentialResolverFactory = credentialResolverFactory;
+	}
+	async startTriggers() {
+		for (const wf of this.workflowRepository.list()) {
+			if (!this.workflowActivationPolicy.isActive(wf.id)) {
+				const summaries = this.formatTriggerSummaries(wf);
+				if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}) is inactive; skipping trigger setup — ${summaries.join("; ")}.`);
+				continue;
+			}
+			await this.startTriggersForWorkflow(wf);
+		}
+	}
+	async syncWorkflowTriggersForActivation(workflowId) {
+		const wf = this.workflowRepository.get(workflowId);
+		if (!wf) return;
+		const summaries = this.formatTriggerSummaries(wf);
+		if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}): stopping triggers — ${summaries.join("; ")}.`);
+		await this.stopTriggersForWorkflow(wf);
+		if (this.workflowActivationPolicy.isActive(workflowId)) {
+			if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}): activation on; starting triggers — ${summaries.join("; ")}.`);
+			await this.startTriggersForWorkflow(wf);
+		} else this.logInfo(`Workflow "${wf.name}" (${wf.id}): activation off; triggers not started.`);
+	}
+	async stop() {
+		for (const workflow of this.workflowRepository.list()) await this.stopTriggersForWorkflow(workflow);
+	}
+	async createTriggerTestItems(args) {
+		const definition = args.workflow.nodes.find((node$2) => node$2.id === args.nodeId);
+		if (!definition) throw new Error(`Unknown trigger nodeId: ${args.nodeId}`);
+		if (definition.kind !== "trigger") throw new Error(`Node ${args.nodeId} is not a trigger`);
+		const node$1 = this.nodeResolver.resolve(definition.type);
+		if (!this.isTestableTriggerNode(node$1)) return;
+		const data = this.runDataFactory.create();
+		const runId = this.runIdFactory.makeRunId();
+		const trigger = {
+			workflowId: args.workflow.id,
+			nodeId: definition.id
+		};
+		const previousState = await this.triggerSetupStateRepository.load(trigger);
+		return await node$1.getTestItems({
+			...this.createExecutionContext({
+				runId,
+				workflowId: args.workflow.id,
+				nodeId: definition.id,
+				data
+			}),
+			trigger,
+			nodeId: definition.id,
+			config: definition.config,
+			previousState: previousState?.state
+		});
+	}
+	async startTriggersForWorkflow(wf) {
+		for (const def of wf.nodes) {
+			if (def.kind !== "trigger") continue;
+			const node$1 = this.nodeResolver.resolve(def.type);
+			const data = this.runDataFactory.create();
+			const triggerRunId = this.runIdFactory.makeRunId();
+			const trigger = {
+				workflowId: wf.id,
+				nodeId: def.id
+			};
+			await this.stopTrigger(trigger);
+			const previousState = await this.triggerSetupStateRepository.load(trigger);
+			let nextState;
+			try {
+				nextState = await node$1.setup({
+					...this.createExecutionContext({
+						runId: triggerRunId,
+						workflowId: wf.id,
+						nodeId: def.id,
+						data
+					}),
+					trigger,
+					config: def.config,
+					previousState: previousState?.state,
+					registerCleanup: (cleanup) => {
+						this.registerTriggerCleanupHandle(trigger, cleanup);
+					},
+					emit: async (items) => {
+						await this.emitHandler.emit(wf, def.id, items);
+					}
+				});
+			} catch (triggerError) {
+				await this.stopTrigger(trigger);
+				const message = triggerError instanceof Error ? triggerError.message : String(triggerError);
+				this.logWarn(`Skipping trigger setup for workflow ${wf.id} node ${def.id}: ${message}`);
+				continue;
+			}
+			if (nextState === void 0) await this.triggerSetupStateRepository.delete(trigger);
+			else await this.triggerSetupStateRepository.save({
+				trigger,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				state: nextState
+			});
+		}
+	}
+	async stopTriggersForWorkflow(workflow) {
+		for (const node$1 of workflow.nodes) {
+			if (node$1.kind !== "trigger") continue;
+			await this.stopTrigger({
+				workflowId: workflow.id,
+				nodeId: node$1.id
+			});
+		}
+	}
+	createExecutionContext(args) {
+		const nodeState = this.nodeExecutionStatePublisherFactory.create(args.runId, args.workflowId, void 0);
+		const rootLimits = this.executionLimitsPolicy.createRootExecutionOptions();
+		return this.executionContextFactory.create({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: void 0,
+			subworkflowDepth: rootLimits.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: rootLimits.maxNodeActivations,
+			engineMaxSubworkflowDepth: rootLimits.maxSubworkflowDepth,
+			data: args.data,
+			nodeState,
+			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId)
+		});
+	}
+	registerTriggerCleanupHandle(trigger, cleanup) {
+		const key = this.toTriggerKey(trigger);
+		const cleanups = this.triggerCleanupHandlesByKey.get(key) ?? [];
+		cleanups.push(cleanup);
+		this.triggerCleanupHandlesByKey.set(key, cleanups);
+	}
+	async stopTrigger(trigger) {
+		const key = this.toTriggerKey(trigger);
+		const cleanups = this.triggerCleanupHandlesByKey.get(key) ?? [];
+		this.triggerCleanupHandlesByKey.delete(key);
+		for (const cleanup of [...cleanups].reverse()) await cleanup.stop();
+	}
+	toTriggerKey(trigger) {
+		return `${trigger.workflowId}:${trigger.nodeId}`;
+	}
+	formatTriggerSummaries(wf) {
+		const out = [];
+		for (const def of wf.nodes) {
+			if (def.kind !== "trigger") continue;
+			out.push(this.describeTriggerNode(def));
+		}
+		return out;
+	}
+	describeTriggerNode(def) {
+		const label = def.name !== void 0 && def.name.trim().length > 0 ? def.name.trim() : String(def.id);
+		const cfg = def.config;
+		if (typeof cfg.endpointKey === "string" && cfg.endpointKey.trim().length > 0) return `${label} (webhook "${cfg.endpointKey.trim()}")`;
+		return label;
+	}
+	logInfo(message) {
+		if (this.diagnostics) this.diagnostics.info(message);
+	}
+	logWarn(message) {
+		if (this.diagnostics) this.diagnostics.warn(message);
+		else console.warn(`[engine] ${message}`);
+	}
+	isTestableTriggerNode(node$1) {
+		return typeof node$1.getTestItems === "function";
+	}
+};
+
+//#endregion
+//#region src/orchestration/EngineWaiters.ts
+var EngineWaiters = class {
+	completionWaiters = /* @__PURE__ */ new Map();
+	webhookResponseWaiters = /* @__PURE__ */ new Map();
+	waitForCompletion(runId) {
+		return new Promise((resolve) => {
+			const list = this.completionWaiters.get(runId) ?? [];
+			list.push(resolve);
+			this.completionWaiters.set(runId, list);
+		});
+	}
+	waitForWebhookResponse(runId) {
+		return new Promise((resolve) => {
+			const list = this.webhookResponseWaiters.get(runId) ?? [];
+			list.push(resolve);
+			this.webhookResponseWaiters.set(runId, list);
+		});
+	}
+	resolveRunCompletion(result) {
+		if (result.status !== "completed" && result.status !== "failed") return;
+		const list = this.completionWaiters.get(result.runId);
+		if (!list || list.length === 0) return;
+		this.completionWaiters.delete(result.runId);
+		for (const r of list) r(result);
+	}
+	resolveWebhookResponse(result) {
+		const list = this.webhookResponseWaiters.get(result.runId);
+		if (!list || list.length === 0) return;
+		this.webhookResponseWaiters.delete(result.runId);
+		for (const resolve of list) resolve(result);
+	}
+};
+
+//#endregion
+//#region src/orchestration/Engine.ts
+/**
+* Runtime facade for orchestration, continuation, triggers, and webhook routing.
+* Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
+* The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+*/
+var Engine = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	loadWorkflows(workflows) {
+		this.deps.tokenRegistry.registerFromWorkflows?.(workflows);
+		this.deps.liveWorkflowRepository.setWorkflows(workflows);
+		this.deps.webhookTriggerMatcher.onEngineWorkflowsLoaded?.();
+	}
+	getTokenRegistry() {
+		return this.deps.tokenRegistry;
+	}
+	resolveWorkflowSnapshot(args) {
+		return this.deps.workflowSnapshotResolver.resolve(args);
+	}
+	async startTriggers() {
+		return await this.deps.triggerRuntime.startTriggers();
+	}
+	async syncWorkflowTriggersForActivation(workflowId) {
+		await this.deps.triggerRuntime.syncWorkflowTriggersForActivation(workflowId);
+		this.deps.webhookTriggerMatcher.reloadWebhookRoutes?.();
+	}
+	async start(workflows) {
+		await this.stop();
+		this.loadWorkflows(workflows);
+		await this.startTriggers();
+	}
+	async stop() {
+		await this.deps.triggerRuntime.stop();
+		this.deps.webhookTriggerMatcher.onEngineStopped?.();
+	}
+	resolveWebhookTrigger(args) {
+		const entry = this.deps.webhookTriggerMatcher.lookup(args.endpointPath);
+		if (!entry) return { status: "notFound" };
+		if (!entry.methods.includes(args.method)) return {
+			status: "methodNotAllowed",
+			match: entry
+		};
+		return {
+			status: "ok",
+			match: entry
+		};
+	}
+	async createTriggerTestItems(args) {
+		return await this.deps.triggerRuntime.createTriggerTestItems(args);
+	}
+	async runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides) {
+		return await this.deps.runStartService.runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides);
+	}
+	async runWorkflowFromState(request) {
+		return await this.deps.runStartService.runWorkflowFromState(request);
+	}
+	async markNodeRunning(args) {
+		return await this.deps.runContinuationService.markNodeRunning(args);
+	}
+	async resumeFromNodeResult(args) {
+		return await this.deps.runContinuationService.resumeFromNodeResult(args);
+	}
+	async resumeFromNodeError(args) {
+		return await this.deps.runContinuationService.resumeFromNodeError(args);
+	}
+	async resumeFromStepResult(args) {
+		return await this.deps.runContinuationService.resumeFromStepResult(args);
+	}
+	async resumeFromStepError(args) {
+		return await this.deps.runContinuationService.resumeFromStepError(args);
+	}
+	async waitForCompletion(runId) {
+		return await this.deps.runContinuationService.waitForCompletion(runId);
+	}
+	async waitForWebhookResponse(runId) {
+		return await this.deps.runContinuationService.waitForWebhookResponse(runId);
+	}
+	async handleNodeExecutionRequest(request) {
+		await this.deps.nodeExecutionRequestHandler.handleNodeExecutionRequest(request);
+	}
+};
+
+//#endregion
+//#region src/runtime/EngineFactory.ts
+/**
+* Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
+* {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
+* Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
+*/
+var EngineFactory = class {
+	create(deps) {
+		const waiters = new EngineWaiters();
+		const credentialResolverFactory = new CredentialResolverFactory(deps.credentialSessions);
+		const nodeEventPublisher = new NodeEventPublisher(deps.eventBus);
+		const nodeStatePublisherFactory = new NodeRunStateWriterFactory(deps.workflowExecutionRepository, nodeEventPublisher);
+		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory);
+		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new EngineExecutionLimitsPolicy();
+		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new WorkflowSnapshotCodec(deps.tokenRegistry);
+		const missingRuntimeFallbacks = deps.missingRuntimeFallbacks ?? new MissingRuntimeFallbacks();
+		const workflowSnapshotResolver = new WorkflowSnapshotResolver(deps.workflowRepository, deps.tokenRegistry, workflowSnapshotCodec, missingRuntimeFallbacks);
+		const semantics = new RunStateSemantics(new MissingRuntimeExecutionMarker());
+		const nodeActivationRequestInputPreparer = new NodeActivationRequestInputPreparer(deps.workflowNodeInstanceFactory);
+		const activationEnqueueService = new ActivationEnqueueService(deps.activationScheduler, deps.workflowExecutionRepository, nodeEventPublisher, nodeActivationRequestInputPreparer);
+		const runExecutionContextFactory = new WorkflowRunExecutionContextFactory(deps.executionContextFactory, credentialResolverFactory);
+		const nodeActivationRequestComposer = new NodeActivationRequestComposer(deps.activationIdFactory, credentialResolverFactory);
+		const persistedRunStateTerminalBuilder = new PersistedRunStateTerminalBuilder();
+		const storagePolicyEvaluator = new WorkflowStoragePolicyEvaluator(deps.nodeResolver);
+		const terminalPersistence = new RunTerminalPersistenceCoordinator(deps.workflowExecutionRepository, storagePolicyEvaluator);
+		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
+		const runStartService = new RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
+		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
+		const nodeExecutionRequestHandler = new NodeExecutionRequestHandlerService(deps.workflowExecutionRepository, workflowSnapshotResolver, deps.runDataFactory, runExecutionContextFactory, nodeStatePublisherFactory, nodeActivationRequestComposer, deps.nodeExecutor, runContinuationService, executionLimitsPolicy);
+		const triggerRuntime = new TriggerRuntimeService(deps.workflowRepository, deps.workflowActivationPolicy, deps.runIdFactory, deps.runDataFactory, deps.executionContextFactory, credentialResolverFactory, nodeStatePublisherFactory, deps.nodeResolver, deps.triggerSetupStateRepository, { emit: async (workflow, triggerNodeId, items) => {
+			await runStartService.runWorkflow(workflow, triggerNodeId, items, void 0);
+		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics);
+		const engine = new Engine({
+			liveWorkflowRepository: deps.liveWorkflowRepository,
+			tokenRegistry: deps.tokenRegistry,
+			webhookTriggerMatcher: deps.webhookTriggerMatcher,
+			workflowSnapshotResolver,
+			triggerRuntime,
+			runStartService,
+			runContinuationService,
+			nodeExecutionRequestHandler
+		});
+		deps.activationScheduler.setContinuation?.(engine);
+		return engine;
+	}
+};
+
+//#endregion
+//#region src/runtime/EngineWorkflowRunnerService.ts
+var EngineWorkflowRunnerService = class {
+	constructor(engine, workflowRepository) {
+		this.engine = engine;
+		this.workflowRepository = workflowRepository;
+	}
+	async runById(args) {
+		const { workflowId, startAt, items, parent } = args;
+		const wf = this.workflowRepository.get(workflowId);
+		if (!wf) throw new Error(`Unknown workflowId: ${workflowId}`);
+		const startNodeId = startAt ?? this.findDefaultStartNodeId(wf);
+		const scheduled = await this.engine.runWorkflow(wf, startNodeId, items, parent);
+		if (scheduled.status !== "pending") return scheduled;
+		return await this.engine.waitForCompletion(scheduled.runId);
+	}
+	findDefaultStartNodeId(wf) {
+		return WorkflowExecutableNodeClassifierFactory.create(wf).findDefaultExecutableStartNodeId(wf);
+	}
+};
+
+//#endregion
+//#region src/runtime/EngineWorkflowRunnerServiceFactory.ts
+var EngineWorkflowRunnerServiceFactory = class {
+	create(engine, workflowRepository) {
+		return new EngineWorkflowRunnerService(engine, workflowRepository);
+	}
+};
+
 //#endregion
 //#region src/runtime/InMemoryLiveWorkflowRepository.ts
 var InMemoryLiveWorkflowRepository = class {
@@ -3369,5 +4397,107 @@ var RunIntentService = class {
 };
 
 //#endregion
-export { delay as $, NodeExecutor as A, NodeEventPublisher as B, WorkflowSnapshotResolver as C, MissingRuntimeTriggerToken as D, MissingRuntimeFallbacks as E, DefaultAsyncSleeper as F, getPersistedRuntimeTypeMetadata as G, WorkflowExecutableNodeClassifier as H, CredentialResolverFactory as I, InjectableRuntimeDecoratorComposer as J, node as K, ActivationEnqueueService as L, InProcessRetryRunnerFactory as M, InProcessRetryRunner as N, MissingRuntimeExecutionMarker as O, DefaultExecutionContextFactory as P, container$1 as Q, DefaultExecutionBinaryService as R, NodeInstanceFactory as S, PersistedWorkflowTokenRegistry as T, ConnectionNodeIdFactory as U, WorkflowExecutableNodeClassifierFactory as V, chatModel as W, StackTraceCallSitePathResolver as X, PersistedRuntimeTypeMetadataStore as Y, PersistedRuntimeTypeNameResolver as Z, WorkflowRunExecutionContextFactory as _, InMemoryBinaryStorage as a, predicateAwareClassFactory as at, NodeRunStateWriterFactory as b, LocalOnlyScheduler as c, CoreTokens as ct, DefaultDrivingScheduler as d, inject as et, ConfigDrivenOffloadPolicy as f, WorkflowTopology as g, RunContinuationService as h, InMemoryRunDataFactory as i, instancePerContainerCachingFactory as it, NodeActivationRequestComposer as j, NodeExecutorFactory as k, InlineDrivingScheduler as l, RunPolicySnapshotFactory as m, InMemoryLiveWorkflowRepository as n, injectable as nt, ENGINE_EXECUTION_LIMITS_DEFAULTS as o, registry as ot, RunStartService as p, tool as q, RunFinishedAtFactory as r, instanceCachingFactory as rt, EngineExecutionLimitsPolicy as s, singleton as st, RunIntentService as t, injectAll as tt, HintOnlyOffloadPolicy as u, RunStateSemantics as v, WorkflowSnapshotCodec as w, NodeInstanceFactoryFactory as x, PersistedRunStateTerminalBuilder as y, UnavailableBinaryStorage as z };
-//# sourceMappingURL=RunIntentService-BFA48UpH.js.map
+//#region src/runtime/RunIntentServiceFactory.ts
+var RunIntentServiceFactory = class {
+	create(engine, workflowRepository) {
+		return new RunIntentService(engine, workflowRepository);
+	}
+};
+
+//#endregion
+//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.ts
+/**
+* Resolves webhook HTTP routes from the live workflow repository (no trigger setup / registration).
+* Maintains an in-memory index keyed by user-defined endpoint path for O(1) lookups after reload.
+*/
+var WorkflowRepositoryWebhookTriggerMatcher = class {
+	routeByPath = /* @__PURE__ */ new Map();
+	engineRoutesActive = false;
+	constructor(workflowRepository, workflowActivationPolicy, diagnostics) {
+		this.workflowRepository = workflowRepository;
+		this.workflowActivationPolicy = workflowActivationPolicy;
+		this.diagnostics = diagnostics;
+	}
+	onEngineWorkflowsLoaded() {
+		this.engineRoutesActive = true;
+		this.rebuildRouteIndex();
+	}
+	onEngineStopped() {
+		this.engineRoutesActive = false;
+		this.routeByPath.clear();
+	}
+	reloadWebhookRoutes() {
+		if (!this.engineRoutesActive) return;
+		this.rebuildRouteIndex();
+	}
+	lookup(endpointPath) {
+		if (!this.engineRoutesActive) return;
+		const normalized = this.normalizeEndpointPath(endpointPath);
+		return this.routeByPath.get(normalized);
+	}
+	match(args) {
+		const entry = this.lookup(args.endpointPath);
+		if (!entry) return;
+		return entry.methods.includes(args.method) ? entry : void 0;
+	}
+	rebuildRouteIndex() {
+		this.routeByPath.clear();
+		for (const workflow of this.workflowRepository.list()) {
+			if (!this.workflowActivationPolicy.isActive(workflow.id)) {
+				if (workflow.nodes.filter((n) => n.kind === "trigger").length > 0) {
+					const paths = this.collectWebhookEndpointPaths(workflow);
+					if (paths.length > 0) this.diagnostics?.info?.(`Workflow "${workflow.name}" (${workflow.id}) is inactive; webhook routes not registered: ${paths.map((p) => `"${p}"`).join(", ")}`);
+					else this.diagnostics?.info?.(`Workflow "${workflow.name}" (${workflow.id}) is inactive; no repository webhook routes for its triggers (other trigger kinds are unchanged).`);
+				}
+				continue;
+			}
+			for (const def of workflow.nodes) {
+				const match = this.tryMatchFromTriggerNode(workflow, def);
+				if (!match) continue;
+				const key = this.normalizeEndpointPath(match.endpointPath);
+				const existing = this.routeByPath.get(key);
+				if (existing) this.diagnostics?.warn(`Duplicate webhook endpoint path "${key}" (workflows "${existing.workflowId}" and "${match.workflowId}"); using "${match.workflowId}".`);
+				this.routeByPath.set(key, match);
+			}
+		}
+	}
+	collectWebhookEndpointPaths(workflow) {
+		const paths = [];
+		for (const def of workflow.nodes) {
+			if (def.kind !== "trigger") continue;
+			const match = this.tryMatchFromTriggerNode(workflow, def);
+			if (match) paths.push(match.endpointPath);
+		}
+		return paths;
+	}
+	tryMatchFromTriggerNode(workflow, def) {
+		if (def.kind !== "trigger") return;
+		const config = def.config;
+		if (typeof config.endpointKey !== "string" || config.endpointKey.length === 0) return;
+		if (!Array.isArray(config.methods) || config.methods.length === 0) return;
+		const methods = config.methods;
+		const parseJsonBody = typeof config.parseJsonBody === "function" ? config.parseJsonBody.bind(config) : void 0;
+		return {
+			endpointPath: config.endpointKey,
+			workflowId: workflow.id,
+			nodeId: def.id,
+			methods: [...methods],
+			parseJsonBody
+		};
+	}
+	normalizeEndpointPath(endpointPath) {
+		return endpointPath.trim();
+	}
+};
+
+//#endregion
+//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcherFactory.ts
+var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
+	create(workflowRepository, workflowActivationPolicy, diagnostics) {
+		return new WorkflowRepositoryWebhookTriggerMatcher(workflowRepository, workflowActivationPolicy, diagnostics);
+	}
+};
+
+//#endregion
+export { injectAll as $, NodeExecutor as A, WorkflowExecutableNodeClassifier as B, RunPolicySnapshotFactory as C, PersistedWorkflowTokenRegistry as D, WorkflowSnapshotCodec as E, CredentialResolverFactory as F, tool as G, chatModel as H, DefaultExecutionBinaryService as I, StackTraceCallSitePathResolver as J, InjectableRuntimeDecoratorComposer as K, UnavailableBinaryStorage as L, InProcessRetryRunner as M, DefaultExecutionContextFactory as N, MissingRuntimeTriggerToken as O, DefaultAsyncSleeper as P, inject as Q, NodeEventPublisher as R, ConfigDrivenOffloadPolicy as S, NodeInstanceFactory as T, getPersistedRuntimeTypeMetadata as U, ConnectionNodeIdFactory as V, node as W, container$1 as X, PersistedRuntimeTypeNameResolver as Y, delay as Z, EngineExecutionLimitsPolicy as _, InMemoryLiveWorkflowRepository as a, singleton as at, HintOnlyOffloadPolicy as b, EngineFactory as c, InMemoryRunDataFactory as d, injectable as et, InMemoryBinaryStorage as f, ENGINE_EXECUTION_LIMITS_DEFAULTS as g, RunTerminalPersistenceCoordinator as h, RunIntentService as i, registry as it, InProcessRetryRunnerFactory as j, NodeExecutorFactory as k, Engine as l, WorkflowPolicyErrorServices as m, WorkflowRepositoryWebhookTriggerMatcher as n, instancePerContainerCachingFactory as nt, EngineWorkflowRunnerServiceFactory as o, CoreTokens as ot, WorkflowStoragePolicyEvaluator as p, PersistedRuntimeTypeMetadataStore as q, RunIntentServiceFactory as r, predicateAwareClassFactory as rt, EngineWorkflowRunnerService as s, WorkflowRepositoryWebhookTriggerMatcherFactory as t, instanceCachingFactory as tt, RunFinishedAtFactory as u, LocalOnlyScheduler as v, NodeInstanceFactoryFactory as w, DefaultDrivingScheduler as x, InlineDrivingScheduler as y, WorkflowExecutableNodeClassifierFactory as z };
+//# sourceMappingURL=runtime-Cy-3FTI_.js.map