@codemation/core 0.0.5 → 0.0.7

package/dist/RunIntentService-CYnn140t.js

@@ -0,0 +1,3136 @@
+import { createHash } from "node:crypto";
+import "reflect-metadata";
+import { container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { ReadableStream } from "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) => {
+			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, import.meta.url);
+}
+/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
+function tool(options = {}) {
+	return InjectableRuntimeDecoratorComposer.compose("tool", options, import.meta.url);
+}
+/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
+function chatModel(options = {}) {
+	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, import.meta.url);
+}
+
+//#endregion
+//#region src/binaries/DefaultNodeBinaryAttachmentServiceFactory.ts
+var DefaultNodeBinaryAttachmentService = class DefaultNodeBinaryAttachmentService {
+	constructor(storage, workflowId, runId, nodeId, activationId, now) {
+		this.storage = storage;
+		this.workflowId = workflowId;
+		this.runId = runId;
+		this.nodeId = nodeId;
+		this.activationId = activationId;
+		this.now = now;
+	}
+	async attach(args) {
+		const attachmentId = this.createAttachmentId();
+		const createdAt = this.now().toISOString();
+		const storageKey = this.createStorageKey(args, attachmentId);
+		const stored = await this.storage.write({
+			storageKey,
+			body: args.body
+		});
+		return {
+			id: attachmentId,
+			storageKey: stored.storageKey,
+			mimeType: args.mimeType,
+			size: stored.size,
+			storageDriver: this.storage.driverName,
+			previewKind: args.previewKind ?? this.resolvePreviewKind(args.mimeType),
+			createdAt,
+			runId: this.runId,
+			workflowId: this.workflowId,
+			nodeId: this.nodeId,
+			activationId: this.activationId,
+			filename: args.filename,
+			sha256: stored.sha256
+		};
+	}
+	withAttachment(item, name, attachment) {
+		return {
+			...item,
+			binary: {
+				...item.binary ?? {},
+				[name]: attachment
+			}
+		};
+	}
+	forNode(args) {
+		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
+	}
+	async openReadStream(attachment) {
+		return await this.storage.openReadStream(attachment.storageKey);
+	}
+	createAttachmentId() {
+		return DefaultNodeBinaryAttachmentService.createAttachmentIdValue(`${this.activationId}-${this.now().getTime()}`);
+	}
+	static createAttachmentIdValue(fallbackValue) {
+		const cryptoObject = globalThis.crypto;
+		if (cryptoObject && typeof cryptoObject.randomUUID === "function") return cryptoObject.randomUUID();
+		return fallbackValue;
+	}
+	createStorageKey(args, attachmentId) {
+		const safeName = this.sanitizeSegment(args.name);
+		const safeFilename = this.sanitizeFilename(args.filename);
+		const filenameSuffix = safeFilename ? `-${safeFilename}` : "";
+		return `${this.sanitizeSegment(this.workflowId)}/${this.sanitizeSegment(this.runId)}/${this.sanitizeSegment(this.nodeId)}/${this.sanitizeSegment(this.activationId)}/${attachmentId}-${safeName}${filenameSuffix}`;
+	}
+	sanitizeSegment(value) {
+		const normalized = value.trim();
+		if (!normalized) return "item";
+		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	}
+	sanitizeFilename(value) {
+		if (!value) return;
+		const normalized = value.trim().split("/").at(-1)?.split("\\").at(-1) ?? value.trim();
+		if (!normalized) return;
+		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	}
+	resolvePreviewKind(mimeType) {
+		if (mimeType.startsWith("image/")) return "image";
+		if (mimeType.startsWith("audio/")) return "audio";
+		if (mimeType.startsWith("video/")) return "video";
+		return "download";
+	}
+};
+
+//#endregion
+//#region src/binaries/UnavailableBinaryStorage.ts
+var UnavailableBinaryStorage = class {
+	driverName = "unavailable";
+	async write() {
+		throw new Error("Binary storage is not configured for this runtime.");
+	}
+	async openReadStream() {}
+	async stat() {
+		return { exists: false };
+	}
+	async delete() {}
+};
+
+//#endregion
+//#region src/binaries/DefaultExecutionBinaryServiceFactory.ts
+var DefaultExecutionBinaryService = class {
+	constructor(storage, workflowId, runId, now) {
+		this.storage = storage;
+		this.workflowId = workflowId;
+		this.runId = runId;
+		this.now = now;
+	}
+	forNode(args) {
+		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
+	}
+	async openReadStream(attachment) {
+		return await this.storage.openReadStream(attachment.storageKey);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutionSnapshotFactory.ts
+var NodeExecutionSnapshotFactory = class {
+	static queued(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: args.parent,
+			status: "queued",
+			queuedAt: args.queuedAt,
+			updatedAt: args.queuedAt,
+			inputsByPort: args.inputsByPort
+		};
+	}
+	static running(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: args.parent,
+			status: "running",
+			queuedAt: args.previous?.queuedAt,
+			startedAt: args.startedAt,
+			updatedAt: args.startedAt,
+			inputsByPort: args.inputsByPort,
+			outputs: args.previous?.outputs,
+			error: void 0
+		};
+	}
+	static completed(args) {
+		const fromPinnedOutput = args.fromPinnedOutput ?? false;
+		const startedAt = fromPinnedOutput ? args.previous?.startedAt ?? args.finishedAt : args.previous?.startedAt;
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: args.parent,
+			status: "completed",
+			queuedAt: args.previous?.queuedAt,
+			startedAt,
+			finishedAt: args.finishedAt,
+			updatedAt: args.finishedAt,
+			inputsByPort: args.inputsByPort,
+			outputs: args.outputs,
+			usedPinnedOutput: fromPinnedOutput,
+			error: void 0
+		};
+	}
+	static skipped(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: args.parent,
+			status: "skipped",
+			queuedAt: args.previous?.queuedAt,
+			startedAt: args.previous?.startedAt,
+			finishedAt: args.finishedAt,
+			updatedAt: args.finishedAt,
+			inputsByPort: args.inputsByPort,
+			outputs: args.outputs,
+			error: void 0
+		};
+	}
+	static failed(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: args.parent,
+			status: "failed",
+			queuedAt: args.previous?.queuedAt,
+			startedAt: args.previous?.startedAt,
+			finishedAt: args.finishedAt,
+			updatedAt: args.finishedAt,
+			inputsByPort: args.inputsByPort,
+			outputs: void 0,
+			error: {
+				message: args.error.message,
+				name: args.error.name,
+				stack: args.error.stack
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/NodeInputsByPortFactory.ts
+var NodeInputsByPortFactory = class {
+	static empty() {
+		return {};
+	}
+	static fromRequest(request) {
+		if (request.kind === "multi") return request.inputsByPort;
+		return { in: request.input };
+	}
+};
+
+//#endregion
+//#region src/execution/ActivationEnqueueService.ts
+var ActivationEnqueueService = class {
+	constructor(activationScheduler, workflowExecutionRepository, nodeEventPublisher) {
+		this.activationScheduler = activationScheduler;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.nodeEventPublisher = nodeEventPublisher;
+	}
+	async enqueueActivation(args) {
+		const { result, queuedSnapshot } = await this.enqueueActivationWithSnapshot(args);
+		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+		return result;
+	}
+	async enqueueActivationWithSnapshot(args) {
+		const receipt = await this.activationScheduler.enqueue(args.request);
+		const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
+		const itemsIn = args.request.kind === "multi" ? args.planner.sumItemsByPort(args.request.inputsByPort) : args.request.input.length;
+		const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const pending = {
+			runId: args.runId,
+			activationId: args.request.activationId,
+			workflowId: args.workflowId,
+			nodeId: args.request.nodeId,
+			itemsIn,
+			inputsByPort,
+			receiptId: receipt.receiptId,
+			queue: receipt.queue,
+			batchId: args.request.batchId,
+			enqueuedAt
+		};
+		const queuedSnapshot = NodeExecutionSnapshotFactory.queued({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			nodeId: args.request.nodeId,
+			activationId: args.request.activationId,
+			parent: args.parent,
+			queuedAt: enqueuedAt,
+			inputsByPort
+		});
+		await this.workflowExecutionRepository.save({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			engineCounters: args.engineCounters,
+			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
+			status: "pending",
+			pending,
+			queue: args.pendingQueue.map((entry) => ({ ...entry })),
+			outputsByNode: args.request.ctx.data.dump(),
+			nodeSnapshotsByNodeId: {
+				...args.previousNodeSnapshotsByNodeId,
+				[args.request.nodeId]: queuedSnapshot
+			}
+		});
+		this.notifyPendingStatePersisted(args.runId);
+		return {
+			result: {
+				runId: args.runId,
+				workflowId: args.workflowId,
+				startedAt: args.startedAt,
+				status: "pending",
+				pending
+			},
+			queuedSnapshot
+		};
+	}
+	notifyPendingStatePersisted(runId) {
+		this.activationScheduler.notifyPendingStatePersisted?.(runId);
+	}
+};
+
+//#endregion
+//#region src/execution/CredentialResolverFactory.ts
+var CredentialResolverFactory = class {
+	constructor(credentialSessions) {
+		this.credentialSessions = credentialSessions;
+	}
+	create(workflowId, nodeId, config) {
+		const acceptedTypesBySlot = /* @__PURE__ */ new Map();
+		for (const requirement of config?.getCredentialRequirements?.() ?? []) acceptedTypesBySlot.set(requirement.slotKey, requirement.acceptedTypes);
+		return async (slotKey) => {
+			try {
+				return await this.credentialSessions.getSession({
+					workflowId,
+					nodeId,
+					slotKey
+				});
+			} catch (error) {
+				const acceptedTypes = acceptedTypesBySlot.get(slotKey) ?? [];
+				const message = error instanceof Error ? error.message : String(error);
+				const alreadyListsAcceptedTypes = message.includes("Accepted types:") || message.includes("Accepted credential types:") || message.includes("binding points at an unknown type");
+				const acceptedTypesSuffix = acceptedTypes.length > 0 && !alreadyListsAcceptedTypes ? ` Accepted types: ${acceptedTypes.join(", ")}.` : "";
+				throw new Error(`Failed to resolve credential for workflow ${workflowId} node ${nodeId} slot "${slotKey}". ${message}${acceptedTypesSuffix}`, { cause: error });
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/DefaultAsyncSleeper.ts
+var DefaultAsyncSleeper = class {
+	sleep(ms) {
+		return new Promise((resolve) => {
+			setTimeout(resolve, ms);
+		});
+	}
+};
+
+//#endregion
+//#region src/execution/DefaultExecutionContextFactory.ts
+var DefaultExecutionContextFactory = class {
+	constructor(binaryStorage = new UnavailableBinaryStorage(), currentDate = () => /* @__PURE__ */ new Date()) {
+		this.binaryStorage = binaryStorage;
+		this.currentDate = currentDate;
+	}
+	create(args) {
+		return {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			subworkflowDepth: args.subworkflowDepth,
+			engineMaxNodeActivations: args.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
+			now: this.currentDate,
+			data: args.data,
+			nodeState: args.nodeState,
+			binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
+			getCredential: args.getCredential
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/InProcessRetryRunner.ts
+var InProcessRetryRunner = class InProcessRetryRunner {
+	constructor(sleeper) {
+		this.sleeper = sleeper;
+	}
+	async run(policy, work) {
+		const spec = InProcessRetryRunner.normalizePolicy(policy);
+		let lastError;
+		for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) try {
+			return await work();
+		} catch (error) {
+			lastError = error;
+			if (attempt >= spec.maxAttempts) break;
+			const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
+			await this.sleeper.sleep(delayMs);
+		}
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+	static delayAfterFailureMs(spec, failedAttempt) {
+		if (spec.kind === "none") return 0;
+		if (spec.kind === "fixed") return spec.delayMs;
+		const exponent = failedAttempt - 1;
+		let ms = spec.initialDelayMs * Math.pow(spec.multiplier, exponent);
+		if (spec.jitter === true) ms *= 1 + Math.random() * .2;
+		if (spec.maxDelayMs !== void 0 && ms > spec.maxDelayMs) ms = spec.maxDelayMs;
+		return Math.max(0, Math.floor(ms));
+	}
+	static normalizePolicy(policy) {
+		if (policy === void 0) return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		if (typeof policy !== "object" || policy === null) return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		const kind = policy.kind;
+		if (kind === "none") return {
+			kind: "none",
+			maxAttempts: 1
+		};
+		if (kind === "fixed") {
+			const p = policy;
+			return {
+				kind: "fixed",
+				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts"),
+				delayMs: InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs")
+			};
+		}
+		if (kind === "exponential") {
+			const p = policy;
+			return {
+				kind: "exponential",
+				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
+				initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
+				multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
+				maxDelayMs: p.maxDelayMs === void 0 ? void 0 : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
+				jitter: p.jitter === true
+			};
+		}
+		return {
+			kind: "none",
+			maxAttempts: 1
+		};
+	}
+	static assertPositiveInt(value, label) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) throw new Error(`Retry policy ${label} must be a positive integer`);
+		return value;
+	}
+	static assertNonNegativeFinite(value, label) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`Retry policy ${label} must be a non-negative finite number`);
+		return value;
+	}
+	static assertMultiplier(value) {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 1) throw new Error(`Retry policy exponential.multiplier must be >= 1`);
+		return value;
+	}
+};
+
+//#endregion
+//#region src/execution/InProcessRetryRunnerFactory.ts
+var InProcessRetryRunnerFactory = class {
+	create(defaultAsyncSleeper) {
+		return new InProcessRetryRunner(defaultAsyncSleeper);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeActivationRequestComposer.ts
+/**
+* Builds {@link NodeActivationRequest} values shared by workflow starters and continuation.
+*/
+var NodeActivationRequestComposer = class {
+	constructor(activationIdFactory, credentialResolverFactory) {
+		this.activationIdFactory = activationIdFactory;
+		this.credentialResolverFactory = credentialResolverFactory;
+	}
+	createSingleFromDefinition(args) {
+		return this.createSingleFromDefinitionWithActivation({
+			...args,
+			activationId: this.activationIdFactory.makeActivationId()
+		});
+	}
+	createSingleFromDefinitionWithActivation(args) {
+		const ctx = this.createNodeExecutionContext(args, args.definition, args.activationId);
+		return {
+			kind: "single",
+			runId: args.runId,
+			activationId: args.activationId,
+			workflowId: args.workflowId,
+			nodeId: args.definition.id,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			batchId: args.batchId,
+			input: args.input,
+			ctx
+		};
+	}
+	createFromPlannedActivation(args) {
+		const activationId = this.activationIdFactory.makeActivationId();
+		const ctx = this.createNodeExecutionContext(args, args.nodeDefinition, activationId);
+		if (args.next.kind === "multi") return {
+			kind: "multi",
+			runId: args.runId,
+			activationId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeDefinition.id,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			batchId: args.next.batchId,
+			inputsByPort: args.next.inputsByPort,
+			ctx
+		};
+		return {
+			kind: "single",
+			runId: args.runId,
+			activationId,
+			workflowId: args.workflowId,
+			nodeId: args.nodeDefinition.id,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			batchId: args.next.batchId,
+			input: args.next.input,
+			ctx
+		};
+	}
+	createNodeExecutionContext(args, definition, activationId) {
+		return {
+			...args.base,
+			data: args.data,
+			nodeId: definition.id,
+			activationId,
+			config: definition.config,
+			binary: args.base.binary.forNode({
+				nodeId: definition.id,
+				activationId
+			}),
+			getCredential: this.credentialResolverFactory.create(args.workflowId, definition.id, definition.config)
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutor.ts
+var NodeExecutor = class {
+	constructor(nodeInstanceFactory, retryRunner) {
+		this.nodeInstanceFactory = nodeInstanceFactory;
+		this.retryRunner = retryRunner;
+	}
+	async execute(request) {
+		const policy = request.ctx.config.retryPolicy;
+		return await this.retryRunner.run(policy, async () => {
+			const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
+			if (request.kind === "multi") return await this.executeMultiInputNode(request, nodeInstance);
+			return await this.executeSingleInputNode(request, nodeInstance);
+		});
+	}
+	async executeMultiInputNode(request, node$1) {
+		const multiInputNode = node$1;
+		if (typeof multiInputNode.executeMulti !== "function") throw new Error(`Node ${request.nodeId} does not support executeMulti but received multi-input activation`);
+		return await multiInputNode.executeMulti(request.inputsByPort, request.ctx);
+	}
+	async executeSingleInputNode(request, node$1) {
+		const singleInputNode = node$1;
+		if (typeof singleInputNode.execute !== "function") throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
+		return await singleInputNode.execute(request.input, request.ctx);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeExecutorFactory.ts
+var NodeExecutorFactory = class {
+	create(workflowNodeInstanceFactory, retryRunner) {
+		return new NodeExecutor(workflowNodeInstanceFactory, retryRunner);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeExecutionMarker.ts
+var MissingRuntimeExecutionMarker = class {
+	isMarked(config) {
+		return Boolean(config?.missingRuntime);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeNodeToken.ts
+var MissingRuntimeNodeToken = class {};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeNodeConfig.ts
+var MissingRuntimeNodeConfig = class {
+	kind = "node";
+	type = MissingRuntimeNodeToken;
+	constructor(name, missingTokenId, missingRuntime = true) {
+		this.name = name;
+		this.missingTokenId = missingTokenId;
+		this.missingRuntime = missingRuntime;
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeTriggerToken.ts
+var MissingRuntimeTriggerToken = class {};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeTriggerConfig.ts
+var MissingRuntimeTriggerConfig = class {
+	kind = "trigger";
+	type = MissingRuntimeTriggerToken;
+	constructor(name, missingTokenId, missingRuntime = true) {
+		this.name = name;
+		this.missingTokenId = missingTokenId;
+		this.missingRuntime = missingRuntime;
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.ts
+var MissingRuntimeFallbacks = class {
+	createDefinition(snapshotNode) {
+		if (snapshotNode.kind === "trigger") return {
+			id: snapshotNode.id,
+			kind: "trigger",
+			name: snapshotNode.name,
+			type: MissingRuntimeTriggerToken,
+			config: new MissingRuntimeTriggerConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId)
+		};
+		return {
+			id: snapshotNode.id,
+			kind: "node",
+			name: snapshotNode.name,
+			type: MissingRuntimeNodeToken,
+			config: new MissingRuntimeNodeConfig(snapshotNode.name ?? snapshotNode.id, snapshotNode.nodeTokenId)
+		};
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeNode.ts
+var MissingRuntimeNode = class {
+	kind = "node";
+	outputPorts = ["main"];
+	async execute(items) {
+		return { main: items };
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/MissingRuntimeTrigger.ts
+var MissingRuntimeTrigger = class {
+	kind = "trigger";
+	outputPorts = ["main"];
+	async setup(_ctx) {}
+	async execute(items) {
+		return { main: items };
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/PersistedRuntimeTypeIdFactory.ts
+var PersistedRuntimeTypeIdFactory = class {
+	static fromMetadata(args) {
+		const metadata = getPersistedRuntimeTypeMetadata(args.type);
+		if (!metadata) return;
+		const packageName = metadata.packageName;
+		if (!packageName) return;
+		return `${packageName}::${metadata.persistedName}`;
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/PersistedWorkflowTokenRegistry.ts
+var PersistedWorkflowTokenRegistry = class {
+	tokensById = /* @__PURE__ */ new Map();
+	tokenIdsByToken = /* @__PURE__ */ new Map();
+	/**
+	* Register a token with its package ID. Token ID is inferred as `packageId::tokenName`.
+	*/
+	register(type, packageId, persistedNameOverride) {
+		const tokenId = `${packageId}::${persistedNameOverride ?? this.displayNameForTypeToken(type)}`;
+		this.tokensById.set(tokenId, type);
+		this.tokenIdsByToken.set(type, tokenId);
+		return tokenId;
+	}
+	/**
+	* Register all decorated runtime types discovered in workflows.
+	*/
+	registerFromWorkflows(workflows) {
+		for (const workflow of workflows) for (const node$1 of workflow.nodes) {
+			this.registerDecoratedType(node$1.type);
+			this.registerDecoratedType(node$1.config.type);
+			this.registerNestedTypes(node$1.config);
+		}
+	}
+	registerDecoratedType(type) {
+		if (this.tokenIdsByToken.has(type)) return;
+		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type });
+		if (!tokenId) return;
+		this.tokensById.set(tokenId, type);
+		this.tokenIdsByToken.set(type, tokenId);
+	}
+	registerNestedTypes(value) {
+		if (Array.isArray(value)) {
+			for (const entry of value) this.registerNestedTypes(entry);
+			return;
+		}
+		if (!value || typeof value !== "object") return;
+		const record = value;
+		const type = this.asTypeToken(record.type);
+		if (type) this.registerDecoratedType(type);
+		for (const v of Object.values(record)) this.registerNestedTypes(v);
+	}
+	displayNameForTypeToken(token) {
+		if (typeof token === "function" && token.name) return token.name;
+		if (typeof token === "string") return token;
+		return "";
+	}
+	asTypeToken(value) {
+		if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") return value;
+	}
+	getTokenId(token) {
+		const existing = this.tokenIdsByToken.get(token);
+		if (existing) return existing;
+		const tokenId = PersistedRuntimeTypeIdFactory.fromMetadata({ type: token });
+		if (!tokenId) return;
+		this.tokensById.set(tokenId, token);
+		this.tokenIdsByToken.set(token, tokenId);
+		return tokenId;
+	}
+	resolve(tokenId) {
+		return this.tokensById.get(tokenId);
+	}
+};
+
+//#endregion
+//#region src/workflowSnapshots/WorkflowSnapshotResolver.ts
+var WorkflowSnapshotResolver = class {
+	constructor(workflowRepository, tokenRegistry, codec, missingRuntimeFallbacks) {
+		this.workflowRepository = workflowRepository;
+		this.tokenRegistry = tokenRegistry;
+		this.codec = codec;
+		this.missingRuntimeFallbacks = missingRuntimeFallbacks;
+	}
+	resolve(args) {
+		const liveWorkflow = this.workflowRepository.get(args.workflowId);
+		if (!args.workflowSnapshot) return liveWorkflow;
+		if (!liveWorkflow) return this.rebuildWorkflow(args.workflowSnapshot, void 0);
+		return this.rebuildWorkflow(args.workflowSnapshot, liveWorkflow);
+	}
+	rebuildWorkflow(snapshot, liveWorkflow) {
+		const liveNodesById = new Map((liveWorkflow?.nodes ?? []).map((node$1) => [node$1.id, node$1]));
+		const nodes = snapshot.nodes.map((snapshotNode) => {
+			const liveNode = liveNodesById.get(snapshotNode.id);
+			if (!this.isCompatibleLiveNode(liveNode, snapshotNode)) return this.missingRuntimeFallbacks.createDefinition(snapshotNode);
+			return {
+				id: snapshotNode.id,
+				kind: snapshotNode.kind,
+				name: snapshotNode.name ?? liveNode.name,
+				type: liveNode.type,
+				config: this.codec.hydrate(snapshotNode, liveNode.config)
+			};
+		});
+		const nodeIds = new Set(nodes.map((node$1) => node$1.id));
+		const connectionsFromSnapshot = snapshot.connections?.map((connection) => ({
+			...connection,
+			childNodeIds: connection.childNodeIds.filter((childId) => nodeIds.has(childId))
+		})).filter((connection) => connection.childNodeIds.length > 0) ?? [];
+		return {
+			id: snapshot.id,
+			name: snapshot.name,
+			nodes,
+			edges: snapshot.edges.filter((edge) => nodeIds.has(edge.from.nodeId) && nodeIds.has(edge.to.nodeId)),
+			...connectionsFromSnapshot.length > 0 ? { connections: connectionsFromSnapshot } : {},
+			...liveWorkflow?.discoveryPathSegments !== void 0 ? { discoveryPathSegments: liveWorkflow.discoveryPathSegments } : {}
+		};
+	}
+	isCompatibleLiveNode(liveNode, snapshotNode) {
+		if (!liveNode || liveNode.kind !== snapshotNode.kind) return false;
+		if (!snapshotNode.nodeTokenId || !snapshotNode.configTokenId) throw new Error(`Persisted workflow snapshot node "${snapshotNode.id}" is missing stable token ids.`);
+		const liveNodeTokenId = this.resolveLiveTokenId(liveNode.type);
+		const liveConfigTokenId = this.resolveLiveTokenId(liveNode.config.type);
+		return liveNodeTokenId === snapshotNode.nodeTokenId && liveConfigTokenId === snapshotNode.configTokenId;
+	}
+	resolveLiveTokenId(type) {
+		const registeredTokenId = this.tokenRegistry.getTokenId(type);
+		if (registeredTokenId) return registeredTokenId;
+		if (typeof type === "function" && type.name) return type.name;
+		if (typeof type === "string") return type;
+	}
+};
+
+//#endregion
+//#region src/execution/NodeInstanceFactory.ts
+var NodeInstanceFactory = class {
+	constructor(nodeResolver) {
+		this.nodeResolver = nodeResolver;
+	}
+	createNodes(workflow) {
+		const nodeInstances = /* @__PURE__ */ new Map();
+		for (const definition of workflow.nodes) nodeInstances.set(definition.id, this.createNode(definition));
+		return nodeInstances;
+	}
+	createNode(definition) {
+		return this.createByType(definition.type);
+	}
+	createByType(type) {
+		if (type === MissingRuntimeNodeToken) return new MissingRuntimeNode();
+		if (type === MissingRuntimeTriggerToken) return new MissingRuntimeTrigger();
+		return this.nodeResolver.resolve(type);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeInstanceFactoryFactory.ts
+var NodeInstanceFactoryFactory = class {
+	create(nodeResolver) {
+		return new NodeInstanceFactory(nodeResolver);
+	}
+};
+
+//#endregion
+//#region src/execution/NodeRunStateWriter.ts
+var NodeRunStateWriter = class {
+	chain = Promise.resolve();
+	constructor(workflowExecutionRepository, runId, workflowId, parent, publishNodeEvent) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.runId = runId;
+		this.workflowId = workflowId;
+		this.parent = parent;
+		this.publishNodeEvent = publishNodeEvent;
+	}
+	markQueued(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const snapshot = NodeExecutionSnapshotFactory.queued({
+				runId: this.runId,
+				workflowId: this.workflowId,
+				nodeId: args.nodeId,
+				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
+				parent: this.parent,
+				queuedAt,
+				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? NodeInputsByPortFactory.empty()
+			});
+			await this.saveSnapshot(state, snapshot);
+			await this.publishNodeEvent("nodeQueued", snapshot);
+		});
+	}
+	markRunning(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const snapshot = NodeExecutionSnapshotFactory.running({
+				previous,
+				runId: this.runId,
+				workflowId: this.workflowId,
+				nodeId: args.nodeId,
+				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
+				parent: this.parent,
+				startedAt,
+				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? NodeInputsByPortFactory.empty()
+			});
+			await this.saveSnapshot(state, snapshot);
+			await this.publishNodeEvent("nodeStarted", snapshot);
+		});
+	}
+	markCompleted(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const snapshot = NodeExecutionSnapshotFactory.completed({
+				previous,
+				runId: this.runId,
+				workflowId: this.workflowId,
+				nodeId: args.nodeId,
+				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
+				parent: this.parent,
+				finishedAt,
+				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+				outputs: args.outputs ?? previous?.outputs ?? {}
+			});
+			await this.saveSnapshot(state, snapshot);
+			await this.publishNodeEvent("nodeCompleted", snapshot);
+		});
+	}
+	markFailed(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const snapshot = NodeExecutionSnapshotFactory.failed({
+				previous,
+				runId: this.runId,
+				workflowId: this.workflowId,
+				nodeId: args.nodeId,
+				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
+				parent: this.parent,
+				finishedAt,
+				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+				error: args.error
+			});
+			await this.saveSnapshot(state, snapshot);
+			await this.publishNodeEvent("nodeFailed", snapshot);
+		});
+	}
+	appendConnectionInvocation(args) {
+		return this.enqueue(async () => {
+			const state = await this.loadState();
+			const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const record = {
+				invocationId: args.invocationId,
+				runId: this.runId,
+				workflowId: this.workflowId,
+				connectionNodeId: args.connectionNodeId,
+				parentAgentNodeId: args.parentAgentNodeId,
+				parentAgentActivationId: args.parentAgentActivationId,
+				status: args.status,
+				managedInput: args.managedInput,
+				managedOutput: args.managedOutput,
+				error: args.error,
+				queuedAt: args.queuedAt,
+				startedAt: args.startedAt,
+				finishedAt: args.finishedAt,
+				updatedAt
+			};
+			await this.workflowExecutionRepository.save({
+				...state,
+				connectionInvocations: [...state.connectionInvocations ?? [], record]
+			});
+		});
+	}
+	enqueue(work) {
+		const next = this.chain.then(work);
+		this.chain = next.catch(() => void 0);
+		return next;
+	}
+	async loadState() {
+		const state = await this.workflowExecutionRepository.load(this.runId);
+		if (!state) throw new Error(`Unknown runId: ${this.runId}`);
+		return state;
+	}
+	async saveSnapshot(state, snapshot) {
+		await this.workflowExecutionRepository.save({
+			...state,
+			nodeSnapshotsByNodeId: {
+				...state.nodeSnapshotsByNodeId ?? {},
+				[snapshot.nodeId]: snapshot
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/execution/NodeRunStateWriterFactory.ts
+var NodeRunStateWriterFactory = class {
+	constructor(workflowExecutionRepository, nodeEventPublisher) {
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.nodeEventPublisher = nodeEventPublisher;
+	}
+	create(runId, workflowId, parent) {
+		return new NodeRunStateWriter(this.workflowExecutionRepository, runId, workflowId, parent, async (kind, snapshot) => {
+			await this.nodeEventPublisher.publish(kind, snapshot);
+		});
+	}
+};
+
+//#endregion
+//#region src/execution/PersistedRunStateTerminalBuilder.ts
+/**
+* Merges common terminal-run fields onto a loaded {@link PersistedRunState} without repeating object literals.
+*/
+var PersistedRunStateTerminalBuilder = class {
+	mergeTerminal(args) {
+		return {
+			...args.state,
+			engineCounters: args.engineCounters,
+			status: args.status,
+			pending: void 0,
+			queue: args.queue,
+			outputsByNode: args.outputsByNode,
+			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
+		};
+	}
+};
+
+//#endregion
+//#region src/execution/RunStateSemantics.ts
+var RunStateSemantics = class {
+	constructor(missingRuntimeExecutionMarker) {
+		this.missingRuntimeExecutionMarker = missingRuntimeExecutionMarker;
+	}
+	isStopConditionSatisfied(stopCondition, nodeId) {
+		if (!stopCondition || stopCondition.kind === "workflowCompleted") return false;
+		return stopCondition.nodeId === nodeId;
+	}
+	resolveResultOutputs(workflow, stopCondition, outputsByNode) {
+		if (stopCondition?.kind === "nodeCompleted") return outputsByNode[stopCondition.nodeId]?.main ?? [];
+		return outputsByNode[WorkflowExecutableNodeClassifierFactory.create(workflow).lastExecutableNodeIdInDefinitionOrder(workflow)]?.main ?? [];
+	}
+	applySkippedSnapshots(args) {
+		const snapshots = { ...args.currentState.nodeSnapshotsByNodeId };
+		const skippedPinnedNodeIds = new Set(args.preservedPinnedNodeIds.filter((nodeId) => args.skippedNodeIds.includes(nodeId)));
+		for (const nodeId of args.skippedNodeIds) if (args.currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort) skippedPinnedNodeIds.add(nodeId);
+		for (const nodeId of skippedPinnedNodeIds) {
+			const previous = snapshots[nodeId];
+			snapshots[nodeId] = NodeExecutionSnapshotFactory.completed({
+				previous,
+				runId: args.runId,
+				workflowId: args.workflowId,
+				nodeId,
+				activationId: previous?.activationId ?? `synthetic_${nodeId}`,
+				parent: args.parent,
+				finishedAt: args.finishedAt,
+				inputsByPort: previous?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+				outputs: args.currentState.outputsByNode[nodeId] ?? {},
+				fromPinnedOutput: true
+			});
+		}
+		return snapshots;
+	}
+	applyPinnedQueueSkips(args) {
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let index = 0; index < args.queue.length; index += 1) {
+				const queueEntry = args.queue[index];
+				const pinnedOutputs = args.mutableState?.nodesById?.[queueEntry.nodeId]?.pinnedOutputsByPort;
+				if (!pinnedOutputs) continue;
+				args.queue.splice(index, 1);
+				const previous = args.nodeSnapshotsByNodeId[queueEntry.nodeId];
+				args.nodeSnapshotsByNodeId[queueEntry.nodeId] = NodeExecutionSnapshotFactory.completed({
+					previous,
+					runId: args.runId,
+					workflowId: args.workflowId,
+					nodeId: queueEntry.nodeId,
+					activationId: previous?.activationId ?? `synthetic_${queueEntry.nodeId}`,
+					parent: args.parent,
+					finishedAt: args.finishedAt,
+					inputsByPort: this.resolveQueueEntryInputsByPort(queueEntry),
+					outputs: pinnedOutputs,
+					fromPinnedOutput: true
+				});
+				args.data.setOutputs(queueEntry.nodeId, pinnedOutputs);
+				args.planner.applyOutputs(args.queue, {
+					fromNodeId: queueEntry.nodeId,
+					outputs: pinnedOutputs,
+					batchId: queueEntry.batchId ?? "batch_1"
+				});
+				changed = true;
+				break;
+			}
+		}
+	}
+	createFinishedSnapshot(args) {
+		const definition = args.workflow.nodes.find((node$1) => node$1.id === args.nodeId);
+		if (this.missingRuntimeExecutionMarker.isMarked(definition?.config)) return NodeExecutionSnapshotFactory.skipped(args);
+		return NodeExecutionSnapshotFactory.completed(args);
+	}
+	resolveQueueEntryInputsByPort(queueEntry) {
+		if (queueEntry.collect) return queueEntry.collect.received;
+		return { [queueEntry.toInput ?? "in"]: queueEntry.input };
+	}
+};
+
+//#endregion
+//#region src/execution/WorkflowRunExecutionContextFactory.ts
+/**
+* Shared {@link ExecutionContextFactory#create} wiring for workflow runners (base context before node-specific fields).
+*/
+var WorkflowRunExecutionContextFactory = class {
+	constructor(executionContextFactory, credentialResolverFactory) {
+		this.executionContextFactory = executionContextFactory;
+		this.credentialResolverFactory = credentialResolverFactory;
+	}
+	create(args) {
+		return this.executionContextFactory.create({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			subworkflowDepth: args.subworkflowDepth,
+			engineMaxNodeActivations: args.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
+			data: args.data,
+			nodeState: args.nodeState,
+			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId)
+		});
+	}
+};
+
+//#endregion
+//#region src/planning/WorkflowTopologyPlanner.ts
+var WorkflowTopology = class WorkflowTopology {
+	constructor(defsById, outgoingByNode, incomingByNode, expectedInputsByNode, rootNodeIds) {
+		this.defsById = defsById;
+		this.outgoingByNode = outgoingByNode;
+		this.incomingByNode = incomingByNode;
+		this.expectedInputsByNode = expectedInputsByNode;
+		this.rootNodeIds = rootNodeIds;
+	}
+	static fromWorkflow(wf) {
+		const classifier = WorkflowExecutableNodeClassifierFactory.create(wf);
+		const defs = /* @__PURE__ */ new Map();
+		for (const n of wf.nodes) if (classifier.isExecutableNodeId(n.id)) defs.set(n.id, n);
+		const outgoing = /* @__PURE__ */ new Map();
+		for (const e of wf.edges) {
+			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
+			const list = outgoing.get(e.from.nodeId) ?? [];
+			list.push({
+				output: e.from.output,
+				to: {
+					nodeId: e.to.nodeId,
+					input: e.to.input
+				}
+			});
+			outgoing.set(e.from.nodeId, list);
+		}
+		const incomingByNode = /* @__PURE__ */ new Map();
+		for (const e of wf.edges) {
+			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
+			const list = incomingByNode.get(e.to.nodeId) ?? [];
+			list.push({
+				from: {
+					nodeId: e.from.nodeId,
+					output: e.from.output
+				},
+				input: e.to.input
+			});
+			incomingByNode.set(e.to.nodeId, list);
+		}
+		const expected = /* @__PURE__ */ new Map();
+		for (const [toNodeId, inputs] of incomingByNode.entries()) {
+			const counts = /* @__PURE__ */ new Map();
+			for (const edge of inputs) counts.set(edge.input, (counts.get(edge.input) ?? 0) + 1);
+			for (const [k, n] of counts.entries()) if (n > 1) throw new Error(`Node ${toNodeId} has multiple edges into input '${k}'. Use a Merge node upstream.`);
+			const order = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const edge of inputs) {
+				if (seen.has(edge.input)) continue;
+				seen.add(edge.input);
+				order.push(edge.input);
+			}
+			expected.set(toNodeId, order);
+		}
+		return new WorkflowTopology(defs, outgoing, incomingByNode, expected, wf.nodes.filter((node$1) => classifier.isExecutableNodeId(node$1.id) && !incomingByNode.has(node$1.id)).map((node$1) => node$1.id));
+	}
+};
+
+//#endregion
+//#region src/orchestration/RunContinuationService.ts
+var RunContinuationService = class {
+	constructor(activationIdFactory, workflowExecutionRepository, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy) {
+		this.activationIdFactory = activationIdFactory;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.runDataFactory = runDataFactory;
+		this.runExecutionContextFactory = runExecutionContextFactory;
+		this.workflowSnapshotResolver = workflowSnapshotResolver;
+		this.planningFactory = planningFactory;
+		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
+		this.credentialResolverFactory = credentialResolverFactory;
+		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
+		this.persistedRunStateTerminalBuilder = persistedRunStateTerminalBuilder;
+		this.activationEnqueueService = activationEnqueueService;
+		this.nodeEventPublisher = nodeEventPublisher;
+		this.semantics = semantics;
+		this.waiters = waiters;
+		this.policyErrorServices = policyErrorServices;
+		this.terminalPersistence = terminalPersistence;
+		this.executionLimitsPolicy = executionLimitsPolicy;
+	}
+	async markNodeRunning(args) {
+		const state = await this.workflowExecutionRepository.load(args.runId);
+		if (!state?.pending) return;
+		if (state.pending.activationId !== args.activationId || state.pending.nodeId !== args.nodeId) return;
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
+		const snapshot = NodeExecutionSnapshotFactory.running({
+			previous,
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: state.parent,
+			startedAt,
+			inputsByPort: args.inputsByPort
+		});
+		await this.workflowExecutionRepository.save({
+			...state,
+			nodeSnapshotsByNodeId: {
+				...state.nodeSnapshotsByNodeId ?? {},
+				[args.nodeId]: snapshot
+			}
+		});
+		await this.nodeEventPublisher.publish("nodeStarted", snapshot);
+	}
+	async resumeFromNodeResult(args) {
+		const state = await this.workflowExecutionRepository.load(args.runId);
+		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
+		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
+		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
+		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
+		const wf = this.resolvePersistedWorkflow(state);
+		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
+		const { topology, planner } = this.planningFactory.create(wf);
+		const data = this.runDataFactory.create(state.outputsByNode);
+		const limits = this.resolveEngineLimitsFromState(state);
+		const base = this.runExecutionContextFactory.create({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: args.nodeId,
+			parent: state.parent,
+			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: limits.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
+		});
+		data.setOutputs(args.nodeId, args.outputs);
+		const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const completedSnapshot = this.semantics.createFinishedSnapshot({
+			workflow: wf,
+			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: state.parent,
+			finishedAt: completedAt,
+			inputsByPort: state.pending.inputsByPort,
+			outputs: args.outputs
+		});
+		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
+		const engineCounters = { completedNodeActivations: completedActivations };
+		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		if (this.semantics.isStopConditionSatisfied(state.control?.stopCondition, args.nodeId)) {
+			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state,
+				engineCounters,
+				status: "completed",
+				queue: [],
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: {
+					...state.nodeSnapshotsByNodeId ?? {},
+					[args.nodeId]: completedSnapshot
+				}
+			});
+			await this.workflowExecutionRepository.save(completedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: wf,
+				state: completedState,
+				finalStatus: "completed",
+				finishedAt: completedAt
+			});
+			const result$1 = {
+				runId: state.runId,
+				workflowId: state.workflowId,
+				startedAt: state.startedAt,
+				status: "completed",
+				outputs: this.semantics.resolveResultOutputs(wf, state.control?.stopCondition, data.dump())
+			};
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		const batchId = state.pending.batchId ?? "batch_1";
+		const queue = (state.queue ?? []).map((q) => ({
+			...q,
+			batchId: q.batchId ?? batchId
+		}));
+		const nextNodeSnapshotsByNodeId = {
+			...state.nodeSnapshotsByNodeId ?? {},
+			[args.nodeId]: completedSnapshot
+		};
+		planner.applyOutputs(queue, {
+			fromNodeId: args.nodeId,
+			outputs: args.outputs,
+			batchId
+		});
+		this.semantics.applyPinnedQueueSkips({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			parent: state.parent,
+			mutableState: state.mutableState,
+			planner,
+			queue,
+			data,
+			nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+			finishedAt: completedAt
+		});
+		let next;
+		try {
+			next = planner.nextActivation(queue);
+		} catch (cause) {
+			const completedDefinition = topology.defsById.get(args.nodeId);
+			const completedNodeLabel = this.formatNodeLabel({
+				definition: completedDefinition,
+				nodeId: args.nodeId
+			});
+			const reason = cause instanceof Error ? cause.message : String(cause);
+			throw new Error(`After completing ${completedNodeLabel}, the engine could not plan the next activation. ${reason} Outputs: ${this.formatOutputCounts(args.outputs)}.`, { cause });
+		}
+		if (!next) {
+			const lastNodeId = WorkflowExecutableNodeClassifierFactory.create(wf).lastExecutableNodeIdInDefinitionOrder(wf);
+			const outputs = data.getOutputItems(lastNodeId, "main");
+			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state,
+				engineCounters,
+				status: "completed",
+				queue: [],
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
+			});
+			await this.workflowExecutionRepository.save(completedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: wf,
+				state: completedState,
+				finalStatus: "completed",
+				finishedAt: completedAt
+			});
+			const result$1 = {
+				runId: state.runId,
+				workflowId: state.workflowId,
+				startedAt: state.startedAt,
+				status: "completed",
+				outputs
+			};
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		if (completedActivations >= maxNodeActivations) {
+			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
+			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state,
+				engineCounters,
+				status: "failed",
+				queue: queue.map((q) => ({ ...q })),
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
+			});
+			await this.workflowExecutionRepository.save(failedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: wf,
+				state: failedState,
+				finalStatus: "failed",
+				finishedAt: completedAt
+			});
+			const result$1 = {
+				runId: state.runId,
+				workflowId: state.workflowId,
+				startedAt: state.startedAt,
+				status: "failed",
+				error: { message }
+			};
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		const def = topology.defsById.get(next.nodeId);
+		if (!def || def.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
+		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
+			next,
+			base,
+			data,
+			runId: state.runId,
+			workflowId: state.workflowId,
+			parent: state.parent,
+			executionOptions: state.executionOptions,
+			nodeDefinition: def
+		});
+		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			startedAt: state.startedAt,
+			parent: state.parent,
+			executionOptions: state.executionOptions,
+			control: state.control,
+			workflowSnapshot: state.workflowSnapshot,
+			mutableState: state.mutableState,
+			policySnapshot: state.policySnapshot,
+			pendingQueue: queue,
+			request,
+			previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+			planner,
+			engineCounters,
+			connectionInvocations: state.connectionInvocations ?? []
+		});
+		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+		return result;
+	}
+	async resumeFromNodeError(args) {
+		const state = await this.workflowExecutionRepository.load(args.runId);
+		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
+		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
+		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
+		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
+		const wf = this.resolvePersistedWorkflow(state);
+		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
+		const failedDefinition = WorkflowTopology.fromWorkflow(wf).defsById.get(args.nodeId);
+		const webhookControlSignal = state.executionOptions?.webhook && failedDefinition?.kind === "trigger" ? this.asWebhookControlSignal(args.error) : void 0;
+		if (webhookControlSignal) return await this.resumeFromWebhookControl({
+			state,
+			workflow: wf,
+			args,
+			signal: webhookControlSignal
+		});
+		if (failedDefinition && failedDefinition.kind === "node") {
+			const nodeHandler = this.policyErrorServices.resolveNodeErrorHandler(failedDefinition.config.nodeErrorHandler);
+			if (nodeHandler) try {
+				const ctx = this.buildNodeExecutionContextForPending(state, wf, failedDefinition, args.nodeId);
+				const inputsByPort = state.pending.inputsByPort;
+				const portKeys = Object.keys(inputsByPort);
+				const kind = portKeys.length === 1 && portKeys[0] === "in" ? "single" : "multi";
+				const items = inputsByPort.in ?? [];
+				const recovered = await nodeHandler.handle({
+					kind,
+					items,
+					inputsByPort: kind === "multi" ? inputsByPort : void 0,
+					ctx,
+					error: args.error
+				});
+				return await this.resumeFromNodeResult({
+					runId: args.runId,
+					activationId: args.activationId,
+					nodeId: args.nodeId,
+					outputs: recovered
+				});
+			} catch {}
+		}
+		const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const message = args.error?.message ?? String(args.error);
+		const failedSnapshot = NodeExecutionSnapshotFactory.failed({
+			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId: args.nodeId,
+			activationId: args.activationId,
+			parent: state.parent,
+			finishedAt,
+			inputsByPort: state.pending.inputsByPort,
+			error: args.error
+		});
+		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+			state,
+			engineCounters: state.engineCounters ?? { completedNodeActivations: 0 },
+			status: "failed",
+			queue: (state.queue ?? []).map((q) => ({ ...q })),
+			outputsByNode: state.outputsByNode,
+			nodeSnapshotsByNodeId: {
+				...state.nodeSnapshotsByNodeId ?? {},
+				[args.nodeId]: failedSnapshot
+			}
+		});
+		await this.workflowExecutionRepository.save(failedState);
+		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
+		const wfErr = this.policyErrorServices.resolveWorkflowErrorHandler(wf.workflowErrorHandler);
+		if (wfErr) await Promise.resolve(wfErr.onError({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			workflow: wf,
+			failedNodeId: args.nodeId,
+			error: args.error,
+			startedAt: state.startedAt,
+			finishedAt
+		}));
+		await this.terminalPersistence.maybeDeleteAfterTerminalState({
+			workflow: wf,
+			state: failedState,
+			finalStatus: "failed",
+			finishedAt
+		});
+		const result = {
+			runId: state.runId,
+			workflowId: state.workflowId,
+			startedAt: state.startedAt,
+			status: "failed",
+			error: { message }
+		};
+		this.waiters.resolveRunCompletion(result);
+		return result;
+	}
+	async resumeFromStepResult(args) {
+		return await this.resumeFromNodeResult(args);
+	}
+	async resumeFromStepError(args) {
+		return await this.resumeFromNodeError(args);
+	}
+	async waitForCompletion(runId) {
+		const existing = await this.workflowExecutionRepository.load(runId);
+		if (existing?.status === "completed") {
+			const wf = this.resolvePersistedWorkflow(existing);
+			const outputs = wf ? this.semantics.resolveResultOutputs(wf, existing.control?.stopCondition, existing.outputsByNode) : [];
+			return {
+				runId: existing.runId,
+				workflowId: existing.workflowId,
+				startedAt: existing.startedAt,
+				status: "completed",
+				outputs
+			};
+		}
+		if (existing?.status === "failed") return {
+			runId: existing.runId,
+			workflowId: existing.workflowId,
+			startedAt: existing.startedAt,
+			status: "failed",
+			error: { message: "Run failed" }
+		};
+		const result = await this.waiters.waitForCompletion(runId);
+		if (result.status !== "completed" && result.status !== "failed") throw new Error(`Unexpected run completion status: ${result.status}`);
+		return result;
+	}
+	async waitForWebhookResponse(runId) {
+		return await this.waiters.waitForWebhookResponse(runId);
+	}
+	async resumeFromWebhookControl(args) {
+		const data = this.runDataFactory.create(args.state.outputsByNode);
+		const { topology, planner } = this.planningFactory.create(args.workflow);
+		const triggerOutputs = { main: args.signal.kind === "respondNowAndContinue" ? args.signal.continueItems ?? [] : args.signal.responseItems };
+		data.setOutputs(args.args.nodeId, triggerOutputs);
+		const completedSnapshot = this.semantics.createFinishedSnapshot({
+			workflow: args.workflow,
+			previous: args.state.nodeSnapshotsByNodeId?.[args.args.nodeId],
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			nodeId: args.args.nodeId,
+			activationId: args.args.activationId,
+			parent: args.state.parent,
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			inputsByPort: args.state.pending?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+			outputs: triggerOutputs
+		});
+		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
+		const engineCounters = { completedNodeActivations: completedActivations };
+		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
+		if (this.semantics.isStopConditionSatisfied(args.state.control?.stopCondition, args.args.nodeId)) {
+			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state: args.state,
+				engineCounters,
+				status: "completed",
+				queue: [],
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: {
+					...args.state.nodeSnapshotsByNodeId ?? {},
+					[args.args.nodeId]: completedSnapshot
+				}
+			});
+			await this.workflowExecutionRepository.save(completedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: args.workflow,
+				state: completedState,
+				finalStatus: "completed",
+				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+			});
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "completed",
+				response: args.signal.responseItems
+			});
+			const result$1 = {
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				status: "completed",
+				outputs: this.semantics.resolveResultOutputs(args.workflow, args.state.control?.stopCondition, data.dump())
+			};
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		if (args.signal.kind === "respondNow") {
+			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state: args.state,
+				engineCounters,
+				status: "completed",
+				queue: [],
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: {
+					...args.state.nodeSnapshotsByNodeId ?? {},
+					[args.args.nodeId]: completedSnapshot
+				}
+			});
+			await this.workflowExecutionRepository.save(completedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: args.workflow,
+				state: completedState,
+				finalStatus: "completed",
+				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+			});
+			const result$1 = {
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				status: "completed",
+				outputs: args.signal.responseItems
+			};
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "completed",
+				response: args.signal.responseItems
+			});
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		const batchId = args.state.pending?.batchId ?? "batch_1";
+		const queue = (args.state.queue ?? []).map((entry) => ({
+			...entry,
+			batchId: entry.batchId ?? batchId
+		}));
+		planner.applyOutputs(queue, {
+			fromNodeId: args.args.nodeId,
+			outputs: triggerOutputs,
+			batchId
+		});
+		const next = planner.nextActivation(queue);
+		if (!next) {
+			const lastNodeId = WorkflowExecutableNodeClassifierFactory.create(args.workflow).lastExecutableNodeIdInDefinitionOrder(args.workflow);
+			const outputs = data.getOutputItems(lastNodeId, "main");
+			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state: args.state,
+				engineCounters,
+				status: "completed",
+				queue: [],
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: {
+					...args.state.nodeSnapshotsByNodeId ?? {},
+					[args.args.nodeId]: completedSnapshot
+				}
+			});
+			await this.workflowExecutionRepository.save(completedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: args.workflow,
+				state: completedState,
+				finalStatus: "completed",
+				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+			});
+			const result$1 = {
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				status: "completed",
+				outputs
+			};
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "completed",
+				response: args.signal.responseItems
+			});
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		if (completedActivations >= maxNodeActivations) {
+			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
+			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+				state: args.state,
+				engineCounters,
+				status: "failed",
+				queue: queue.map((q) => ({ ...q })),
+				outputsByNode: data.dump(),
+				nodeSnapshotsByNodeId: {
+					...args.state.nodeSnapshotsByNodeId ?? {},
+					[args.args.nodeId]: completedSnapshot
+				}
+			});
+			await this.workflowExecutionRepository.save(failedState);
+			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+			await this.terminalPersistence.maybeDeleteAfterTerminalState({
+				workflow: args.workflow,
+				state: failedState,
+				finalStatus: "failed",
+				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+			});
+			const result$1 = {
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				status: "failed",
+				error: { message }
+			};
+			this.waiters.resolveWebhookResponse({
+				runId: args.state.runId,
+				workflowId: args.state.workflowId,
+				startedAt: args.state.startedAt,
+				runStatus: "pending",
+				response: args.signal.responseItems
+			});
+			this.waiters.resolveRunCompletion(result$1);
+			return result$1;
+		}
+		const nextDefinition = topology.defsById.get(next.nodeId);
+		if (!nextDefinition || nextDefinition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
+		const webhookLimits = this.resolveEngineLimitsFromState(args.state);
+		const base = this.runExecutionContextFactory.create({
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			nodeId: nextDefinition.id,
+			parent: args.state.parent,
+			subworkflowDepth: args.state.executionOptions?.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent)
+		});
+		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
+			next,
+			base,
+			data,
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			parent: args.state.parent,
+			executionOptions: args.state.executionOptions,
+			nodeDefinition: nextDefinition
+		});
+		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			startedAt: args.state.startedAt,
+			parent: args.state.parent,
+			executionOptions: args.state.executionOptions,
+			control: args.state.control,
+			workflowSnapshot: args.state.workflowSnapshot,
+			mutableState: args.state.mutableState,
+			policySnapshot: args.state.policySnapshot,
+			pendingQueue: queue,
+			request,
+			previousNodeSnapshotsByNodeId: {
+				...args.state.nodeSnapshotsByNodeId ?? {},
+				[args.args.nodeId]: completedSnapshot
+			},
+			planner,
+			engineCounters,
+			connectionInvocations: args.state.connectionInvocations ?? []
+		});
+		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+		this.waiters.resolveWebhookResponse({
+			runId: args.state.runId,
+			workflowId: args.state.workflowId,
+			startedAt: args.state.startedAt,
+			runStatus: "pending",
+			response: args.signal.responseItems
+		});
+		return result;
+	}
+	asWebhookControlSignal(error) {
+		const candidate = error;
+		if (!candidate || candidate.__webhookControl !== true) return void 0;
+		if (candidate.kind !== "respondNow" && candidate.kind !== "respondNowAndContinue") return void 0;
+		if (!Array.isArray(candidate.responseItems)) return void 0;
+		return candidate;
+	}
+	resolvePersistedWorkflow(state) {
+		return this.workflowSnapshotResolver.resolve({
+			workflowId: state.workflowId,
+			workflowSnapshot: state.workflowSnapshot
+		});
+	}
+	buildNodeExecutionContextForPending(state, wf, def, nodeId) {
+		const data = this.runDataFactory.create(state.outputsByNode);
+		const limits = this.resolveEngineLimitsFromState(state);
+		const base = this.runExecutionContextFactory.create({
+			runId: state.runId,
+			workflowId: state.workflowId,
+			nodeId,
+			parent: state.parent,
+			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: limits.engineMaxNodeActivations,
+			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
+		});
+		const activationId = state.pending.activationId;
+		return {
+			...base,
+			data,
+			nodeId,
+			activationId,
+			config: def.config,
+			binary: base.binary.forNode({
+				nodeId,
+				activationId
+			}),
+			getCredential: this.credentialResolverFactory.create(wf.id, nodeId, def.config)
+		};
+	}
+	resolveEngineLimitsFromState(state) {
+		const fb = this.executionLimitsPolicy.createRootExecutionOptions();
+		return {
+			engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fb.maxNodeActivations,
+			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fb.maxSubworkflowDepth
+		};
+	}
+	formatNodeLabel(args) {
+		const tokenName = typeof args.definition?.type === "function" ? args.definition.type.name : "Node";
+		return args.definition?.name ? `"${args.definition.name}" (${tokenName}:${args.nodeId})` : `${tokenName}:${args.nodeId}`;
+	}
+	formatOutputCounts(outputs) {
+		const entries = Object.entries(outputs ?? {});
+		if (entries.length === 0) return "no outputs";
+		return entries.map(([port, items]) => `${port}=${items?.length ?? 0}`).join(", ");
+	}
+};
+
+//#endregion
+//#region src/planning/CurrentStateFrontierPlanner.ts
+var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
+	constructor(topology) {
+		this.topology = topology;
+	}
+	/** Composition-root-friendly factory (avoids `new` at orchestration call sites under ESLint manual-DI rules). */
+	static createFromTopology(topology) {
+		return new CurrentStateFrontierPlanner(topology);
+	}
+	plan(args) {
+		const stopCondition = args.stopCondition ?? { kind: "workflowCompleted" };
+		const baseState = this.cloneCurrentState(args.currentState);
+		const normalizedState = this.overlayPinnedOutputs(baseState);
+		const resetResult = this.applyReset({
+			currentState: normalizedState,
+			reset: args.reset
+		});
+		const requiredNodeIds = this.collectRequiredNodeIds(stopCondition, resetResult.currentState);
+		const satisfiedNodeIds = this.collectSatisfiedNodeIds(resetResult.currentState);
+		const skippedNodeIds = [...new Set([...[...requiredNodeIds].filter((nodeId) => this.isNodeSatisfied(resetResult.currentState, nodeId)), ...resetResult.preservedPinnedNodeIds.filter((nodeId) => requiredNodeIds.has(nodeId))])];
+		const frontierNodeIds = this.collectFrontierNodeIds(requiredNodeIds, resetResult.currentState);
+		const rootNodeIds = frontierNodeIds.filter((nodeId) => (this.topology.incomingByNode.get(nodeId) ?? []).length === 0);
+		if (rootNodeIds.length > 1) throw new Error(`Ambiguous execution frontier. Multiple root nodes require input: ${rootNodeIds.join(", ")}`);
+		if (frontierNodeIds.length === 0) return {
+			queue: [],
+			currentState: resetResult.currentState,
+			stopCondition,
+			satisfiedNodeIds,
+			skippedNodeIds,
+			clearedNodeIds: resetResult.clearedNodeIds,
+			preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
+		};
+		if (rootNodeIds.length === 1) {
+			const rootNodeId = rootNodeIds[0];
+			const definition = this.topology.defsById.get(rootNodeId);
+			if (!definition) throw new Error(`Unknown frontier nodeId: ${rootNodeId}`);
+			return {
+				rootNodeId,
+				rootNodeInput: this.resolveRootNodeInput({
+					nodeKind: definition.kind,
+					items: args.items
+				}),
+				queue: [],
+				currentState: resetResult.currentState,
+				stopCondition,
+				satisfiedNodeIds,
+				skippedNodeIds,
+				clearedNodeIds: resetResult.clearedNodeIds,
+				preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
+			};
+		}
+		const queue = [];
+		for (const nodeId of frontierNodeIds) queue.push(...this.buildFrontierQueue(nodeId, resetResult.currentState));
+		return {
+			queue,
+			currentState: resetResult.currentState,
+			stopCondition,
+			satisfiedNodeIds,
+			skippedNodeIds,
+			clearedNodeIds: resetResult.clearedNodeIds,
+			preservedPinnedNodeIds: resetResult.preservedPinnedNodeIds
+		};
+	}
+	cloneCurrentState(currentState) {
+		if (!currentState) return {
+			outputsByNode: {},
+			nodeSnapshotsByNodeId: {},
+			connectionInvocations: [],
+			mutableState: void 0
+		};
+		return {
+			outputsByNode: { ...currentState.outputsByNode },
+			nodeSnapshotsByNodeId: { ...currentState.nodeSnapshotsByNodeId },
+			connectionInvocations: currentState.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
+			mutableState: currentState.mutableState
+		};
+	}
+	overlayPinnedOutputs(currentState) {
+		const outputsByNode = { ...currentState.outputsByNode };
+		for (const [nodeId, nodeState] of Object.entries(currentState.mutableState?.nodesById ?? {})) {
+			const pinnedOutputs = nodeState.pinnedOutputsByPort;
+			if (!pinnedOutputs) continue;
+			outputsByNode[nodeId] = pinnedOutputs;
+		}
+		return {
+			outputsByNode,
+			nodeSnapshotsByNodeId: { ...currentState.nodeSnapshotsByNodeId },
+			connectionInvocations: currentState.connectionInvocations,
+			mutableState: currentState.mutableState
+		};
+	}
+	applyReset(args) {
+		if (!args.reset) return {
+			currentState: args.currentState,
+			clearedNodeIds: [],
+			preservedPinnedNodeIds: []
+		};
+		const outputsByNode = { ...args.currentState.outputsByNode };
+		const nodeSnapshotsByNodeId = { ...args.currentState.nodeSnapshotsByNodeId };
+		const clearedNodeIds = [];
+		const preservedPinnedNodeIds = [];
+		const descendants = this.collectDescendants(args.reset.clearFromNodeId);
+		const runtimeDescendants = this.collectRuntimeDescendants(args.currentState, descendants);
+		const clearedIdSet = new Set([...descendants, ...runtimeDescendants]);
+		for (const nodeId of [...descendants, ...runtimeDescendants]) {
+			const pinnedOutputs = this.getPinnedOutputs(args.currentState, nodeId);
+			if (pinnedOutputs) {
+				outputsByNode[nodeId] = pinnedOutputs;
+				delete nodeSnapshotsByNodeId[nodeId];
+				preservedPinnedNodeIds.push(nodeId);
+				continue;
+			}
+			delete outputsByNode[nodeId];
+			delete nodeSnapshotsByNodeId[nodeId];
+			clearedNodeIds.push(nodeId);
+		}
+		return {
+			currentState: {
+				outputsByNode,
+				nodeSnapshotsByNodeId,
+				connectionInvocations: this.filterConnectionInvocations(args.currentState.connectionInvocations, clearedIdSet),
+				mutableState: args.currentState.mutableState
+			},
+			clearedNodeIds,
+			preservedPinnedNodeIds
+		};
+	}
+	collectSatisfiedNodeIds(currentState) {
+		const satisfiedNodeIds = [];
+		for (const nodeId of this.topology.defsById.keys()) if (this.isNodeSatisfied(currentState, nodeId)) satisfiedNodeIds.push(nodeId);
+		return satisfiedNodeIds;
+	}
+	collectFrontierNodeIds(requiredNodeIds, currentState) {
+		const frontierNodeIds = [];
+		for (const nodeId of this.topology.defsById.keys()) {
+			if (!requiredNodeIds.has(nodeId) || this.isNodeSatisfied(currentState, nodeId)) continue;
+			if ((this.topology.incomingByNode.get(nodeId) ?? []).every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.input))) frontierNodeIds.push(nodeId);
+		}
+		return frontierNodeIds;
+	}
+	collectRequiredNodeIds(stopCondition, currentState) {
+		const requiredNodeIds = /* @__PURE__ */ new Set();
+		if (stopCondition.kind === "workflowCompleted") {
+			for (const nodeId of this.topology.defsById.keys()) if (!this.isNodeSatisfied(currentState, nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, nodeId);
+			return requiredNodeIds;
+		}
+		if (!this.topology.defsById.has(stopCondition.nodeId)) throw new Error(`Unknown stop nodeId: ${stopCondition.nodeId}`);
+		this.collectRequiredNode(requiredNodeIds, currentState, stopCondition.nodeId);
+		return requiredNodeIds;
+	}
+	collectRequiredNode(requiredNodeIds, currentState, nodeId) {
+		if (requiredNodeIds.has(nodeId)) return;
+		if (this.isNodeSatisfied(currentState, nodeId) && !this.isNodeSatisfiedByOutputsOnly(currentState, nodeId)) return;
+		requiredNodeIds.add(nodeId);
+		for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) if (!this.isEdgeSatisfied(currentState, nodeId, edge.input) || this.isNodeSatisfiedByOutputsOnly(currentState, edge.from.nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, edge.from.nodeId);
+	}
+	buildFrontierQueue(nodeId, currentState) {
+		const incomingEdges = this.topology.incomingByNode.get(nodeId) ?? [];
+		if (incomingEdges.length === 0) return [];
+		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
+		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
+			const received = {};
+			for (const input$1 of expectedInputs) received[input$1] = this.resolveInput(currentState, nodeId, input$1);
+			return [{
+				nodeId,
+				input: [],
+				batchId: "batch_1",
+				collect: {
+					expectedInputs,
+					received
+				}
+			}];
+		}
+		const input = expectedInputs[0] ?? "in";
+		const incomingEdge = incomingEdges.find((edge) => edge.input === input);
+		return [{
+			nodeId,
+			input: this.resolveInput(currentState, nodeId, input),
+			toInput: input,
+			batchId: "batch_1",
+			from: incomingEdge?.from
+		}];
+	}
+	resolveRootNodeInput(args) {
+		if (args.items) return args.items;
+		if (args.nodeKind === "trigger") return [];
+		return [{ json: {} }];
+	}
+	isNodeSatisfied(currentState, nodeId) {
+		return this.hasOutputs(currentState, nodeId) || this.hasCompletedSnapshot(currentState, nodeId);
+	}
+	isNodeSatisfiedByOutputsOnly(currentState, nodeId) {
+		return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
+	}
+	isEdgeSatisfied(currentState, nodeId, input) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+		if (!incomingEdge) return false;
+		return this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+	}
+	resolveInput(currentState, nodeId, input) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+		if (!incomingEdge) return [];
+		return this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+	}
+	hasOutputs(currentState, nodeId) {
+		return Object.prototype.hasOwnProperty.call(currentState.outputsByNode, nodeId);
+	}
+	hasCompletedSnapshot(currentState, nodeId) {
+		const snapshot = currentState.nodeSnapshotsByNodeId[nodeId];
+		return snapshot?.status === "completed" || snapshot?.status === "skipped";
+	}
+	hasOutputPort(currentState, nodeId, output) {
+		const outputs = currentState.outputsByNode[nodeId];
+		if (!outputs) return false;
+		return Object.prototype.hasOwnProperty.call(outputs, output);
+	}
+	resolveOutputItems(currentState, nodeId, output) {
+		return currentState.outputsByNode[nodeId]?.[output] ?? [];
+	}
+	getPinnedOutputs(currentState, nodeId) {
+		return currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort;
+	}
+	filterConnectionInvocations(invocations, clearedIdSet) {
+		if (!invocations || invocations.length === 0) return invocations;
+		const kept = invocations.filter((invocation) => !clearedIdSet.has(invocation.parentAgentNodeId) && !clearedIdSet.has(invocation.connectionNodeId));
+		return kept.length === invocations.length ? invocations : kept;
+	}
+	collectDescendants(startNodeId) {
+		const pendingNodeIds = [startNodeId];
+		const descendants = /* @__PURE__ */ new Set();
+		while (pendingNodeIds.length > 0) {
+			const nodeId = pendingNodeIds.pop();
+			if (!nodeId || descendants.has(nodeId)) continue;
+			descendants.add(nodeId);
+			for (const edge of this.topology.outgoingByNode.get(nodeId) ?? []) pendingNodeIds.push(edge.to.nodeId);
+		}
+		return [...descendants];
+	}
+	collectRuntimeDescendants(currentState, descendantNodeIds) {
+		const descendantSet = new Set(descendantNodeIds);
+		const runtimeNodeIds = /* @__PURE__ */ new Set();
+		for (const nodeId of [
+			...Object.keys(currentState.outputsByNode),
+			...Object.keys(currentState.nodeSnapshotsByNodeId),
+			...Object.keys(currentState.mutableState?.nodesById ?? {})
+		]) if (this.isRuntimeDescendant(nodeId, descendantSet)) runtimeNodeIds.add(nodeId);
+		return [...runtimeNodeIds];
+	}
+	isRuntimeDescendant(nodeId, descendantNodeIds) {
+		for (const descendantNodeId of descendantNodeIds) {
+			if (nodeId === descendantNodeId) return false;
+			if (ConnectionNodeIdFactory.isConnectionOwnedDescendantOf(descendantNodeId, nodeId)) return true;
+		}
+		return false;
+	}
+};
+
+//#endregion
+//#region src/policies/storage/RunPolicySnapshotFactory.ts
+var RunPolicySnapshotFactory = class {
+	static create(workflow, defaults) {
+		const prune = workflow.prunePolicy;
+		return {
+			retentionSeconds: prune?.runDataRetentionSeconds ?? defaults?.retentionSeconds,
+			binaryRetentionSeconds: prune?.binaryRetentionSeconds ?? defaults?.binaryRetentionSeconds,
+			storagePolicy: typeof workflow.storagePolicy === "string" ? workflow.storagePolicy : defaults?.storagePolicy ?? "ALL"
+		};
+	}
+};
+
+//#endregion
+//#region src/orchestration/RunStartService.ts
+var RunStartService = class {
+	constructor(runIdFactory, workflowExecutionRepository, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
+		this.runIdFactory = runIdFactory;
+		this.workflowExecutionRepository = workflowExecutionRepository;
+		this.runDataFactory = runDataFactory;
+		this.workflowSnapshotFactory = workflowSnapshotFactory;
+		this.planningFactory = planningFactory;
+		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
+		this.runExecutionContextFactory = runExecutionContextFactory;
+		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
+		this.activationEnqueueService = activationEnqueueService;
+		this.semantics = semantics;
+		this.waiters = waiters;
+		this.workflowPolicyRuntimeDefaults = workflowPolicyRuntimeDefaults;
+		this.executionLimitsPolicy = executionLimitsPolicy;
+	}
+	async runWorkflow(workflow, startAt, items, parent, executionOptions, persistedStateOverrides) {
+		const runId = this.runIdFactory.makeRunId();
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const workflowSnapshot = persistedStateOverrides?.workflowSnapshot ?? this.workflowSnapshotFactory.create(workflow);
+		const mutableState = persistedStateOverrides?.mutableState;
+		const policySnapshot = RunPolicySnapshotFactory.create(workflow, this.workflowPolicyRuntimeDefaults);
+		const mergedExecutionOptions = this.executionLimitsPolicy.mergeExecutionOptionsForNewRun(parent, executionOptions);
+		await this.workflowExecutionRepository.createRun({
+			runId,
+			workflowId: workflow.id,
+			startedAt,
+			parent,
+			executionOptions: mergedExecutionOptions,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			engineCounters: { completedNodeActivations: 0 }
+		});
+		const data = this.runDataFactory.create();
+		const base = this.runExecutionContextFactory.create({
+			runId,
+			workflowId: workflow.id,
+			nodeId: startAt,
+			parent,
+			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
+			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(runId, workflow.id, parent)
+		});
+		const { topology, planner } = this.planningFactory.create(workflow);
+		const startDefinition = topology.defsById.get(startAt);
+		if (!startDefinition) throw new Error(`Unknown start nodeId: ${startAt}`);
+		const initialNodeSnapshotsByNodeId = {};
+		if (startDefinition.kind === "trigger") {
+			const request = this.nodeActivationRequestComposer.createSingleFromDefinition({
+				runId,
+				workflowId: workflow.id,
+				definition: startDefinition,
+				parent,
+				executionOptions: mergedExecutionOptions,
+				batchId: "batch_1",
+				input: items,
+				base,
+				data
+			});
+			return await this.activationEnqueueService.enqueueActivation({
+				runId,
+				workflowId: workflow.id,
+				startedAt,
+				parent,
+				executionOptions: mergedExecutionOptions,
+				workflowSnapshot,
+				mutableState,
+				policySnapshot,
+				control: void 0,
+				pendingQueue: [],
+				request,
+				previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+				planner,
+				engineCounters: { completedNodeActivations: 0 },
+				connectionInvocations: []
+			});
+		}
+		const queue = [{
+			nodeId: startAt,
+			input: items,
+			toInput: "in",
+			batchId: "batch_1"
+		}];
+		return await this.scheduleQueuedPlan({
+			runId,
+			workflowId: workflow.id,
+			startedAt,
+			parent,
+			executionOptions: mergedExecutionOptions,
+			control: void 0,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			workflow,
+			planner,
+			queue,
+			base,
+			data,
+			nodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+			connectionInvocations: []
+		});
+	}
+	async runWorkflowFromState(request) {
+		const runId = this.runIdFactory.makeRunId();
+		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const workflowSnapshot = request.workflowSnapshot ?? this.workflowSnapshotFactory.create(request.workflow);
+		const mutableState = request.mutableState ?? request.currentState?.mutableState;
+		const policySnapshot = RunPolicySnapshotFactory.create(request.workflow, this.workflowPolicyRuntimeDefaults);
+		const control = { stopCondition: request.stopCondition ?? { kind: "workflowCompleted" } };
+		const mergedExecutionOptions = this.executionLimitsPolicy.mergeExecutionOptionsForNewRun(request.parent, request.executionOptions);
+		await this.workflowExecutionRepository.createRun({
+			runId,
+			workflowId: request.workflow.id,
+			startedAt,
+			parent: request.parent,
+			executionOptions: mergedExecutionOptions,
+			control,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			engineCounters: { completedNodeActivations: 0 }
+		});
+		const { topology, planner } = this.planningFactory.create(request.workflow);
+		const plan = CurrentStateFrontierPlanner.createFromTopology(topology).plan({
+			currentState: this.createRunCurrentState(request.currentState, mutableState),
+			stopCondition: control.stopCondition,
+			reset: request.reset,
+			items: request.items
+		});
+		const data = this.runDataFactory.create(plan.currentState.outputsByNode);
+		const base = this.runExecutionContextFactory.create({
+			runId,
+			workflowId: request.workflow.id,
+			nodeId: WorkflowExecutableNodeClassifierFactory.create(request.workflow).firstExecutableNodeIdInDefinitionOrder(request.workflow) ?? "unknown_node",
+			parent: request.parent,
+			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
+			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
+			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
+			data,
+			nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent)
+		});
+		return await this.scheduleInitialPlan({
+			runId,
+			startedAt,
+			workflow: request.workflow,
+			workflowSnapshot,
+			mutableState,
+			policySnapshot,
+			executionOptions: mergedExecutionOptions,
+			control,
+			parent: request.parent,
+			planner,
+			plan,
+			base,
+			data
+		});
+	}
+	createRunCurrentState(currentState, mutableState) {
+		return {
+			outputsByNode: { ...currentState?.outputsByNode ?? {} },
+			nodeSnapshotsByNodeId: { ...currentState?.nodeSnapshotsByNodeId ?? {} },
+			connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
+			mutableState: mutableState ?? currentState?.mutableState
+		};
+	}
+	async scheduleInitialPlan(args) {
+		const initialNodeSnapshotsByNodeId = this.semantics.applySkippedSnapshots({
+			runId: args.runId,
+			workflowId: args.workflow.id,
+			parent: args.parent,
+			currentState: args.plan.currentState,
+			skippedNodeIds: args.plan.skippedNodeIds,
+			preservedPinnedNodeIds: args.plan.preservedPinnedNodeIds,
+			finishedAt: args.startedAt
+		});
+		if (args.plan.rootNodeId) {
+			const startDef = WorkflowTopology.fromWorkflow(args.workflow).defsById.get(args.plan.rootNodeId);
+			if (!startDef) throw new Error(`Unknown frontier nodeId: ${args.plan.rootNodeId}`);
+			const startItems = args.plan.rootNodeInput ?? [];
+			const request = this.nodeActivationRequestComposer.createSingleFromDefinition({
+				runId: args.runId,
+				workflowId: args.workflow.id,
+				definition: startDef,
+				parent: args.parent,
+				executionOptions: args.executionOptions,
+				batchId: "batch_1",
+				input: startItems,
+				base: args.base,
+				data: args.data
+			});
+			return await this.activationEnqueueService.enqueueActivation({
+				runId: args.runId,
+				workflowId: args.workflow.id,
+				startedAt: args.startedAt,
+				parent: args.parent,
+				executionOptions: args.executionOptions,
+				control: args.control,
+				workflowSnapshot: args.workflowSnapshot,
+				mutableState: args.mutableState,
+				policySnapshot: args.policySnapshot,
+				pendingQueue: [],
+				request,
+				previousNodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+				planner: args.planner,
+				engineCounters: { completedNodeActivations: 0 },
+				connectionInvocations: args.plan.currentState.connectionInvocations ?? []
+			});
+		}
+		return await this.scheduleQueuedPlan({
+			runId: args.runId,
+			workflowId: args.workflow.id,
+			startedAt: args.startedAt,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			workflow: args.workflow,
+			planner: args.planner,
+			queue: [...args.plan.queue],
+			base: args.base,
+			data: args.data,
+			nodeSnapshotsByNodeId: initialNodeSnapshotsByNodeId,
+			connectionInvocations: args.plan.currentState.connectionInvocations ?? []
+		});
+	}
+	async scheduleQueuedPlan(args) {
+		this.semantics.applyPinnedQueueSkips({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			mutableState: args.mutableState,
+			planner: args.planner,
+			queue: args.queue,
+			data: args.data,
+			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
+			finishedAt: args.startedAt
+		});
+		const next = args.planner.nextActivation(args.queue);
+		if (!next) return await this.completeRun({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			workflow: args.workflow,
+			data: args.data,
+			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
+			connectionInvocations: args.connectionInvocations
+		});
+		const definition = WorkflowTopology.fromWorkflow(args.workflow).defsById.get(next.nodeId);
+		if (!definition || definition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
+		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
+			next,
+			base: args.base,
+			data: args.data,
+			runId: args.runId,
+			workflowId: args.workflowId,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			nodeDefinition: definition
+		});
+		return await this.activationEnqueueService.enqueueActivation({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			pendingQueue: args.queue,
+			request,
+			previousNodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
+			planner: args.planner,
+			engineCounters: { completedNodeActivations: 0 },
+			connectionInvocations: args.connectionInvocations ?? []
+		});
+	}
+	async completeRun(args) {
+		await this.workflowExecutionRepository.save({
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			control: args.control,
+			workflowSnapshot: args.workflowSnapshot,
+			mutableState: args.mutableState,
+			policySnapshot: args.policySnapshot,
+			engineCounters: { completedNodeActivations: 0 },
+			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
+			status: "completed",
+			pending: void 0,
+			queue: [],
+			outputsByNode: args.data.dump(),
+			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
+		});
+		const result = {
+			runId: args.runId,
+			workflowId: args.workflowId,
+			startedAt: args.startedAt,
+			status: "completed",
+			outputs: this.semantics.resolveResultOutputs(args.workflow, args.control?.stopCondition, args.data.dump())
+		};
+		this.waiters.resolveRunCompletion(result);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/scheduler/ConfigDrivenOffloadPolicy.ts
+var ConfigDrivenOffloadPolicy = class {
+	defaultMode;
+	constructor(defaultMode = "worker") {
+		this.defaultMode = defaultMode;
+	}
+	decide(args) {
+		const hint = args.config.execution?.hint;
+		const queue = args.config.execution?.queue;
+		if (hint === "local") return { mode: "local" };
+		if (hint === "worker") return {
+			mode: "worker",
+			queue
+		};
+		if (queue) return {
+			mode: "worker",
+			queue
+		};
+		return { mode: this.defaultMode };
+	}
+};
+
+//#endregion
+//#region src/scheduler/DefaultDrivingScheduler.ts
+var DefaultDrivingScheduler = class {
+	constructor(offloadPolicy, workerScheduler, inline) {
+		this.offloadPolicy = offloadPolicy;
+		this.workerScheduler = workerScheduler;
+		this.inline = inline;
+	}
+	setContinuation(continuation) {
+		this.inline.setContinuation(continuation);
+	}
+	async enqueue(request) {
+		const selection = await this.selectScheduler(request);
+		if (selection.mode === "worker") {
+			if (request.kind === "multi") throw new Error(`Multi-input node ${request.nodeId} cannot be scheduled to worker (insert local placement)`);
+			const workerRequest = {
+				runId: request.runId,
+				activationId: request.activationId,
+				workflowId: request.workflowId,
+				nodeId: request.nodeId,
+				input: request.input,
+				parent: request.parent,
+				queue: selection.queue,
+				executionOptions: request.executionOptions
+			};
+			return {
+				receiptId: (await this.workerScheduler.enqueue(workerRequest)).receiptId,
+				mode: "worker",
+				queue: selection.queue
+			};
+		}
+		return await this.enqueueInline(request);
+	}
+	notifyPendingStatePersisted(runId) {
+		this.inline.notifyPendingStatePersisted(runId);
+	}
+	/**
+	* Scheduler precedence is explicit:
+	* 1. run-intent override (`executionOptions.localOnly`)
+	* 2. node-level execution hint / queue policy
+	* 3. container-default scheduler policy fallback
+	*/
+	async selectScheduler(request) {
+		if (request.executionOptions?.localOnly) return {
+			mode: "local",
+			decision: "runIntentOverride"
+		};
+		const decision = this.offloadPolicy.decide({
+			workflowId: request.workflowId,
+			nodeId: request.nodeId,
+			config: request.ctx.config
+		});
+		if (this.hasNodeSchedulingPreference(request)) return {
+			mode: decision.mode,
+			queue: decision.queue,
+			decision: "nodePolicy"
+		};
+		return {
+			mode: decision.mode,
+			queue: decision.queue,
+			decision: "containerDefault"
+		};
+	}
+	hasNodeSchedulingPreference(request) {
+		return request.ctx.config.execution?.hint !== void 0 || request.ctx.config.execution?.queue !== void 0;
+	}
+	async enqueueInline(request) {
+		return {
+			...await this.inline.enqueue(request),
+			mode: "local"
+		};
+	}
+};
+
+//#endregion
+//#region src/scheduler/HintOnlyOffloadPolicy.ts
+var HintOnlyOffloadPolicy = class {
+	decide(args) {
+		if (args.config.execution?.hint === "worker") return {
+			mode: "worker",
+			queue: args.config.execution?.queue
+		};
+		return { mode: "local" };
+	}
+};
+
+//#endregion
+//#region src/scheduler/InlineDrivingScheduler.ts
+var InlineDrivingScheduler = class {
+	continuation;
+	drainingRuns = /* @__PURE__ */ new Set();
+	queuesByRunId = /* @__PURE__ */ new Map();
+	scheduledRuns = /* @__PURE__ */ new Set();
+	seq = 0;
+	constructor(nodeExecutor) {
+		this.nodeExecutor = nodeExecutor;
+	}
+	setContinuation(continuation) {
+		this.continuation = continuation;
+	}
+	async enqueue(request) {
+		const receipt = {
+			receiptId: `inline_${++this.seq}`,
+			mode: "local"
+		};
+		const q = this.queuesByRunId.get(request.runId) ?? [];
+		q.push({
+			request,
+			receipt
+		});
+		this.queuesByRunId.set(request.runId, q);
+		return receipt;
+	}
+	notifyPendingStatePersisted(runId) {
+		if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) return;
+		this.scheduleDrain(runId);
+	}
+	async drainRun(runId) {
+		if (this.drainingRuns.has(runId)) return;
+		this.drainingRuns.add(runId);
+		this.scheduledRuns.delete(runId);
+		try {
+			const q = this.queuesByRunId.get(runId) ?? [];
+			while (q.length > 0) {
+				const { request } = q.shift();
+				const cont = this.continuation;
+				if (!cont) throw new Error("InlineDrivingScheduler is missing a continuation (setContinuation was not called)");
+				await cont.markNodeRunning({
+					runId: request.runId,
+					activationId: request.activationId,
+					nodeId: request.nodeId,
+					inputsByPort: request.kind === "multi" ? request.inputsByPort : { in: request.input }
+				});
+				let outputs;
+				try {
+					outputs = await this.nodeExecutor.execute(request);
+				} catch (e) {
+					await this.resumeAfterExecutionError(cont, request, this.asError(e));
+					continue;
+				}
+				await this.resumeAfterExecutionResult(cont, request, outputs ?? {});
+			}
+		} finally {
+			if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) this.queuesByRunId.delete(runId);
+			this.drainingRuns.delete(runId);
+			if ((this.queuesByRunId.get(runId)?.length ?? 0) > 0) this.scheduleDrain(runId);
+		}
+	}
+	scheduleDrain(runId) {
+		if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
+		this.scheduledRuns.add(runId);
+		setTimeout(() => {
+			this.scheduledRuns.delete(runId);
+			this.drainRun(runId);
+		}, 0);
+	}
+	async resumeAfterExecutionResult(continuation, request, outputs) {
+		try {
+			await continuation.resumeFromNodeResult({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				outputs
+			});
+		} catch (e) {
+			this.rethrowUnlessIgnorableContinuationError(e);
+		}
+	}
+	async resumeAfterExecutionError(continuation, request, error) {
+		try {
+			await continuation.resumeFromNodeError({
+				runId: request.runId,
+				activationId: request.activationId,
+				nodeId: request.nodeId,
+				error
+			});
+		} catch (e) {
+			this.rethrowUnlessIgnorableContinuationError(e);
+		}
+	}
+	asError(e) {
+		return e instanceof Error ? e : new Error(String(e));
+	}
+	rethrowUnlessIgnorableContinuationError(e) {
+		if (this.isIgnorableContinuationError(e)) return;
+		throw this.asError(e);
+	}
+	isIgnorableContinuationError(e) {
+		const message = this.asError(e).message;
+		return message.includes(" is not pending") || message.includes("activationId mismatch") || message.includes("nodeId mismatch");
+	}
+};
+
+//#endregion
+//#region src/scheduler/LocalOnlyScheduler.ts
+var LocalOnlyScheduler = class {
+	async enqueue(_request) {
+		throw new Error("No worker scheduler configured");
+	}
+};
+
+//#endregion
+//#region src/policies/executionLimits/EngineExecutionLimitsPolicy.ts
+/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
+const ENGINE_EXECUTION_LIMITS_DEFAULTS = {
+	defaultMaxNodeActivations: 1e5,
+	hardMaxNodeActivations: 1e5,
+	defaultMaxSubworkflowDepth: 32,
+	hardMaxSubworkflowDepth: 32
+};
+/**
+* Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
+*/
+var EngineExecutionLimitsPolicy = class {
+	constructor(config = ENGINE_EXECUTION_LIMITS_DEFAULTS) {
+		this.config = config;
+	}
+	/**
+	* Effective options for a new root run (depth 0): defaults merged with engine ceilings.
+	* Replaces a separate one-method factory for root-run bootstrap.
+	*/
+	createRootExecutionOptions() {
+		return this.mergeExecutionOptionsForNewRun(void 0, void 0);
+	}
+	mergeExecutionOptionsForNewRun(parent, user) {
+		const subworkflowDepth = parent === void 0 ? 0 : (parent.subworkflowDepth ?? 0) + 1;
+		const inheritedMaxNode = parent?.engineMaxNodeActivations;
+		const inheritedMaxSub = parent?.engineMaxSubworkflowDepth;
+		const maxNodeActivations = this.capNumber(user?.maxNodeActivations ?? inheritedMaxNode, this.config.defaultMaxNodeActivations, this.config.hardMaxNodeActivations);
+		const maxSubworkflowDepth = this.capNumber(user?.maxSubworkflowDepth ?? inheritedMaxSub, this.config.defaultMaxSubworkflowDepth, this.config.hardMaxSubworkflowDepth);
+		if (subworkflowDepth > maxSubworkflowDepth) throw new Error(`Subworkflow nesting depth ${subworkflowDepth} exceeds maxSubworkflowDepth ${maxSubworkflowDepth} (run would be a child of parent run).`);
+		return {
+			...user,
+			subworkflowDepth,
+			maxNodeActivations,
+			maxSubworkflowDepth
+		};
+	}
+	capNumber(requested, defaultValue, hardCeiling) {
+		const base = requested === void 0 ? defaultValue : requested;
+		return Math.min(base, hardCeiling);
+	}
+};
+
+//#endregion
+//#region src/runStorage/BinaryBodyBufferReader.ts
+var BinaryBodyBufferReader = class {
+	async read(body) {
+		if (body instanceof Uint8Array) return body;
+		if (body instanceof ArrayBuffer) return new Uint8Array(body);
+		if (body instanceof 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 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: 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
+export { instancePerContainerCachingFactory as $, InProcessRetryRunnerFactory as A, node as B, PersistedWorkflowTokenRegistry as C, NodeExecutorFactory as D, MissingRuntimeExecutionMarker as E, ActivationEnqueueService as F, PersistedRuntimeTypeNameResolver as G, InjectableRuntimeDecoratorComposer as H, DefaultExecutionBinaryService as I, delay as J, NodeEventPublisher as K, UnavailableBinaryStorage as L, DefaultExecutionContextFactory as M, DefaultAsyncSleeper as N, NodeExecutor as O, CredentialResolverFactory as P, instanceCachingFactory as Q, chatModel as R, WorkflowSnapshotResolver as S, MissingRuntimeTriggerToken as T, PersistedRuntimeTypeMetadataStore as U, tool as V, StackTraceCallSitePathResolver as W, injectAll as X, inject as Y, injectable as Z, RunStateSemantics as _, ENGINE_EXECUTION_LIMITS_DEFAULTS as a, WorkflowExecutableNodeClassifier as at, NodeInstanceFactoryFactory as b, InlineDrivingScheduler as c, ConfigDrivenOffloadPolicy as d, predicateAwareClassFactory as et, RunStartService as f, WorkflowRunExecutionContextFactory as g, WorkflowTopology as h, InMemoryBinaryStorage as i, WorkflowExecutableNodeClassifierFactory as it, InProcessRetryRunner as j, NodeActivationRequestComposer as k, HintOnlyOffloadPolicy as l, RunContinuationService as m, RunFinishedAtFactory as n, singleton as nt, EngineExecutionLimitsPolicy as o, ConnectionNodeIdFactory as ot, RunPolicySnapshotFactory as p, container as q, InMemoryRunDataFactory as r, CoreTokens as rt, LocalOnlyScheduler as s, RunIntentService as t, registry as tt, DefaultDrivingScheduler as u, PersistedRunStateTerminalBuilder as v, MissingRuntimeFallbacks as w, NodeInstanceFactory as x, NodeRunStateWriterFactory as y, getPersistedRuntimeTypeMetadata as z };
+//# sourceMappingURL=RunIntentService-CYnn140t.js.map