@codemation/core 0.0.7 → 0.0.11

package/dist/RunIntentService-2ivFmNQh.cjs

@@ -1,3462 +0,0 @@
-//#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) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = this.createNodeExecutionContext(args, args.definition, activationId);
-		return {
-			kind: "single",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.definition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.batchId,
-			input: args.input,
-			ctx
-		};
-	}
-	createFromPlannedActivation(args) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = 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-2ivFmNQh.cjs.map