@codemation/core 0.0.19 → 0.2.1

package/dist/bootstrap-D67Sf2BF.js

@@ -0,0 +1,1136 @@
+import { A as NodeExecutor, B as NodeEventPublisher, C as WorkflowSnapshotResolver, E as MissingRuntimeFallbacks, F as DefaultAsyncSleeper, I as CredentialResolverFactory, L as ActivationEnqueueService, M as InProcessRetryRunnerFactory, O as MissingRuntimeExecutionMarker, V as WorkflowExecutableNodeClassifierFactory, _ as WorkflowRunExecutionContextFactory, b as NodeRunStateWriterFactory, ct as CoreTokens, g as WorkflowTopology, h as RunContinuationService, j as NodeActivationRequestComposer, k as NodeExecutorFactory, l as InlineDrivingScheduler, o as ENGINE_EXECUTION_LIMITS_DEFAULTS, p as RunStartService, r as RunFinishedAtFactory, rt as instanceCachingFactory, s as EngineExecutionLimitsPolicy, t as RunIntentService, v as RunStateSemantics, w as WorkflowSnapshotCodec, x as NodeInstanceFactoryFactory, y as PersistedRunStateTerminalBuilder } from "./RunIntentService-BFA48UpH.js";
+
+//#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 EngineExecutionLimitsPolicy({
+			...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: 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 = 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 = 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 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 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 activationEnqueueService = new ActivationEnqueueService(deps.activationScheduler, deps.workflowExecutionRepository, nodeEventPublisher);
+		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/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
+//#region src/scheduler/InlineDrivingSchedulerFactory.ts
+var InlineDrivingSchedulerFactory = class {
+	create(nodeExecutor) {
+		return new 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(NodeInstanceFactoryFactory, { useClass: NodeInstanceFactoryFactory });
+		container.register(DefaultAsyncSleeper, { useClass: DefaultAsyncSleeper });
+		container.register(InProcessRetryRunnerFactory, { useClass: InProcessRetryRunnerFactory });
+		container.register(NodeExecutorFactory, { useClass: 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(CoreTokens.EngineExecutionLimitsPolicy, true)) return;
+		container.register(CoreTokens.EngineExecutionLimitsPolicy, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			const merged = options?.resolveEngineExecutionLimits?.() ?? options?.engineExecutionLimits;
+			return dependencyContainer.resolve(EngineExecutionLimitsPolicyFactory).create(merged);
+		}) });
+	}
+	ensureWorkflowNodeInstanceFactory(container) {
+		if (container.isRegistered(CoreTokens.WorkflowNodeInstanceFactory, true)) return;
+		container.register(CoreTokens.WorkflowNodeInstanceFactory, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			return dependencyContainer.resolve(NodeInstanceFactoryFactory).create(dependencyContainer.resolve(CoreTokens.NodeResolver));
+		}) });
+	}
+	ensureNodeExecutor(container) {
+		if (container.isRegistered(NodeExecutor, true)) return;
+		container.register(NodeExecutor, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			const retryRunner = dependencyContainer.resolve(InProcessRetryRunnerFactory).create(dependencyContainer.resolve(DefaultAsyncSleeper));
+			return dependencyContainer.resolve(NodeExecutorFactory).create(dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory), retryRunner);
+		}) });
+	}
+	registerDefaultActivationScheduler(container) {
+		if (container.isRegistered(CoreTokens.NodeActivationScheduler, true)) return;
+		container.register(InlineDrivingScheduler, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			return dependencyContainer.resolve(InlineDrivingSchedulerFactory).create(dependencyContainer.resolve(NodeExecutor));
+		}) });
+		container.register(CoreTokens.NodeActivationScheduler, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			return dependencyContainer.resolve(InlineDrivingScheduler);
+		}) });
+	}
+	registerEngine(container, options) {
+		container.register(EngineFactory, { useClass: EngineFactory });
+		const matcherProvider = this.resolveMatcherProvider(options);
+		container.register(Engine, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			const liveWorkflowRepository = dependencyContainer.resolve(CoreTokens.LiveWorkflowRepository);
+			const nodeResolver = dependencyContainer.resolve(CoreTokens.NodeResolver);
+			const tokenRegistryLike = dependencyContainer.resolve(CoreTokens.PersistedWorkflowTokenRegistry);
+			const workflowActivationPolicy = dependencyContainer.resolve(CoreTokens.WorkflowActivationPolicy);
+			const webhookTriggerMatcher = matcherProvider.createMatcher(dependencyContainer);
+			const workflowNodeInstanceFactory = dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory);
+			const triggerRuntimeDiagnostics = options?.triggerRuntimeDiagnosticsProvider?.create(dependencyContainer);
+			return dependencyContainer.resolve(EngineFactory).create({
+				credentialSessions: dependencyContainer.resolve(CoreTokens.CredentialSessionService),
+				liveWorkflowRepository,
+				workflowRepository: dependencyContainer.resolve(CoreTokens.WorkflowRepository),
+				workflowActivationPolicy,
+				nodeResolver,
+				triggerSetupStateRepository: dependencyContainer.resolve(CoreTokens.TriggerSetupStateRepository),
+				webhookTriggerMatcher,
+				runIdFactory: dependencyContainer.resolve(CoreTokens.RunIdFactory),
+				activationIdFactory: dependencyContainer.resolve(CoreTokens.ActivationIdFactory),
+				workflowExecutionRepository: dependencyContainer.resolve(CoreTokens.WorkflowExecutionRepository),
+				activationScheduler: dependencyContainer.resolve(CoreTokens.NodeActivationScheduler),
+				runDataFactory: dependencyContainer.resolve(CoreTokens.RunDataFactory),
+				executionContextFactory: dependencyContainer.resolve(CoreTokens.ExecutionContextFactory),
+				nodeExecutor: dependencyContainer.resolve(NodeExecutor),
+				eventBus: dependencyContainer.resolve(CoreTokens.RunEventBus),
+				tokenRegistry: tokenRegistryLike,
+				workflowNodeInstanceFactory,
+				executionLimitsPolicy: dependencyContainer.resolve(CoreTokens.EngineExecutionLimitsPolicy),
+				triggerRuntimeDiagnostics
+			});
+		}) });
+	}
+	registerIntentServices(container) {
+		container.register(RunIntentService, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			return dependencyContainer.resolve(RunIntentServiceFactory).create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(CoreTokens.WorkflowRepository));
+		}) });
+		container.register(CoreTokens.WorkflowRunnerService, { useFactory: instanceCachingFactory((dependencyContainer) => {
+			return dependencyContainer.resolve(EngineWorkflowRunnerServiceFactory).create(dependencyContainer.resolve(Engine), dependencyContainer.resolve(CoreTokens.WorkflowRepository));
+		}) });
+	}
+	resolveMatcherProvider(options) {
+		if (options?.webhookTriggerMatcherProvider) return options.webhookTriggerMatcherProvider;
+		return { createMatcher: (container) => container.resolve(WorkflowRepositoryWebhookTriggerMatcherFactory).create(container.resolve(CoreTokens.WorkflowRepository), container.resolve(CoreTokens.WorkflowActivationPolicy), options?.webhookTriggerRoutingDiagnostics) };
+	}
+};
+
+//#endregion
+export { Engine as a, WorkflowStoragePolicyEvaluator as c, EngineExecutionLimitsPolicyFactory as d, EngineFactory as i, WorkflowPolicyErrorServices as l, WorkflowRepositoryWebhookTriggerMatcher as n, InMemoryWorkflowExecutionRepository as o, EngineWorkflowRunnerService as r, RunSummaryMapper as s, EngineRuntimeRegistrar as t, RunTerminalPersistenceCoordinator as u };
+//# sourceMappingURL=bootstrap-D67Sf2BF.js.map