@codemation/core 0.0.5 → 0.0.11

package/dist/EngineFactory-CBnntY3J.cjs

@@ -1,3152 +0,0 @@
-const require_PersistedWorkflowSnapshotFactory = require('./PersistedWorkflowSnapshotFactory-UjQ1SJev.cjs');
-
-//#region src/engine/materialization/MissingRuntimeTriggerToken.ts
-var MissingRuntimeTriggerToken = class {};
-
-//#endregion
-//#region src/engine/policies/EngineExecutionLimitsPolicy.ts
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
-const ENGINE_EXECUTION_LIMITS_DEFAULTS = {
-	defaultMaxNodeActivations: 1e5,
-	hardMaxNodeActivations: 1e5,
-	defaultMaxSubworkflowDepth: 32,
-	hardMaxSubworkflowDepth: 32
-};
-/**
-* Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
-*/
-var EngineExecutionLimitsPolicy = class {
-	constructor(config = ENGINE_EXECUTION_LIMITS_DEFAULTS) {
-		this.config = config;
-	}
-	/**
-	* Effective options for a new root run (depth 0): defaults merged with engine ceilings.
-	* Replaces a separate one-method factory for root-run bootstrap.
-	*/
-	createRootExecutionOptions() {
-		return this.mergeExecutionOptionsForNewRun(void 0, void 0);
-	}
-	mergeExecutionOptionsForNewRun(parent, user) {
-		const subworkflowDepth = parent === void 0 ? 0 : (parent.subworkflowDepth ?? 0) + 1;
-		const inheritedMaxNode = parent?.engineMaxNodeActivations;
-		const inheritedMaxSub = parent?.engineMaxSubworkflowDepth;
-		const maxNodeActivations = this.capNumber(user?.maxNodeActivations ?? inheritedMaxNode, this.config.defaultMaxNodeActivations, this.config.hardMaxNodeActivations);
-		const maxSubworkflowDepth = this.capNumber(user?.maxSubworkflowDepth ?? inheritedMaxSub, this.config.defaultMaxSubworkflowDepth, this.config.hardMaxSubworkflowDepth);
-		if (subworkflowDepth > maxSubworkflowDepth) throw new Error(`Subworkflow nesting depth ${subworkflowDepth} exceeds maxSubworkflowDepth ${maxSubworkflowDepth} (run would be a child of parent run).`);
-		return {
-			...user,
-			subworkflowDepth,
-			maxNodeActivations,
-			maxSubworkflowDepth
-		};
-	}
-	capNumber(requested, defaultValue, hardCeiling) {
-		const base = requested === void 0 ? defaultValue : requested;
-		return Math.min(base, hardCeiling);
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/MissingRuntimeNodeToken.ts
-var MissingRuntimeNodeToken = class {};
-
-//#endregion
-//#region src/engine/api/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.workflowCatalog.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.workflowRunStarter.runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides);
-	}
-	async runWorkflowFromState(request) {
-		return await this.deps.currentStateRunStarter.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);
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/MissingRuntimeNodeConfig.ts
-var MissingRuntimeNodeConfig = class {
-	kind = "node";
-	type = MissingRuntimeNodeToken;
-	constructor(name, missingTokenId, missingRuntime = true) {
-		this.name = name;
-		this.missingTokenId = missingTokenId;
-		this.missingRuntime = missingRuntime;
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/MissingRuntimeTriggerConfig.ts
-var MissingRuntimeTriggerConfig = class {
-	kind = "trigger";
-	type = MissingRuntimeTriggerToken;
-	constructor(name, missingTokenId, missingRuntime = true) {
-		this.name = name;
-		this.missingTokenId = missingTokenId;
-		this.missingRuntime = missingRuntime;
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/MissingRuntimeNodeDefinitionFactory.ts
-var MissingRuntimeNodeDefinitionFactory = class {
-	create(snapshotNode) {
-		if (snapshotNode.kind === "trigger") {
-			const config$1 = new MissingRuntimeTriggerConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId);
-			return {
-				id: snapshotNode.id,
-				kind: "trigger",
-				name: snapshotNode.name,
-				type: MissingRuntimeTriggerToken,
-				config: config$1
-			};
-		}
-		const config = new MissingRuntimeNodeConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId);
-		return {
-			id: snapshotNode.id,
-			kind: "node",
-			name: snapshotNode.name,
-			type: MissingRuntimeNodeToken,
-			config
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/PersistedWorkflowConfigHydrator.ts
-var PersistedWorkflowConfigHydrator = class {
-	constructor(tokenRegistry) {
-		this.tokenRegistry = tokenRegistry;
-	}
-	hydrate(snapshotNode, liveConfig) {
-		const hydrated = this.mergeValue(liveConfig, snapshotNode.config);
-		const configToken = this.tokenRegistry.resolve(snapshotNode.configTokenId);
-		Object.assign(hydrated, {
-			type: configToken ?? liveConfig.type,
-			kind: snapshotNode.kind
-		});
-		if (snapshotNode.name && !("name" in hydrated && hydrated.name)) Object.assign(hydrated, { name: snapshotNode.name });
-		return hydrated;
-	}
-	mergeValue(liveValue, snapshotValue) {
-		const liveRecord = this.asRecord(liveValue);
-		const snapshotRecord = this.asRecord(snapshotValue);
-		const hydrated = Object.create(liveValue && typeof liveValue === "object" ? Object.getPrototypeOf(liveValue) ?? Object.prototype : Object.prototype);
-		for (const [key, value] of Object.entries(snapshotRecord)) hydrated[key] = this.mergeNestedValue(liveRecord[key], value);
-		this.restoreNonSerializableProperties(liveRecord, hydrated);
-		this.restoreTypeProperty(hydrated);
-		return hydrated;
-	}
-	mergeNestedValue(liveValue, snapshotValue) {
-		if (Array.isArray(snapshotValue)) {
-			const liveArray = Array.isArray(liveValue) ? liveValue : [];
-			return snapshotValue.map((entry, index) => this.mergeNestedValue(liveArray[index], entry));
-		}
-		if (snapshotValue && typeof snapshotValue === "object") return this.mergeValue(liveValue, snapshotValue);
-		return snapshotValue;
-	}
-	restoreNonSerializableProperties(liveRecord, hydrated) {
-		for (const [key, value] of Object.entries(liveRecord)) if (typeof value === "function" || typeof value === "symbol") hydrated[key] = value;
-	}
-	restoreTypeProperty(record) {
-		const tokenId = typeof record.tokenId === "string" ? record.tokenId : void 0;
-		if (!tokenId) return;
-		const type = this.tokenRegistry.resolve(tokenId);
-		if (type) record.type = type;
-	}
-	asRecord(value) {
-		if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-		return { ...value };
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/PersistedWorkflowResolver.ts
-var PersistedWorkflowResolver = class {
-	constructor(workflowRepository, tokenRegistry, configHydrator, missingNodeDefinitionFactory) {
-		this.workflowRepository = workflowRepository;
-		this.tokenRegistry = tokenRegistry;
-		this.configHydrator = configHydrator;
-		this.missingNodeDefinitionFactory = missingNodeDefinitionFactory;
-	}
-	resolve(args) {
-		const liveWorkflow = this.workflowRepository.get(args.workflowId);
-		if (!args.workflowSnapshot) return liveWorkflow;
-		if (!liveWorkflow) return this.rebuildWorkflow(args.workflowSnapshot, void 0);
-		return this.rebuildWorkflow(args.workflowSnapshot, liveWorkflow);
-	}
-	rebuildWorkflow(snapshot, liveWorkflow) {
-		const liveNodesById = new Map((liveWorkflow?.nodes ?? []).map((node) => [node.id, node]));
-		const nodes = snapshot.nodes.map((snapshotNode) => {
-			const liveNode = liveNodesById.get(snapshotNode.id);
-			if (!this.isCompatibleLiveNode(liveNode, snapshotNode)) return this.missingNodeDefinitionFactory.create(snapshotNode);
-			return {
-				id: snapshotNode.id,
-				kind: snapshotNode.kind,
-				name: snapshotNode.name ?? liveNode.name,
-				type: liveNode.type,
-				config: this.configHydrator.hydrate(snapshotNode, liveNode.config)
-			};
-		});
-		const nodeIds = new Set(nodes.map((node) => node.id));
-		const connectionsFromSnapshot = snapshot.connections?.map((connection) => ({
-			...connection,
-			childNodeIds: connection.childNodeIds.filter((childId) => nodeIds.has(childId))
-		})).filter((connection) => connection.childNodeIds.length > 0) ?? [];
-		return {
-			id: snapshot.id,
-			name: snapshot.name,
-			nodes,
-			edges: snapshot.edges.filter((edge) => nodeIds.has(edge.from.nodeId) && nodeIds.has(edge.to.nodeId)),
-			...connectionsFromSnapshot.length > 0 ? { connections: connectionsFromSnapshot } : {},
-			...liveWorkflow?.discoveryPathSegments !== void 0 ? { discoveryPathSegments: liveWorkflow.discoveryPathSegments } : {}
-		};
-	}
-	isCompatibleLiveNode(liveNode, snapshotNode) {
-		if (!liveNode || liveNode.kind !== snapshotNode.kind) return false;
-		if (!snapshotNode.nodeTokenId || !snapshotNode.configTokenId) throw new Error(`Persisted workflow snapshot node "${snapshotNode.id}" is missing stable token ids.`);
-		const liveNodeTokenId = this.resolveLiveTokenId(liveNode.type);
-		const liveConfigTokenId = this.resolveLiveTokenId(liveNode.config.type);
-		return liveNodeTokenId === snapshotNode.nodeTokenId && liveConfigTokenId === snapshotNode.configTokenId;
-	}
-	resolveLiveTokenId(type) {
-		const registeredTokenId = this.tokenRegistry.getTokenId(type);
-		if (registeredTokenId) return registeredTokenId;
-		if (typeof type === "function" && type.name) return type.name;
-		if (typeof type === "string") return type;
-	}
-};
-
-//#endregion
-//#region src/engine/state/InputPortMapFactory.ts
-var InputPortMap = class {
-	static empty() {
-		return {};
-	}
-	static fromRequest(request) {
-		if (request.kind === "multi") return request.inputsByPort;
-		return { in: request.input };
-	}
-};
-
-//#endregion
-//#region src/engine/state/NodeSnapshotFactory.ts
-var NodeSnapshotFactory = class {
-	static queued(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "queued",
-			queuedAt: args.queuedAt,
-			updatedAt: args.queuedAt,
-			inputsByPort: args.inputsByPort
-		};
-	}
-	static running(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "running",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.startedAt,
-			updatedAt: args.startedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.previous?.outputs,
-			error: void 0
-		};
-	}
-	static completed(args) {
-		const fromPinnedOutput = args.fromPinnedOutput ?? false;
-		const startedAt = fromPinnedOutput ? args.previous?.startedAt ?? args.finishedAt : args.previous?.startedAt;
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "completed",
-			queuedAt: args.previous?.queuedAt,
-			startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.outputs,
-			usedPinnedOutput: fromPinnedOutput,
-			error: void 0
-		};
-	}
-	static skipped(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "skipped",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.previous?.startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.outputs,
-			error: void 0
-		};
-	}
-	static failed(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "failed",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.previous?.startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: void 0,
-			error: {
-				message: args.error.message,
-				name: args.error.name,
-				stack: args.error.stack
-			}
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/execution/ActivationEnqueueService.ts
-var ActivationEnqueueService = class {
-	constructor(activationScheduler, runStore, nodeEventPublisher) {
-		this.activationScheduler = activationScheduler;
-		this.runStore = runStore;
-		this.nodeEventPublisher = nodeEventPublisher;
-	}
-	async enqueueActivation(args) {
-		const { result, queuedSnapshot } = await this.enqueueActivationWithSnapshot(args);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		return result;
-	}
-	async enqueueActivationWithSnapshot(args) {
-		const receipt = await this.activationScheduler.enqueue(args.request);
-		const inputsByPort = InputPortMap.fromRequest(args.request);
-		const itemsIn = args.request.kind === "multi" ? args.planner.sumItemsByPort(args.request.inputsByPort) : args.request.input.length;
-		const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const pending = {
-			runId: args.runId,
-			activationId: args.request.activationId,
-			workflowId: args.workflowId,
-			nodeId: args.request.nodeId,
-			itemsIn,
-			inputsByPort,
-			receiptId: receipt.receiptId,
-			queue: receipt.queue,
-			batchId: args.request.batchId,
-			enqueuedAt
-		};
-		const queuedSnapshot = NodeSnapshotFactory.queued({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.request.nodeId,
-			activationId: args.request.activationId,
-			parent: args.parent,
-			queuedAt: enqueuedAt,
-			inputsByPort
-		});
-		await this.runStore.save({
-			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,
-			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
-			status: "pending",
-			pending,
-			queue: args.pendingQueue.map((entry) => ({ ...entry })),
-			outputsByNode: args.request.ctx.data.dump(),
-			nodeSnapshotsByNodeId: {
-				...args.previousNodeSnapshotsByNodeId,
-				[args.request.nodeId]: queuedSnapshot
-			}
-		});
-		this.notifyPendingStatePersisted(args.runId);
-		return {
-			result: {
-				runId: args.runId,
-				workflowId: args.workflowId,
-				startedAt: args.startedAt,
-				status: "pending",
-				pending
-			},
-			queuedSnapshot
-		};
-	}
-	notifyPendingStatePersisted(runId) {
-		this.activationScheduler.notifyPendingStatePersisted?.(runId);
-	}
-};
-
-//#endregion
-//#region src/workflow/WorkflowExecutableNodeClassifier.ts
-/**
-* Derives which workflow nodes participate in the main execution graph vs connection-only children.
-*/
-var WorkflowExecutableNodeClassifier = class {
-	connectionOwnedIds;
-	constructor(workflow) {
-		this.connectionOwnedIds = this.collectConnectionOwnedIds(workflow);
-	}
-	isConnectionOwnedNodeId(nodeId) {
-		return this.connectionOwnedIds.has(nodeId);
-	}
-	isExecutableNodeId(nodeId) {
-		return !this.connectionOwnedIds.has(nodeId);
-	}
-	filterExecutableNodeDefinitions(nodes) {
-		return nodes.filter((n) => this.isExecutableNodeId(n.id));
-	}
-	collectConnectionOwnedIds(workflow) {
-		const ids = /* @__PURE__ */ new Set();
-		for (const connection of workflow.connections ?? []) for (const childId of connection.childNodeIds) ids.add(childId);
-		return ids;
-	}
-	/**
-	* Resolves the default start node: first trigger, else first executable node with no incoming edges from executable nodes.
-	*/
-	findDefaultExecutableStartNodeId(workflow) {
-		const firstTrigger = workflow.nodes.find((n) => n.kind === "trigger" && this.isExecutableNodeId(n.id))?.id;
-		if (firstTrigger) return firstTrigger;
-		const incoming = /* @__PURE__ */ new Map();
-		for (const n of workflow.nodes) if (this.isExecutableNodeId(n.id)) incoming.set(n.id, 0);
-		for (const e of workflow.edges) {
-			if (!this.isExecutableNodeId(e.from.nodeId) || !this.isExecutableNodeId(e.to.nodeId)) continue;
-			incoming.set(e.to.nodeId, (incoming.get(e.to.nodeId) ?? 0) + 1);
-		}
-		return workflow.nodes.find((n) => this.isExecutableNodeId(n.id) && (incoming.get(n.id) ?? 0) === 0)?.id ?? workflow.nodes.find((n) => this.isExecutableNodeId(n.id))?.id ?? (() => {
-			throw new Error(`Workflow ${workflow.id} has no executable nodes`);
-		})();
-	}
-	firstExecutableNodeIdInDefinitionOrder(workflow) {
-		return workflow.nodes.find((n) => this.isExecutableNodeId(n.id))?.id;
-	}
-	lastExecutableNodeIdInDefinitionOrder(workflow) {
-		for (let i = workflow.nodes.length - 1; i >= 0; i--) {
-			const n = workflow.nodes[i];
-			if (this.isExecutableNodeId(n.id)) return n.id;
-		}
-		throw new Error(`Workflow ${workflow.id} has no executable nodes`);
-	}
-};
-
-//#endregion
-//#region src/workflow/workflowExecutableNodeClassifier.types.ts
-function createWorkflowExecutableNodeClassifier(workflow) {
-	return new WorkflowExecutableNodeClassifier(workflow);
-}
-
-//#endregion
-//#region src/engine/planning/DependencySatisfactionResolver.ts
-var DependencySatisfactionResolver = class {
-	constructor(topology, currentState) {
-		this.topology = topology;
-		this.currentState = currentState;
-	}
-	isNodeSatisfied(nodeId) {
-		return this.hasOutputs(nodeId) || this.hasCompletedSnapshot(nodeId);
-	}
-	isNodeSatisfiedByOutputsOnly(nodeId) {
-		return this.hasOutputs(nodeId) && !this.hasCompletedSnapshot(nodeId);
-	}
-	isEdgeSatisfied(args) {
-		const incomingEdge = (this.topology.incomingByNode.get(args.nodeId) ?? []).find((edge) => edge.input === args.input);
-		if (!incomingEdge) return false;
-		return this.hasOutputPort(incomingEdge.from.nodeId, incomingEdge.from.output);
-	}
-	resolveInput(args) {
-		const incomingEdge = (this.topology.incomingByNode.get(args.nodeId) ?? []).find((edge) => edge.input === args.input);
-		if (!incomingEdge) return [];
-		return this.resolveOutputItems(incomingEdge.from.nodeId, incomingEdge.from.output);
-	}
-	hasOutputs(nodeId) {
-		return Object.prototype.hasOwnProperty.call(this.currentState.outputsByNode, nodeId);
-	}
-	hasCompletedSnapshot(nodeId) {
-		const snapshot = this.currentState.nodeSnapshotsByNodeId[nodeId];
-		return snapshot?.status === "completed" || snapshot?.status === "skipped";
-	}
-	hasOutputPort(nodeId, output) {
-		const outputs = this.currentState.outputsByNode[nodeId];
-		if (!outputs) return false;
-		return Object.prototype.hasOwnProperty.call(outputs, output);
-	}
-	resolveOutputItems(nodeId, output) {
-		return this.currentState.outputsByNode[nodeId]?.[output] ?? [];
-	}
-};
-
-//#endregion
-//#region src/engine/planning/FrontierQueueBuilder.ts
-var FrontierQueueBuilder = class {
-	constructor(topology, satisfactionResolver) {
-		this.topology = topology;
-		this.satisfactionResolver = satisfactionResolver;
-	}
-	build(args) {
-		const incomingEdges = this.topology.incomingByNode.get(args.nodeId) ?? [];
-		if (incomingEdges.length === 0) return [];
-		const expectedInputs = this.topology.expectedInputsByNode.get(args.nodeId) ?? [];
-		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
-			const received = {};
-			for (const input$1 of expectedInputs) received[input$1] = this.satisfactionResolver.resolveInput({
-				nodeId: args.nodeId,
-				input: input$1
-			});
-			return [{
-				nodeId: args.nodeId,
-				input: [],
-				batchId: "batch_1",
-				collect: {
-					expectedInputs,
-					received
-				}
-			}];
-		}
-		const input = expectedInputs[0] ?? "in";
-		const incomingEdge = incomingEdges.find((edge) => edge.input === input);
-		return [{
-			nodeId: args.nodeId,
-			input: this.satisfactionResolver.resolveInput({
-				nodeId: args.nodeId,
-				input
-			}),
-			toInput: input,
-			batchId: "batch_1",
-			from: incomingEdge?.from
-		}];
-	}
-};
-
-//#endregion
-//#region src/engine/planning/PinnedOutputResolver.ts
-var PinnedOutputResolver = class {
-	constructor(currentState) {
-		this.currentState = currentState;
-	}
-	overlayPinnedOutputs() {
-		const outputsByNode = { ...this.currentState.outputsByNode };
-		for (const [nodeId, nodeState] of Object.entries(this.currentState.mutableState?.nodesById ?? {})) {
-			const pinnedOutputs = this.resolvePinnedOutputs(nodeState);
-			if (!pinnedOutputs) continue;
-			outputsByNode[nodeId] = pinnedOutputs;
-		}
-		return {
-			outputsByNode,
-			nodeSnapshotsByNodeId: { ...this.currentState.nodeSnapshotsByNodeId },
-			mutableState: this.currentState.mutableState
-		};
-	}
-	hasPinnedOutputs(nodeId) {
-		return this.getPinnedOutputs(nodeId) !== void 0;
-	}
-	getPinnedOutputs(nodeId) {
-		const nodeState = this.currentState.mutableState?.nodesById?.[nodeId];
-		return this.resolvePinnedOutputs(nodeState);
-	}
-	resolvePinnedOutputs(nodeState) {
-		if (!nodeState) return;
-		return nodeState.pinnedOutputsByPort;
-	}
-};
-
-//#endregion
-//#region src/engine/planning/RequiredNodeCollector.ts
-var RequiredNodeCollector = class {
-	requiredNodeIds = /* @__PURE__ */ new Set();
-	constructor(topology, satisfactionResolver) {
-		this.topology = topology;
-		this.satisfactionResolver = satisfactionResolver;
-	}
-	collect(stopCondition) {
-		if (stopCondition.kind === "workflowCompleted") {
-			for (const nodeId of this.topology.defsById.keys()) if (!this.satisfactionResolver.isNodeSatisfied(nodeId)) this.collectNode(nodeId);
-			return this.requiredNodeIds;
-		}
-		if (!this.topology.defsById.has(stopCondition.nodeId)) throw new Error(`Unknown stop nodeId: ${stopCondition.nodeId}`);
-		this.collectNode(stopCondition.nodeId);
-		return this.requiredNodeIds;
-	}
-	collectNode(nodeId) {
-		if (this.requiredNodeIds.has(nodeId)) return;
-		if (this.satisfactionResolver.isNodeSatisfied(nodeId) && !this.satisfactionResolver.isNodeSatisfiedByOutputsOnly(nodeId)) return;
-		this.requiredNodeIds.add(nodeId);
-		for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) if (!this.satisfactionResolver.isEdgeSatisfied({
-			nodeId,
-			input: edge.input
-		}) || this.satisfactionResolver.isNodeSatisfiedByOutputsOnly(edge.from.nodeId)) this.collectNode(edge.from.nodeId);
-	}
-};
-
-//#endregion
-//#region src/engine/planning/RootNodeInputResolver.ts
-var RootNodeInputResolver = class {
-	resolve(args) {
-		if (args.items) return args.items;
-		if (args.nodeKind === "trigger") return [];
-		return [{ json: {} }];
-	}
-};
-
-//#endregion
-//#region src/engine/planning/RunCurrentStateFactory.ts
-var RunCurrentStateFactory = class {
-	static empty() {
-		return {
-			outputsByNode: {},
-			nodeSnapshotsByNodeId: {},
-			connectionInvocations: [],
-			mutableState: void 0
-		};
-	}
-	static clone(currentState) {
-		if (!currentState) return this.empty();
-		return {
-			outputsByNode: { ...currentState.outputsByNode },
-			nodeSnapshotsByNodeId: { ...currentState.nodeSnapshotsByNodeId },
-			connectionInvocations: currentState.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
-			mutableState: currentState.mutableState
-		};
-	}
-};
-
-//#endregion
-//#region src/workflow/ConnectionNodeIdFactory.ts
-/**
-* Deterministic ids for workflow connection-owned child nodes (LLM slot, tools, etc.).
-* These are stable across loads.
-*/
-var ConnectionNodeIdFactory = class {
-	static connectionSegment = "__conn__";
-	static languageModelConnectionNodeId(parentNodeId) {
-		return `${parentNodeId}${this.connectionSegment}llm`;
-	}
-	static toolConnectionNodeId(parentNodeId, toolName) {
-		const normalized = this.normalizeToolName(toolName);
-		return `${parentNodeId}${this.connectionSegment}tool${this.connectionSegment}${normalized}`;
-	}
-	static isLanguageModelConnectionNodeId(nodeId) {
-		return nodeId.endsWith(`${this.connectionSegment}llm`);
-	}
-	static isToolConnectionNodeId(nodeId) {
-		return nodeId.includes(`${this.connectionSegment}tool${this.connectionSegment}`);
-	}
-	/** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
-	static isConnectionOwnedDescendantOf(parentNodeId, nodeId) {
-		return nodeId.startsWith(`${parentNodeId}${this.connectionSegment}`);
-	}
-	/** Normalizes a tool display name to a stable id segment. */
-	static normalizeToolName(toolName) {
-		return toolName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "tool";
-	}
-};
-
-//#endregion
-//#region src/engine/planning/RunStateResetter.ts
-var RunStateResetter = class {
-	constructor(topology, pinnedOutputResolver) {
-		this.topology = topology;
-		this.pinnedOutputResolver = pinnedOutputResolver;
-	}
-	apply(args) {
-		if (!args.reset) return {
-			currentState: args.currentState,
-			clearedNodeIds: [],
-			preservedPinnedNodeIds: []
-		};
-		const outputsByNode = { ...args.currentState.outputsByNode };
-		const nodeSnapshotsByNodeId = { ...args.currentState.nodeSnapshotsByNodeId };
-		const clearedNodeIds = [];
-		const preservedPinnedNodeIds = [];
-		const descendants = this.collectDescendants(args.reset.clearFromNodeId);
-		const runtimeDescendants = this.collectRuntimeDescendants(args.currentState, descendants);
-		const clearedIdSet = new Set([...descendants, ...runtimeDescendants]);
-		for (const nodeId of [...descendants, ...runtimeDescendants]) {
-			if (this.pinnedOutputResolver.hasPinnedOutputs(nodeId)) {
-				const pinnedOutputs = this.pinnedOutputResolver.getPinnedOutputs(nodeId);
-				if (pinnedOutputs) outputsByNode[nodeId] = pinnedOutputs;
-				delete nodeSnapshotsByNodeId[nodeId];
-				preservedPinnedNodeIds.push(nodeId);
-				continue;
-			}
-			delete outputsByNode[nodeId];
-			delete nodeSnapshotsByNodeId[nodeId];
-			clearedNodeIds.push(nodeId);
-		}
-		return {
-			currentState: {
-				outputsByNode,
-				nodeSnapshotsByNodeId,
-				connectionInvocations: this.filterConnectionInvocations(args.currentState.connectionInvocations, clearedIdSet),
-				mutableState: args.currentState.mutableState
-			},
-			clearedNodeIds,
-			preservedPinnedNodeIds
-		};
-	}
-	filterConnectionInvocations(invocations, clearedIdSet) {
-		if (!invocations || invocations.length === 0) return invocations;
-		const kept = invocations.filter((inv) => !clearedIdSet.has(inv.parentAgentNodeId) && !clearedIdSet.has(inv.connectionNodeId));
-		return kept.length === invocations.length ? invocations : kept;
-	}
-	collectDescendants(startNodeId) {
-		const pendingNodeIds = [startNodeId];
-		const descendants = /* @__PURE__ */ new Set();
-		while (pendingNodeIds.length > 0) {
-			const nodeId = pendingNodeIds.pop();
-			if (!nodeId || descendants.has(nodeId)) continue;
-			descendants.add(nodeId);
-			for (const edge of this.topology.outgoingByNode.get(nodeId) ?? []) pendingNodeIds.push(edge.to.nodeId);
-		}
-		return [...descendants];
-	}
-	collectRuntimeDescendants(currentState, descendantNodeIds) {
-		const descendantSet = new Set(descendantNodeIds);
-		const runtimeNodeIds = /* @__PURE__ */ new Set();
-		for (const nodeId of [
-			...Object.keys(currentState.outputsByNode),
-			...Object.keys(currentState.nodeSnapshotsByNodeId),
-			...Object.keys(currentState.mutableState?.nodesById ?? {})
-		]) {
-			if (!this.isRuntimeDescendant(nodeId, descendantSet)) continue;
-			runtimeNodeIds.add(nodeId);
-		}
-		return [...runtimeNodeIds];
-	}
-	isRuntimeDescendant(nodeId, descendantNodeIds) {
-		for (const descendantNodeId of descendantNodeIds) {
-			if (nodeId === descendantNodeId) return false;
-			if (ConnectionNodeIdFactory.isConnectionOwnedDescendantOf(descendantNodeId, nodeId)) return true;
-		}
-		return false;
-	}
-};
-
-//#endregion
-//#region src/engine/planning/CurrentStateFrontierPlanner.ts
-var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
-	rootNodeInputResolver = new RootNodeInputResolver();
-	constructor(topology) {
-		this.topology = topology;
-	}
-	/** Composition-root-friendly factory (avoids `new` at orchestration call sites under ESLint manual-DI rules). */
-	static createFromTopology(topology) {
-		return new CurrentStateFrontierPlanner(topology);
-	}
-	plan(args) {
-		const stopCondition = args.stopCondition ?? { kind: "workflowCompleted" };
-		const normalizedState = new PinnedOutputResolver(RunCurrentStateFactory.clone(args.currentState)).overlayPinnedOutputs();
-		const resetResult = new RunStateResetter(this.topology, new PinnedOutputResolver(normalizedState)).apply({
-			currentState: normalizedState,
-			reset: args.reset
-		});
-		const satisfactionResolver = new DependencySatisfactionResolver(this.topology, resetResult.currentState);
-		const requiredNodeIds = new RequiredNodeCollector(this.topology, satisfactionResolver).collect(stopCondition);
-		const satisfiedNodeIds = this.collectSatisfiedNodeIds(satisfactionResolver);
-		const skippedNodeIds = [...new Set([...[...requiredNodeIds].filter((nodeId) => satisfactionResolver.isNodeSatisfied(nodeId)), ...resetResult.preservedPinnedNodeIds.filter((nodeId) => requiredNodeIds.has(nodeId))])];
-		const frontierNodeIds = this.collectFrontierNodeIds(requiredNodeIds, satisfactionResolver);
-		const rootNodeIds = frontierNodeIds.filter((nodeId) => (this.topology.incomingByNode.get(nodeId) ?? []).length === 0);
-		if (rootNodeIds.length > 1) throw new Error(`Ambiguous execution frontier. Multiple root nodes require input: ${rootNodeIds.join(", ")}`);
-		if (frontierNodeIds.length === 0) return {
-			queue: [],
-			currentState: resetResult.currentState,
-			stopCondition,
-			satisfiedNodeIds,
-			skippedNodeIds,
-			clearedNodeIds: resetResult.clearedNodeIds,
-			preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
-		};
-		if (rootNodeIds.length === 1) {
-			const rootNodeId = rootNodeIds[0];
-			const definition = this.topology.defsById.get(rootNodeId);
-			if (!definition) throw new Error(`Unknown frontier nodeId: ${rootNodeId}`);
-			return {
-				rootNodeId,
-				rootNodeInput: this.rootNodeInputResolver.resolve({
-					nodeKind: definition.kind,
-					items: args.items
-				}),
-				queue: [],
-				currentState: resetResult.currentState,
-				stopCondition,
-				satisfiedNodeIds,
-				skippedNodeIds,
-				clearedNodeIds: resetResult.clearedNodeIds,
-				preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
-			};
-		}
-		const queueBuilder = new FrontierQueueBuilder(this.topology, satisfactionResolver);
-		const queue = [];
-		for (const nodeId of frontierNodeIds) queue.push(...queueBuilder.build({ nodeId }));
-		return {
-			queue,
-			currentState: resetResult.currentState,
-			stopCondition,
-			satisfiedNodeIds,
-			skippedNodeIds,
-			clearedNodeIds: resetResult.clearedNodeIds,
-			preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
-		};
-	}
-	collectSatisfiedNodeIds(satisfactionResolver) {
-		const satisfiedNodeIds = [];
-		for (const nodeId of this.topology.defsById.keys()) if (satisfactionResolver.isNodeSatisfied(nodeId)) satisfiedNodeIds.push(nodeId);
-		return satisfiedNodeIds;
-	}
-	collectFrontierNodeIds(requiredNodeIds, satisfactionResolver) {
-		const frontierNodeIds = [];
-		for (const nodeId of this.topology.defsById.keys()) {
-			if (!requiredNodeIds.has(nodeId) || satisfactionResolver.isNodeSatisfied(nodeId)) continue;
-			if ((this.topology.incomingByNode.get(nodeId) ?? []).every((edge) => satisfactionResolver.isEdgeSatisfied({
-				nodeId,
-				input: edge.input
-			}))) frontierNodeIds.push(nodeId);
-		}
-		return frontierNodeIds;
-	}
-};
-
-//#endregion
-//#region src/engine/planning/WorkflowTopologyPlanner.ts
-var WorkflowTopology = class WorkflowTopology {
-	constructor(defsById, outgoingByNode, incomingByNode, expectedInputsByNode, rootNodeIds) {
-		this.defsById = defsById;
-		this.outgoingByNode = outgoingByNode;
-		this.incomingByNode = incomingByNode;
-		this.expectedInputsByNode = expectedInputsByNode;
-		this.rootNodeIds = rootNodeIds;
-	}
-	static fromWorkflow(wf) {
-		const classifier = createWorkflowExecutableNodeClassifier(wf);
-		const defs = /* @__PURE__ */ new Map();
-		for (const n of wf.nodes) if (classifier.isExecutableNodeId(n.id)) defs.set(n.id, n);
-		const outgoing = /* @__PURE__ */ new Map();
-		for (const e of wf.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = outgoing.get(e.from.nodeId) ?? [];
-			list.push({
-				output: e.from.output,
-				to: {
-					nodeId: e.to.nodeId,
-					input: e.to.input
-				}
-			});
-			outgoing.set(e.from.nodeId, list);
-		}
-		const incomingByNode = /* @__PURE__ */ new Map();
-		for (const e of wf.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = incomingByNode.get(e.to.nodeId) ?? [];
-			list.push({
-				from: {
-					nodeId: e.from.nodeId,
-					output: e.from.output
-				},
-				input: e.to.input
-			});
-			incomingByNode.set(e.to.nodeId, list);
-		}
-		const expected = /* @__PURE__ */ new Map();
-		for (const [toNodeId, inputs] of incomingByNode.entries()) {
-			const counts = /* @__PURE__ */ new Map();
-			for (const edge of inputs) counts.set(edge.input, (counts.get(edge.input) ?? 0) + 1);
-			for (const [k, n] of counts.entries()) if (n > 1) throw new Error(`Node ${toNodeId} has multiple edges into input '${k}'. Use a Merge node upstream.`);
-			const order = [];
-			const seen = /* @__PURE__ */ new Set();
-			for (const edge of inputs) {
-				if (seen.has(edge.input)) continue;
-				seen.add(edge.input);
-				order.push(edge.input);
-			}
-			expected.set(toNodeId, order);
-		}
-		return new WorkflowTopology(defs, outgoing, incomingByNode, expected, wf.nodes.filter((node) => classifier.isExecutableNodeId(node.id) && !incomingByNode.has(node.id)).map((node) => node.id));
-	}
-};
-
-//#endregion
-//#region src/engine/policies/RunPolicySnapshotFactory.ts
-var RunPolicySnapshotFactory = class {
-	static create(workflow, defaults) {
-		const prune = workflow.prunePolicy;
-		return {
-			retentionSeconds: prune?.runDataRetentionSeconds ?? defaults?.retentionSeconds,
-			binaryRetentionSeconds: prune?.binaryRetentionSeconds ?? defaults?.binaryRetentionSeconds,
-			storagePolicy: typeof workflow.storagePolicy === "string" ? workflow.storagePolicy : defaults?.storagePolicy ?? "ALL"
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/execution/CurrentStateRunStarter.ts
-var CurrentStateRunStarter = class {
-	constructor(runIdFactory, runStore, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
-		this.runIdFactory = runIdFactory;
-		this.runStore = runStore;
-		this.runDataFactory = runDataFactory;
-		this.workflowSnapshotFactory = workflowSnapshotFactory;
-		this.planningFactory = planningFactory;
-		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
-		this.runExecutionContextFactory = runExecutionContextFactory;
-		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
-		this.activationEnqueueService = activationEnqueueService;
-		this.semantics = semantics;
-		this.waiters = waiters;
-		this.workflowPolicyRuntimeDefaults = workflowPolicyRuntimeDefaults;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-	}
-	async runWorkflowFromState(request) {
-		const runId = this.runIdFactory.makeRunId();
-		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const workflowSnapshot = request.workflowSnapshot ?? this.workflowSnapshotFactory.create(request.workflow);
-		const mutableState = request.mutableState ?? request.currentState?.mutableState;
-		const policySnapshot = RunPolicySnapshotFactory.create(request.workflow, this.workflowPolicyRuntimeDefaults);
-		const control = { stopCondition: request.stopCondition ?? { kind: "workflowCompleted" } };
-		const mergedExecutionOptions = this.executionLimitsPolicy.mergeExecutionOptionsForNewRun(request.parent, request.executionOptions);
-		await this.runStore.createRun({
-			runId,
-			workflowId: request.workflow.id,
-			startedAt,
-			parent: request.parent,
-			executionOptions: mergedExecutionOptions,
-			control,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			engineCounters: { completedNodeActivations: 0 }
-		});
-		const { topology, planner } = this.planningFactory.create(request.workflow);
-		const plan = CurrentStateFrontierPlanner.createFromTopology(topology).plan({
-			currentState: this.createRunCurrentState(request.currentState, mutableState),
-			stopCondition: control.stopCondition,
-			reset: request.reset,
-			items: request.items
-		});
-		const data = this.runDataFactory.create(plan.currentState.outputsByNode);
-		const base = this.runExecutionContextFactory.create({
-			runId,
-			workflowId: request.workflow.id,
-			nodeId: createWorkflowExecutableNodeClassifier(request.workflow).firstExecutableNodeIdInDefinitionOrder(request.workflow) ?? "unknown_node",
-			parent: request.parent,
-			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
-			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent)
-		});
-		return await this.scheduleInitialPlan({
-			runId,
-			startedAt,
-			workflow: request.workflow,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			executionOptions: mergedExecutionOptions,
-			control,
-			parent: request.parent,
-			planner,
-			plan,
-			base,
-			data
-		});
-	}
-	createRunCurrentState(currentState, mutableState) {
-		return {
-			outputsByNode: { ...currentState?.outputsByNode ?? {} },
-			nodeSnapshotsByNodeId: { ...currentState?.nodeSnapshotsByNodeId ?? {} },
-			connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
-			mutableState: mutableState ?? currentState?.mutableState
-		};
-	}
-	async scheduleInitialPlan(args) {
-		const initialNodeSnapshotsByNodeId = this.semantics.applySkippedSnapshots({
-			runId: args.runId,
-			workflowId: args.workflow.id,
-			parent: args.parent,
-			currentState: args.plan.currentState,
-			skippedNodeIds: args.plan.skippedNodeIds,
-			preservedPinnedNodeIds: args.plan.preservedPinnedNodeIds,
-			finishedAt: args.startedAt
-		});
-		if (args.plan.rootNodeId) {
-			const startDef = WorkflowTopology.fromWorkflow(args.workflow).defsById.get(args.plan.rootNodeId);
-			if (!startDef) throw new Error(`Unknown frontier nodeId: ${args.plan.rootNodeId}`);
-			const startItems = args.plan.rootNodeInput ?? [];
-			if (startDef.kind === "trigger") {
-				const request$1 = this.nodeActivationRequestComposer.createSingleFromDefinition({
-					runId: args.runId,
-					workflowId: args.workflow.id,
-					definition: startDef,
-					parent: args.parent,
-					executionOptions: args.executionOptions,
-					batchId: "batch_1",
-					input: startItems,
-					base: args.base,
-					data: args.data
-				});
-				return await this.activationEnqueueService.enqueueActivation({
-					runId: args.runId,
-					workflowId: args.workflow.id,
-					startedAt: args.startedAt,
-					parent: args.parent,
-					executionOptions: args.executionOptions,
-					control: args.control,
-					workflowSnapshot: args.workflowSnapshot,
-					mutableState: args.mutableState,
-					policySnapshot: args.policySnapshot,
-					pendingQueue: [],
-					request: request$1,
-					previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
-					planner: args.planner,
-					engineCounters: { completedNodeActivations: 0 },
-					connectionInvocations: args.plan.currentState.connectionInvocations ?? []
-				});
-			}
-			const request = this.nodeActivationRequestComposer.createSingleFromDefinition({
-				runId: args.runId,
-				workflowId: args.workflow.id,
-				definition: startDef,
-				parent: args.parent,
-				executionOptions: args.executionOptions,
-				batchId: "batch_1",
-				input: startItems,
-				base: args.base,
-				data: args.data
-			});
-			return await this.activationEnqueueService.enqueueActivation({
-				runId: args.runId,
-				workflowId: args.workflow.id,
-				startedAt: args.startedAt,
-				parent: args.parent,
-				executionOptions: args.executionOptions,
-				control: args.control,
-				workflowSnapshot: args.workflowSnapshot,
-				mutableState: args.mutableState,
-				policySnapshot: args.policySnapshot,
-				pendingQueue: [],
-				request,
-				previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
-				planner: args.planner,
-				connectionInvocations: args.plan.currentState.connectionInvocations ?? []
-			});
-		}
-		return await this.scheduleQueuedPlan({
-			runId: args.runId,
-			workflowId: args.workflow.id,
-			startedAt: args.startedAt,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			control: args.control,
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState,
-			policySnapshot: args.policySnapshot,
-			workflow: args.workflow,
-			planner: args.planner,
-			queue: [...args.plan.queue],
-			base: args.base,
-			data: args.data,
-			nodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
-			connectionInvocations: args.plan.currentState.connectionInvocations ?? []
-		});
-	}
-	async scheduleQueuedPlan(args) {
-		this.semantics.applyPinnedQueueSkips({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			parent: args.parent,
-			mutableState: args.mutableState,
-			planner: args.planner,
-			queue: args.queue,
-			data: args.data,
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
-			finishedAt: args.startedAt
-		});
-		const next = args.planner.nextActivation(args.queue);
-		if (!next) return await this.completeRun({
-			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,
-			workflow: args.workflow,
-			data: args.data,
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
-			connectionInvocations: args.connectionInvocations
-		});
-		const definition = WorkflowTopology.fromWorkflow(args.workflow).defsById.get(next.nodeId);
-		if (!definition || definition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base: args.base,
-			data: args.data,
-			runId: args.runId,
-			workflowId: args.workflowId,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			nodeDefinition: definition
-		});
-		return await this.activationEnqueueService.enqueueActivation({
-			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,
-			pendingQueue: args.queue,
-			request,
-			previousNodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
-			planner: args.planner,
-			engineCounters: { completedNodeActivations: 0 },
-			connectionInvocations: args.connectionInvocations ?? []
-		});
-	}
-	async completeRun(args) {
-		await this.runStore.save({
-			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: { completedNodeActivations: 0 },
-			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
-			status: "completed",
-			pending: void 0,
-			queue: [],
-			outputsByNode: args.data.dump(),
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
-		});
-		const result = {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			startedAt: args.startedAt,
-			status: "completed",
-			outputs: this.semantics.resolveResultOutputs(args.workflow, args.control?.stopCondition, args.data.dump())
-		};
-		this.waiters.resolveRunCompletion(result);
-		return result;
-	}
-};
-
-//#endregion
-//#region src/engine/execution/NodeActivationRequestComposer.ts
-/**
-* Builds {@link NodeActivationRequest} values shared by workflow starters and continuation.
-*/
-var NodeActivationRequestComposer = class {
-	constructor(activationIdFactory, credentialResolverFactory) {
-		this.activationIdFactory = activationIdFactory;
-		this.credentialResolverFactory = credentialResolverFactory;
-	}
-	createSingleFromDefinition(args) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = {
-			...args.base,
-			data: args.data,
-			nodeId: args.definition.id,
-			activationId,
-			config: args.definition.config,
-			binary: args.base.binary.forNode({
-				nodeId: args.definition.id,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.definition.id, args.definition.config)
-		};
-		return {
-			kind: "single",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.definition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.batchId,
-			input: args.input,
-			ctx
-		};
-	}
-	createFromPlannedActivation(args) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = {
-			...args.base,
-			data: args.data,
-			nodeId: args.nodeDefinition.id,
-			activationId,
-			config: args.nodeDefinition.config,
-			binary: args.base.binary.forNode({
-				nodeId: args.nodeDefinition.id,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeDefinition.id, args.nodeDefinition.config)
-		};
-		if (args.next.kind === "multi") return {
-			kind: "multi",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeDefinition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.next.batchId,
-			inputsByPort: args.next.inputsByPort,
-			ctx
-		};
-		return {
-			kind: "single",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeDefinition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.next.batchId,
-			input: args.next.input,
-			ctx
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/execution/PersistedRunStateTerminalBuilder.ts
-/**
-* Merges common terminal-run fields onto a loaded {@link PersistedRunState} without repeating object literals.
-*/
-var PersistedRunStateTerminalBuilder = class {
-	mergeTerminal(args) {
-		return {
-			...args.state,
-			engineCounters: args.engineCounters,
-			status: args.status,
-			pending: void 0,
-			queue: args.queue,
-			outputsByNode: args.outputsByNode,
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/state/RuntimeContinuationDiagnosticsReporter.ts
-var RuntimeContinuationDiagnostics = class {
-	static formatNodeLabel(args) {
-		const tokenName = typeof args.definition?.type === "function" ? args.definition.type.name : "Node";
-		return args.definition?.name ? `"${args.definition.name}" (${tokenName}:${args.nodeId})` : `${tokenName}:${args.nodeId}`;
-	}
-	static formatOutputCounts(outputs) {
-		const entries = Object.entries(outputs ?? {});
-		if (entries.length === 0) return "no outputs";
-		return entries.map(([port, items]) => `${port}=${items?.length ?? 0}`).join(", ");
-	}
-};
-
-//#endregion
-//#region src/engine/execution/RunContinuationService.ts
-var RunContinuationService = class {
-	constructor(activationIdFactory, runStore, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy) {
-		this.activationIdFactory = activationIdFactory;
-		this.runStore = runStore;
-		this.runDataFactory = runDataFactory;
-		this.runExecutionContextFactory = runExecutionContextFactory;
-		this.workflowSnapshotResolver = workflowSnapshotResolver;
-		this.planningFactory = planningFactory;
-		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
-		this.credentialResolverFactory = credentialResolverFactory;
-		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
-		this.persistedRunStateTerminalBuilder = persistedRunStateTerminalBuilder;
-		this.activationEnqueueService = activationEnqueueService;
-		this.nodeEventPublisher = nodeEventPublisher;
-		this.semantics = semantics;
-		this.waiters = waiters;
-		this.policyErrorServices = policyErrorServices;
-		this.terminalPersistence = terminalPersistence;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-	}
-	async markNodeRunning(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state?.pending) return;
-		if (state.pending.activationId !== args.activationId || state.pending.nodeId !== args.nodeId) return;
-		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-		const snapshot = NodeSnapshotFactory.running({
-			previous,
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			startedAt,
-			inputsByPort: args.inputsByPort
-		});
-		await this.runStore.save({
-			...state,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[args.nodeId]: snapshot
-			}
-		});
-		await this.nodeEventPublisher.publish("nodeStarted", snapshot);
-	}
-	async resumeFromNodeResult(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
-		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
-		const wf = this.resolvePersistedWorkflow(state);
-		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
-		const { topology, planner } = this.planningFactory.create(wf);
-		const data = this.runDataFactory.create(state.outputsByNode);
-		const limits = this.resolveEngineLimitsFromState(state);
-		const base = this.runExecutionContextFactory.create({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			parent: state.parent,
-			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: limits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
-		});
-		data.setOutputs(args.nodeId, args.outputs);
-		const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const completedSnapshot = this.semantics.createFinishedSnapshot({
-			workflow: wf,
-			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			finishedAt: completedAt,
-			inputsByPort: state.pending.inputsByPort,
-			outputs: args.outputs
-		});
-		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
-		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
-		if (this.semantics.isStopConditionSatisfied(state.control?.stopCondition, args.nodeId)) {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...state.nodeSnapshotsByNodeId ?? {},
-					[args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "completed",
-				outputs: this.semantics.resolveResultOutputs(wf, state.control?.stopCondition, data.dump())
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const batchId = state.pending.batchId ?? "batch_1";
-		const queue = (state.queue ?? []).map((q) => ({
-			...q,
-			batchId: q.batchId ?? batchId
-		}));
-		const nextNodeSnapshotsByNodeId = {
-			...state.nodeSnapshotsByNodeId ?? {},
-			[args.nodeId]: completedSnapshot
-		};
-		planner.applyOutputs(queue, {
-			fromNodeId: args.nodeId,
-			outputs: args.outputs,
-			batchId
-		});
-		this.semantics.applyPinnedQueueSkips({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			parent: state.parent,
-			mutableState: state.mutableState,
-			planner,
-			queue,
-			data,
-			nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-			finishedAt: completedAt
-		});
-		let next;
-		try {
-			next = planner.nextActivation(queue);
-		} catch (cause) {
-			const completedDefinition = topology.defsById.get(args.nodeId);
-			const completedNodeLabel = RuntimeContinuationDiagnostics.formatNodeLabel({
-				definition: completedDefinition,
-				nodeId: args.nodeId
-			});
-			const reason = cause instanceof Error ? cause.message : String(cause);
-			throw new Error(`After completing ${completedNodeLabel}, the engine could not plan the next activation. ${reason} Outputs: ${RuntimeContinuationDiagnostics.formatOutputCounts(args.outputs)}.`, { cause });
-		}
-		if (!next) {
-			const lastNodeId = createWorkflowExecutableNodeClassifier(wf).lastExecutableNodeIdInDefinitionOrder(wf);
-			const outputs = data.getOutputItems(lastNodeId, "main");
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "completed",
-				outputs
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (completedActivations >= maxNodeActivations) {
-			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
-			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "failed",
-				queue: queue.map((q) => ({ ...q })),
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
-			});
-			await this.runStore.save(failedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: failedState,
-				finalStatus: "failed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "failed",
-				error: { message }
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const def = topology.defsById.get(next.nodeId);
-		if (!def || def.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base,
-			data,
-			runId: state.runId,
-			workflowId: state.workflowId,
-			parent: state.parent,
-			executionOptions: state.executionOptions,
-			nodeDefinition: def
-		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			parent: state.parent,
-			executionOptions: state.executionOptions,
-			control: state.control,
-			workflowSnapshot: state.workflowSnapshot,
-			mutableState: state.mutableState,
-			policySnapshot: state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-			planner,
-			engineCounters,
-			connectionInvocations: state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		return result;
-	}
-	async resumeFromNodeError(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
-		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
-		const wf = this.resolvePersistedWorkflow(state);
-		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
-		const failedDefinition = WorkflowTopology.fromWorkflow(wf).defsById.get(args.nodeId);
-		const webhookControlSignal = state.executionOptions?.webhook && failedDefinition?.kind === "trigger" ? this.asWebhookControlSignal(args.error) : void 0;
-		if (webhookControlSignal) return await this.resumeFromWebhookControl({
-			state,
-			workflow: wf,
-			args,
-			signal: webhookControlSignal
-		});
-		if (failedDefinition && failedDefinition.kind === "node") {
-			const nodeHandler = this.policyErrorServices.resolveNodeErrorHandler(failedDefinition.config.nodeErrorHandler);
-			if (nodeHandler) try {
-				const ctx = this.buildNodeExecutionContextForPending(state, wf, failedDefinition, args.nodeId);
-				const inputsByPort = state.pending.inputsByPort;
-				const portKeys = Object.keys(inputsByPort);
-				const kind = portKeys.length === 1 && portKeys[0] === "in" ? "single" : "multi";
-				const items = inputsByPort.in ?? [];
-				const recovered = await nodeHandler.handle({
-					kind,
-					items,
-					inputsByPort: kind === "multi" ? inputsByPort : void 0,
-					ctx,
-					error: args.error
-				});
-				return await this.resumeFromNodeResult({
-					runId: args.runId,
-					activationId: args.activationId,
-					nodeId: args.nodeId,
-					outputs: recovered
-				});
-			} catch {}
-		}
-		const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const message = args.error?.message ?? String(args.error);
-		const failedSnapshot = NodeSnapshotFactory.failed({
-			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			finishedAt,
-			inputsByPort: state.pending.inputsByPort,
-			error: args.error
-		});
-		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-			state,
-			engineCounters: state.engineCounters ?? { completedNodeActivations: 0 },
-			status: "failed",
-			queue: (state.queue ?? []).map((q) => ({ ...q })),
-			outputsByNode: state.outputsByNode,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[args.nodeId]: failedSnapshot
-			}
-		});
-		await this.runStore.save(failedState);
-		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
-		const wfErr = this.policyErrorServices.resolveWorkflowErrorHandler(wf.workflowErrorHandler);
-		if (wfErr) await Promise.resolve(wfErr.onError({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			workflow: wf,
-			failedNodeId: args.nodeId,
-			error: args.error,
-			startedAt: state.startedAt,
-			finishedAt
-		}));
-		await this.terminalPersistence.maybeDeleteAfterTerminalState({
-			workflow: wf,
-			state: failedState,
-			finalStatus: "failed",
-			finishedAt
-		});
-		const result = {
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			status: "failed",
-			error: { message }
-		};
-		this.waiters.resolveRunCompletion(result);
-		return result;
-	}
-	async resumeFromStepResult(args) {
-		return await this.resumeFromNodeResult(args);
-	}
-	async resumeFromStepError(args) {
-		return await this.resumeFromNodeError(args);
-	}
-	async waitForCompletion(runId) {
-		const existing = await this.runStore.load(runId);
-		if (existing?.status === "completed") {
-			const wf = this.resolvePersistedWorkflow(existing);
-			const outputs = wf ? this.semantics.resolveResultOutputs(wf, existing.control?.stopCondition, existing.outputsByNode) : [];
-			return {
-				runId: existing.runId,
-				workflowId: existing.workflowId,
-				startedAt: existing.startedAt,
-				status: "completed",
-				outputs
-			};
-		}
-		if (existing?.status === "failed") return {
-			runId: existing.runId,
-			workflowId: existing.workflowId,
-			startedAt: existing.startedAt,
-			status: "failed",
-			error: { message: "Run failed" }
-		};
-		const result = await this.waiters.waitForCompletion(runId);
-		if (result.status !== "completed" && result.status !== "failed") throw new Error(`Unexpected run completion status: ${result.status}`);
-		return result;
-	}
-	async waitForWebhookResponse(runId) {
-		return await this.waiters.waitForWebhookResponse(runId);
-	}
-	async resumeFromWebhookControl(args) {
-		const data = this.runDataFactory.create(args.state.outputsByNode);
-		const { topology, planner } = this.planningFactory.create(args.workflow);
-		const triggerOutputs = { main: args.signal.kind === "respondNowAndContinue" ? args.signal.continueItems ?? [] : args.signal.responseItems };
-		data.setOutputs(args.args.nodeId, triggerOutputs);
-		const completedSnapshot = this.semantics.createFinishedSnapshot({
-			workflow: args.workflow,
-			previous: args.state.nodeSnapshotsByNodeId?.[args.args.nodeId],
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			nodeId: args.args.nodeId,
-			activationId: args.args.activationId,
-			parent: args.state.parent,
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			inputsByPort: args.state.pending?.inputsByPort ?? InputPortMap.empty(),
-			outputs: triggerOutputs
-		});
-		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
-		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
-		if (this.semantics.isStopConditionSatisfied(args.state.control?.stopCondition, args.args.nodeId)) {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs: this.semantics.resolveResultOutputs(args.workflow, args.state.control?.stopCondition, data.dump())
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (args.signal.kind === "respondNow") {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs: args.signal.responseItems
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const batchId = args.state.pending?.batchId ?? "batch_1";
-		const queue = (args.state.queue ?? []).map((entry) => ({
-			...entry,
-			batchId: entry.batchId ?? batchId
-		}));
-		planner.applyOutputs(queue, {
-			fromNodeId: args.args.nodeId,
-			outputs: triggerOutputs,
-			batchId
-		});
-		const next = planner.nextActivation(queue);
-		if (!next) {
-			const lastNodeId = createWorkflowExecutableNodeClassifier(args.workflow).lastExecutableNodeIdInDefinitionOrder(args.workflow);
-			const outputs = data.getOutputItems(lastNodeId, "main");
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (completedActivations >= maxNodeActivations) {
-			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
-			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "failed",
-				queue: queue.map((q) => ({ ...q })),
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(failedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: failedState,
-				finalStatus: "failed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "failed",
-				error: { message }
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "pending",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const nextDefinition = topology.defsById.get(next.nodeId);
-		if (!nextDefinition || nextDefinition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const webhookLimits = this.resolveEngineLimitsFromState(args.state);
-		const base = this.runExecutionContextFactory.create({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			nodeId: nextDefinition.id,
-			parent: args.state.parent,
-			subworkflowDepth: args.state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent)
-		});
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base,
-			data,
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			parent: args.state.parent,
-			executionOptions: args.state.executionOptions,
-			nodeDefinition: nextDefinition
-		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			parent: args.state.parent,
-			executionOptions: args.state.executionOptions,
-			control: args.state.control,
-			workflowSnapshot: args.state.workflowSnapshot,
-			mutableState: args.state.mutableState,
-			policySnapshot: args.state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: {
-				...args.state.nodeSnapshotsByNodeId ?? {},
-				[args.args.nodeId]: completedSnapshot
-			},
-			planner,
-			engineCounters,
-			connectionInvocations: args.state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		this.waiters.resolveWebhookResponse({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			runStatus: "pending",
-			response: args.signal.responseItems
-		});
-		return result;
-	}
-	asWebhookControlSignal(error) {
-		const candidate = error;
-		if (!candidate || candidate.__webhookControl !== true) return void 0;
-		if (candidate.kind !== "respondNow" && candidate.kind !== "respondNowAndContinue") return void 0;
-		if (!Array.isArray(candidate.responseItems)) return void 0;
-		return candidate;
-	}
-	resolvePersistedWorkflow(state) {
-		return this.workflowSnapshotResolver.resolve({
-			workflowId: state.workflowId,
-			workflowSnapshot: state.workflowSnapshot
-		});
-	}
-	buildNodeExecutionContextForPending(state, wf, def, nodeId) {
-		const data = this.runDataFactory.create(state.outputsByNode);
-		const limits = this.resolveEngineLimitsFromState(state);
-		const base = this.runExecutionContextFactory.create({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId,
-			parent: state.parent,
-			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: limits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
-		});
-		const activationId = state.pending.activationId;
-		return {
-			...base,
-			data,
-			nodeId,
-			activationId,
-			config: def.config,
-			binary: base.binary.forNode({
-				nodeId,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(wf.id, nodeId, def.config)
-		};
-	}
-	resolveEngineLimitsFromState(state) {
-		const fb = this.executionLimitsPolicy.createRootExecutionOptions();
-		return {
-			engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fb.maxNodeActivations,
-			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fb.maxSubworkflowDepth
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/materialization/MissingRuntimeExecutionMarkerFactory.ts
-var MissingRuntimeExecutionMarker = class {
-	static isMarked(config) {
-		return Boolean(config?.missingRuntime);
-	}
-};
-
-//#endregion
-//#region src/engine/execution/RunStateSemantics.ts
-var RunStateSemantics = class {
-	isStopConditionSatisfied(stopCondition, nodeId) {
-		if (!stopCondition || stopCondition.kind === "workflowCompleted") return false;
-		return stopCondition.nodeId === nodeId;
-	}
-	resolveResultOutputs(workflow, stopCondition, outputsByNode) {
-		if (stopCondition?.kind === "nodeCompleted") return outputsByNode[stopCondition.nodeId]?.main ?? [];
-		return outputsByNode[createWorkflowExecutableNodeClassifier(workflow).lastExecutableNodeIdInDefinitionOrder(workflow)]?.main ?? [];
-	}
-	applySkippedSnapshots(args) {
-		const snapshots = { ...args.currentState.nodeSnapshotsByNodeId };
-		const skippedPinnedNodeIds = new Set(args.preservedPinnedNodeIds.filter((nodeId) => args.skippedNodeIds.includes(nodeId)));
-		for (const nodeId of args.skippedNodeIds) if (args.currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort) skippedPinnedNodeIds.add(nodeId);
-		for (const nodeId of skippedPinnedNodeIds) {
-			const previous = snapshots[nodeId];
-			snapshots[nodeId] = NodeSnapshotFactory.completed({
-				previous,
-				runId: args.runId,
-				workflowId: args.workflowId,
-				nodeId,
-				activationId: previous?.activationId ?? `synthetic_${nodeId}`,
-				parent: args.parent,
-				finishedAt: args.finishedAt,
-				inputsByPort: previous?.inputsByPort ?? InputPortMap.empty(),
-				outputs: args.currentState.outputsByNode[nodeId] ?? {},
-				fromPinnedOutput: true
-			});
-		}
-		return snapshots;
-	}
-	applyPinnedQueueSkips(args) {
-		let changed = true;
-		while (changed) {
-			changed = false;
-			for (let index = 0; index < args.queue.length; index += 1) {
-				const queueEntry = args.queue[index];
-				const pinnedOutputs = args.mutableState?.nodesById?.[queueEntry.nodeId]?.pinnedOutputsByPort;
-				if (!pinnedOutputs) continue;
-				args.queue.splice(index, 1);
-				const previous = args.nodeSnapshotsByNodeId[queueEntry.nodeId];
-				args.nodeSnapshotsByNodeId[queueEntry.nodeId] = NodeSnapshotFactory.completed({
-					previous,
-					runId: args.runId,
-					workflowId: args.workflowId,
-					nodeId: queueEntry.nodeId,
-					activationId: previous?.activationId ?? `synthetic_${queueEntry.nodeId}`,
-					parent: args.parent,
-					finishedAt: args.finishedAt,
-					inputsByPort: this.resolveQueueEntryInputsByPort(queueEntry),
-					outputs: pinnedOutputs,
-					fromPinnedOutput: true
-				});
-				args.data.setOutputs(queueEntry.nodeId, pinnedOutputs);
-				args.planner.applyOutputs(args.queue, {
-					fromNodeId: queueEntry.nodeId,
-					outputs: pinnedOutputs,
-					batchId: queueEntry.batchId ?? "batch_1"
-				});
-				changed = true;
-				break;
-			}
-		}
-	}
-	createFinishedSnapshot(args) {
-		const definition = args.workflow.nodes.find((node) => node.id === args.nodeId);
-		if (MissingRuntimeExecutionMarker.isMarked(definition?.config)) return NodeSnapshotFactory.skipped(args);
-		return NodeSnapshotFactory.completed(args);
-	}
-	resolveQueueEntryInputsByPort(queueEntry) {
-		if (queueEntry.collect) return queueEntry.collect.received;
-		return { [queueEntry.toInput ?? "in"]: queueEntry.input };
-	}
-};
-
-//#endregion
-//#region src/engine/execution/WorkflowRunExecutionContextFactory.ts
-/**
-* Shared {@link ExecutionContextFactory#create} wiring for workflow runners (base context before node-specific fields).
-*/
-var WorkflowRunExecutionContextFactory = class {
-	constructor(executionContextFactory, credentialResolverFactory) {
-		this.executionContextFactory = executionContextFactory;
-		this.credentialResolverFactory = credentialResolverFactory;
-	}
-	create(args) {
-		return this.executionContextFactory.create({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			parent: args.parent,
-			subworkflowDepth: args.subworkflowDepth,
-			engineMaxNodeActivations: args.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
-			data: args.data,
-			nodeState: args.nodeState,
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId)
-		});
-	}
-};
-
-//#endregion
-//#region src/engine/execution/WorkflowRunStarter.ts
-var WorkflowRunStarter = class {
-	constructor(runIdFactory, runStore, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
-		this.runIdFactory = runIdFactory;
-		this.runStore = runStore;
-		this.runDataFactory = runDataFactory;
-		this.workflowSnapshotFactory = workflowSnapshotFactory;
-		this.planningFactory = planningFactory;
-		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
-		this.runExecutionContextFactory = runExecutionContextFactory;
-		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
-		this.activationEnqueueService = activationEnqueueService;
-		this.waiters = waiters;
-		this.workflowPolicyRuntimeDefaults = workflowPolicyRuntimeDefaults;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-	}
-	async runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides) {
-		const runId = this.runIdFactory.makeRunId();
-		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const workflowSnapshot = persistedStateOverrides?.workflowSnapshot ?? this.workflowSnapshotFactory.create(wf);
-		const mutableState = persistedStateOverrides?.mutableState;
-		const policySnapshot = RunPolicySnapshotFactory.create(wf, this.workflowPolicyRuntimeDefaults);
-		const mergedExecutionOptions = this.executionLimitsPolicy.mergeExecutionOptionsForNewRun(parent, executionOptions);
-		await this.runStore.createRun({
-			runId,
-			workflowId: wf.id,
-			startedAt,
-			parent,
-			executionOptions: mergedExecutionOptions,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			engineCounters: { completedNodeActivations: 0 }
-		});
-		const data = this.runDataFactory.create();
-		const base = this.runExecutionContextFactory.create({
-			runId,
-			workflowId: wf.id,
-			nodeId: startAt,
-			parent,
-			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
-			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(runId, wf.id, parent)
-		});
-		const { topology, planner } = this.planningFactory.create(wf);
-		const startDef = topology.defsById.get(startAt);
-		if (!startDef) throw new Error(`Unknown start nodeId: ${startAt}`);
-		const batchId = "batch_1";
-		const queue = [];
-		const initialNodeSnapshotsByNodeId = {};
-		if (startDef.kind === "trigger") {
-			const request$1 = this.nodeActivationRequestComposer.createSingleFromDefinition({
-				runId,
-				workflowId: wf.id,
-				definition: startDef,
-				parent,
-				executionOptions: mergedExecutionOptions,
-				batchId,
-				input: items,
-				base,
-				data
-			});
-			return await this.activationEnqueueService.enqueueActivation({
-				runId,
-				workflowId: wf.id,
-				startedAt,
-				parent,
-				executionOptions: mergedExecutionOptions,
-				workflowSnapshot,
-				mutableState,
-				policySnapshot,
-				control: void 0,
-				pendingQueue: [],
-				request: request$1,
-				previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
-				planner,
-				engineCounters: { completedNodeActivations: 0 },
-				connectionInvocations: []
-			});
-		}
-		queue.push({
-			nodeId: startAt,
-			input: items,
-			toInput: "in",
-			batchId
-		});
-		const next = planner.nextActivation(queue);
-		if (!next) {
-			const lastNodeId = createWorkflowExecutableNodeClassifier(wf).lastExecutableNodeIdInDefinitionOrder(wf);
-			const outputs = data.getOutputItems(lastNodeId, "main");
-			await this.runStore.save({
-				runId,
-				workflowId: wf.id,
-				startedAt,
-				parent,
-				executionOptions: mergedExecutionOptions,
-				workflowSnapshot,
-				mutableState,
-				policySnapshot,
-				engineCounters: { completedNodeActivations: 0 },
-				connectionInvocations: [],
-				status: "completed",
-				pending: void 0,
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId
-			});
-			const result = {
-				runId,
-				workflowId: wf.id,
-				startedAt,
-				status: "completed",
-				outputs
-			};
-			this.waiters.resolveRunCompletion(result);
-			return result;
-		}
-		const def = topology.defsById.get(next.nodeId);
-		if (!def || def.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base,
-			data,
-			runId,
-			workflowId: wf.id,
-			parent,
-			executionOptions: mergedExecutionOptions,
-			nodeDefinition: def
-		});
-		return await this.activationEnqueueService.enqueueActivation({
-			runId,
-			workflowId: wf.id,
-			startedAt,
-			parent,
-			executionOptions: mergedExecutionOptions,
-			control: void 0,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
-			planner,
-			engineCounters: { completedNodeActivations: 0 },
-			connectionInvocations: []
-		});
-	}
-};
-
-//#endregion
-//#region src/engine/policies/RunTerminalPersistenceCoordinator.ts
-var RunTerminalPersistenceCoordinator = class {
-	constructor(runStore, storageEvaluator) {
-		this.runStore = runStore;
-		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.runStore.deleteRun) return;
-		await this.runStore.deleteRun(args.state.runId);
-	}
-};
-
-//#endregion
-//#region src/engine/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/engine/policies/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/engine/credentials/CredentialResolverFactory.ts
-var CredentialResolverFactory = class {
-	constructor(credentialSessions) {
-		this.credentialSessions = credentialSessions;
-	}
-	create(workflowId, nodeId, config) {
-		const acceptedTypesBySlot = /* @__PURE__ */ new Map();
-		for (const requirement of config?.getCredentialRequirements?.() ?? []) acceptedTypesBySlot.set(requirement.slotKey, requirement.acceptedTypes);
-		return async (slotKey) => {
-			try {
-				return await this.credentialSessions.getSession({
-					workflowId,
-					nodeId,
-					slotKey
-				});
-			} catch (error) {
-				const acceptedTypes = acceptedTypesBySlot.get(slotKey) ?? [];
-				const message = error instanceof Error ? error.message : String(error);
-				const alreadyListsAcceptedTypes = message.includes("Accepted types:") || message.includes("Accepted credential types:") || message.includes("binding points at an unknown type");
-				const acceptedTypesSuffix = acceptedTypes.length > 0 && !alreadyListsAcceptedTypes ? ` Accepted types: ${acceptedTypes.join(", ")}.` : "";
-				throw new Error(`Failed to resolve credential for workflow ${workflowId} node ${nodeId} slot "${slotKey}". ${message}${acceptedTypesSuffix}`, { cause: error });
-			}
-		};
-	}
-};
-
-//#endregion
-//#region src/events/NodeEventPublisher.ts
-/** Publishes node lifecycle snapshots onto the run {@link RunEventBus}. */
-var NodeEventPublisher = class {
-	constructor(eventBus) {
-		this.eventBus = eventBus;
-	}
-	async publish(kind, snapshot) {
-		if (!this.eventBus) return;
-		await this.eventBus.publish({
-			kind,
-			runId: snapshot.runId,
-			workflowId: snapshot.workflowId,
-			parent: snapshot.parent,
-			at: snapshot.updatedAt,
-			snapshot
-		});
-	}
-};
-
-//#endregion
-//#region src/engine/planning/RunQueuePlannerDiagnostics.ts
-var RunQueuePlannerDiagnostics = class {
-	constructor(topology, nodeInstances) {
-		this.topology = topology;
-		this.nodeInstances = nodeInstances;
-	}
-	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/engine/planning/RunQueuePlanner.ts
-var RunQueuePlanner = class {
-	diagnostics;
-	constructor(topology, nodeInstances) {
-		this.topology = topology;
-		this.nodeInstances = nodeInstances;
-		this.diagnostics = new RunQueuePlannerDiagnostics(topology, 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.diagnostics.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";
-	}
-};
-
-//#endregion
-//#region src/engine/planning/EngineWorkflowPlanningFactory.ts
-var EngineWorkflowPlanningFactory = class {
-	constructor(workflowNodeInstanceFactory, directedCycleDetector) {
-		this.workflowNodeInstanceFactory = workflowNodeInstanceFactory;
-		this.directedCycleDetector = directedCycleDetector;
-	}
-	create(workflow) {
-		this.directedCycleDetector.validateAcyclic(workflow);
-		const topology = WorkflowTopology.fromWorkflow(workflow);
-		const planner = new RunQueuePlanner(topology, this.workflowNodeInstanceFactory.createNodes(workflow));
-		planner.validateNodeKinds();
-		return {
-			topology,
-			planner
-		};
-	}
-};
-
-//#endregion
-//#region src/engine/planning/DirectedCycleDetector.ts
-/**
-* Rejects workflow definitions whose edges contain a directed cycle (including self-loops).
-*/
-var DirectedCycleDetector = class {
-	validateAcyclic(workflow) {
-		const classifier = createWorkflowExecutableNodeClassifier(workflow);
-		const outgoing = this.buildOutgoingAdjacency(workflow, classifier);
-		const state = /* @__PURE__ */ new Map();
-		for (const n of workflow.nodes) if (classifier.isExecutableNodeId(n.id)) state.set(n.id, "unvisited");
-		for (const n of workflow.nodes) if (classifier.isExecutableNodeId(n.id) && state.get(n.id) === "unvisited") this.depthFirstSearch(n.id, outgoing, state);
-	}
-	buildOutgoingAdjacency(workflow, classifier) {
-		const map = /* @__PURE__ */ new Map();
-		for (const e of workflow.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = map.get(e.from.nodeId) ?? [];
-			list.push(e.to.nodeId);
-			map.set(e.from.nodeId, list);
-		}
-		return map;
-	}
-	depthFirstSearch(nodeId, outgoing, visitState) {
-		visitState.set(nodeId, "visiting");
-		for (const toId of outgoing.get(nodeId) ?? []) {
-			const s = visitState.get(toId);
-			if (s === "visiting") throw new Error(`Workflow graph contains a directed cycle (edge ${nodeId} -> ${toId}).`);
-			if (s === "unvisited") this.depthFirstSearch(toId, outgoing, visitState);
-		}
-		visitState.set(nodeId, "done");
-	}
-};
-
-//#endregion
-//#region src/engine/state/BoundNodeExecutionStatePublisher.ts
-var BoundNodeExecutionStatePublisher = class {
-	chain = Promise.resolve();
-	constructor(runStore, runId, workflowId, parent, publishNodeEvent) {
-		this.runStore = runStore;
-		this.runId = runId;
-		this.workflowId = workflowId;
-		this.parent = parent;
-		this.publishNodeEvent = publishNodeEvent;
-	}
-	markQueued(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.queued({
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				queuedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty()
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeQueued", snapshot);
-		});
-	}
-	markRunning(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.running({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				startedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty()
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeStarted", snapshot);
-		});
-	}
-	markCompleted(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.completed({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				finishedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty(),
-				outputs: args.outputs ?? previous?.outputs ?? {}
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeCompleted", snapshot);
-		});
-	}
-	markFailed(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.failed({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				finishedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty(),
-				error: args.error
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeFailed", snapshot);
-		});
-	}
-	appendConnectionInvocation(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const record = {
-				invocationId: args.invocationId,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				connectionNodeId: args.connectionNodeId,
-				parentAgentNodeId: args.parentAgentNodeId,
-				parentAgentActivationId: args.parentAgentActivationId,
-				status: args.status,
-				managedInput: args.managedInput,
-				managedOutput: args.managedOutput,
-				error: args.error,
-				queuedAt: args.queuedAt,
-				startedAt: args.startedAt,
-				finishedAt: args.finishedAt,
-				updatedAt
-			};
-			await this.runStore.save({
-				...state,
-				connectionInvocations: [...state.connectionInvocations ?? [], record]
-			});
-		});
-	}
-	enqueue(work) {
-		const next = this.chain.then(work);
-		this.chain = next.catch(() => void 0);
-		return next;
-	}
-	async loadState() {
-		const state = await this.runStore.load(this.runId);
-		if (!state) throw new Error(`Unknown runId: ${this.runId}`);
-		return state;
-	}
-	async saveSnapshot(state, snapshot) {
-		await this.runStore.save({
-			...state,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[snapshot.nodeId]: snapshot
-			}
-		});
-	}
-};
-
-//#endregion
-//#region src/engine/state/NodeExecutionStatePublisherFactory.ts
-var NodeExecutionStatePublisherFactory = class {
-	constructor(runStore, nodeEventPublisher) {
-		this.runStore = runStore;
-		this.nodeEventPublisher = nodeEventPublisher;
-	}
-	create(runId, workflowId, parent) {
-		return new BoundNodeExecutionStatePublisher(this.runStore, runId, workflowId, parent, async (kind, snapshot) => {
-			await this.nodeEventPublisher.publish(kind, snapshot);
-		});
-	}
-};
-
-//#endregion
-//#region src/engine/triggers/TriggerRuntimeService.ts
-var TriggerRuntimeService = class {
-	credentialResolverFactory;
-	triggerCleanupHandlesByKey = /* @__PURE__ */ new Map();
-	constructor(workflowRepository, workflowActivationPolicy, runIdFactory, runDataFactory, executionContextFactory, credentialResolverFactory, nodeExecutionStatePublisherFactory, nodeResolver, triggerSetupStateStore, 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.triggerSetupStateStore = triggerSetupStateStore;
-		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.triggerSetupStateStore.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.triggerSetupStateStore.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.triggerSetupStateStore.delete(trigger);
-			else await this.triggerSetupStateStore.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/engine/waiters/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/engine/api/EngineFactory.ts
-/**
-* Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
-* {@link import("../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 NodeExecutionStatePublisherFactory(deps.runStore, nodeEventPublisher);
-		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory, new DirectedCycleDetector());
-		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new EngineExecutionLimitsPolicy();
-		const workflowSnapshotFactory = new require_PersistedWorkflowSnapshotFactory.PersistedWorkflowSnapshotFactory(deps.tokenRegistry);
-		const persistedWorkflowConfigHydrator = deps.persistedWorkflowConfigHydrator ?? new PersistedWorkflowConfigHydrator(deps.tokenRegistry);
-		const missingRuntimeNodeDefinitionFactory = deps.missingRuntimeNodeDefinitionFactory ?? new MissingRuntimeNodeDefinitionFactory();
-		const workflowSnapshotResolver = new PersistedWorkflowResolver(deps.workflowRepository, deps.tokenRegistry, persistedWorkflowConfigHydrator, missingRuntimeNodeDefinitionFactory);
-		const semantics = new RunStateSemantics();
-		const activationEnqueueService = new ActivationEnqueueService(deps.activationScheduler, deps.runStore, 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.runStore, storagePolicyEvaluator);
-		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
-		const workflowRunStarter = new WorkflowRunStarter(deps.runIdFactory, deps.runStore, deps.runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
-		const currentStateRunStarter = new CurrentStateRunStarter(deps.runIdFactory, deps.runStore, deps.runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
-		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.runStore, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
-		const triggerRuntime = new TriggerRuntimeService(deps.workflowRepository, deps.workflowActivationPolicy, deps.runIdFactory, deps.runDataFactory, deps.executionContextFactory, credentialResolverFactory, nodeStatePublisherFactory, deps.nodeResolver, deps.triggerSetupStateStore, { emit: async (workflow, triggerNodeId, items) => {
-			await workflowRunStarter.runWorkflow(workflow, triggerNodeId, items, void 0);
-		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics);
-		const engine = new Engine({
-			workflowCatalog: deps.workflowCatalog,
-			tokenRegistry: deps.tokenRegistry,
-			webhookTriggerMatcher: deps.webhookTriggerMatcher,
-			workflowSnapshotResolver,
-			triggerRuntime,
-			workflowRunStarter,
-			currentStateRunStarter,
-			runContinuationService
-		});
-		deps.activationScheduler.setContinuation?.(engine);
-		return engine;
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'ConnectionNodeIdFactory', {
-  enumerable: true,
-  get: function () {
-    return ConnectionNodeIdFactory;
-  }
-});
-Object.defineProperty(exports, 'CredentialResolverFactory', {
-  enumerable: true,
-  get: function () {
-    return CredentialResolverFactory;
-  }
-});
-Object.defineProperty(exports, 'ENGINE_EXECUTION_LIMITS_DEFAULTS', {
-  enumerable: true,
-  get: function () {
-    return ENGINE_EXECUTION_LIMITS_DEFAULTS;
-  }
-});
-Object.defineProperty(exports, 'Engine', {
-  enumerable: true,
-  get: function () {
-    return Engine;
-  }
-});
-Object.defineProperty(exports, 'EngineExecutionLimitsPolicy', {
-  enumerable: true,
-  get: function () {
-    return EngineExecutionLimitsPolicy;
-  }
-});
-Object.defineProperty(exports, 'EngineFactory', {
-  enumerable: true,
-  get: function () {
-    return EngineFactory;
-  }
-});
-Object.defineProperty(exports, 'MissingRuntimeNodeToken', {
-  enumerable: true,
-  get: function () {
-    return MissingRuntimeNodeToken;
-  }
-});
-Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
-  enumerable: true,
-  get: function () {
-    return MissingRuntimeTriggerToken;
-  }
-});
-Object.defineProperty(exports, 'NodeEventPublisher', {
-  enumerable: true,
-  get: function () {
-    return NodeEventPublisher;
-  }
-});
-Object.defineProperty(exports, 'RunPolicySnapshotFactory', {
-  enumerable: true,
-  get: function () {
-    return RunPolicySnapshotFactory;
-  }
-});
-Object.defineProperty(exports, 'RunTerminalPersistenceCoordinator', {
-  enumerable: true,
-  get: function () {
-    return RunTerminalPersistenceCoordinator;
-  }
-});
-Object.defineProperty(exports, 'WorkflowExecutableNodeClassifier', {
-  enumerable: true,
-  get: function () {
-    return WorkflowExecutableNodeClassifier;
-  }
-});
-Object.defineProperty(exports, 'WorkflowPolicyErrorServices', {
-  enumerable: true,
-  get: function () {
-    return WorkflowPolicyErrorServices;
-  }
-});
-Object.defineProperty(exports, 'WorkflowStoragePolicyEvaluator', {
-  enumerable: true,
-  get: function () {
-    return WorkflowStoragePolicyEvaluator;
-  }
-});
-Object.defineProperty(exports, 'createWorkflowExecutableNodeClassifier', {
-  enumerable: true,
-  get: function () {
-    return createWorkflowExecutableNodeClassifier;
-  }
-});
-//# sourceMappingURL=EngineFactory-CBnntY3J.cjs.map