@codemation/core 0.0.5 → 0.0.7

package/dist/RunIntentService-DlQH5eZ2.cjs

@@ -0,0 +1,3467 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+require("reflect-metadata");
+let tsyringe = require("tsyringe");
+tsyringe = __toESM(tsyringe);
+let node_stream_web = require("node:stream/web");
+node_stream_web = __toESM(node_stream_web);
+
+//#region src/workflow/definition/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/workflow/definition/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/definition/WorkflowExecutableNodeClassifierFactory.ts
+var WorkflowExecutableNodeClassifierFactory = class {
+	static create(workflow) {
+		return new WorkflowExecutableNodeClassifier(workflow);
+	}
+};
+
+//#endregion
+//#region src/di/CoreTokens.ts
+const CoreTokens = {
+	PersistedWorkflowTokenRegistry: Symbol.for("codemation.core.PersistedWorkflowTokenRegistry"),
+	CredentialSessionService: Symbol.for("codemation.core.CredentialSessionService"),
+	CredentialTypeRegistry: Symbol.for("codemation.core.CredentialTypeRegistry"),
+	WorkflowRunnerService: Symbol.for("codemation.core.WorkflowRunnerService"),
+	LiveWorkflowRepository: Symbol.for("codemation.core.LiveWorkflowRepository"),
+	WorkflowRepository: Symbol.for("codemation.core.WorkflowRepository"),
+	NodeResolver: Symbol.for("codemation.core.NodeResolver"),
+	WorkflowNodeInstanceFactory: Symbol.for("codemation.core.WorkflowNodeInstanceFactory"),
+	RunIdFactory: Symbol.for("codemation.core.RunIdFactory"),
+	ActivationIdFactory: Symbol.for("codemation.core.ActivationIdFactory"),
+	WorkflowExecutionRepository: Symbol.for("codemation.core.WorkflowExecutionRepository"),
+	TriggerSetupStateRepository: Symbol.for("codemation.core.TriggerSetupStateRepository"),
+	NodeActivationScheduler: Symbol.for("codemation.core.NodeActivationScheduler"),
+	RunDataFactory: Symbol.for("codemation.core.RunDataFactory"),
+	ExecutionContextFactory: Symbol.for("codemation.core.ExecutionContextFactory"),
+	RunEventBus: Symbol.for("codemation.core.RunEventBus"),
+	BinaryStorage: Symbol.for("codemation.core.BinaryStorage"),
+	WebhookBasePath: Symbol.for("codemation.core.WebhookBasePath"),
+	EngineExecutionLimitsPolicy: Symbol.for("codemation.core.EngineExecutionLimitsPolicy"),
+	WorkflowActivationPolicy: Symbol.for("codemation.core.WorkflowActivationPolicy")
+};
+
+//#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/runtime-types/persistedRuntimeTypeModelRegistry.ts
+/** Shared metadata key used to attach persisted runtime-type information to decorated classes. */
+const persistedRuntimeTypeMetadataKey = Symbol.for("codemation.core.persistedRuntimeTypeMetadata");
+/** Normalizes decorator options so persistence metadata has stable defaults. */
+var PersistedRuntimeTypeDecoratorDefaults = class {
+	static appPackageName = "app";
+	static apply(options) {
+		return {
+			...options,
+			packageName: options.packageName ?? this.appPackageName
+		};
+	}
+};
+
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeNameResolver.ts
+/** Resolves the persisted type name from either an explicit override or the class name itself. */
+var PersistedRuntimeTypeNameResolver = class {
+	static resolve(target, override) {
+		const resolved = override ?? target.name;
+		if (!resolved) throw new Error("Persisted runtime token metadata requires a named class or an explicit decorator name override.");
+		return resolved;
+	}
+};
+
+//#endregion
+//#region src/runtime-types/StackTraceCallSitePathResolver.ts
+var StackTraceCallSitePathResolver = class {
+	static resolve(decoratorFileUrl) {
+		const stack = (/* @__PURE__ */ new Error()).stack ?? "";
+		for (const line of stack.split("\n")) {
+			const candidate = this.extractPath(line.trim());
+			if (!candidate) continue;
+			if (candidate === decoratorFileUrl || candidate.includes("runtimeTypeDecorators")) continue;
+			return candidate;
+		}
+	}
+	static extractPath(line) {
+		const fileUrlMatch = line.match(/file:\/\/[^\s)]+/);
+		if (fileUrlMatch) return fileUrlMatch[0];
+		const parenMatch = line.match(/\((\/[^)]+)\)/);
+		if (parenMatch) return parenMatch[1];
+		return line.match(/at (\/[^\s]+)/)?.[1];
+	}
+};
+
+//#endregion
+//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.ts
+/**
+* Defines and retrieves persisted runtime metadata on decorated classes.
+* The metadata is attached as a non-enumerable property so runtime objects stay serializable.
+*/
+var PersistedRuntimeTypeMetadataStore = class {
+	static define(target, kind, options, decoratorFileUrl) {
+		const normalizedOptions = PersistedRuntimeTypeDecoratorDefaults.apply(options);
+		const metadata = {
+			persistedName: PersistedRuntimeTypeNameResolver.resolve(target, normalizedOptions.name),
+			kind,
+			packageName: normalizedOptions.packageName ?? PersistedRuntimeTypeDecoratorDefaults.appPackageName,
+			sourceHint: normalizedOptions.moduleUrl ?? StackTraceCallSitePathResolver.resolve(decoratorFileUrl)
+		};
+		Object.defineProperty(target, persistedRuntimeTypeMetadataKey, {
+			configurable: false,
+			enumerable: false,
+			writable: false,
+			value: metadata
+		});
+	}
+	static get(target) {
+		if (!target || typeof target !== "function" && typeof target !== "object") return;
+		return target[persistedRuntimeTypeMetadataKey];
+	}
+};
+
+//#endregion
+//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.ts
+/**
+* Applies both tsyringe injectability and persisted runtime metadata in one decorator.
+* This keeps runtime-type decorators thin while still recording enough data for snapshot hydration.
+*/
+var InjectableRuntimeDecoratorComposer = class {
+	static compose(kind, options, decoratorFileUrl) {
+		return (target) => {
+			(0, tsyringe.injectable)()(target);
+			PersistedRuntimeTypeMetadataStore.define(target, kind, options, decoratorFileUrl);
+		};
+	}
+};
+
+//#endregion
+//#region src/runtime-types/runtimeTypeDecorators.types.ts
+/** Reads persisted runtime metadata from a decorated class or object. */
+function getPersistedRuntimeTypeMetadata(target) {
+	return PersistedRuntimeTypeMetadataStore.get(target);
+}
+/** Marks a class as a persisted node runtime type and an injectable tsyringe service. */
+function node(options = {}) {
+	return InjectableRuntimeDecoratorComposer.compose("node", options, require("url").pathToFileURL(__filename).href);
+}
+/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
+function tool(options = {}) {
+	return InjectableRuntimeDecoratorComposer.compose("tool", options, require("url").pathToFileURL(__filename).href);
+}
+/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
+function chatModel(options = {}) {
+	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, require("url").pathToFileURL(__filename).href);
+}
+
+//#endregion
+//#region src/binaries/DefaultNodeBinaryAttachmentServiceFactory.ts
+var DefaultNodeBinaryAttachmentService = class DefaultNodeBinaryAttachmentService {
+	constructor(storage, workflowId, runId, nodeId, activationId, now) {
+		this.storage = storage;
+		this.workflowId = workflowId;
+		this.runId = runId;
+		this.nodeId = nodeId;
+		this.activationId = activationId;
+		this.now = now;
+	}
+	async attach(args) {
+		const attachmentId = this.createAttachmentId();
+		const createdAt = this.now().toISOString();
+		const storageKey = this.createStorageKey(args, attachmentId);
+		const stored = await this.storage.write({
+			storageKey,
+			body: args.body
+		});
+		return {
+			id: attachmentId,
+			storageKey: stored.storageKey,
+			mimeType: args.mimeType,
+			size: stored.size,
+			storageDriver: this.storage.driverName,
+			previewKind: args.previewKind ?? this.resolvePreviewKind(args.mimeType),
+			createdAt,
+			runId: this.runId,
+			workflowId: this.workflowId,
+			nodeId: this.nodeId,
+			activationId: this.activationId,
+			filename: args.filename,
+			sha256: stored.sha256
+		};
+	}
+	withAttachment(item, name, attachment) {
+		return {
+			...item,
+			binary: {
+				...item.binary ?? {},
+				[name]: attachment
+			}
+		};
+	}
+	forNode(args) {
+		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
+	}
+	async openReadStream(attachment) {
+		return await this.storage.openReadStream(attachment.storageKey);
+	}
+	createAttachmentId() {
+		return DefaultNodeBinaryAttachmentService.createAttachmentIdValue(`${this.activationId}-${this.now().getTime()}`);
+	}
+	static createAttachmentIdValue(fallbackValue) {
+		const cryptoObject = globalThis.crypto;
+		if (cryptoObject && typeof cryptoObject.randomUUID === "function") return cryptoObject.randomUUID();
+		return fallbackValue;
+	}
+	createStorageKey(args, attachmentId) {
+		const safeName = this.sanitizeSegment(args.name);
+		const safeFilename = this.sanitizeFilename(args.filename);
+		const filenameSuffix = safeFilename ? `-${safeFilename}` : "";
+		return `${this.sanitizeSegment(this.workflowId)}/${this.sanitizeSegment(this.runId)}/${this.sanitizeSegment(this.nodeId)}/${this.sanitizeSegment(this.activationId)}/${attachmentId}-${safeName}${filenameSuffix}`;
+	}
+	sanitizeSegment(value) {
+		const normalized = value.trim();
+		if (!normalized) return "item";
+		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	}
+	sanitizeFilename(value) {
+		if (!value) return;
+		const normalized = value.trim().split("/").at(-1)?.split("\\").at(-1) ?? value.trim();
+		if (!normalized) return;
+		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	}
+	resolvePreviewKind(mimeType) {
+		if (mimeType.startsWith("image/")) return "image";
+		if (mimeType.startsWith("audio/")) return "audio";
+		if (mimeType.startsWith("video/")) return "video";
+		return "download";
+	}
+};
+
+//#endregion
+//#region src/binaries/UnavailableBinaryStorage.ts
+var UnavailableBinaryStorage = class {
+	driverName = "unavailable";
+	async write() {
+		throw new Error("Binary storage is not configured for this runtime.");
+	}
+	async openReadStream() {}
+	async stat() {
+		return { exists: false };
+	}
+	async delete() {}
+};
+
+//#endregion
+//#region src/binaries/DefaultExecutionBinaryServiceFactory.ts
+var DefaultExecutionBinaryService = class {
+	constructor(storage, workflowId, runId, now) {
+		this.storage = storage;
+		this.workflowId = workflowId;
+		this.runId = runId;
+		this.now = now;
+	}
+	forNode(args) {
+		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
+	}
+	async openReadStream(attachment) {
+		return await this.storage.openReadStream(attachment.storageKey);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutionSnapshotFactory.ts
+var NodeExecutionSnapshotFactory = 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/execution/NodeInputsByPortFactory.ts
+var NodeInputsByPortFactory = class {
+	static empty() {
+		return {};
+	}
+	static fromRequest(request) {
+		if (request.kind === "multi") return request.inputsByPort;
+		return { in: request.input };
+	}
+};
+
+//#endregion
+//#region src/execution/ActivationEnqueueService.ts
+var ActivationEnqueueService = class {
+	constructor(activationScheduler, workflowExecutionRepository, nodeEventPublisher) {
+		this.activationScheduler = activationScheduler;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		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 = NodeInputsByPortFactory.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 = NodeExecutionSnapshotFactory.queued({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.request.nodeId,
+			activationId: args.request.activationId,
+			parent: args.parent,
+			queuedAt: enqueuedAt,
+			inputsByPort
+		});
+		await this.workflowExecutionRepository.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/execution/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/execution/DefaultAsyncSleeper.ts
+var DefaultAsyncSleeper = class {
+	sleep(ms) {
+		return new Promise((resolve) => {
+			setTimeout(resolve, ms);
+		});
+	}
+};
+
+//#endregion
+//#region src/execution/DefaultExecutionContextFactory.ts
+var DefaultExecutionContextFactory = class {
+	constructor(binaryStorage = new UnavailableBinaryStorage(), currentDate = () => /* @__PURE__ */ new Date()) {
+		this.binaryStorage = binaryStorage;
+		this.currentDate = currentDate;
+	}
+	create(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			subworkflowDepth: args.subworkflowDepth,
+			engineMaxNodeActivations: args.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
+			now: this.currentDate,
+			data: args.data,
+			nodeState: args.nodeState,
+			binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
+			getCredential: args.getCredential
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/InProcessRetryRunner.ts
+var InProcessRetryRunner = class InProcessRetryRunner {
+	constructor(sleeper) {
+		this.sleeper = sleeper;
+	}
+	async run(policy, work) {
+		const spec = InProcessRetryRunner.normalizePolicy(policy);
+		let lastError;
+		for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) try {
+			return await work();
+		} catch (error) {
+			lastError = error;
+			if (attempt >= spec.maxAttempts) break;
+			const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
+			await this.sleeper.sleep(delayMs);
+		}
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+	static delayAfterFailureMs(spec, failedAttempt) {
+		if (spec.kind === "none") return 0;
+		if (spec.kind === "fixed") return spec.delayMs;
+		const exponent = failedAttempt - 1;
+		let ms = spec.initialDelayMs * Math.pow(spec.multiplier, exponent);
+		if (spec.jitter === true) ms *= 1 + Math.random() * .2;
+		if (spec.maxDelayMs !== void 0 && ms > spec.maxDelayMs) ms = spec.maxDelayMs;
+		return Math.max(0, Math.floor(ms));
+	}
+	static normalizePolicy(policy) {
+		if (policy === void 0) return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		if (typeof policy !== "object" || policy === null) return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		const kind = policy.kind;
+		if (kind === "none") return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		if (kind === "fixed") {
+			const p = policy;
+			return {
+				kind: "fixed",
+				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts"),
+				delayMs: InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs")
+			};
+		}
+		if (kind === "exponential") {
+			const p = policy;
+			return {
+				kind: "exponential",
+				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
+				initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
+				multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
+				maxDelayMs: p.maxDelayMs === void 0 ? void 0 : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
+				jitter: p.jitter === true
+			};
+		}
+		return {
+			kind: "none",
+			maxAttempts: 1
+		};
+	}
+	static assertPositiveInt(value, label) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) throw new Error(`Retry policy ${label} must be a positive integer`);
+		return value;
+	}
+	static assertNonNegativeFinite(value, label) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`Retry policy ${label} must be a non-negative finite number`);
+		return value;
+	}
+	static assertMultiplier(value) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 1) throw new Error(`Retry policy exponential.multiplier must be >= 1`);
+		return value;
+	}
+};
+
+//#endregion
+//#region src/execution/InProcessRetryRunnerFactory.ts
+var InProcessRetryRunnerFactory = class {
+	create(defaultAsyncSleeper) {
+		return new InProcessRetryRunner(defaultAsyncSleeper);
+	}
+};
+
+//#endregion
+//#region src/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) {
+		return this.createSingleFromDefinitionWithActivation({
+			...args,
+			activationId: this.activationIdFactory.makeActivationId()
+		});
+	}
+	createSingleFromDefinitionWithActivation(args) {
+		const ctx = this.createNodeExecutionContext(args, args.definition, args.activationId);
+		return {
+			kind: "single",
+			runId: args.runId,
+			activationId: args.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 = this.createNodeExecutionContext(args, args.nodeDefinition, activationId);
+		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
+		};
+	}
+	createNodeExecutionContext(args, definition, activationId) {
+		return {
+			...args.base,
+			data: args.data,
+			nodeId: definition.id,
+			activationId,
+			config: definition.config,
+			binary: args.base.binary.forNode({
+				nodeId: definition.id,
+				activationId
+			}),
+			getCredential: this.credentialResolverFactory.create(args.workflowId, definition.id, definition.config)
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutor.ts
+var NodeExecutor = class {
+	constructor(nodeInstanceFactory, retryRunner) {
+		this.nodeInstanceFactory = nodeInstanceFactory;
+		this.retryRunner = retryRunner;
+	}
+	async execute(request) {
+		const policy = request.ctx.config.retryPolicy;
+		return await this.retryRunner.run(policy, async () => {
+			const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
+			if (request.kind === "multi") return await this.executeMultiInputNode(request, nodeInstance);
+			return await this.executeSingleInputNode(request, nodeInstance);
+		});
+	}
+	async executeMultiInputNode(request, node$1) {
+		const multiInputNode = node$1;
+		if (typeof multiInputNode.executeMulti !== "function") throw new Error(`Node ${request.nodeId} does not support executeMulti but received multi-input activation`);
+		return await multiInputNode.executeMulti(request.inputsByPort, request.ctx);
+	}
+	async executeSingleInputNode(request, node$1) {
+		const singleInputNode = node$1;
+		if (typeof singleInputNode.execute !== "function") throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
+		return await singleInputNode.execute(request.input, request.ctx);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutorFactory.ts
+var NodeExecutorFactory = class {
+	create(workflowNodeInstanceFactory, retryRunner) {
+		return new NodeExecutor(workflowNodeInstanceFactory, retryRunner);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeExecutionMarker.ts
+var MissingRuntimeExecutionMarker = class {
+	isMarked(config) {
+		return Boolean(config?.missingRuntime);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeNodeToken.ts
+var MissingRuntimeNodeToken = class {};
+
+//#endregion
+//#region src/workflowSnapshots/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/workflowSnapshots/MissingRuntimeTriggerToken.ts
+var MissingRuntimeTriggerToken = class {};
+
+//#endregion
+//#region src/workflowSnapshots/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/workflowSnapshots/MissingRuntimeFallbacksFactory.ts
+var MissingRuntimeFallbacks = class {
+	createDefinition(snapshotNode) {
+		if (snapshotNode.kind === "trigger") return {
+			id: snapshotNode.id,
+			kind: "trigger",
+			name: snapshotNode.name,
+			type: MissingRuntimeTriggerToken,
+			config: new MissingRuntimeTriggerConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId)
+		};
+		return {
+			id: snapshotNode.id,
+			kind: "node",
+			name: snapshotNode.name,
+			type: MissingRuntimeNodeToken,
+			config: new MissingRuntimeNodeConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId)
+		};
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeNode.ts
+var MissingRuntimeNode = class {
+	kind = "node";
+	outputPorts = ["main"];
+	async execute(items) {
+		return { main: items };
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeTrigger.ts
+var MissingRuntimeTrigger = class {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(_ctx) {}
+	async execute(items) {
+		return { main: items };
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/PersistedRuntimeTypeIdFactory.ts
+var PersistedRuntimeTypeIdFactory = class {
+	static fromMetadata(args) {
+		const metadata = getPersistedRuntimeTypeMetadata(args.type);
+		if (!metadata) return;
+		const packageName = metadata.packageName;
+		if (!packageName) return;
+		return `${packageName}::${metadata.persistedName}`;
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/PersistedWorkflowTokenRegistry.ts
+var PersistedWorkflowTokenRegistry = class {
+	tokensById = /* @__PURE__ */ new Map();
+	tokenIdsByToken = /* @__PURE__ */ new Map();
+	/**
+	* Register a token with its package ID. Token ID is inferred as `packageId::tokenName`.
+	*/
+	register(type, packageId, persistedNameOverride) {
+		const tokenId = `${packageId}::${persistedNameOverride ?? this.displayNameForTypeToken(type)}`;
+		this.tokensById.set(tokenId, type);
+		this.tokenIdsByToken.set(type, tokenId);
+		return tokenId;
+	}
+	/**
+	* Register all decorated runtime types discovered in workflows.
+	*/
+	registerFromWorkflows(workflows) {
+		for (const workflow of workflows) for (const node$1 of workflow.nodes) {
+			this.registerDecoratedType(node$1.type);
+			this.registerDecoratedType(node$1.config.type);
+			this.registerNestedTypes(node$1.config);
+		}
+	}
+	registerDecoratedType(type) {
+		if (this.tokenIdsByToken.has(type)) return;
+		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type });
+		if (!tokenId) return;
+		this.tokensById.set(tokenId, type);
+		this.tokenIdsByToken.set(type, tokenId);
+	}
+	registerNestedTypes(value) {
+		if (Array.isArray(value)) {
+			for (const entry of value) this.registerNestedTypes(entry);
+			return;
+		}
+		if (!value || typeof value !== "object") return;
+		const record = value;
+		const type = this.asTypeToken(record.type);
+		if (type) this.registerDecoratedType(type);
+		for (const v of Object.values(record)) this.registerNestedTypes(v);
+	}
+	displayNameForTypeToken(token) {
+		if (typeof token === "function" && token.name) return token.name;
+		if (typeof token === "string") return token;
+		return "";
+	}
+	asTypeToken(value) {
+		if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") return value;
+	}
+	getTokenId(token) {
+		const existing = this.tokenIdsByToken.get(token);
+		if (existing) return existing;
+		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type: token });
+		if (!tokenId) return;
+		this.tokensById.set(tokenId, token);
+		this.tokenIdsByToken.set(token, tokenId);
+		return tokenId;
+	}
+	resolve(tokenId) {
+		return this.tokensById.get(tokenId);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/WorkflowSnapshotResolver.ts
+var WorkflowSnapshotResolver = class {
+	constructor(workflowRepository, tokenRegistry, codec, missingRuntimeFallbacks) {
+		this.workflowRepository = workflowRepository;
+		this.tokenRegistry = tokenRegistry;
+		this.codec = codec;
+		this.missingRuntimeFallbacks = missingRuntimeFallbacks;
+	}
+	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$1) => [node$1.id, node$1]));
+		const nodes = snapshot.nodes.map((snapshotNode) => {
+			const liveNode = liveNodesById.get(snapshotNode.id);
+			if (!this.isCompatibleLiveNode(liveNode, snapshotNode)) return this.missingRuntimeFallbacks.createDefinition(snapshotNode);
+			return {
+				id: snapshotNode.id,
+				kind: snapshotNode.kind,
+				name: snapshotNode.name ?? liveNode.name,
+				type: liveNode.type,
+				config: this.codec.hydrate(snapshotNode, liveNode.config)
+			};
+		});
+		const nodeIds = new Set(nodes.map((node$1) => node$1.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/execution/NodeInstanceFactory.ts
+var NodeInstanceFactory = class {
+	constructor(nodeResolver) {
+		this.nodeResolver = nodeResolver;
+	}
+	createNodes(workflow) {
+		const nodeInstances = /* @__PURE__ */ new Map();
+		for (const definition of workflow.nodes) nodeInstances.set(definition.id, this.createNode(definition));
+		return nodeInstances;
+	}
+	createNode(definition) {
+		return this.createByType(definition.type);
+	}
+	createByType(type) {
+		if (type === MissingRuntimeNodeToken) return new MissingRuntimeNode();
+		if (type === MissingRuntimeTriggerToken) return new MissingRuntimeTrigger();
+		return this.nodeResolver.resolve(type);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeInstanceFactoryFactory.ts
+var NodeInstanceFactoryFactory = class {
+	create(nodeResolver) {
+		return new NodeInstanceFactory(nodeResolver);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeRunStateWriter.ts
+var NodeRunStateWriter = class {
+	chain = Promise.resolve();
+	constructor(workflowExecutionRepository, runId, workflowId, parent, publishNodeEvent) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		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 = NodeExecutionSnapshotFactory.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 ?? NodeInputsByPortFactory.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 = NodeExecutionSnapshotFactory.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 ?? NodeInputsByPortFactory.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 = NodeExecutionSnapshotFactory.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 ?? NodeInputsByPortFactory.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 = NodeExecutionSnapshotFactory.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 ?? NodeInputsByPortFactory.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.workflowExecutionRepository.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.workflowExecutionRepository.load(this.runId);
+		if (!state) throw new Error(`Unknown runId: ${this.runId}`);
+		return state;
+	}
+	async saveSnapshot(state, snapshot) {
+		await this.workflowExecutionRepository.save({
+			...state,
+			nodeSnapshotsByNodeId: {
+				...state.nodeSnapshotsByNodeId ?? {},
+				[snapshot.nodeId]: snapshot
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/execution/NodeRunStateWriterFactory.ts
+var NodeRunStateWriterFactory = class {
+	constructor(workflowExecutionRepository, nodeEventPublisher) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.nodeEventPublisher = nodeEventPublisher;
+	}
+	create(runId, workflowId, parent) {
+		return new NodeRunStateWriter(this.workflowExecutionRepository, runId, workflowId, parent, async (kind, snapshot) => {
+			await this.nodeEventPublisher.publish(kind, snapshot);
+		});
+	}
+};
+
+//#endregion
+//#region src/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/execution/RunStateSemantics.ts
+var RunStateSemantics = class {
+	constructor(missingRuntimeExecutionMarker) {
+		this.missingRuntimeExecutionMarker = missingRuntimeExecutionMarker;
+	}
+	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[WorkflowExecutableNodeClassifierFactory.create(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] = NodeExecutionSnapshotFactory.completed({
+				previous,
+				runId: args.runId,
+				workflowId: args.workflowId,
+				nodeId,
+				activationId: previous?.activationId ?? `synthetic_${nodeId}`,
+				parent: args.parent,
+				finishedAt: args.finishedAt,
+				inputsByPort: previous?.inputsByPort ?? NodeInputsByPortFactory.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] = NodeExecutionSnapshotFactory.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$1) => node$1.id === args.nodeId);
+		if (this.missingRuntimeExecutionMarker.isMarked(definition?.config)) return NodeExecutionSnapshotFactory.skipped(args);
+		return NodeExecutionSnapshotFactory.completed(args);
+	}
+	resolveQueueEntryInputsByPort(queueEntry) {
+		if (queueEntry.collect) return queueEntry.collect.received;
+		return { [queueEntry.toInput ?? "in"]: queueEntry.input };
+	}
+};
+
+//#endregion
+//#region src/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/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 = WorkflowExecutableNodeClassifierFactory.create(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$1) => classifier.isExecutableNodeId(node$1.id) && !incomingByNode.has(node$1.id)).map((node$1) => node$1.id));
+	}
+};
+
+//#endregion
+//#region src/orchestration/RunContinuationService.ts
+var RunContinuationService = class {
+	constructor(activationIdFactory, workflowExecutionRepository, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy) {
+		this.activationIdFactory = activationIdFactory;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		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.workflowExecutionRepository.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 = NodeExecutionSnapshotFactory.running({
+			previous,
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: state.parent,
+			startedAt,
+			inputsByPort: args.inputsByPort
+		});
+		await this.workflowExecutionRepository.save({
+			...state,
+			nodeSnapshotsByNodeId: {
+				...state.nodeSnapshotsByNodeId ?? {},
+				[args.nodeId]: snapshot
+			}
+		});
+		await this.nodeEventPublisher.publish("nodeStarted", snapshot);
+	}
+	async resumeFromNodeResult(args) {
+		const state = await this.workflowExecutionRepository.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.workflowExecutionRepository.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 = this.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: ${this.formatOutputCounts(args.outputs)}.`, { cause });
+		}
+		if (!next) {
+			const lastNodeId = WorkflowExecutableNodeClassifierFactory.create(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.workflowExecutionRepository.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.workflowExecutionRepository.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.workflowExecutionRepository.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 = NodeExecutionSnapshotFactory.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.workflowExecutionRepository.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.workflowExecutionRepository.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 ?? NodeInputsByPortFactory.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.workflowExecutionRepository.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.workflowExecutionRepository.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 = WorkflowExecutableNodeClassifierFactory.create(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.workflowExecutionRepository.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.workflowExecutionRepository.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
+		};
+	}
+	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}`;
+	}
+	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/planning/CurrentStateFrontierPlanner.ts
+var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
+	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 baseState = this.cloneCurrentState(args.currentState);
+		const normalizedState = this.overlayPinnedOutputs(baseState);
+		const resetResult = this.applyReset({
+			currentState: normalizedState,
+			reset: args.reset
+		});
+		const requiredNodeIds = this.collectRequiredNodeIds(stopCondition, resetResult.currentState);
+		const satisfiedNodeIds = this.collectSatisfiedNodeIds(resetResult.currentState);
+		const skippedNodeIds = [...new Set([...[...requiredNodeIds].filter((nodeId) => this.isNodeSatisfied(resetResult.currentState, nodeId)), ...resetResult.preservedPinnedNodeIds.filter((nodeId) => requiredNodeIds.has(nodeId))])];
+		const frontierNodeIds = this.collectFrontierNodeIds(requiredNodeIds, resetResult.currentState);
+		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.resolveRootNodeInput({
+					nodeKind: definition.kind,
+					items: args.items
+				}),
+				queue: [],
+				currentState: resetResult.currentState,
+				stopCondition,
+				satisfiedNodeIds,
+				skippedNodeIds,
+				clearedNodeIds: resetResult.clearedNodeIds,
+				preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
+			};
+		}
+		const queue = [];
+		for (const nodeId of frontierNodeIds) queue.push(...this.buildFrontierQueue(nodeId, resetResult.currentState));
+		return {
+			queue,
+			currentState: resetResult.currentState,
+			stopCondition,
+			satisfiedNodeIds,
+			skippedNodeIds,
+			clearedNodeIds: resetResult.clearedNodeIds,
+			preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
+		};
+	}
+	cloneCurrentState(currentState) {
+		if (!currentState) return {
+			outputsByNode: {},
+			nodeSnapshotsByNodeId: {},
+			connectionInvocations: [],
+			mutableState: void 0
+		};
+		return {
+			outputsByNode: { ...currentState.outputsByNode },
+			nodeSnapshotsByNodeId: { ...currentState.nodeSnapshotsByNodeId },
+			connectionInvocations: currentState.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
+			mutableState: currentState.mutableState
+		};
+	}
+	overlayPinnedOutputs(currentState) {
+		const outputsByNode = { ...currentState.outputsByNode };
+		for (const [nodeId, nodeState] of Object.entries(currentState.mutableState?.nodesById ?? {})) {
+			const pinnedOutputs = nodeState.pinnedOutputsByPort;
+			if (!pinnedOutputs) continue;
+			outputsByNode[nodeId] = pinnedOutputs;
+		}
+		return {
+			outputsByNode,
+			nodeSnapshotsByNodeId: { ...currentState.nodeSnapshotsByNodeId },
+			connectionInvocations: currentState.connectionInvocations,
+			mutableState: currentState.mutableState
+		};
+	}
+	applyReset(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]) {
+			const pinnedOutputs = this.getPinnedOutputs(args.currentState, 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
+		};
+	}
+	collectSatisfiedNodeIds(currentState) {
+		const satisfiedNodeIds = [];
+		for (const nodeId of this.topology.defsById.keys()) if (this.isNodeSatisfied(currentState, nodeId)) satisfiedNodeIds.push(nodeId);
+		return satisfiedNodeIds;
+	}
+	collectFrontierNodeIds(requiredNodeIds, currentState) {
+		const frontierNodeIds = [];
+		for (const nodeId of this.topology.defsById.keys()) {
+			if (!requiredNodeIds.has(nodeId) || this.isNodeSatisfied(currentState, nodeId)) continue;
+			if ((this.topology.incomingByNode.get(nodeId) ?? []).every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.input))) frontierNodeIds.push(nodeId);
+		}
+		return frontierNodeIds;
+	}
+	collectRequiredNodeIds(stopCondition, currentState) {
+		const requiredNodeIds = /* @__PURE__ */ new Set();
+		if (stopCondition.kind === "workflowCompleted") {
+			for (const nodeId of this.topology.defsById.keys()) if (!this.isNodeSatisfied(currentState, nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, nodeId);
+			return requiredNodeIds;
+		}
+		if (!this.topology.defsById.has(stopCondition.nodeId)) throw new Error(`Unknown stop nodeId: ${stopCondition.nodeId}`);
+		this.collectRequiredNode(requiredNodeIds, currentState, stopCondition.nodeId);
+		return requiredNodeIds;
+	}
+	collectRequiredNode(requiredNodeIds, currentState, nodeId) {
+		if (requiredNodeIds.has(nodeId)) return;
+		if (this.isNodeSatisfied(currentState, nodeId) && !this.isNodeSatisfiedByOutputsOnly(currentState, nodeId)) return;
+		requiredNodeIds.add(nodeId);
+		for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) if (!this.isEdgeSatisfied(currentState, nodeId, edge.input) || this.isNodeSatisfiedByOutputsOnly(currentState, edge.from.nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, edge.from.nodeId);
+	}
+	buildFrontierQueue(nodeId, currentState) {
+		const incomingEdges = this.topology.incomingByNode.get(nodeId) ?? [];
+		if (incomingEdges.length === 0) return [];
+		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
+		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
+			const received = {};
+			for (const input$1 of expectedInputs) received[input$1] = this.resolveInput(currentState, nodeId, input$1);
+			return [{
+				nodeId,
+				input: [],
+				batchId: "batch_1",
+				collect: {
+					expectedInputs,
+					received
+				}
+			}];
+		}
+		const input = expectedInputs[0] ?? "in";
+		const incomingEdge = incomingEdges.find((edge) => edge.input === input);
+		return [{
+			nodeId,
+			input: this.resolveInput(currentState, nodeId, input),
+			toInput: input,
+			batchId: "batch_1",
+			from: incomingEdge?.from
+		}];
+	}
+	resolveRootNodeInput(args) {
+		if (args.items) return args.items;
+		if (args.nodeKind === "trigger") return [];
+		return [{ json: {} }];
+	}
+	isNodeSatisfied(currentState, nodeId) {
+		return this.hasOutputs(currentState, nodeId) || this.hasCompletedSnapshot(currentState, nodeId);
+	}
+	isNodeSatisfiedByOutputsOnly(currentState, nodeId) {
+		return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
+	}
+	isEdgeSatisfied(currentState, nodeId, input) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+		if (!incomingEdge) return false;
+		return this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+	}
+	resolveInput(currentState, nodeId, input) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+		if (!incomingEdge) return [];
+		return this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+	}
+	hasOutputs(currentState, nodeId) {
+		return Object.prototype.hasOwnProperty.call(currentState.outputsByNode, nodeId);
+	}
+	hasCompletedSnapshot(currentState, nodeId) {
+		const snapshot = currentState.nodeSnapshotsByNodeId[nodeId];
+		return snapshot?.status === "completed" || snapshot?.status === "skipped";
+	}
+	hasOutputPort(currentState, nodeId, output) {
+		const outputs = currentState.outputsByNode[nodeId];
+		if (!outputs) return false;
+		return Object.prototype.hasOwnProperty.call(outputs, output);
+	}
+	resolveOutputItems(currentState, nodeId, output) {
+		return currentState.outputsByNode[nodeId]?.[output] ?? [];
+	}
+	getPinnedOutputs(currentState, nodeId) {
+		return currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort;
+	}
+	filterConnectionInvocations(invocations, clearedIdSet) {
+		if (!invocations || invocations.length === 0) return invocations;
+		const kept = invocations.filter((invocation) => !clearedIdSet.has(invocation.parentAgentNodeId) && !clearedIdSet.has(invocation.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)) 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/policies/storage/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/orchestration/RunStartService.ts
+var RunStartService = class {
+	constructor(runIdFactory, workflowExecutionRepository, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
+		this.runIdFactory = runIdFactory;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		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 runWorkflow(workflow, startAt, items, parent, executionOptions, persistedStateOverrides) {
+		const runId = this.runIdFactory.makeRunId();
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const workflowSnapshot = persistedStateOverrides?.workflowSnapshot ?? this.workflowSnapshotFactory.create(workflow);
+		const mutableState = persistedStateOverrides?.mutableState;
+		const policySnapshot = RunPolicySnapshotFactory.create(workflow, this.workflowPolicyRuntimeDefaults);
+		const mergedExecutionOptions = this.executionLimitsPolicy.mergeExecutionOptionsForNewRun(parent, executionOptions);
+		await this.workflowExecutionRepository.createRun({
+			runId,
+			workflowId: workflow.id,
+			startedAt,
+			parent,
+			executionOptions: mergedExecutionOptions,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			engineCounters: { completedNodeActivations: 0 }
+		});
+		const data = this.runDataFactory.create();
+		const base = this.runExecutionContextFactory.create({
+			runId,
+			workflowId: workflow.id,
+			nodeId: startAt,
+			parent,
+			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
+			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(runId, workflow.id, parent)
+		});
+		const { topology, planner } = this.planningFactory.create(workflow);
+		const startDefinition = topology.defsById.get(startAt);
+		if (!startDefinition) throw new Error(`Unknown start nodeId: ${startAt}`);
+		const initialNodeSnapshotsByNodeId = {};
+		if (startDefinition.kind === "trigger") {
+			const request = this.nodeActivationRequestComposer.createSingleFromDefinition({
+				runId,
+				workflowId: workflow.id,
+				definition: startDefinition,
+				parent,
+				executionOptions: mergedExecutionOptions,
+				batchId: "batch_1",
+				input: items,
+				base,
+				data
+			});
+			return await this.activationEnqueueService.enqueueActivation({
+				runId,
+				workflowId: workflow.id,
+				startedAt,
+				parent,
+				executionOptions: mergedExecutionOptions,
+				workflowSnapshot,
+				mutableState,
+				policySnapshot,
+				control: void 0,
+				pendingQueue: [],
+				request,
+				previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+				planner,
+				engineCounters: { completedNodeActivations: 0 },
+				connectionInvocations: []
+			});
+		}
+		const queue = [{
+			nodeId: startAt,
+			input: items,
+			toInput: "in",
+			batchId: "batch_1"
+		}];
+		return await this.scheduleQueuedPlan({
+			runId,
+			workflowId: workflow.id,
+			startedAt,
+			parent,
+			executionOptions: mergedExecutionOptions,
+			control: void 0,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			workflow,
+			planner,
+			queue,
+			base,
+			data,
+			nodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+			connectionInvocations: []
+		});
+	}
+	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.workflowExecutionRepository.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: WorkflowExecutableNodeClassifierFactory.create(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 ?? [];
+			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,
+				engineCounters: { completedNodeActivations: 0 },
+				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.workflowExecutionRepository.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/scheduler/ConfigDrivenOffloadPolicy.ts
+var ConfigDrivenOffloadPolicy = class {
+	defaultMode;
+	constructor(defaultMode = "worker") {
+		this.defaultMode = defaultMode;
+	}
+	decide(args) {
+		const hint = args.config.execution?.hint;
+		const queue = args.config.execution?.queue;
+		if (hint === "local") return { mode: "local" };
+		if (hint === "worker") return {
+			mode: "worker",
+			queue
+		};
+		if (queue) return {
+			mode: "worker",
+			queue
+		};
+		return { mode: this.defaultMode };
+	}
+};
+
+//#endregion
+//#region src/scheduler/DefaultDrivingScheduler.ts
+var DefaultDrivingScheduler = class {
+	constructor(offloadPolicy, workerScheduler, inline) {
+		this.offloadPolicy = offloadPolicy;
+		this.workerScheduler = workerScheduler;
+		this.inline = inline;
+	}
+	setContinuation(continuation) {
+		this.inline.setContinuation(continuation);
+	}
+	async enqueue(request) {
+		const selection = await this.selectScheduler(request);
+		if (selection.mode === "worker") {
+			if (request.kind === "multi") throw new Error(`Multi-input node ${request.nodeId} cannot be scheduled to worker (insert local placement)`);
+			const workerRequest = {
+				runId: request.runId,
+				activationId: request.activationId,
+				workflowId: request.workflowId,
+				nodeId: request.nodeId,
+				input: request.input,
+				parent: request.parent,
+				queue: selection.queue,
+				executionOptions: request.executionOptions
+			};
+			return {
+				receiptId: (await this.workerScheduler.enqueue(workerRequest)).receiptId,
+				mode: "worker",
+				queue: selection.queue
+			};
+		}
+		return await this.enqueueInline(request);
+	}
+	notifyPendingStatePersisted(runId) {
+		this.inline.notifyPendingStatePersisted(runId);
+	}
+	/**
+	* Scheduler precedence is explicit:
+	* 1. run-intent override (`executionOptions.localOnly`)
+	* 2. node-level execution hint / queue policy
+	* 3. container-default scheduler policy fallback
+	*/
+	async selectScheduler(request) {
+		if (request.executionOptions?.localOnly) return {
+			mode: "local",
+			decision: "runIntentOverride"
+		};
+		const decision = this.offloadPolicy.decide({
+			workflowId: request.workflowId,
+			nodeId: request.nodeId,
+			config: request.ctx.config
+		});
+		if (this.hasNodeSchedulingPreference(request)) return {
+			mode: decision.mode,
+			queue: decision.queue,
+			decision: "nodePolicy"
+		};
+		return {
+			mode: decision.mode,
+			queue: decision.queue,
+			decision: "containerDefault"
+		};
+	}
+	hasNodeSchedulingPreference(request) {
+		return request.ctx.config.execution?.hint !== void 0 || request.ctx.config.execution?.queue !== void 0;
+	}
+	async enqueueInline(request) {
+		return {
+			...await this.inline.enqueue(request),
+			mode: "local"
+		};
+	}
+};
+
+//#endregion
+//#region src/scheduler/HintOnlyOffloadPolicy.ts
+var HintOnlyOffloadPolicy = class {
+	decide(args) {
+		if (args.config.execution?.hint === "worker") return {
+			mode: "worker",
+			queue: args.config.execution?.queue
+		};
+		return { mode: "local" };
+	}
+};
+
+//#endregion
+//#region src/scheduler/InlineDrivingScheduler.ts
+var InlineDrivingScheduler = class {
+	continuation;
+	drainingRuns = /* @__PURE__ */ new Set();
+	queuesByRunId = /* @__PURE__ */ new Map();
+	scheduledRuns = /* @__PURE__ */ new Set();
+	seq = 0;
+	constructor(nodeExecutor) {
+		this.nodeExecutor = nodeExecutor;
+	}
+	setContinuation(continuation) {
+		this.continuation = continuation;
+	}
+	async enqueue(request) {
+		const receipt = {
+			receiptId: `inline_${++this.seq}`,
+			mode: "local"
+		};
+		const q = this.queuesByRunId.get(request.runId) ?? [];
+		q.push({
+			request,
+			receipt
+		});
+		this.queuesByRunId.set(request.runId, q);
+		return receipt;
+	}
+	notifyPendingStatePersisted(runId) {
+		if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) return;
+		this.scheduleDrain(runId);
+	}
+	async drainRun(runId) {
+		if (this.drainingRuns.has(runId)) return;
+		this.drainingRuns.add(runId);
+		this.scheduledRuns.delete(runId);
+		try {
+			const q = this.queuesByRunId.get(runId) ?? [];
+			while (q.length > 0) {
+				const { request } = q.shift();
+				const cont = this.continuation;
+				if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
+				await cont.markNodeRunning({
+					runId: request.runId,
+					activationId: request.activationId,
+					nodeId: request.nodeId,
+					inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
+				});
+				let outputs;
+				try {
+					outputs = await this.nodeExecutor.execute(request);
+				} catch (e) {
+					await this.resumeAfterExecutionError(cont, request, this.asError(e));
+					continue;
+				}
+				await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
+			}
+		} finally {
+			if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) this.queuesByRunId.delete(runId);
+			this.drainingRuns.delete(runId);
+			if ((this.queuesByRunId.get(runId)?.length ?? 0) > 0) this.scheduleDrain(runId);
+		}
+	}
+	scheduleDrain(runId) {
+		if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
+		this.scheduledRuns.add(runId);
+		setTimeout(() => {
+			this.scheduledRuns.delete(runId);
+			this.drainRun(runId);
+		}, 0);
+	}
+	async resumeAfterExecutionResult(continuation, request, outputs) {
+		try {
+			await continuation.resumeFromNodeResult({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				outputs
+			});
+		} catch (e) {
+			this.rethrowUnlessIgnorableContinuationError(e);
+		}
+	}
+	async resumeAfterExecutionError(continuation, request, error) {
+		try {
+			await continuation.resumeFromNodeError({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				error
+			});
+		} catch (e) {
+			this.rethrowUnlessIgnorableContinuationError(e);
+		}
+	}
+	asError(e) {
+		return e instanceof Error ? e : new Error(String(e));
+	}
+	rethrowUnlessIgnorableContinuationError(e) {
+		if (this.isIgnorableContinuationError(e)) return;
+		throw this.asError(e);
+	}
+	isIgnorableContinuationError(e) {
+		const message = this.asError(e).message;
+		return message.includes(" is not pending") || message.includes("activationId mismatch") || message.includes("nodeId mismatch");
+	}
+};
+
+//#endregion
+//#region src/scheduler/LocalOnlyScheduler.ts
+var LocalOnlyScheduler = class {
+	async enqueue(_request) {
+		throw new Error("No worker scheduler configured");
+	}
+};
+
+//#endregion
+//#region src/policies/executionLimits/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/runStorage/BinaryBodyBufferReader.ts
+var BinaryBodyBufferReader = class {
+	async read(body) {
+		if (body instanceof Uint8Array) return body;
+		if (body instanceof ArrayBuffer) return new Uint8Array(body);
+		if (body instanceof node_stream_web.ReadableStream) return await this.readReadableStream(body);
+		return await this.readAsyncIterable(body);
+	}
+	async readReadableStream(body) {
+		const reader = body.getReader();
+		const chunks = [];
+		let totalSize = 0;
+		try {
+			while (true) {
+				const result = await reader.read();
+				if (result.done) break;
+				chunks.push(result.value);
+				totalSize += result.value.byteLength;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		return this.joinChunks(chunks, totalSize);
+	}
+	async readAsyncIterable(body) {
+		const chunks = [];
+		let totalSize = 0;
+		for await (const chunk of body) {
+			chunks.push(chunk);
+			totalSize += chunk.byteLength;
+		}
+		return this.joinChunks(chunks, totalSize);
+	}
+	joinChunks(chunks, totalSize) {
+		const bytes = new Uint8Array(totalSize);
+		let offset = 0;
+		for (const chunk of chunks) {
+			bytes.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return bytes;
+	}
+};
+
+//#endregion
+//#region src/runStorage/BinaryBodyReadableStreamFactory.ts
+var BinaryBodyReadableStreamFactory = class {
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+	create() {
+		const value = this.bytes;
+		let consumed = false;
+		return new node_stream_web.ReadableStream({ pull(controller) {
+			if (consumed) {
+				controller.close();
+				return;
+			}
+			consumed = true;
+			controller.enqueue(value);
+			controller.close();
+		} });
+	}
+};
+
+//#endregion
+//#region src/runStorage/InMemoryBinaryStorageRegistry.ts
+var InMemoryBinaryStorage = class {
+	driverName = "memory";
+	values = /* @__PURE__ */ new Map();
+	async write(args) {
+		const bytes = await new BinaryBodyBufferReader().read(args.body);
+		this.values.set(args.storageKey, bytes);
+		return {
+			storageKey: args.storageKey,
+			size: bytes.byteLength,
+			sha256: (0, node_crypto.createHash)("sha256").update(bytes).digest("hex")
+		};
+	}
+	async openReadStream(storageKey) {
+		const bytes = this.values.get(storageKey);
+		if (!bytes) return;
+		return {
+			body: new BinaryBodyReadableStreamFactory(bytes).create(),
+			size: bytes.byteLength
+		};
+	}
+	async stat(storageKey) {
+		const bytes = this.values.get(storageKey);
+		if (!bytes) return { exists: false };
+		return {
+			exists: true,
+			size: bytes.byteLength
+		};
+	}
+	async delete(storageKey) {
+		this.values.delete(storageKey);
+	}
+};
+
+//#endregion
+//#region src/runStorage/InMemoryRunData.ts
+var InMemoryRunData = class {
+	byNode = /* @__PURE__ */ new Map();
+	constructor(initial) {
+		if (initial) for (const [nodeId, outputs] of Object.entries(initial)) this.byNode.set(nodeId, outputs);
+	}
+	setOutputs(nodeId, outputs) {
+		this.byNode.set(nodeId, outputs);
+	}
+	getOutputs(nodeId) {
+		return this.byNode.get(nodeId);
+	}
+	getOutputItems(nodeId, output = "main") {
+		return this.byNode.get(nodeId)?.[output] ?? [];
+	}
+	getOutputItem(nodeId, itemIndex, output = "main") {
+		return this.getOutputItems(nodeId, output)[itemIndex];
+	}
+	dump() {
+		const out = {};
+		for (const [nodeId, outputs] of this.byNode.entries()) out[nodeId] = outputs;
+		return out;
+	}
+};
+
+//#endregion
+//#region src/runStorage/InMemoryRunDataFactory.ts
+var InMemoryRunDataFactory = class {
+	create(initial) {
+		return new InMemoryRunData(initial);
+	}
+};
+
+//#endregion
+//#region src/contracts/runFinishedAtFactory.ts
+/** Derives workflow end time from node snapshots for run listings. */
+var RunFinishedAtFactory = class {
+	static resolveIso(state) {
+		if (state.status === "running" || state.status === "pending") return;
+		let max;
+		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
+		return max;
+	}
+};
+
+//#endregion
+//#region src/runtime/RunIntentService.ts
+var RunIntentService = class {
+	constructor(engine, workflowRepository) {
+		this.engine = engine;
+		this.workflowRepository = workflowRepository;
+	}
+	async startWorkflow(args) {
+		if (args.startAt && !args.currentState && !args.stopCondition && !args.reset) return await this.engine.runWorkflow(args.workflow, args.startAt, args.items, args.parent, args.executionOptions, {
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState
+		});
+		return await this.engine.runWorkflowFromState({
+			workflow: args.workflow,
+			items: args.items,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			currentState: args.currentState,
+			stopCondition: args.stopCondition ?? { kind: "workflowCompleted" },
+			reset: args.reset
+		});
+	}
+	async rerunFromNode(args) {
+		if (args.items) return await this.engine.runWorkflow(args.workflow, args.nodeId, args.items, args.parent, args.executionOptions, {
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState
+		});
+		return await this.engine.runWorkflowFromState({
+			workflow: args.workflow,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			currentState: args.currentState,
+			stopCondition: { kind: "workflowCompleted" },
+			reset: { clearFromNodeId: args.nodeId }
+		});
+	}
+	resolveWebhookTrigger(args) {
+		return this.engine.resolveWebhookTrigger(args);
+	}
+	async runMatchedWebhook(args) {
+		const resolution = this.resolveWebhookTrigger(args);
+		if (resolution.status === "notFound") throw new Error("Unknown webhook endpoint");
+		if (resolution.status === "methodNotAllowed") throw new Error("Method not allowed");
+		return await this.runWebhookMatch({
+			match: resolution.match,
+			requestItem: args.requestItem
+		});
+	}
+	async runWebhookMatch(args) {
+		const workflow = this.workflowRepository.get(args.match.workflowId);
+		if (!workflow) throw new Error(`Unknown workflowId: ${args.match.workflowId}`);
+		const scheduled = await this.engine.runWorkflow(workflow, args.match.nodeId, [args.requestItem], void 0, this.createWebhookExecutionOptions());
+		if (scheduled.status === "failed") throw new Error(scheduled.error.message);
+		if (scheduled.status === "completed") return {
+			runId: scheduled.runId,
+			workflowId: scheduled.workflowId,
+			startedAt: scheduled.startedAt,
+			runStatus: "completed",
+			response: scheduled.outputs
+		};
+		return await Promise.race([this.engine.waitForWebhookResponse(scheduled.runId), this.engine.waitForCompletion(scheduled.runId).then((completed) => {
+			if (completed.status === "failed") throw new Error(completed.error.message);
+			return {
+				runId: completed.runId,
+				workflowId: completed.workflowId,
+				startedAt: completed.startedAt,
+				runStatus: "completed",
+				response: completed.outputs
+			};
+		})]);
+	}
+	/**
+	* Webhook-triggered runs always force inline execution first.
+	* This is the highest-precedence scheduler override: it wins over node hints and container defaults.
+	*/
+	createWebhookExecutionOptions() {
+		return {
+			localOnly: true,
+			webhook: true
+		};
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ActivationEnqueueService', {
+  enumerable: true,
+  get: function () {
+    return ActivationEnqueueService;
+  }
+});
+Object.defineProperty(exports, 'ConfigDrivenOffloadPolicy', {
+  enumerable: true,
+  get: function () {
+    return ConfigDrivenOffloadPolicy;
+  }
+});
+Object.defineProperty(exports, 'ConnectionNodeIdFactory', {
+  enumerable: true,
+  get: function () {
+    return ConnectionNodeIdFactory;
+  }
+});
+Object.defineProperty(exports, 'CoreTokens', {
+  enumerable: true,
+  get: function () {
+    return CoreTokens;
+  }
+});
+Object.defineProperty(exports, 'CredentialResolverFactory', {
+  enumerable: true,
+  get: function () {
+    return CredentialResolverFactory;
+  }
+});
+Object.defineProperty(exports, 'DefaultAsyncSleeper', {
+  enumerable: true,
+  get: function () {
+    return DefaultAsyncSleeper;
+  }
+});
+Object.defineProperty(exports, 'DefaultDrivingScheduler', {
+  enumerable: true,
+  get: function () {
+    return DefaultDrivingScheduler;
+  }
+});
+Object.defineProperty(exports, 'DefaultExecutionBinaryService', {
+  enumerable: true,
+  get: function () {
+    return DefaultExecutionBinaryService;
+  }
+});
+Object.defineProperty(exports, 'DefaultExecutionContextFactory', {
+  enumerable: true,
+  get: function () {
+    return DefaultExecutionContextFactory;
+  }
+});
+Object.defineProperty(exports, 'ENGINE_EXECUTION_LIMITS_DEFAULTS', {
+  enumerable: true,
+  get: function () {
+    return ENGINE_EXECUTION_LIMITS_DEFAULTS;
+  }
+});
+Object.defineProperty(exports, 'EngineExecutionLimitsPolicy', {
+  enumerable: true,
+  get: function () {
+    return EngineExecutionLimitsPolicy;
+  }
+});
+Object.defineProperty(exports, 'HintOnlyOffloadPolicy', {
+  enumerable: true,
+  get: function () {
+    return HintOnlyOffloadPolicy;
+  }
+});
+Object.defineProperty(exports, 'InMemoryBinaryStorage', {
+  enumerable: true,
+  get: function () {
+    return InMemoryBinaryStorage;
+  }
+});
+Object.defineProperty(exports, 'InMemoryRunDataFactory', {
+  enumerable: true,
+  get: function () {
+    return InMemoryRunDataFactory;
+  }
+});
+Object.defineProperty(exports, 'InProcessRetryRunner', {
+  enumerable: true,
+  get: function () {
+    return InProcessRetryRunner;
+  }
+});
+Object.defineProperty(exports, 'InProcessRetryRunnerFactory', {
+  enumerable: true,
+  get: function () {
+    return InProcessRetryRunnerFactory;
+  }
+});
+Object.defineProperty(exports, 'InjectableRuntimeDecoratorComposer', {
+  enumerable: true,
+  get: function () {
+    return InjectableRuntimeDecoratorComposer;
+  }
+});
+Object.defineProperty(exports, 'InlineDrivingScheduler', {
+  enumerable: true,
+  get: function () {
+    return InlineDrivingScheduler;
+  }
+});
+Object.defineProperty(exports, 'LocalOnlyScheduler', {
+  enumerable: true,
+  get: function () {
+    return LocalOnlyScheduler;
+  }
+});
+Object.defineProperty(exports, 'MissingRuntimeExecutionMarker', {
+  enumerable: true,
+  get: function () {
+    return MissingRuntimeExecutionMarker;
+  }
+});
+Object.defineProperty(exports, 'MissingRuntimeFallbacks', {
+  enumerable: true,
+  get: function () {
+    return MissingRuntimeFallbacks;
+  }
+});
+Object.defineProperty(exports, 'MissingRuntimeTriggerToken', {
+  enumerable: true,
+  get: function () {
+    return MissingRuntimeTriggerToken;
+  }
+});
+Object.defineProperty(exports, 'NodeActivationRequestComposer', {
+  enumerable: true,
+  get: function () {
+    return NodeActivationRequestComposer;
+  }
+});
+Object.defineProperty(exports, 'NodeEventPublisher', {
+  enumerable: true,
+  get: function () {
+    return NodeEventPublisher;
+  }
+});
+Object.defineProperty(exports, 'NodeExecutor', {
+  enumerable: true,
+  get: function () {
+    return NodeExecutor;
+  }
+});
+Object.defineProperty(exports, 'NodeExecutorFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeExecutorFactory;
+  }
+});
+Object.defineProperty(exports, 'NodeInstanceFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeInstanceFactory;
+  }
+});
+Object.defineProperty(exports, 'NodeInstanceFactoryFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeInstanceFactoryFactory;
+  }
+});
+Object.defineProperty(exports, 'NodeRunStateWriterFactory', {
+  enumerable: true,
+  get: function () {
+    return NodeRunStateWriterFactory;
+  }
+});
+Object.defineProperty(exports, 'PersistedRunStateTerminalBuilder', {
+  enumerable: true,
+  get: function () {
+    return PersistedRunStateTerminalBuilder;
+  }
+});
+Object.defineProperty(exports, 'PersistedRuntimeTypeMetadataStore', {
+  enumerable: true,
+  get: function () {
+    return PersistedRuntimeTypeMetadataStore;
+  }
+});
+Object.defineProperty(exports, 'PersistedRuntimeTypeNameResolver', {
+  enumerable: true,
+  get: function () {
+    return PersistedRuntimeTypeNameResolver;
+  }
+});
+Object.defineProperty(exports, 'PersistedWorkflowTokenRegistry', {
+  enumerable: true,
+  get: function () {
+    return PersistedWorkflowTokenRegistry;
+  }
+});
+Object.defineProperty(exports, 'RunContinuationService', {
+  enumerable: true,
+  get: function () {
+    return RunContinuationService;
+  }
+});
+Object.defineProperty(exports, 'RunFinishedAtFactory', {
+  enumerable: true,
+  get: function () {
+    return RunFinishedAtFactory;
+  }
+});
+Object.defineProperty(exports, 'RunIntentService', {
+  enumerable: true,
+  get: function () {
+    return RunIntentService;
+  }
+});
+Object.defineProperty(exports, 'RunPolicySnapshotFactory', {
+  enumerable: true,
+  get: function () {
+    return RunPolicySnapshotFactory;
+  }
+});
+Object.defineProperty(exports, 'RunStartService', {
+  enumerable: true,
+  get: function () {
+    return RunStartService;
+  }
+});
+Object.defineProperty(exports, 'RunStateSemantics', {
+  enumerable: true,
+  get: function () {
+    return RunStateSemantics;
+  }
+});
+Object.defineProperty(exports, 'StackTraceCallSitePathResolver', {
+  enumerable: true,
+  get: function () {
+    return StackTraceCallSitePathResolver;
+  }
+});
+Object.defineProperty(exports, 'UnavailableBinaryStorage', {
+  enumerable: true,
+  get: function () {
+    return UnavailableBinaryStorage;
+  }
+});
+Object.defineProperty(exports, 'WorkflowExecutableNodeClassifier', {
+  enumerable: true,
+  get: function () {
+    return WorkflowExecutableNodeClassifier;
+  }
+});
+Object.defineProperty(exports, 'WorkflowExecutableNodeClassifierFactory', {
+  enumerable: true,
+  get: function () {
+    return WorkflowExecutableNodeClassifierFactory;
+  }
+});
+Object.defineProperty(exports, 'WorkflowRunExecutionContextFactory', {
+  enumerable: true,
+  get: function () {
+    return WorkflowRunExecutionContextFactory;
+  }
+});
+Object.defineProperty(exports, 'WorkflowSnapshotResolver', {
+  enumerable: true,
+  get: function () {
+    return WorkflowSnapshotResolver;
+  }
+});
+Object.defineProperty(exports, 'WorkflowTopology', {
+  enumerable: true,
+  get: function () {
+    return WorkflowTopology;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'chatModel', {
+  enumerable: true,
+  get: function () {
+    return chatModel;
+  }
+});
+Object.defineProperty(exports, 'getPersistedRuntimeTypeMetadata', {
+  enumerable: true,
+  get: function () {
+    return getPersistedRuntimeTypeMetadata;
+  }
+});
+Object.defineProperty(exports, 'node', {
+  enumerable: true,
+  get: function () {
+    return node;
+  }
+});
+Object.defineProperty(exports, 'tool', {
+  enumerable: true,
+  get: function () {
+    return tool;
+  }
+});
+//# sourceMappingURL=RunIntentService-DlQH5eZ2.cjs.map