@codemation/core 0.0.19 → 0.2.1

package/dist/bootstrap/index.cjs

@@ -1,1126 +1,6 @@
-const require_RunIntentService = require('../RunIntentService-ZkjpY7MS.cjs');
-const require_InMemoryLiveWorkflowRepository = require('../InMemoryLiveWorkflowRepository-BTzHpQ6e.cjs');
-let tsyringe = require("tsyringe");
-tsyringe = require_RunIntentService.__toESM(tsyringe);
+const require_RunIntentService = require('../RunIntentService-DcxXf_AM.cjs');
+const require_bootstrap = require('../bootstrap-DoQHAEQJ.cjs');
 
-//#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,
-			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 save(state) {
-		this.runs.set(state.runId, state);
-	}
-	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 = await this.workflowExecutionRepository.load(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}`);
-		if (state.status !== "pending" || !state.pending) return;
-		if (state.pending.activationId !== request.activationId || state.pending.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 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: state.pending.batchId ?? "batch_1",
-			input: request.input
-		});
-		await this.continuation.markNodeRunning({
-			runId: activationRequest.runId,
-			activationId: activationRequest.activationId,
-			nodeId: activationRequest.nodeId,
-			inputsByPort: { in: activationRequest.input }
-		});
-		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_InMemoryLiveWorkflowRepository.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
 exports.ConfigDrivenOffloadPolicy = require_RunIntentService.ConfigDrivenOffloadPolicy;
 exports.CredentialResolverFactory = require_RunIntentService.CredentialResolverFactory;
 exports.DefaultAsyncSleeper = require_RunIntentService.DefaultAsyncSleeper;
@@ -1128,17 +8,17 @@ exports.DefaultDrivingScheduler = require_RunIntentService.DefaultDrivingSchedul
 exports.DefaultExecutionBinaryService = require_RunIntentService.DefaultExecutionBinaryService;
 exports.DefaultExecutionContextFactory = require_RunIntentService.DefaultExecutionContextFactory;
 exports.ENGINE_EXECUTION_LIMITS_DEFAULTS = require_RunIntentService.ENGINE_EXECUTION_LIMITS_DEFAULTS;
-exports.Engine = Engine;
+exports.Engine = require_bootstrap.Engine;
 exports.EngineExecutionLimitsPolicy = require_RunIntentService.EngineExecutionLimitsPolicy;
-exports.EngineExecutionLimitsPolicyFactory = EngineExecutionLimitsPolicyFactory;
-exports.EngineFactory = EngineFactory;
-exports.EngineRuntimeRegistrar = EngineRuntimeRegistrar;
-exports.EngineWorkflowRunnerService = EngineWorkflowRunnerService;
+exports.EngineExecutionLimitsPolicyFactory = require_bootstrap.EngineExecutionLimitsPolicyFactory;
+exports.EngineFactory = require_bootstrap.EngineFactory;
+exports.EngineRuntimeRegistrar = require_bootstrap.EngineRuntimeRegistrar;
+exports.EngineWorkflowRunnerService = require_bootstrap.EngineWorkflowRunnerService;
 exports.HintOnlyOffloadPolicy = require_RunIntentService.HintOnlyOffloadPolicy;
 exports.InMemoryBinaryStorage = require_RunIntentService.InMemoryBinaryStorage;
-exports.InMemoryLiveWorkflowRepository = require_InMemoryLiveWorkflowRepository.InMemoryLiveWorkflowRepository;
+exports.InMemoryLiveWorkflowRepository = require_RunIntentService.InMemoryLiveWorkflowRepository;
 exports.InMemoryRunDataFactory = require_RunIntentService.InMemoryRunDataFactory;
-exports.InMemoryWorkflowExecutionRepository = InMemoryWorkflowExecutionRepository;
+exports.InMemoryWorkflowExecutionRepository = require_bootstrap.InMemoryWorkflowExecutionRepository;
 exports.InProcessRetryRunner = require_RunIntentService.InProcessRetryRunner;
 exports.InlineDrivingScheduler = require_RunIntentService.InlineDrivingScheduler;
 exports.LocalOnlyScheduler = require_RunIntentService.LocalOnlyScheduler;
@@ -1148,10 +28,9 @@ exports.NodeInstanceFactory = require_RunIntentService.NodeInstanceFactory;
 exports.PersistedWorkflowTokenRegistry = require_RunIntentService.PersistedWorkflowTokenRegistry;
 exports.RunIntentService = require_RunIntentService.RunIntentService;
 exports.RunPolicySnapshotFactory = require_RunIntentService.RunPolicySnapshotFactory;
-exports.RunSummaryMapper = RunSummaryMapper;
-exports.RunTerminalPersistenceCoordinator = RunTerminalPersistenceCoordinator;
+exports.RunSummaryMapper = require_bootstrap.RunSummaryMapper;
+exports.RunTerminalPersistenceCoordinator = require_bootstrap.RunTerminalPersistenceCoordinator;
 exports.UnavailableBinaryStorage = require_RunIntentService.UnavailableBinaryStorage;
-exports.WorkflowPolicyErrorServices = WorkflowPolicyErrorServices;
-exports.WorkflowRepositoryWebhookTriggerMatcher = WorkflowRepositoryWebhookTriggerMatcher;
-exports.WorkflowStoragePolicyEvaluator = WorkflowStoragePolicyEvaluator;
-//# sourceMappingURL=index.cjs.map
+exports.WorkflowPolicyErrorServices = require_bootstrap.WorkflowPolicyErrorServices;
+exports.WorkflowRepositoryWebhookTriggerMatcher = require_bootstrap.WorkflowRepositoryWebhookTriggerMatcher;
+exports.WorkflowStoragePolicyEvaluator = require_bootstrap.WorkflowStoragePolicyEvaluator;