@codemation/core 0.2.1 → 0.3.0

package/dist/{RunIntentService-DcxXf_AM.cjs → runtime-ZJUpWmPH.cjs}

@@ -24,6 +24,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 require("reflect-metadata");
 let tsyringe = require("tsyringe");
 tsyringe = __toESM(tsyringe);
+let zod = require("zod");
+zod = __toESM(zod);
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(node_crypto);
 let node_stream_web = require("node:stream/web");
@@ -513,10 +515,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);
@@ -524,9 +527,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,
@@ -587,6 +591,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 zod.z.unknown();
+	}
+	formatContractFailure(cause) {
+		if (cause instanceof zod.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 {
@@ -832,10 +905,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
@@ -1650,15 +1745,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) => ({
@@ -1717,15 +1812,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}).`;
@@ -1746,15 +1841,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`);
@@ -1768,26 +1863,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)]);
@@ -1964,15 +2076,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({
@@ -1995,7 +2107,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,
@@ -2009,8 +2121,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) => ({
@@ -2046,7 +2158,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,
@@ -2060,8 +2172,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}).`;
@@ -2085,7 +2197,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,
@@ -2099,8 +2211,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`);
@@ -2126,36 +2238,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;
@@ -2213,6 +2352,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}`;
@@ -3103,6 +3302,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 {
@@ -3251,6 +3511,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 of expected) if (!(input 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 of queueEntry.collect.expectedInputs ?? []) if (!(input in received)) received[input] = [];
+	}
+	/**
+	* 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) => !receivedInputs.includes(input));
+		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, items]) => `${input} (${items.length} item${items.length === 1 ? "" : "s"})`).join(", ");
+	}
+	describeMissingInputs(nodeId, missingInputs) {
+		if (missingInputs.length === 0) return "none";
+		return missingInputs.map((input) => {
+			const sources = this.findSources(nodeId, input);
+			if (sources.length === 0) return input;
+			return `${input} from ${sources.join(" or ")}`;
+		}).join(", ");
+	}
+	findSources(nodeId, input) {
+		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) 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 {
@@ -3395,12 +4424,108 @@ var RunIntentService = class {
 };
 
 //#endregion
-Object.defineProperty(exports, 'ActivationEnqueueService', {
-  enumerable: true,
-  get: function () {
-    return ActivationEnqueueService;
-  }
-});
+//#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
 Object.defineProperty(exports, 'ConfigDrivenOffloadPolicy', {
   enumerable: true,
   get: function () {
@@ -3455,12 +4580,36 @@ Object.defineProperty(exports, 'ENGINE_EXECUTION_LIMITS_DEFAULTS', {
     return ENGINE_EXECUTION_LIMITS_DEFAULTS;
   }
 });
+Object.defineProperty(exports, 'Engine', {
+  enumerable: true,
+  get: function () {
+    return Engine;
+  }
+});
 Object.defineProperty(exports, 'EngineExecutionLimitsPolicy', {
   enumerable: true,
   get: function () {
     return EngineExecutionLimitsPolicy;
   }
 });
+Object.defineProperty(exports, 'EngineFactory', {
+  enumerable: true,
+  get: function () {
+    return EngineFactory;
+  }
+});
+Object.defineProperty(exports, 'EngineWorkflowRunnerService', {
+  enumerable: true,
+  get: function () {
+    return EngineWorkflowRunnerService;
+  }
+});
+Object.defineProperty(exports, 'EngineWorkflowRunnerServiceFactory', {
+  enumerable: true,
+  get: function () {
+    return EngineWorkflowRunnerServiceFactory;
+  }
+});
 Object.defineProperty(exports, 'HintOnlyOffloadPolicy', {
   enumerable: true,
   get: function () {
@@ -3515,30 +4664,12 @@ Object.defineProperty(exports, 'LocalOnlyScheduler', {
     return LocalOnlyScheduler;
   }
 });
-Object.defineProperty(exports, 'MissingRuntimeExecutionMarker', {
-  enumerable: true,
-  get: function () {
-    return MissingRuntimeExecutionMarker;
-  }
-});
-Object.defineProperty(exports, 'MissingRuntimeFallbacks', {
-  enumerable: true,
-  get: function () {
-    return MissingRuntimeFallbacks;
-  }
-});
 Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
   enumerable: true,
   get: function () {
     return MissingRuntimeTriggerToken;
   }
 });
-Object.defineProperty(exports, 'NodeActivationRequestComposer', {
-  enumerable: true,
-  get: function () {
-    return NodeActivationRequestComposer;
-  }
-});
 Object.defineProperty(exports, 'NodeEventPublisher', {
   enumerable: true,
   get: function () {
@@ -3569,18 +4700,6 @@ Object.defineProperty(exports, 'NodeInstanceFactoryFactory', {
     return NodeInstanceFactoryFactory;
   }
 });
-Object.defineProperty(exports, 'NodeRunStateWriterFactory', {
-  enumerable: true,
-  get: function () {
-    return NodeRunStateWriterFactory;
-  }
-});
-Object.defineProperty(exports, 'PersistedRunStateTerminalBuilder', {
-  enumerable: true,
-  get: function () {
-    return PersistedRunStateTerminalBuilder;
-  }
-});
 Object.defineProperty(exports, 'PersistedRuntimeTypeMetadataStore', {
   enumerable: true,
   get: function () {
@@ -3599,12 +4718,6 @@ Object.defineProperty(exports, 'PersistedWorkflowTokenRegistry', {
     return PersistedWorkflowTokenRegistry;
   }
 });
-Object.defineProperty(exports, 'RunContinuationService', {
-  enumerable: true,
-  get: function () {
-    return RunContinuationService;
-  }
-});
 Object.defineProperty(exports, 'RunFinishedAtFactory', {
   enumerable: true,
   get: function () {
@@ -3617,22 +4730,22 @@ Object.defineProperty(exports, 'RunIntentService', {
     return RunIntentService;
   }
 });
-Object.defineProperty(exports, 'RunPolicySnapshotFactory', {
+Object.defineProperty(exports, 'RunIntentServiceFactory', {
   enumerable: true,
   get: function () {
-    return RunPolicySnapshotFactory;
+    return RunIntentServiceFactory;
   }
 });
-Object.defineProperty(exports, 'RunStartService', {
+Object.defineProperty(exports, 'RunPolicySnapshotFactory', {
   enumerable: true,
   get: function () {
-    return RunStartService;
+    return RunPolicySnapshotFactory;
   }
 });
-Object.defineProperty(exports, 'RunStateSemantics', {
+Object.defineProperty(exports, 'RunTerminalPersistenceCoordinator', {
   enumerable: true,
   get: function () {
-    return RunStateSemantics;
+    return RunTerminalPersistenceCoordinator;
   }
 });
 Object.defineProperty(exports, 'StackTraceCallSitePathResolver', {
@@ -3659,28 +4772,34 @@ Object.defineProperty(exports, 'WorkflowExecutableNodeClassifierFactory', {
     return WorkflowExecutableNodeClassifierFactory;
   }
 });
-Object.defineProperty(exports, 'WorkflowRunExecutionContextFactory', {
+Object.defineProperty(exports, 'WorkflowPolicyErrorServices', {
   enumerable: true,
   get: function () {
-    return WorkflowRunExecutionContextFactory;
+    return WorkflowPolicyErrorServices;
   }
 });
-Object.defineProperty(exports, 'WorkflowSnapshotCodec', {
+Object.defineProperty(exports, 'WorkflowRepositoryWebhookTriggerMatcher', {
   enumerable: true,
   get: function () {
-    return WorkflowSnapshotCodec;
+    return WorkflowRepositoryWebhookTriggerMatcher;
   }
 });
-Object.defineProperty(exports, 'WorkflowSnapshotResolver', {
+Object.defineProperty(exports, 'WorkflowRepositoryWebhookTriggerMatcherFactory', {
   enumerable: true,
   get: function () {
-    return WorkflowSnapshotResolver;
+    return WorkflowRepositoryWebhookTriggerMatcherFactory;
+  }
+});
+Object.defineProperty(exports, 'WorkflowSnapshotCodec', {
+  enumerable: true,
+  get: function () {
+    return WorkflowSnapshotCodec;
   }
 });
-Object.defineProperty(exports, 'WorkflowTopology', {
+Object.defineProperty(exports, 'WorkflowStoragePolicyEvaluator', {
   enumerable: true,
   get: function () {
-    return WorkflowTopology;
+    return WorkflowStoragePolicyEvaluator;
   }
 });
 Object.defineProperty(exports, '__toESM', {
@@ -3713,4 +4832,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=RunIntentService-DcxXf_AM.cjs.map
+//# sourceMappingURL=runtime-ZJUpWmPH.cjs.map