@codemation/core 0.0.18 → 0.2.0

package/dist/bootstrap-DoQHAEQJ.cjs

@@ -0,0 +1,1203 @@
+const require_RunIntentService = require('./RunIntentService-DcxXf_AM.cjs');
+let tsyringe = require("tsyringe");
+tsyringe = require_RunIntentService.__toESM(tsyringe);
+
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.ts
+/**
+* Builds {@link EngineExecutionLimitsPolicy} by merging {@link ENGINE_EXECUTION_LIMITS_DEFAULTS} with optional `overrides` (e.g. host `runtime.engineExecutionLimits`).
+*/
+var EngineExecutionLimitsPolicyFactory = class {
+	create(overrides) {
+		return new require_RunIntentService.EngineExecutionLimitsPolicy({
+			...require_RunIntentService.ENGINE_EXECUTION_LIMITS_DEFAULTS,
+			...overrides
+		});
+	}
+};
+
+//#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/RunSummaryMapper.ts
+/** Maps persisted run state to API run summaries for listings. */
+var RunSummaryMapper = class {
+	static fromPersistedState(state) {
+		return {
+			runId: state.runId,
+			workflowId: state.workflowId,
+			startedAt: state.startedAt,
+			status: state.status,
+			finishedAt: require_RunIntentService.RunFinishedAtFactory.resolveIso(state),
+			parent: state.parent,
+			executionOptions: state.executionOptions
+		};
+	}
+};
+
+//#endregion
+//#region src/runStorage/InMemoryWorkflowExecutionRepository.ts
+var InMemoryWorkflowExecutionRepository = class {
+	runs = /* @__PURE__ */ new Map();
+	async createRun(args) {
+		this.runs.set(args.runId, {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			revision: 0,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			engineCounters: args.engineCounters,
+			status: "running",
+			queue: [],
+			outputsByNode: {},
+			nodeSnapshotsByNodeId: {},
+			connectionInvocations: []
+		});
+	}
+	async load(runId) {
+		return this.runs.get(runId);
+	}
+	async loadSchedulingState(runId) {
+		const state = this.runs.get(runId);
+		if (!state) return;
+		return {
+			pending: state.pending ? { ...state.pending } : void 0,
+			queue: state.queue.map((entry) => ({ ...entry }))
+		};
+	}
+	async save(state) {
+		this.runs.set(state.runId, {
+			...state,
+			revision: (state.revision ?? 0) + 1
+		});
+	}
+	async deleteRun(runId) {
+		this.runs.delete(runId);
+	}
+	async listRuns(args) {
+		const limit = args?.limit ?? 50;
+		return [...this.runs.values()].filter((s) => args?.workflowId ? s.workflowId === args.workflowId : true).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, limit).map((s) => RunSummaryMapper.fromPersistedState(s));
+	}
+	async listRunsOlderThan(args) {
+		const limit = args.limit ?? 100;
+		const out = [];
+		for (const s of this.runs.values()) {
+			if (s.status !== "completed" && s.status !== "failed") continue;
+			const finishedAt = require_RunIntentService.RunFinishedAtFactory.resolveIso(s);
+			if (!finishedAt || finishedAt >= args.beforeIso) continue;
+			out.push({
+				runId: s.runId,
+				workflowId: s.workflowId,
+				startedAt: s.startedAt,
+				finishedAt
+			});
+		}
+		out.sort((a, b) => a.finishedAt.localeCompare(b.finishedAt));
+		return out.slice(0, limit);
+	}
+};
+
+//#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) => node.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] = [];
+	}
+	enqueueEdge(queue, args) {
+		const target = this.nodeInstances.get(args.to.nodeId);
+		if (!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 = require_RunIntentService.WorkflowTopology.fromWorkflow(workflow);
+		const planner = new RunQueuePlanner(topology, this.workflowNodeInstanceFactory.createNodes(workflow));
+		planner.validateNodeKinds();
+		return {
+			topology,
+			planner
+		};
+	}
+	validateAcyclic(workflow) {
+		const classifier = require_RunIntentService.WorkflowExecutableNodeClassifierFactory.create(workflow);
+		const outgoing = /* @__PURE__ */ new Map();
+		const visitState = /* @__PURE__ */ new Map();
+		for (const node of workflow.nodes) if (classifier.isExecutableNodeId(node.id)) visitState.set(node.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 of workflow.nodes) if (classifier.isExecutableNodeId(node.id) && visitState.get(node.id) === "unvisited") this.depthFirstSearch(node.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$1) => node$1.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 = this.nodeResolver.resolve(definition.type);
+		if (!this.isTestableTriggerNode(node)) 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.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 = 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.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 of workflow.nodes) {
+			if (node.kind !== "trigger") continue;
+			await this.stopTrigger({
+				workflowId: workflow.id,
+				nodeId: node.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) {
+		return typeof node.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 require_RunIntentService.CredentialResolverFactory(deps.credentialSessions);
+		const nodeEventPublisher = new require_RunIntentService.NodeEventPublisher(deps.eventBus);
+		const nodeStatePublisherFactory = new require_RunIntentService.NodeRunStateWriterFactory(deps.workflowExecutionRepository, nodeEventPublisher);
+		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory);
+		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new require_RunIntentService.EngineExecutionLimitsPolicy();
+		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new require_RunIntentService.WorkflowSnapshotCodec(deps.tokenRegistry);
+		const missingRuntimeFallbacks = deps.missingRuntimeFallbacks ?? new require_RunIntentService.MissingRuntimeFallbacks();
+		const workflowSnapshotResolver = new require_RunIntentService.WorkflowSnapshotResolver(deps.workflowRepository, deps.tokenRegistry, workflowSnapshotCodec, missingRuntimeFallbacks);
+		const semantics = new require_RunIntentService.RunStateSemantics(new require_RunIntentService.MissingRuntimeExecutionMarker());
+		const activationEnqueueService = new require_RunIntentService.ActivationEnqueueService(deps.activationScheduler, deps.workflowExecutionRepository, nodeEventPublisher);
+		const runExecutionContextFactory = new require_RunIntentService.WorkflowRunExecutionContextFactory(deps.executionContextFactory, credentialResolverFactory);
+		const nodeActivationRequestComposer = new require_RunIntentService.NodeActivationRequestComposer(deps.activationIdFactory, credentialResolverFactory);
+		const persistedRunStateTerminalBuilder = new require_RunIntentService.PersistedRunStateTerminalBuilder();
+		const storagePolicyEvaluator = new WorkflowStoragePolicyEvaluator(deps.nodeResolver);
+		const terminalPersistence = new RunTerminalPersistenceCoordinator(deps.workflowExecutionRepository, storagePolicyEvaluator);
+		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
+		const runStartService = new require_RunIntentService.RunStartService(deps.runIdFactory, deps.workflowExecutionRepository, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
+		const runContinuationService = new require_RunIntentService.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 require_RunIntentService.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/RunIntentServiceFactory.ts
+var RunIntentServiceFactory = class {
+	create(engine, workflowRepository) {
+		return new require_RunIntentService.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
+//#region src/scheduler/InlineDrivingSchedulerFactory.ts
+var InlineDrivingSchedulerFactory = class {
+	create(nodeExecutor) {
+		return new require_RunIntentService.InlineDrivingScheduler(nodeExecutor);
+	}
+};
+
+//#endregion
+//#region src/bootstrap/runtime/EngineRuntimeRegistrar.ts
+/**
+* Container-first entry: call on a host/test container **after** workflow, run, node, and credential
+* ports are registered. The registrar owns the default inline scheduler, engine binding,
+* and intent-surface wiring so hosts only override the seams they actually replace.
+*/
+var EngineRuntimeRegistrar = class {
+	register(container, options) {
+		this.registerSupportFactories(container);
+		this.registerExecutionLimitsPolicy(container, options);
+		this.ensureWorkflowNodeInstanceFactory(container);
+		this.ensureNodeExecutor(container);
+		this.registerDefaultActivationScheduler(container);
+		this.registerEngine(container, options);
+		this.registerIntentServices(container);
+	}
+	registerSupportFactories(container) {
+		container.register(EngineExecutionLimitsPolicyFactory, { useClass: EngineExecutionLimitsPolicyFactory });
+		container.register(require_RunIntentService.NodeInstanceFactoryFactory, { useClass: require_RunIntentService.NodeInstanceFactoryFactory });
+		container.register(require_RunIntentService.DefaultAsyncSleeper, { useClass: require_RunIntentService.DefaultAsyncSleeper });
+		container.register(require_RunIntentService.InProcessRetryRunnerFactory, { useClass: require_RunIntentService.InProcessRetryRunnerFactory });
+		container.register(require_RunIntentService.NodeExecutorFactory, { useClass: require_RunIntentService.NodeExecutorFactory });
+		container.register(InlineDrivingSchedulerFactory, { useClass: InlineDrivingSchedulerFactory });
+		container.register(RunIntentServiceFactory, { useClass: RunIntentServiceFactory });
+		container.register(EngineWorkflowRunnerServiceFactory, { useClass: EngineWorkflowRunnerServiceFactory });
+		container.register(WorkflowRepositoryWebhookTriggerMatcherFactory, { useClass: WorkflowRepositoryWebhookTriggerMatcherFactory });
+	}
+	registerExecutionLimitsPolicy(container, options) {
+		if (container.isRegistered(require_RunIntentService.CoreTokens.EngineExecutionLimitsPolicy, true)) return;
+		container.register(require_RunIntentService.CoreTokens.EngineExecutionLimitsPolicy, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			const merged = options?.resolveEngineExecutionLimits?.() ?? options?.engineExecutionLimits;
+			return dependencyContainer.resolve(EngineExecutionLimitsPolicyFactory).create(merged);
+		}) });
+	}
+	ensureWorkflowNodeInstanceFactory(container) {
+		if (container.isRegistered(require_RunIntentService.CoreTokens.WorkflowNodeInstanceFactory, true)) return;
+		container.register(require_RunIntentService.CoreTokens.WorkflowNodeInstanceFactory, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			return dependencyContainer.resolve(require_RunIntentService.NodeInstanceFactoryFactory).create(dependencyContainer.resolve(require_RunIntentService.CoreTokens.NodeResolver));
+		}) });
+	}
+	ensureNodeExecutor(container) {
+		if (container.isRegistered(require_RunIntentService.NodeExecutor, true)) return;
+		container.register(require_RunIntentService.NodeExecutor, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			const retryRunner = dependencyContainer.resolve(require_RunIntentService.InProcessRetryRunnerFactory).create(dependencyContainer.resolve(require_RunIntentService.DefaultAsyncSleeper));
+			return dependencyContainer.resolve(require_RunIntentService.NodeExecutorFactory).create(dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowNodeInstanceFactory), retryRunner);
+		}) });
+	}
+	registerDefaultActivationScheduler(container) {
+		if (container.isRegistered(require_RunIntentService.CoreTokens.NodeActivationScheduler, true)) return;
+		container.register(require_RunIntentService.InlineDrivingScheduler, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			return dependencyContainer.resolve(InlineDrivingSchedulerFactory).create(dependencyContainer.resolve(require_RunIntentService.NodeExecutor));
+		}) });
+		container.register(require_RunIntentService.CoreTokens.NodeActivationScheduler, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			return dependencyContainer.resolve(require_RunIntentService.InlineDrivingScheduler);
+		}) });
+	}
+	registerEngine(container, options) {
+		container.register(EngineFactory, { useClass: EngineFactory });
+		const matcherProvider = this.resolveMatcherProvider(options);
+		container.register(Engine, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			const liveWorkflowRepository = dependencyContainer.resolve(require_RunIntentService.CoreTokens.LiveWorkflowRepository);
+			const nodeResolver = dependencyContainer.resolve(require_RunIntentService.CoreTokens.NodeResolver);
+			const tokenRegistryLike = dependencyContainer.resolve(require_RunIntentService.CoreTokens.PersistedWorkflowTokenRegistry);
+			const workflowActivationPolicy = dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowActivationPolicy);
+			const webhookTriggerMatcher = matcherProvider.createMatcher(dependencyContainer);
+			const workflowNodeInstanceFactory = dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowNodeInstanceFactory);
+			const triggerRuntimeDiagnostics = options?.triggerRuntimeDiagnosticsProvider?.create(dependencyContainer);
+			return dependencyContainer.resolve(EngineFactory).create({
+				credentialSessions: dependencyContainer.resolve(require_RunIntentService.CoreTokens.CredentialSessionService),
+				liveWorkflowRepository,
+				workflowRepository: dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowRepository),
+				workflowActivationPolicy,
+				nodeResolver,
+				triggerSetupStateRepository: dependencyContainer.resolve(require_RunIntentService.CoreTokens.TriggerSetupStateRepository),
+				webhookTriggerMatcher,
+				runIdFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.RunIdFactory),
+				activationIdFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.ActivationIdFactory),
+				workflowExecutionRepository: dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowExecutionRepository),
+				activationScheduler: dependencyContainer.resolve(require_RunIntentService.CoreTokens.NodeActivationScheduler),
+				runDataFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.RunDataFactory),
+				executionContextFactory: dependencyContainer.resolve(require_RunIntentService.CoreTokens.ExecutionContextFactory),
+				nodeExecutor: dependencyContainer.resolve(require_RunIntentService.NodeExecutor),
+				eventBus: dependencyContainer.resolve(require_RunIntentService.CoreTokens.RunEventBus),
+				tokenRegistry: tokenRegistryLike,
+				workflowNodeInstanceFactory,
+				executionLimitsPolicy: dependencyContainer.resolve(require_RunIntentService.CoreTokens.EngineExecutionLimitsPolicy),
+				triggerRuntimeDiagnostics
+			});
+		}) });
+	}
+	registerIntentServices(container) {
+		container.register(require_RunIntentService.RunIntentService, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			return dependencyContainer.resolve(RunIntentServiceFactory).create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowRepository));
+		}) });
+		container.register(require_RunIntentService.CoreTokens.WorkflowRunnerService, { useFactory: (0, tsyringe.instanceCachingFactory)((dependencyContainer) => {
+			return dependencyContainer.resolve(EngineWorkflowRunnerServiceFactory).create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(require_RunIntentService.CoreTokens.WorkflowRepository));
+		}) });
+	}
+	resolveMatcherProvider(options) {
+		if (options?.webhookTriggerMatcherProvider) return options.webhookTriggerMatcherProvider;
+		return { createMatcher: (container) => container.resolve(WorkflowRepositoryWebhookTriggerMatcherFactory).create(container.resolve(require_RunIntentService.CoreTokens.WorkflowRepository), container.resolve(require_RunIntentService.CoreTokens.WorkflowActivationPolicy), options?.webhookTriggerRoutingDiagnostics) };
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Engine', {
+  enumerable: true,
+  get: function () {
+    return Engine;
+  }
+});
+Object.defineProperty(exports, 'EngineExecutionLimitsPolicyFactory', {
+  enumerable: true,
+  get: function () {
+    return EngineExecutionLimitsPolicyFactory;
+  }
+});
+Object.defineProperty(exports, 'EngineFactory', {
+  enumerable: true,
+  get: function () {
+    return EngineFactory;
+  }
+});
+Object.defineProperty(exports, 'EngineRuntimeRegistrar', {
+  enumerable: true,
+  get: function () {
+    return EngineRuntimeRegistrar;
+  }
+});
+Object.defineProperty(exports, 'EngineWorkflowRunnerService', {
+  enumerable: true,
+  get: function () {
+    return EngineWorkflowRunnerService;
+  }
+});
+Object.defineProperty(exports, 'InMemoryWorkflowExecutionRepository', {
+  enumerable: true,
+  get: function () {
+    return InMemoryWorkflowExecutionRepository;
+  }
+});
+Object.defineProperty(exports, 'RunSummaryMapper', {
+  enumerable: true,
+  get: function () {
+    return RunSummaryMapper;
+  }
+});
+Object.defineProperty(exports, 'RunTerminalPersistenceCoordinator', {
+  enumerable: true,
+  get: function () {
+    return RunTerminalPersistenceCoordinator;
+  }
+});
+Object.defineProperty(exports, 'WorkflowPolicyErrorServices', {
+  enumerable: true,
+  get: function () {
+    return WorkflowPolicyErrorServices;
+  }
+});
+Object.defineProperty(exports, 'WorkflowRepositoryWebhookTriggerMatcher', {
+  enumerable: true,
+  get: function () {
+    return WorkflowRepositoryWebhookTriggerMatcher;
+  }
+});
+Object.defineProperty(exports, 'WorkflowStoragePolicyEvaluator', {
+  enumerable: true,
+  get: function () {
+    return WorkflowStoragePolicyEvaluator;
+  }
+});
+//# sourceMappingURL=bootstrap-DoQHAEQJ.cjs.map