@codemation/core 0.0.5 → 0.0.11

package/dist/runtime-vc76SSAa.js

@@ -1,3685 +0,0 @@
-import { n as WorkflowSnapshotCodec } from "./InMemoryWorkflowCatalog-BzrAr--Y.js";
-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
-function createWorkflowExecutableNodeClassifier(workflow) {
-	return new WorkflowExecutableNodeClassifier(workflow);
-}
-
-//#endregion
-//#region src/diTokens/index.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"),
-	WorkflowCatalog: Symbol.for("codemation.core.WorkflowCatalog"),
-	WorkflowRepository: Symbol.for("codemation.core.WorkflowRepository"),
-	ServiceContainer: Symbol.for("codemation.core.ServiceContainer"),
-	NodeResolver: Symbol.for("codemation.core.NodeResolver"),
-	WorkflowNodeInstanceFactory: Symbol.for("codemation.core.WorkflowNodeInstanceFactory"),
-	RunIdFactory: Symbol.for("codemation.core.RunIdFactory"),
-	ActivationIdFactory: Symbol.for("codemation.core.ActivationIdFactory"),
-	RunStateStore: Symbol.for("codemation.core.RunStateStore"),
-	TriggerSetupStateStore: Symbol.for("codemation.core.TriggerSetupStateStore"),
-	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 \0@oxc-project+runtime@0.95.0/helpers/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-//#endregion
-//#region src/runtime-types/persistedRuntimeTypeModelRegistry.ts
-const persistedRuntimeTypeMetadataKey = Symbol.for("codemation.core.persistedRuntimeTypeMetadata");
-var PersistedRuntimeTypeDecoratorDefaults = class {
-	static appPackageName = "app";
-	static apply(options) {
-		return {
-			...options,
-			packageName: options.packageName ?? this.appPackageName
-		};
-	}
-};
-
-//#endregion
-//#region src/runtime-types/PersistedRuntimeTypeNameResolver.ts
-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
-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
-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
-function getPersistedRuntimeTypeMetadata(target) {
-	return PersistedRuntimeTypeMetadataStore.get(target);
-}
-function node(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("node", options, import.meta.url);
-}
-function tool(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("tool", options, import.meta.url);
-}
-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/observability/InputPortMapFactory.ts
-var InputPortMap = class {
-	static empty() {
-		return {};
-	}
-	static fromRequest(request) {
-		if (request.kind === "multi") return request.inputsByPort;
-		return { in: request.input };
-	}
-};
-
-//#endregion
-//#region src/observability/NodeSnapshotFactory.ts
-var NodeSnapshotFactory = class {
-	static queued(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "queued",
-			queuedAt: args.queuedAt,
-			updatedAt: args.queuedAt,
-			inputsByPort: args.inputsByPort
-		};
-	}
-	static running(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "running",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.startedAt,
-			updatedAt: args.startedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.previous?.outputs,
-			error: void 0
-		};
-	}
-	static completed(args) {
-		const fromPinnedOutput = args.fromPinnedOutput ?? false;
-		const startedAt = fromPinnedOutput ? args.previous?.startedAt ?? args.finishedAt : args.previous?.startedAt;
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "completed",
-			queuedAt: args.previous?.queuedAt,
-			startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.outputs,
-			usedPinnedOutput: fromPinnedOutput,
-			error: void 0
-		};
-	}
-	static skipped(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "skipped",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.previous?.startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: args.outputs,
-			error: void 0
-		};
-	}
-	static failed(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: args.parent,
-			status: "failed",
-			queuedAt: args.previous?.queuedAt,
-			startedAt: args.previous?.startedAt,
-			finishedAt: args.finishedAt,
-			updatedAt: args.finishedAt,
-			inputsByPort: args.inputsByPort,
-			outputs: void 0,
-			error: {
-				message: args.error.message,
-				name: args.error.name,
-				stack: args.error.stack
-			}
-		};
-	}
-};
-
-//#endregion
-//#region src/execution/ActivationEnqueueService.ts
-var ActivationEnqueueService = class {
-	constructor(activationScheduler, runStore, nodeEventPublisher) {
-		this.activationScheduler = activationScheduler;
-		this.runStore = runStore;
-		this.nodeEventPublisher = nodeEventPublisher;
-	}
-	async enqueueActivation(args) {
-		const { result, queuedSnapshot } = await this.enqueueActivationWithSnapshot(args);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		return result;
-	}
-	async enqueueActivationWithSnapshot(args) {
-		const receipt = await this.activationScheduler.enqueue(args.request);
-		const inputsByPort = InputPortMap.fromRequest(args.request);
-		const itemsIn = args.request.kind === "multi" ? args.planner.sumItemsByPort(args.request.inputsByPort) : args.request.input.length;
-		const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const pending = {
-			runId: args.runId,
-			activationId: args.request.activationId,
-			workflowId: args.workflowId,
-			nodeId: args.request.nodeId,
-			itemsIn,
-			inputsByPort,
-			receiptId: receipt.receiptId,
-			queue: receipt.queue,
-			batchId: args.request.batchId,
-			enqueuedAt
-		};
-		const queuedSnapshot = NodeSnapshotFactory.queued({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			nodeId: args.request.nodeId,
-			activationId: args.request.activationId,
-			parent: args.parent,
-			queuedAt: enqueuedAt,
-			inputsByPort
-		});
-		await this.runStore.save({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			startedAt: args.startedAt,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			control: args.control,
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState,
-			policySnapshot: args.policySnapshot,
-			engineCounters: args.engineCounters,
-			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
-			status: "pending",
-			pending,
-			queue: args.pendingQueue.map((entry) => ({ ...entry })),
-			outputsByNode: args.request.ctx.data.dump(),
-			nodeSnapshotsByNodeId: {
-				...args.previousNodeSnapshotsByNodeId,
-				[args.request.nodeId]: queuedSnapshot
-			}
-		});
-		this.notifyPendingStatePersisted(args.runId);
-		return {
-			result: {
-				runId: args.runId,
-				workflowId: args.workflowId,
-				startedAt: args.startedAt,
-				status: "pending",
-				pending
-			},
-			queuedSnapshot
-		};
-	}
-	notifyPendingStatePersisted(runId) {
-		this.activationScheduler.notifyPendingStatePersisted?.(runId);
-	}
-};
-
-//#endregion
-//#region src/execution/DefaultAsyncSleeper.ts
-var DefaultAsyncSleeper = class {
-	sleep(ms) {
-		return new Promise((resolve) => {
-			setTimeout(resolve, ms);
-		});
-	}
-};
-
-//#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/NodeActivationRequestComposer.ts
-/**
-* Builds {@link NodeActivationRequest} values shared by workflow starters and continuation.
-*/
-var NodeActivationRequestComposer = class {
-	constructor(activationIdFactory, credentialResolverFactory) {
-		this.activationIdFactory = activationIdFactory;
-		this.credentialResolverFactory = credentialResolverFactory;
-	}
-	createSingleFromDefinition(args) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = {
-			...args.base,
-			data: args.data,
-			nodeId: args.definition.id,
-			activationId,
-			config: args.definition.config,
-			binary: args.base.binary.forNode({
-				nodeId: args.definition.id,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.definition.id, args.definition.config)
-		};
-		return {
-			kind: "single",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.definition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.batchId,
-			input: args.input,
-			ctx
-		};
-	}
-	createFromPlannedActivation(args) {
-		const activationId = this.activationIdFactory.makeActivationId();
-		const ctx = {
-			...args.base,
-			data: args.data,
-			nodeId: args.nodeDefinition.id,
-			activationId,
-			config: args.nodeDefinition.config,
-			binary: args.base.binary.forNode({
-				nodeId: args.nodeDefinition.id,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeDefinition.id, args.nodeDefinition.config)
-		};
-		if (args.next.kind === "multi") return {
-			kind: "multi",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeDefinition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.next.batchId,
-			inputsByPort: args.next.inputsByPort,
-			ctx
-		};
-		return {
-			kind: "single",
-			runId: args.runId,
-			activationId,
-			workflowId: args.workflowId,
-			nodeId: args.nodeDefinition.id,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			batchId: args.next.batchId,
-			input: args.next.input,
-			ctx
-		};
-	}
-};
-
-//#endregion
-//#region src/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/workflowSnapshots/MissingRuntimeFallbacks.ts
-var MissingRuntimeNodeToken = class {};
-var MissingRuntimeTriggerToken = class {};
-var MissingRuntimeNodeConfig = class {
-	kind = "node";
-	type = MissingRuntimeNodeToken;
-	constructor(name, missingTokenId, missingRuntime = true) {
-		this.name = name;
-		this.missingTokenId = missingTokenId;
-		this.missingRuntime = missingRuntime;
-	}
-};
-var MissingRuntimeTriggerConfig = class {
-	kind = "trigger";
-	type = MissingRuntimeTriggerToken;
-	constructor(name, missingTokenId, missingRuntime = true) {
-		this.name = name;
-		this.missingTokenId = missingTokenId;
-		this.missingRuntime = missingRuntime;
-	}
-};
-var MissingRuntimeNode = class {
-	kind = "node";
-	outputPorts = ["main"];
-	async execute(items) {
-		return { main: items };
-	}
-};
-var MissingRuntimeTrigger = class {
-	kind = "trigger";
-	outputPorts = ["main"];
-	async setup(_ctx) {}
-	async execute(items) {
-		return { main: items };
-	}
-};
-var MissingRuntimeExecutionMarker = class {
-	static isMarked(config) {
-		return Boolean(config?.missingRuntime);
-	}
-};
-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/execution/RunStateSemantics.ts
-var RunStateSemantics = class {
-	isStopConditionSatisfied(stopCondition, nodeId) {
-		if (!stopCondition || stopCondition.kind === "workflowCompleted") return false;
-		return stopCondition.nodeId === nodeId;
-	}
-	resolveResultOutputs(workflow, stopCondition, outputsByNode) {
-		if (stopCondition?.kind === "nodeCompleted") return outputsByNode[stopCondition.nodeId]?.main ?? [];
-		return outputsByNode[createWorkflowExecutableNodeClassifier(workflow).lastExecutableNodeIdInDefinitionOrder(workflow)]?.main ?? [];
-	}
-	applySkippedSnapshots(args) {
-		const snapshots = { ...args.currentState.nodeSnapshotsByNodeId };
-		const skippedPinnedNodeIds = new Set(args.preservedPinnedNodeIds.filter((nodeId) => args.skippedNodeIds.includes(nodeId)));
-		for (const nodeId of args.skippedNodeIds) if (args.currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort) skippedPinnedNodeIds.add(nodeId);
-		for (const nodeId of skippedPinnedNodeIds) {
-			const previous = snapshots[nodeId];
-			snapshots[nodeId] = NodeSnapshotFactory.completed({
-				previous,
-				runId: args.runId,
-				workflowId: args.workflowId,
-				nodeId,
-				activationId: previous?.activationId ?? `synthetic_${nodeId}`,
-				parent: args.parent,
-				finishedAt: args.finishedAt,
-				inputsByPort: previous?.inputsByPort ?? InputPortMap.empty(),
-				outputs: args.currentState.outputsByNode[nodeId] ?? {},
-				fromPinnedOutput: true
-			});
-		}
-		return snapshots;
-	}
-	applyPinnedQueueSkips(args) {
-		let changed = true;
-		while (changed) {
-			changed = false;
-			for (let index = 0; index < args.queue.length; index += 1) {
-				const queueEntry = args.queue[index];
-				const pinnedOutputs = args.mutableState?.nodesById?.[queueEntry.nodeId]?.pinnedOutputsByPort;
-				if (!pinnedOutputs) continue;
-				args.queue.splice(index, 1);
-				const previous = args.nodeSnapshotsByNodeId[queueEntry.nodeId];
-				args.nodeSnapshotsByNodeId[queueEntry.nodeId] = NodeSnapshotFactory.completed({
-					previous,
-					runId: args.runId,
-					workflowId: args.workflowId,
-					nodeId: queueEntry.nodeId,
-					activationId: previous?.activationId ?? `synthetic_${queueEntry.nodeId}`,
-					parent: args.parent,
-					finishedAt: args.finishedAt,
-					inputsByPort: this.resolveQueueEntryInputsByPort(queueEntry),
-					outputs: pinnedOutputs,
-					fromPinnedOutput: true
-				});
-				args.data.setOutputs(queueEntry.nodeId, pinnedOutputs);
-				args.planner.applyOutputs(args.queue, {
-					fromNodeId: queueEntry.nodeId,
-					outputs: pinnedOutputs,
-					batchId: queueEntry.batchId ?? "batch_1"
-				});
-				changed = true;
-				break;
-			}
-		}
-	}
-	createFinishedSnapshot(args) {
-		const definition = args.workflow.nodes.find((node$1) => node$1.id === args.nodeId);
-		if (MissingRuntimeExecutionMarker.isMarked(definition?.config)) return NodeSnapshotFactory.skipped(args);
-		return NodeSnapshotFactory.completed(args);
-	}
-	resolveQueueEntryInputsByPort(queueEntry) {
-		if (queueEntry.collect) return queueEntry.collect.received;
-		return { [queueEntry.toInput ?? "in"]: queueEntry.input };
-	}
-};
-
-//#endregion
-//#region src/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 \0@oxc-project+runtime@0.95.0/helpers/decorateMetadata.js
-function __decorateMetadata(k, v) {
-	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.95.0/helpers/decorateParam.js
-function __decorateParam(paramIndex, decorator) {
-	return function(target, key) {
-		decorator(target, key, paramIndex);
-	};
-}
-
-//#endregion
-//#region src/executor/NodeExecutor.ts
-let NodeExecutor = class NodeExecutor$1 {
-	retryRunner = new InProcessRetryRunner(new DefaultAsyncSleeper());
-	constructor(nodeInstanceFactory) {
-		this.nodeInstanceFactory = nodeInstanceFactory;
-	}
-	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);
-	}
-};
-NodeExecutor = __decorate([
-	injectable(),
-	__decorateParam(0, inject(CoreTokens.WorkflowNodeInstanceFactory)),
-	__decorateMetadata("design:paramtypes", [Object])
-], NodeExecutor);
-
-//#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 = createWorkflowExecutableNodeClassifier(wf);
-		const defs = /* @__PURE__ */ new Map();
-		for (const n of wf.nodes) if (classifier.isExecutableNodeId(n.id)) defs.set(n.id, n);
-		const outgoing = /* @__PURE__ */ new Map();
-		for (const e of wf.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = outgoing.get(e.from.nodeId) ?? [];
-			list.push({
-				output: e.from.output,
-				to: {
-					nodeId: e.to.nodeId,
-					input: e.to.input
-				}
-			});
-			outgoing.set(e.from.nodeId, list);
-		}
-		const incomingByNode = /* @__PURE__ */ new Map();
-		for (const e of wf.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = incomingByNode.get(e.to.nodeId) ?? [];
-			list.push({
-				from: {
-					nodeId: e.from.nodeId,
-					output: e.from.output
-				},
-				input: e.to.input
-			});
-			incomingByNode.set(e.to.nodeId, list);
-		}
-		const expected = /* @__PURE__ */ new Map();
-		for (const [toNodeId, inputs] of incomingByNode.entries()) {
-			const counts = /* @__PURE__ */ new Map();
-			for (const edge of inputs) counts.set(edge.input, (counts.get(edge.input) ?? 0) + 1);
-			for (const [k, n] of counts.entries()) if (n > 1) throw new Error(`Node ${toNodeId} has multiple edges into input '${k}'. Use a Merge node upstream.`);
-			const order = [];
-			const seen = /* @__PURE__ */ new Set();
-			for (const edge of inputs) {
-				if (seen.has(edge.input)) continue;
-				seen.add(edge.input);
-				order.push(edge.input);
-			}
-			expected.set(toNodeId, order);
-		}
-		return new WorkflowTopology(defs, outgoing, incomingByNode, expected, wf.nodes.filter((node$1) => classifier.isExecutableNodeId(node$1.id) && !incomingByNode.has(node$1.id)).map((node$1) => node$1.id));
-	}
-};
-
-//#endregion
-//#region src/observability/RuntimeContinuationDiagnosticsReporter.ts
-var RuntimeContinuationDiagnostics = class {
-	static formatNodeLabel(args) {
-		const tokenName = typeof args.definition?.type === "function" ? args.definition.type.name : "Node";
-		return args.definition?.name ? `"${args.definition.name}" (${tokenName}:${args.nodeId})` : `${tokenName}:${args.nodeId}`;
-	}
-	static formatOutputCounts(outputs) {
-		const entries = Object.entries(outputs ?? {});
-		if (entries.length === 0) return "no outputs";
-		return entries.map(([port, items]) => `${port}=${items?.length ?? 0}`).join(", ");
-	}
-};
-
-//#endregion
-//#region src/orchestration/RunContinuationService.ts
-var RunContinuationService = class {
-	constructor(activationIdFactory, runStore, runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy) {
-		this.activationIdFactory = activationIdFactory;
-		this.runStore = runStore;
-		this.runDataFactory = runDataFactory;
-		this.runExecutionContextFactory = runExecutionContextFactory;
-		this.workflowSnapshotResolver = workflowSnapshotResolver;
-		this.planningFactory = planningFactory;
-		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
-		this.credentialResolverFactory = credentialResolverFactory;
-		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
-		this.persistedRunStateTerminalBuilder = persistedRunStateTerminalBuilder;
-		this.activationEnqueueService = activationEnqueueService;
-		this.nodeEventPublisher = nodeEventPublisher;
-		this.semantics = semantics;
-		this.waiters = waiters;
-		this.policyErrorServices = policyErrorServices;
-		this.terminalPersistence = terminalPersistence;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-	}
-	async markNodeRunning(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state?.pending) return;
-		if (state.pending.activationId !== args.activationId || state.pending.nodeId !== args.nodeId) return;
-		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-		const snapshot = NodeSnapshotFactory.running({
-			previous,
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			startedAt,
-			inputsByPort: args.inputsByPort
-		});
-		await this.runStore.save({
-			...state,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[args.nodeId]: snapshot
-			}
-		});
-		await this.nodeEventPublisher.publish("nodeStarted", snapshot);
-	}
-	async resumeFromNodeResult(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
-		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
-		const wf = this.resolvePersistedWorkflow(state);
-		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
-		const { topology, planner } = this.planningFactory.create(wf);
-		const data = this.runDataFactory.create(state.outputsByNode);
-		const limits = this.resolveEngineLimitsFromState(state);
-		const base = this.runExecutionContextFactory.create({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			parent: state.parent,
-			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: limits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
-		});
-		data.setOutputs(args.nodeId, args.outputs);
-		const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const completedSnapshot = this.semantics.createFinishedSnapshot({
-			workflow: wf,
-			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			finishedAt: completedAt,
-			inputsByPort: state.pending.inputsByPort,
-			outputs: args.outputs
-		});
-		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
-		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
-		if (this.semantics.isStopConditionSatisfied(state.control?.stopCondition, args.nodeId)) {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...state.nodeSnapshotsByNodeId ?? {},
-					[args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "completed",
-				outputs: this.semantics.resolveResultOutputs(wf, state.control?.stopCondition, data.dump())
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const batchId = state.pending.batchId ?? "batch_1";
-		const queue = (state.queue ?? []).map((q) => ({
-			...q,
-			batchId: q.batchId ?? batchId
-		}));
-		const nextNodeSnapshotsByNodeId = {
-			...state.nodeSnapshotsByNodeId ?? {},
-			[args.nodeId]: completedSnapshot
-		};
-		planner.applyOutputs(queue, {
-			fromNodeId: args.nodeId,
-			outputs: args.outputs,
-			batchId
-		});
-		this.semantics.applyPinnedQueueSkips({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			parent: state.parent,
-			mutableState: state.mutableState,
-			planner,
-			queue,
-			data,
-			nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-			finishedAt: completedAt
-		});
-		let next;
-		try {
-			next = planner.nextActivation(queue);
-		} catch (cause) {
-			const completedDefinition = topology.defsById.get(args.nodeId);
-			const completedNodeLabel = RuntimeContinuationDiagnostics.formatNodeLabel({
-				definition: completedDefinition,
-				nodeId: args.nodeId
-			});
-			const reason = cause instanceof Error ? cause.message : String(cause);
-			throw new Error(`After completing ${completedNodeLabel}, the engine could not plan the next activation. ${reason} Outputs: ${RuntimeContinuationDiagnostics.formatOutputCounts(args.outputs)}.`, { cause });
-		}
-		if (!next) {
-			const lastNodeId = createWorkflowExecutableNodeClassifier(wf).lastExecutableNodeIdInDefinitionOrder(wf);
-			const outputs = data.getOutputItems(lastNodeId, "main");
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "completed",
-				outputs
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (completedActivations >= maxNodeActivations) {
-			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
-			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state,
-				engineCounters,
-				status: "failed",
-				queue: queue.map((q) => ({ ...q })),
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
-			});
-			await this.runStore.save(failedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: wf,
-				state: failedState,
-				finalStatus: "failed",
-				finishedAt: completedAt
-			});
-			const result$1 = {
-				runId: state.runId,
-				workflowId: state.workflowId,
-				startedAt: state.startedAt,
-				status: "failed",
-				error: { message }
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const def = topology.defsById.get(next.nodeId);
-		if (!def || def.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base,
-			data,
-			runId: state.runId,
-			workflowId: state.workflowId,
-			parent: state.parent,
-			executionOptions: state.executionOptions,
-			nodeDefinition: def
-		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			parent: state.parent,
-			executionOptions: state.executionOptions,
-			control: state.control,
-			workflowSnapshot: state.workflowSnapshot,
-			mutableState: state.mutableState,
-			policySnapshot: state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-			planner,
-			engineCounters,
-			connectionInvocations: state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		return result;
-	}
-	async resumeFromNodeError(args) {
-		const state = await this.runStore.load(args.runId);
-		if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-		if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-		if (state.pending.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
-		if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
-		const wf = this.resolvePersistedWorkflow(state);
-		if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
-		const failedDefinition = WorkflowTopology.fromWorkflow(wf).defsById.get(args.nodeId);
-		const webhookControlSignal = state.executionOptions?.webhook && failedDefinition?.kind === "trigger" ? this.asWebhookControlSignal(args.error) : void 0;
-		if (webhookControlSignal) return await this.resumeFromWebhookControl({
-			state,
-			workflow: wf,
-			args,
-			signal: webhookControlSignal
-		});
-		if (failedDefinition && failedDefinition.kind === "node") {
-			const nodeHandler = this.policyErrorServices.resolveNodeErrorHandler(failedDefinition.config.nodeErrorHandler);
-			if (nodeHandler) try {
-				const ctx = this.buildNodeExecutionContextForPending(state, wf, failedDefinition, args.nodeId);
-				const inputsByPort = state.pending.inputsByPort;
-				const portKeys = Object.keys(inputsByPort);
-				const kind = portKeys.length === 1 && portKeys[0] === "in" ? "single" : "multi";
-				const items = inputsByPort.in ?? [];
-				const recovered = await nodeHandler.handle({
-					kind,
-					items,
-					inputsByPort: kind === "multi" ? inputsByPort : void 0,
-					ctx,
-					error: args.error
-				});
-				return await this.resumeFromNodeResult({
-					runId: args.runId,
-					activationId: args.activationId,
-					nodeId: args.nodeId,
-					outputs: recovered
-				});
-			} catch {}
-		}
-		const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const message = args.error?.message ?? String(args.error);
-		const failedSnapshot = NodeSnapshotFactory.failed({
-			previous: state.nodeSnapshotsByNodeId?.[args.nodeId],
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId: args.nodeId,
-			activationId: args.activationId,
-			parent: state.parent,
-			finishedAt,
-			inputsByPort: state.pending.inputsByPort,
-			error: args.error
-		});
-		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-			state,
-			engineCounters: state.engineCounters ?? { completedNodeActivations: 0 },
-			status: "failed",
-			queue: (state.queue ?? []).map((q) => ({ ...q })),
-			outputsByNode: state.outputsByNode,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[args.nodeId]: failedSnapshot
-			}
-		});
-		await this.runStore.save(failedState);
-		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
-		const wfErr = this.policyErrorServices.resolveWorkflowErrorHandler(wf.workflowErrorHandler);
-		if (wfErr) await Promise.resolve(wfErr.onError({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			workflow: wf,
-			failedNodeId: args.nodeId,
-			error: args.error,
-			startedAt: state.startedAt,
-			finishedAt
-		}));
-		await this.terminalPersistence.maybeDeleteAfterTerminalState({
-			workflow: wf,
-			state: failedState,
-			finalStatus: "failed",
-			finishedAt
-		});
-		const result = {
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			status: "failed",
-			error: { message }
-		};
-		this.waiters.resolveRunCompletion(result);
-		return result;
-	}
-	async resumeFromStepResult(args) {
-		return await this.resumeFromNodeResult(args);
-	}
-	async resumeFromStepError(args) {
-		return await this.resumeFromNodeError(args);
-	}
-	async waitForCompletion(runId) {
-		const existing = await this.runStore.load(runId);
-		if (existing?.status === "completed") {
-			const wf = this.resolvePersistedWorkflow(existing);
-			const outputs = wf ? this.semantics.resolveResultOutputs(wf, existing.control?.stopCondition, existing.outputsByNode) : [];
-			return {
-				runId: existing.runId,
-				workflowId: existing.workflowId,
-				startedAt: existing.startedAt,
-				status: "completed",
-				outputs
-			};
-		}
-		if (existing?.status === "failed") return {
-			runId: existing.runId,
-			workflowId: existing.workflowId,
-			startedAt: existing.startedAt,
-			status: "failed",
-			error: { message: "Run failed" }
-		};
-		const result = await this.waiters.waitForCompletion(runId);
-		if (result.status !== "completed" && result.status !== "failed") throw new Error(`Unexpected run completion status: ${result.status}`);
-		return result;
-	}
-	async waitForWebhookResponse(runId) {
-		return await this.waiters.waitForWebhookResponse(runId);
-	}
-	async resumeFromWebhookControl(args) {
-		const data = this.runDataFactory.create(args.state.outputsByNode);
-		const { topology, planner } = this.planningFactory.create(args.workflow);
-		const triggerOutputs = { main: args.signal.kind === "respondNowAndContinue" ? args.signal.continueItems ?? [] : args.signal.responseItems };
-		data.setOutputs(args.args.nodeId, triggerOutputs);
-		const completedSnapshot = this.semantics.createFinishedSnapshot({
-			workflow: args.workflow,
-			previous: args.state.nodeSnapshotsByNodeId?.[args.args.nodeId],
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			nodeId: args.args.nodeId,
-			activationId: args.args.activationId,
-			parent: args.state.parent,
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			inputsByPort: args.state.pending?.inputsByPort ?? InputPortMap.empty(),
-			outputs: triggerOutputs
-		});
-		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
-		const engineCounters = { completedNodeActivations: completedActivations };
-		const maxNodeActivations = args.state.executionOptions?.maxNodeActivations ?? Number.MAX_SAFE_INTEGER;
-		if (this.semantics.isStopConditionSatisfied(args.state.control?.stopCondition, args.args.nodeId)) {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs: this.semantics.resolveResultOutputs(args.workflow, args.state.control?.stopCondition, data.dump())
-			};
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (args.signal.kind === "respondNow") {
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs: args.signal.responseItems
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const batchId = args.state.pending?.batchId ?? "batch_1";
-		const queue = (args.state.queue ?? []).map((entry) => ({
-			...entry,
-			batchId: entry.batchId ?? batchId
-		}));
-		planner.applyOutputs(queue, {
-			fromNodeId: args.args.nodeId,
-			outputs: triggerOutputs,
-			batchId
-		});
-		const next = planner.nextActivation(queue);
-		if (!next) {
-			const lastNodeId = createWorkflowExecutableNodeClassifier(args.workflow).lastExecutableNodeIdInDefinitionOrder(args.workflow);
-			const outputs = data.getOutputItems(lastNodeId, "main");
-			const completedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "completed",
-				queue: [],
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(completedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: completedState,
-				finalStatus: "completed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "completed",
-				outputs
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "completed",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		if (completedActivations >= maxNodeActivations) {
-			const message = `Run exceeded maxNodeActivations (${maxNodeActivations}) after ${completedActivations} completed node activations (next would be ${next.nodeId}).`;
-			const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
-				state: args.state,
-				engineCounters,
-				status: "failed",
-				queue: queue.map((q) => ({ ...q })),
-				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				}
-			});
-			await this.runStore.save(failedState);
-			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-			await this.terminalPersistence.maybeDeleteAfterTerminalState({
-				workflow: args.workflow,
-				state: failedState,
-				finalStatus: "failed",
-				finishedAt: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
-			});
-			const result$1 = {
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				status: "failed",
-				error: { message }
-			};
-			this.waiters.resolveWebhookResponse({
-				runId: args.state.runId,
-				workflowId: args.state.workflowId,
-				startedAt: args.state.startedAt,
-				runStatus: "pending",
-				response: args.signal.responseItems
-			});
-			this.waiters.resolveRunCompletion(result$1);
-			return result$1;
-		}
-		const nextDefinition = topology.defsById.get(next.nodeId);
-		if (!nextDefinition || nextDefinition.kind !== "node") throw new Error(`Node ${next.nodeId} is not a runnable node`);
-		const webhookLimits = this.resolveEngineLimitsFromState(args.state);
-		const base = this.runExecutionContextFactory.create({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			nodeId: nextDefinition.id,
-			parent: args.state.parent,
-			subworkflowDepth: args.state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: webhookLimits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: webhookLimits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(args.state.runId, args.state.workflowId, args.state.parent)
-		});
-		const request = this.nodeActivationRequestComposer.createFromPlannedActivation({
-			next,
-			base,
-			data,
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			parent: args.state.parent,
-			executionOptions: args.state.executionOptions,
-			nodeDefinition: nextDefinition
-		});
-		const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			parent: args.state.parent,
-			executionOptions: args.state.executionOptions,
-			control: args.state.control,
-			workflowSnapshot: args.state.workflowSnapshot,
-			mutableState: args.state.mutableState,
-			policySnapshot: args.state.policySnapshot,
-			pendingQueue: queue,
-			request,
-			previousNodeSnapshotsByNodeId: {
-				...args.state.nodeSnapshotsByNodeId ?? {},
-				[args.args.nodeId]: completedSnapshot
-			},
-			planner,
-			engineCounters,
-			connectionInvocations: args.state.connectionInvocations ?? []
-		});
-		await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-		await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-		this.waiters.resolveWebhookResponse({
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			startedAt: args.state.startedAt,
-			runStatus: "pending",
-			response: args.signal.responseItems
-		});
-		return result;
-	}
-	asWebhookControlSignal(error) {
-		const candidate = error;
-		if (!candidate || candidate.__webhookControl !== true) return void 0;
-		if (candidate.kind !== "respondNow" && candidate.kind !== "respondNowAndContinue") return void 0;
-		if (!Array.isArray(candidate.responseItems)) return void 0;
-		return candidate;
-	}
-	resolvePersistedWorkflow(state) {
-		return this.workflowSnapshotResolver.resolve({
-			workflowId: state.workflowId,
-			workflowSnapshot: state.workflowSnapshot
-		});
-	}
-	buildNodeExecutionContextForPending(state, wf, def, nodeId) {
-		const data = this.runDataFactory.create(state.outputsByNode);
-		const limits = this.resolveEngineLimitsFromState(state);
-		const base = this.runExecutionContextFactory.create({
-			runId: state.runId,
-			workflowId: state.workflowId,
-			nodeId,
-			parent: state.parent,
-			subworkflowDepth: state.executionOptions?.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: limits.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: limits.engineMaxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
-		});
-		const activationId = state.pending.activationId;
-		return {
-			...base,
-			data,
-			nodeId,
-			activationId,
-			config: def.config,
-			binary: base.binary.forNode({
-				nodeId,
-				activationId
-			}),
-			getCredential: this.credentialResolverFactory.create(wf.id, nodeId, def.config)
-		};
-	}
-	resolveEngineLimitsFromState(state) {
-		const fb = this.executionLimitsPolicy.createRootExecutionOptions();
-		return {
-			engineMaxNodeActivations: state.executionOptions?.maxNodeActivations ?? fb.maxNodeActivations,
-			engineMaxSubworkflowDepth: state.executionOptions?.maxSubworkflowDepth ?? fb.maxSubworkflowDepth
-		};
-	}
-};
-
-//#endregion
-//#region src/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/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, runStore, runDataFactory, workflowSnapshotFactory, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, workflowPolicyRuntimeDefaults, executionLimitsPolicy) {
-		this.runIdFactory = runIdFactory;
-		this.runStore = runStore;
-		this.runDataFactory = runDataFactory;
-		this.workflowSnapshotFactory = workflowSnapshotFactory;
-		this.planningFactory = planningFactory;
-		this.nodeStatePublisherFactory = nodeStatePublisherFactory;
-		this.runExecutionContextFactory = runExecutionContextFactory;
-		this.nodeActivationRequestComposer = nodeActivationRequestComposer;
-		this.activationEnqueueService = activationEnqueueService;
-		this.semantics = semantics;
-		this.waiters = waiters;
-		this.workflowPolicyRuntimeDefaults = workflowPolicyRuntimeDefaults;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-	}
-	async 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.runStore.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.runStore.createRun({
-			runId,
-			workflowId: request.workflow.id,
-			startedAt,
-			parent: request.parent,
-			executionOptions: mergedExecutionOptions,
-			control,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			engineCounters: { completedNodeActivations: 0 }
-		});
-		const { topology, planner } = this.planningFactory.create(request.workflow);
-		const plan = CurrentStateFrontierPlanner.createFromTopology(topology).plan({
-			currentState: this.createRunCurrentState(request.currentState, mutableState),
-			stopCondition: control.stopCondition,
-			reset: request.reset,
-			items: request.items
-		});
-		const data = this.runDataFactory.create(plan.currentState.outputsByNode);
-		const base = this.runExecutionContextFactory.create({
-			runId,
-			workflowId: request.workflow.id,
-			nodeId: createWorkflowExecutableNodeClassifier(request.workflow).firstExecutableNodeIdInDefinitionOrder(request.workflow) ?? "unknown_node",
-			parent: request.parent,
-			subworkflowDepth: mergedExecutionOptions.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: mergedExecutionOptions.maxNodeActivations,
-			engineMaxSubworkflowDepth: mergedExecutionOptions.maxSubworkflowDepth,
-			data,
-			nodeState: this.nodeStatePublisherFactory.create(runId, request.workflow.id, request.parent)
-		});
-		return await this.scheduleInitialPlan({
-			runId,
-			startedAt,
-			workflow: request.workflow,
-			workflowSnapshot,
-			mutableState,
-			policySnapshot,
-			executionOptions: mergedExecutionOptions,
-			control,
-			parent: request.parent,
-			planner,
-			plan,
-			base,
-			data
-		});
-	}
-	createRunCurrentState(currentState, mutableState) {
-		return {
-			outputsByNode: { ...currentState?.outputsByNode ?? {} },
-			nodeSnapshotsByNodeId: { ...currentState?.nodeSnapshotsByNodeId ?? {} },
-			connectionInvocations: currentState?.connectionInvocations ? [...currentState.connectionInvocations] : void 0,
-			mutableState: mutableState ?? currentState?.mutableState
-		};
-	}
-	async scheduleInitialPlan(args) {
-		const initialNodeSnapshotsByNodeId = this.semantics.applySkippedSnapshots({
-			runId: args.runId,
-			workflowId: args.workflow.id,
-			parent: args.parent,
-			currentState: args.plan.currentState,
-			skippedNodeIds: args.plan.skippedNodeIds,
-			preservedPinnedNodeIds: args.plan.preservedPinnedNodeIds,
-			finishedAt: args.startedAt
-		});
-		if (args.plan.rootNodeId) {
-			const startDef = WorkflowTopology.fromWorkflow(args.workflow).defsById.get(args.plan.rootNodeId);
-			if (!startDef) throw new Error(`Unknown frontier nodeId: ${args.plan.rootNodeId}`);
-			const startItems = args.plan.rootNodeInput ?? [];
-			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.runStore.save({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			startedAt: args.startedAt,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			control: args.control,
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState,
-			policySnapshot: args.policySnapshot,
-			engineCounters: { completedNodeActivations: 0 },
-			connectionInvocations: args.connectionInvocations ? [...args.connectionInvocations] : [],
-			status: "completed",
-			pending: void 0,
-			queue: [],
-			outputsByNode: args.data.dump(),
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
-		});
-		const result = {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			startedAt: args.startedAt,
-			status: "completed",
-			outputs: this.semantics.resolveResultOutputs(args.workflow, args.control?.stopCondition, args.data.dump())
-		};
-		this.waiters.resolveRunCompletion(result);
-		return result;
-	}
-};
-
-//#endregion
-//#region src/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) {
-		if (request.executionOptions?.localOnly) return {
-			...await this.inline.enqueue(request),
-			mode: "local"
-		};
-		const decision = this.offloadPolicy.decide({
-			workflowId: request.workflowId,
-			nodeId: request.nodeId,
-			config: request.ctx.config
-		});
-		if (decision.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: decision.queue,
-				executionOptions: request.executionOptions
-			};
-			return {
-				receiptId: (await this.workerScheduler.enqueue(workerRequest)).receiptId,
-				mode: "worker",
-				queue: decision.queue
-			};
-		}
-		return {
-			...await this.inline.enqueue(request),
-			mode: "local"
-		};
-	}
-	notifyPendingStatePersisted(runId) {
-		this.inline.notifyPendingStatePersisted(runId);
-	}
-};
-
-//#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 _ref$2;
-let InlineDrivingScheduler = class InlineDrivingScheduler$1 {
-	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");
-	}
-};
-InlineDrivingScheduler = __decorate([
-	injectable(),
-	__decorateParam(0, inject(NodeExecutor)),
-	__decorateMetadata("design:paramtypes", [typeof (_ref$2 = typeof NodeExecutor !== "undefined" && NodeExecutor) === "function" ? _ref$2 : Object])
-], InlineDrivingScheduler);
-
-//#endregion
-//#region src/scheduler/LocalOnlyScheduler.ts
-var LocalOnlyScheduler = class {
-	async enqueue(_request) {
-		throw new Error("No worker scheduler configured");
-	}
-};
-
-//#endregion
-//#region src/executionContext/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/executionContext/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/policies/EngineExecutionLimitsPolicy.ts
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
-const ENGINE_EXECUTION_LIMITS_DEFAULTS = {
-	defaultMaxNodeActivations: 1e5,
-	hardMaxNodeActivations: 1e5,
-	defaultMaxSubworkflowDepth: 32,
-	hardMaxSubworkflowDepth: 32
-};
-/**
-* Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
-*/
-var EngineExecutionLimitsPolicy = class {
-	constructor(config = ENGINE_EXECUTION_LIMITS_DEFAULTS) {
-		this.config = config;
-	}
-	/**
-	* Effective options for a new root run (depth 0): defaults merged with engine ceilings.
-	* Replaces a separate one-method factory for root-run bootstrap.
-	*/
-	createRootExecutionOptions() {
-		return this.mergeExecutionOptionsForNewRun(void 0, void 0);
-	}
-	mergeExecutionOptionsForNewRun(parent, user) {
-		const subworkflowDepth = parent === void 0 ? 0 : (parent.subworkflowDepth ?? 0) + 1;
-		const inheritedMaxNode = parent?.engineMaxNodeActivations;
-		const inheritedMaxSub = parent?.engineMaxSubworkflowDepth;
-		const maxNodeActivations = this.capNumber(user?.maxNodeActivations ?? inheritedMaxNode, this.config.defaultMaxNodeActivations, this.config.hardMaxNodeActivations);
-		const maxSubworkflowDepth = this.capNumber(user?.maxSubworkflowDepth ?? inheritedMaxSub, this.config.defaultMaxSubworkflowDepth, this.config.hardMaxSubworkflowDepth);
-		if (subworkflowDepth > maxSubworkflowDepth) throw new Error(`Subworkflow nesting depth ${subworkflowDepth} exceeds maxSubworkflowDepth ${maxSubworkflowDepth} (run would be a child of parent run).`);
-		return {
-			...user,
-			subworkflowDepth,
-			maxNodeActivations,
-			maxSubworkflowDepth
-		};
-	}
-	capNumber(requested, defaultValue, hardCeiling) {
-		const base = requested === void 0 ? defaultValue : requested;
-		return Math.min(base, hardCeiling);
-	}
-};
-
-//#endregion
-//#region src/policies/RunTerminalPersistenceCoordinator.ts
-var RunTerminalPersistenceCoordinator = class {
-	constructor(runStore, storageEvaluator) {
-		this.runStore = runStore;
-		this.storageEvaluator = storageEvaluator;
-	}
-	async maybeDeleteAfterTerminalState(args) {
-		if (await this.storageEvaluator.shouldPersist(args.workflow, args.state.policySnapshot, {
-			runId: args.state.runId,
-			workflowId: args.state.workflowId,
-			workflow: args.workflow,
-			finalStatus: args.finalStatus,
-			startedAt: args.state.startedAt,
-			finishedAt: args.finishedAt
-		})) return;
-		if (!this.runStore.deleteRun) return;
-		await this.runStore.deleteRun(args.state.runId);
-	}
-};
-
-//#endregion
-//#region src/policies/WorkflowPolicyErrorServices.ts
-var WorkflowPolicyErrorServices = class {
-	constructor(nodeResolver) {
-		this.nodeResolver = nodeResolver;
-	}
-	resolveNodeErrorHandler(spec) {
-		if (!spec) return void 0;
-		if (typeof spec === "object" && spec !== null && "handle" in spec && typeof spec.handle === "function") return spec;
-		return this.nodeResolver.resolve(spec);
-	}
-	resolveWorkflowErrorHandler(spec) {
-		if (!spec) return void 0;
-		if (typeof spec === "object" && spec !== null && "onError" in spec && typeof spec.onError === "function") return spec;
-		return this.nodeResolver.resolve(spec);
-	}
-};
-
-//#endregion
-//#region src/policies/WorkflowStoragePolicyEvaluator.ts
-var WorkflowStoragePolicyEvaluator = class {
-	constructor(nodeResolver) {
-		this.nodeResolver = nodeResolver;
-	}
-	async shouldPersist(workflow, snapshot, args) {
-		const spec = workflow.storagePolicy;
-		if (spec === void 0) return this.modeMatches(snapshot?.storagePolicy ?? "ALL", args);
-		if (typeof spec === "string") return this.modeMatches(spec, args);
-		const resolver = this.nodeResolver.resolve(spec);
-		return Boolean(await resolver.shouldPersist(args));
-	}
-	modeMatches(mode, args) {
-		if (mode === "ALL") return true;
-		if (mode === "NEVER") return false;
-		if (mode === "SUCCESS") return args.finalStatus === "completed";
-		if (mode === "ERROR") return args.finalStatus === "failed";
-		return true;
-	}
-};
-
-//#endregion
-//#region src/runStorage/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/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/planning/RunQueuePlanner.ts
-var RunQueuePlanner = class {
-	constructor(topology, nodeInstances) {
-		this.topology = topology;
-		this.nodeInstances = nodeInstances;
-	}
-	validateNodeKinds() {
-		for (const [toNodeId, inputs] of this.topology.expectedInputsByNode.entries()) {
-			if (inputs.length <= 1) {
-				const only = inputs[0];
-				if (only && only !== "in") {
-					const inst$1 = this.nodeInstances.get(toNodeId);
-					if (!this.isMultiInputNode(inst$1)) throw new Error(`Node ${toNodeId} only supports input 'in' (got '${only}').`);
-				}
-				continue;
-			}
-			const inst = this.nodeInstances.get(toNodeId);
-			if (!this.isMultiInputNode(inst)) throw new Error(`Node ${toNodeId} has ${inputs.length} inbound edges. Insert a Merge node to combine branches.`);
-		}
-	}
-	seedFromTrigger(args) {
-		const queue = [];
-		for (const e of this.topology.outgoingByNode.get(args.startNodeId) ?? []) {
-			if (e.output !== "main") continue;
-			this.enqueueEdge(queue, {
-				batchId: args.batchId,
-				to: e.to,
-				from: {
-					nodeId: args.startNodeId,
-					output: "main"
-				},
-				items: args.items
-			});
-		}
-		return queue;
-	}
-	applyOutputs(queue, args) {
-		for (const e of this.topology.outgoingByNode.get(args.fromNodeId) ?? []) {
-			const outItems = args.outputs[e.output] ?? [];
-			this.enqueueEdge(queue, {
-				batchId: args.batchId,
-				to: e.to,
-				from: {
-					nodeId: args.fromNodeId,
-					output: e.output
-				},
-				items: outItems
-			});
-		}
-	}
-	nextActivation(queue) {
-		const readyCollect = this.resolveReadyCollect(queue);
-		if (readyCollect) return readyCollect;
-		const jobIdx = queue.findIndex((q) => !q.collect);
-		if (jobIdx === -1) {
-			if (queue.length === 0) return null;
-			const sealedCollect = this.resolveSealedCollect(queue);
-			if (sealedCollect) return sealedCollect;
-			const stuck = queue[0];
-			throw new Error(this.describeUnsatisfiedCollect(stuck));
-		}
-		const job = queue.splice(jobIdx, 1)[0];
-		const def = this.topology.defsById.get(job.nodeId);
-		if (!def || def.kind !== "node") return this.nextActivation(queue);
-		return {
-			kind: "single",
-			nodeId: job.nodeId,
-			input: job.input,
-			batchId: job.batchId ?? "batch_1"
-		};
-	}
-	sumItemsByPort(inputsByPort) {
-		let n = 0;
-		for (const v of Object.values(inputsByPort)) n += v?.length ?? 0;
-		return n;
-	}
-	resolveReadyCollect(queue) {
-		for (let i = 0; i < queue.length; i++) {
-			const ready = this.tryDequeueCollect(queue, i);
-			if (ready) return ready;
-		}
-		return null;
-	}
-	resolveSealedCollect(queue) {
-		for (let i = 0; i < queue.length; i++) {
-			const queueEntry = queue[i];
-			if (!queueEntry.collect) continue;
-			const received = queueEntry.collect.received;
-			if (Object.keys(received).length === 0) continue;
-			this.fillMissingCollectInputs(queueEntry);
-			const ready = this.tryDequeueCollect(queue, i);
-			if (ready) return ready;
-		}
-		return null;
-	}
-	tryDequeueCollect(queue, index) {
-		const queueEntry = queue[index];
-		if (!queueEntry.collect) return null;
-		const batchId = queueEntry.batchId ?? "batch_1";
-		const expected = queueEntry.collect.expectedInputs ?? [];
-		const received = queueEntry.collect.received;
-		for (const input of expected) if (!(input in received)) return null;
-		queue.splice(index, 1);
-		return {
-			kind: "multi",
-			nodeId: queueEntry.nodeId,
-			inputsByPort: received,
-			batchId
-		};
-	}
-	fillMissingCollectInputs(queueEntry) {
-		if (!queueEntry.collect) return;
-		const received = queueEntry.collect.received;
-		for (const input of queueEntry.collect.expectedInputs ?? []) if (!(input in received)) received[input] = [];
-	}
-	enqueueEdge(queue, args) {
-		const target = this.nodeInstances.get(args.to.nodeId);
-		if (!this.isMultiInputNode(target)) {
-			if (args.items.length === 0) {
-				if (this.shouldContinueAfterEmptyOutputFromSource(args.from.nodeId)) {
-					queue.push({
-						nodeId: args.to.nodeId,
-						input: args.items,
-						toInput: args.to.input,
-						batchId: args.batchId,
-						from: args.from
-					});
-					return;
-				}
-				this.propagateEmptyPath(queue, args.to.nodeId, args.batchId);
-				return;
-			}
-			queue.push({
-				nodeId: args.to.nodeId,
-				input: args.items,
-				toInput: args.to.input,
-				batchId: args.batchId,
-				from: args.from
-			});
-			return;
-		}
-		const expected = this.topology.expectedInputsByNode.get(args.to.nodeId) ?? [];
-		let collect = queue.find((q) => q.nodeId === args.to.nodeId && (q.batchId ?? "batch_1") === args.batchId && !!q.collect);
-		if (!collect) {
-			collect = {
-				nodeId: args.to.nodeId,
-				input: [],
-				batchId: args.batchId,
-				collect: {
-					expectedInputs: expected,
-					received: {}
-				}
-			};
-			queue.push(collect);
-		}
-		const received = collect.collect.received;
-		received[args.to.input] = args.items;
-	}
-	shouldContinueAfterEmptyOutputFromSource(fromNodeId) {
-		const def = this.topology.defsById.get(fromNodeId);
-		if (!def) return false;
-		return def.config.continueWhenEmptyOutput === true;
-	}
-	propagateEmptyPath(queue, nodeId, batchId) {
-		for (const edge of this.topology.outgoingByNode.get(nodeId) ?? []) this.enqueueEdge(queue, {
-			batchId,
-			to: edge.to,
-			from: {
-				nodeId,
-				output: edge.output
-			},
-			items: []
-		});
-	}
-	isMultiInputNode(n) {
-		return typeof n?.executeMulti === "function";
-	}
-	describeUnsatisfiedCollect(queueEntry) {
-		const batchId = queueEntry.batchId ?? "batch_1";
-		const expectedInputs = queueEntry.collect?.expectedInputs ?? [];
-		const receivedInputs = Object.keys(queueEntry.collect?.received ?? {});
-		const missingInputs = expectedInputs.filter((input) => !receivedInputs.includes(input));
-		const mergeNodeLabel = this.formatNodeLabel(queueEntry.nodeId);
-		const receivedSummary = this.describeReceivedInputs(queueEntry);
-		const missingSummary = this.describeMissingInputs(queueEntry.nodeId, missingInputs);
-		return [
-			`Multi-input collect is stuck at ${mergeNodeLabel} (batchId=${batchId}).`,
-			`Expected inputs: ${this.formatInputList(expectedInputs)}.`,
-			`Received inputs: ${receivedSummary}.`,
-			`Missing inputs: ${missingSummary}.`
-		].join(" ");
-	}
-	describeReceivedInputs(queueEntry) {
-		const received = queueEntry.collect?.received ?? {};
-		const receivedEntries = Object.entries(received);
-		if (receivedEntries.length === 0) return "none";
-		return receivedEntries.map(([input, items]) => `${input} (${items.length} item${items.length === 1 ? "" : "s"})`).join(", ");
-	}
-	describeMissingInputs(nodeId, missingInputs) {
-		if (missingInputs.length === 0) return "none";
-		return missingInputs.map((input) => {
-			const sources = this.findSources(nodeId, input);
-			if (sources.length === 0) return input;
-			return `${input} from ${sources.join(" or ")}`;
-		}).join(", ");
-	}
-	findSources(nodeId, input) {
-		const matches = [];
-		for (const [sourceNodeId, edges] of this.topology.outgoingByNode.entries()) for (const edge of edges) if (edge.to.nodeId === nodeId && edge.to.input === input) matches.push(this.formatNodeLabel(sourceNodeId));
-		return matches;
-	}
-	formatInputList(inputs) {
-		return inputs.length > 0 ? `[${inputs.join(", ")}]` : "[]";
-	}
-	formatNodeLabel(nodeId) {
-		const definition = this.topology.defsById.get(nodeId);
-		const instance = this.nodeInstances.get(nodeId);
-		const typeName = definition?.type && typeof definition.type === "function" ? definition.type.name : instance && typeof instance === "object" && "constructor" in instance ? instance.constructor.name ?? "Node" : "Node";
-		return definition?.name ? `"${definition.name}" (${typeName}:${nodeId})` : `${typeName}:${nodeId}`;
-	}
-};
-
-//#endregion
-//#region src/planning/EngineWorkflowPlanningFactory.ts
-var EngineWorkflowPlanningFactory = class {
-	constructor(workflowNodeInstanceFactory) {
-		this.workflowNodeInstanceFactory = workflowNodeInstanceFactory;
-	}
-	create(workflow) {
-		this.validateAcyclic(workflow);
-		const topology = WorkflowTopology.fromWorkflow(workflow);
-		const planner = new RunQueuePlanner(topology, this.workflowNodeInstanceFactory.createNodes(workflow));
-		planner.validateNodeKinds();
-		return {
-			topology,
-			planner
-		};
-	}
-	validateAcyclic(workflow) {
-		const classifier = createWorkflowExecutableNodeClassifier(workflow);
-		const outgoing = /* @__PURE__ */ new Map();
-		const visitState = /* @__PURE__ */ new Map();
-		for (const node$1 of workflow.nodes) if (classifier.isExecutableNodeId(node$1.id)) visitState.set(node$1.id, "unvisited");
-		for (const edge of workflow.edges) {
-			if (!classifier.isExecutableNodeId(edge.from.nodeId) || !classifier.isExecutableNodeId(edge.to.nodeId)) continue;
-			const destinations = outgoing.get(edge.from.nodeId) ?? [];
-			destinations.push(edge.to.nodeId);
-			outgoing.set(edge.from.nodeId, destinations);
-		}
-		for (const node$1 of workflow.nodes) if (classifier.isExecutableNodeId(node$1.id) && visitState.get(node$1.id) === "unvisited") this.depthFirstSearch(node$1.id, outgoing, visitState);
-	}
-	depthFirstSearch(nodeId, outgoing, visitState) {
-		visitState.set(nodeId, "visiting");
-		for (const toNodeId of outgoing.get(nodeId) ?? []) {
-			const state = visitState.get(toNodeId);
-			if (state === "visiting") throw new Error(`Workflow graph contains a directed cycle (edge ${nodeId} -> ${toNodeId}).`);
-			if (state === "unvisited") this.depthFirstSearch(toNodeId, outgoing, visitState);
-		}
-		visitState.set(nodeId, "done");
-	}
-};
-
-//#endregion
-//#region src/observability/BoundNodeExecutionStatePublisher.ts
-var BoundNodeExecutionStatePublisher = class {
-	chain = Promise.resolve();
-	constructor(runStore, runId, workflowId, parent, publishNodeEvent) {
-		this.runStore = runStore;
-		this.runId = runId;
-		this.workflowId = workflowId;
-		this.parent = parent;
-		this.publishNodeEvent = publishNodeEvent;
-	}
-	markQueued(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.queued({
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				queuedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty()
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeQueued", snapshot);
-		});
-	}
-	markRunning(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.running({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				startedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty()
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeStarted", snapshot);
-		});
-	}
-	markCompleted(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.completed({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				finishedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty(),
-				outputs: args.outputs ?? previous?.outputs ?? {}
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeCompleted", snapshot);
-		});
-	}
-	markFailed(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
-			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const snapshot = NodeSnapshotFactory.failed({
-				previous,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				nodeId: args.nodeId,
-				activationId: args.activationId ?? previous?.activationId ?? `synthetic_${args.nodeId}`,
-				parent: this.parent,
-				finishedAt,
-				inputsByPort: args.inputsByPort ?? previous?.inputsByPort ?? InputPortMap.empty(),
-				error: args.error
-			});
-			await this.saveSnapshot(state, snapshot);
-			await this.publishNodeEvent("nodeFailed", snapshot);
-		});
-	}
-	appendConnectionInvocation(args) {
-		return this.enqueue(async () => {
-			const state = await this.loadState();
-			const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-			const record = {
-				invocationId: args.invocationId,
-				runId: this.runId,
-				workflowId: this.workflowId,
-				connectionNodeId: args.connectionNodeId,
-				parentAgentNodeId: args.parentAgentNodeId,
-				parentAgentActivationId: args.parentAgentActivationId,
-				status: args.status,
-				managedInput: args.managedInput,
-				managedOutput: args.managedOutput,
-				error: args.error,
-				queuedAt: args.queuedAt,
-				startedAt: args.startedAt,
-				finishedAt: args.finishedAt,
-				updatedAt
-			};
-			await this.runStore.save({
-				...state,
-				connectionInvocations: [...state.connectionInvocations ?? [], record]
-			});
-		});
-	}
-	enqueue(work) {
-		const next = this.chain.then(work);
-		this.chain = next.catch(() => void 0);
-		return next;
-	}
-	async loadState() {
-		const state = await this.runStore.load(this.runId);
-		if (!state) throw new Error(`Unknown runId: ${this.runId}`);
-		return state;
-	}
-	async saveSnapshot(state, snapshot) {
-		await this.runStore.save({
-			...state,
-			nodeSnapshotsByNodeId: {
-				...state.nodeSnapshotsByNodeId ?? {},
-				[snapshot.nodeId]: snapshot
-			}
-		});
-	}
-};
-
-//#endregion
-//#region src/observability/NodeExecutionStatePublisherFactory.ts
-var NodeExecutionStatePublisherFactory = class {
-	constructor(runStore, nodeEventPublisher) {
-		this.runStore = runStore;
-		this.nodeEventPublisher = nodeEventPublisher;
-	}
-	create(runId, workflowId, parent) {
-		return new BoundNodeExecutionStatePublisher(this.runStore, runId, workflowId, parent, async (kind, snapshot) => {
-			await this.nodeEventPublisher.publish(kind, snapshot);
-		});
-	}
-};
-
-//#endregion
-//#region src/orchestration/TriggerRuntimeService.ts
-var TriggerRuntimeService = class {
-	credentialResolverFactory;
-	triggerCleanupHandlesByKey = /* @__PURE__ */ new Map();
-	constructor(workflowRepository, workflowActivationPolicy, runIdFactory, runDataFactory, executionContextFactory, credentialResolverFactory, nodeExecutionStatePublisherFactory, nodeResolver, triggerSetupStateStore, emitHandler, executionLimitsPolicy, diagnostics) {
-		this.workflowRepository = workflowRepository;
-		this.workflowActivationPolicy = workflowActivationPolicy;
-		this.runIdFactory = runIdFactory;
-		this.runDataFactory = runDataFactory;
-		this.executionContextFactory = executionContextFactory;
-		this.nodeExecutionStatePublisherFactory = nodeExecutionStatePublisherFactory;
-		this.nodeResolver = nodeResolver;
-		this.triggerSetupStateStore = triggerSetupStateStore;
-		this.emitHandler = emitHandler;
-		this.executionLimitsPolicy = executionLimitsPolicy;
-		this.diagnostics = diagnostics;
-		this.credentialResolverFactory = credentialResolverFactory;
-	}
-	async startTriggers() {
-		for (const wf of this.workflowRepository.list()) {
-			if (!this.workflowActivationPolicy.isActive(wf.id)) {
-				const summaries = this.formatTriggerSummaries(wf);
-				if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}) is inactive; skipping trigger setup — ${summaries.join("; ")}.`);
-				continue;
-			}
-			await this.startTriggersForWorkflow(wf);
-		}
-	}
-	async syncWorkflowTriggersForActivation(workflowId) {
-		const wf = this.workflowRepository.get(workflowId);
-		if (!wf) return;
-		const summaries = this.formatTriggerSummaries(wf);
-		if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}): stopping triggers — ${summaries.join("; ")}.`);
-		await this.stopTriggersForWorkflow(wf);
-		if (this.workflowActivationPolicy.isActive(workflowId)) {
-			if (summaries.length > 0) this.logInfo(`Workflow "${wf.name}" (${wf.id}): activation on; starting triggers — ${summaries.join("; ")}.`);
-			await this.startTriggersForWorkflow(wf);
-		} else this.logInfo(`Workflow "${wf.name}" (${wf.id}): activation off; triggers not started.`);
-	}
-	async stop() {
-		for (const workflow of this.workflowRepository.list()) await this.stopTriggersForWorkflow(workflow);
-	}
-	async createTriggerTestItems(args) {
-		const definition = args.workflow.nodes.find((node$2) => node$2.id === args.nodeId);
-		if (!definition) throw new Error(`Unknown trigger nodeId: ${args.nodeId}`);
-		if (definition.kind !== "trigger") throw new Error(`Node ${args.nodeId} is not a trigger`);
-		const node$1 = this.nodeResolver.resolve(definition.type);
-		if (!this.isTestableTriggerNode(node$1)) return;
-		const data = this.runDataFactory.create();
-		const runId = this.runIdFactory.makeRunId();
-		const trigger = {
-			workflowId: args.workflow.id,
-			nodeId: definition.id
-		};
-		const previousState = await this.triggerSetupStateStore.load(trigger);
-		return await node$1.getTestItems({
-			...this.createExecutionContext({
-				runId,
-				workflowId: args.workflow.id,
-				nodeId: definition.id,
-				data
-			}),
-			trigger,
-			nodeId: definition.id,
-			config: definition.config,
-			previousState: previousState?.state
-		});
-	}
-	async startTriggersForWorkflow(wf) {
-		for (const def of wf.nodes) {
-			if (def.kind !== "trigger") continue;
-			const node$1 = this.nodeResolver.resolve(def.type);
-			const data = this.runDataFactory.create();
-			const triggerRunId = this.runIdFactory.makeRunId();
-			const trigger = {
-				workflowId: wf.id,
-				nodeId: def.id
-			};
-			await this.stopTrigger(trigger);
-			const previousState = await this.triggerSetupStateStore.load(trigger);
-			let nextState;
-			try {
-				nextState = await node$1.setup({
-					...this.createExecutionContext({
-						runId: triggerRunId,
-						workflowId: wf.id,
-						nodeId: def.id,
-						data
-					}),
-					trigger,
-					config: def.config,
-					previousState: previousState?.state,
-					registerCleanup: (cleanup) => {
-						this.registerTriggerCleanupHandle(trigger, cleanup);
-					},
-					emit: async (items) => {
-						await this.emitHandler.emit(wf, def.id, items);
-					}
-				});
-			} catch (triggerError) {
-				await this.stopTrigger(trigger);
-				const message = triggerError instanceof Error ? triggerError.message : String(triggerError);
-				this.logWarn(`Skipping trigger setup for workflow ${wf.id} node ${def.id}: ${message}`);
-				continue;
-			}
-			if (nextState === void 0) await this.triggerSetupStateStore.delete(trigger);
-			else await this.triggerSetupStateStore.save({
-				trigger,
-				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				state: nextState
-			});
-		}
-	}
-	async stopTriggersForWorkflow(workflow) {
-		for (const node$1 of workflow.nodes) {
-			if (node$1.kind !== "trigger") continue;
-			await this.stopTrigger({
-				workflowId: workflow.id,
-				nodeId: node$1.id
-			});
-		}
-	}
-	createExecutionContext(args) {
-		const nodeState = this.nodeExecutionStatePublisherFactory.create(args.runId, args.workflowId, void 0);
-		const rootLimits = this.executionLimitsPolicy.createRootExecutionOptions();
-		return this.executionContextFactory.create({
-			runId: args.runId,
-			workflowId: args.workflowId,
-			parent: void 0,
-			subworkflowDepth: rootLimits.subworkflowDepth ?? 0,
-			engineMaxNodeActivations: rootLimits.maxNodeActivations,
-			engineMaxSubworkflowDepth: rootLimits.maxSubworkflowDepth,
-			data: args.data,
-			nodeState,
-			getCredential: this.credentialResolverFactory.create(args.workflowId, args.nodeId)
-		});
-	}
-	registerTriggerCleanupHandle(trigger, cleanup) {
-		const key = this.toTriggerKey(trigger);
-		const cleanups = this.triggerCleanupHandlesByKey.get(key) ?? [];
-		cleanups.push(cleanup);
-		this.triggerCleanupHandlesByKey.set(key, cleanups);
-	}
-	async stopTrigger(trigger) {
-		const key = this.toTriggerKey(trigger);
-		const cleanups = this.triggerCleanupHandlesByKey.get(key) ?? [];
-		this.triggerCleanupHandlesByKey.delete(key);
-		for (const cleanup of [...cleanups].reverse()) await cleanup.stop();
-	}
-	toTriggerKey(trigger) {
-		return `${trigger.workflowId}:${trigger.nodeId}`;
-	}
-	formatTriggerSummaries(wf) {
-		const out = [];
-		for (const def of wf.nodes) {
-			if (def.kind !== "trigger") continue;
-			out.push(this.describeTriggerNode(def));
-		}
-		return out;
-	}
-	describeTriggerNode(def) {
-		const label = def.name !== void 0 && def.name.trim().length > 0 ? def.name.trim() : String(def.id);
-		const cfg = def.config;
-		if (typeof cfg.endpointKey === "string" && cfg.endpointKey.trim().length > 0) return `${label} (webhook "${cfg.endpointKey.trim()}")`;
-		return label;
-	}
-	logInfo(message) {
-		if (this.diagnostics) this.diagnostics.info(message);
-	}
-	logWarn(message) {
-		if (this.diagnostics) this.diagnostics.warn(message);
-		else console.warn(`[engine] ${message}`);
-	}
-	isTestableTriggerNode(node$1) {
-		return typeof node$1.getTestItems === "function";
-	}
-};
-
-//#endregion
-//#region src/orchestration/EngineWaiters.ts
-var EngineWaiters = class {
-	completionWaiters = /* @__PURE__ */ new Map();
-	webhookResponseWaiters = /* @__PURE__ */ new Map();
-	waitForCompletion(runId) {
-		return new Promise((resolve) => {
-			const list = this.completionWaiters.get(runId) ?? [];
-			list.push(resolve);
-			this.completionWaiters.set(runId, list);
-		});
-	}
-	waitForWebhookResponse(runId) {
-		return new Promise((resolve) => {
-			const list = this.webhookResponseWaiters.get(runId) ?? [];
-			list.push(resolve);
-			this.webhookResponseWaiters.set(runId, list);
-		});
-	}
-	resolveRunCompletion(result) {
-		if (result.status !== "completed" && result.status !== "failed") return;
-		const list = this.completionWaiters.get(result.runId);
-		if (!list || list.length === 0) return;
-		this.completionWaiters.delete(result.runId);
-		for (const r of list) r(result);
-	}
-	resolveWebhookResponse(result) {
-		const list = this.webhookResponseWaiters.get(result.runId);
-		if (!list || list.length === 0) return;
-		this.webhookResponseWaiters.delete(result.runId);
-		for (const resolve of list) resolve(result);
-	}
-};
-
-//#endregion
-//#region src/orchestration/Engine.ts
-/**
-* Runtime facade for orchestration, continuation, triggers, and webhook routing.
-* Prefer {@link import("../intents/RunIntentService").RunIntentService} for host/HTTP invocation boundaries.
-* The class token is exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
-*/
-var Engine = class {
-	constructor(deps) {
-		this.deps = deps;
-	}
-	loadWorkflows(workflows) {
-		this.deps.tokenRegistry.registerFromWorkflows?.(workflows);
-		this.deps.workflowCatalog.setWorkflows(workflows);
-		this.deps.webhookTriggerMatcher.onEngineWorkflowsLoaded?.();
-	}
-	getTokenRegistry() {
-		return this.deps.tokenRegistry;
-	}
-	resolveWorkflowSnapshot(args) {
-		return this.deps.workflowSnapshotResolver.resolve(args);
-	}
-	async startTriggers() {
-		return await this.deps.triggerRuntime.startTriggers();
-	}
-	async syncWorkflowTriggersForActivation(workflowId) {
-		await this.deps.triggerRuntime.syncWorkflowTriggersForActivation(workflowId);
-		this.deps.webhookTriggerMatcher.reloadWebhookRoutes?.();
-	}
-	async start(workflows) {
-		await this.stop();
-		this.loadWorkflows(workflows);
-		await this.startTriggers();
-	}
-	async stop() {
-		await this.deps.triggerRuntime.stop();
-		this.deps.webhookTriggerMatcher.onEngineStopped?.();
-	}
-	resolveWebhookTrigger(args) {
-		const entry = this.deps.webhookTriggerMatcher.lookup(args.endpointPath);
-		if (!entry) return { status: "notFound" };
-		if (!entry.methods.includes(args.method)) return {
-			status: "methodNotAllowed",
-			match: entry
-		};
-		return {
-			status: "ok",
-			match: entry
-		};
-	}
-	async createTriggerTestItems(args) {
-		return await this.deps.triggerRuntime.createTriggerTestItems(args);
-	}
-	async runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides) {
-		return await this.deps.runStartService.runWorkflow(wf, startAt, items, parent, executionOptions, persistedStateOverrides);
-	}
-	async runWorkflowFromState(request) {
-		return await this.deps.runStartService.runWorkflowFromState(request);
-	}
-	async markNodeRunning(args) {
-		return await this.deps.runContinuationService.markNodeRunning(args);
-	}
-	async resumeFromNodeResult(args) {
-		return await this.deps.runContinuationService.resumeFromNodeResult(args);
-	}
-	async resumeFromNodeError(args) {
-		return await this.deps.runContinuationService.resumeFromNodeError(args);
-	}
-	async resumeFromStepResult(args) {
-		return await this.deps.runContinuationService.resumeFromStepResult(args);
-	}
-	async resumeFromStepError(args) {
-		return await this.deps.runContinuationService.resumeFromStepError(args);
-	}
-	async waitForCompletion(runId) {
-		return await this.deps.runContinuationService.waitForCompletion(runId);
-	}
-	async waitForWebhookResponse(runId) {
-		return await this.deps.runContinuationService.waitForWebhookResponse(runId);
-	}
-};
-
-//#endregion
-//#region src/runtime/EngineFactory.ts
-/**
-* Composes the {@link Engine} graph from {@link EngineCompositionDeps}. Production wiring usually goes through
-* {@link import("../bootstrap/runtime/EngineRuntimeRegistrar").EngineRuntimeRegistrar}; this factory remains for tests and custom composition.
-* Exported from `@codemation/core/bootstrap` (not the main `@codemation/core` barrel).
-*/
-var EngineFactory = class {
-	create(deps) {
-		const waiters = new EngineWaiters();
-		const credentialResolverFactory = new CredentialResolverFactory(deps.credentialSessions);
-		const nodeEventPublisher = new NodeEventPublisher(deps.eventBus);
-		const nodeStatePublisherFactory = new NodeExecutionStatePublisherFactory(deps.runStore, nodeEventPublisher);
-		const planningFactory = new EngineWorkflowPlanningFactory(deps.workflowNodeInstanceFactory);
-		const executionLimitsPolicy = deps.executionLimitsPolicy ?? new EngineExecutionLimitsPolicy();
-		const workflowSnapshotCodec = deps.workflowSnapshotCodec ?? new WorkflowSnapshotCodec(deps.tokenRegistry);
-		const missingRuntimeFallbacks = deps.missingRuntimeFallbacks ?? new MissingRuntimeFallbacks();
-		const workflowSnapshotResolver = new WorkflowSnapshotResolver(deps.workflowRepository, deps.tokenRegistry, workflowSnapshotCodec, missingRuntimeFallbacks);
-		const semantics = new RunStateSemantics();
-		const activationEnqueueService = new ActivationEnqueueService(deps.activationScheduler, deps.runStore, nodeEventPublisher);
-		const runExecutionContextFactory = new WorkflowRunExecutionContextFactory(deps.executionContextFactory, credentialResolverFactory);
-		const nodeActivationRequestComposer = new NodeActivationRequestComposer(deps.activationIdFactory, credentialResolverFactory);
-		const persistedRunStateTerminalBuilder = new PersistedRunStateTerminalBuilder();
-		const storagePolicyEvaluator = new WorkflowStoragePolicyEvaluator(deps.nodeResolver);
-		const terminalPersistence = new RunTerminalPersistenceCoordinator(deps.runStore, storagePolicyEvaluator);
-		const policyErrorServices = new WorkflowPolicyErrorServices(deps.nodeResolver);
-		const runStartService = new RunStartService(deps.runIdFactory, deps.runStore, deps.runDataFactory, workflowSnapshotCodec, planningFactory, nodeStatePublisherFactory, runExecutionContextFactory, nodeActivationRequestComposer, activationEnqueueService, semantics, waiters, deps.workflowPolicyRuntimeDefaults, executionLimitsPolicy);
-		const runContinuationService = new RunContinuationService(deps.activationIdFactory, deps.runStore, deps.runDataFactory, runExecutionContextFactory, workflowSnapshotResolver, planningFactory, nodeStatePublisherFactory, credentialResolverFactory, nodeActivationRequestComposer, persistedRunStateTerminalBuilder, activationEnqueueService, nodeEventPublisher, semantics, waiters, policyErrorServices, terminalPersistence, executionLimitsPolicy);
-		const triggerRuntime = new TriggerRuntimeService(deps.workflowRepository, deps.workflowActivationPolicy, deps.runIdFactory, deps.runDataFactory, deps.executionContextFactory, credentialResolverFactory, nodeStatePublisherFactory, deps.nodeResolver, deps.triggerSetupStateStore, { emit: async (workflow, triggerNodeId, items) => {
-			await runStartService.runWorkflow(workflow, triggerNodeId, items, void 0);
-		} }, executionLimitsPolicy, deps.triggerRuntimeDiagnostics);
-		const engine = new Engine({
-			workflowCatalog: deps.workflowCatalog,
-			tokenRegistry: deps.tokenRegistry,
-			webhookTriggerMatcher: deps.webhookTriggerMatcher,
-			workflowSnapshotResolver,
-			triggerRuntime,
-			runStartService,
-			runContinuationService
-		});
-		deps.activationScheduler.setContinuation?.(engine);
-		return engine;
-	}
-};
-
-//#endregion
-//#region src/runtime/EngineWorkflowRunnerService.ts
-var _ref$1;
-let EngineWorkflowRunnerService = class EngineWorkflowRunnerService$1 {
-	constructor(engine, workflowRepository) {
-		this.engine = engine;
-		this.workflowRepository = workflowRepository;
-	}
-	async runById(args) {
-		const { workflowId, startAt, items, parent } = args;
-		const wf = this.workflowRepository.get(workflowId);
-		if (!wf) throw new Error(`Unknown workflowId: ${workflowId}`);
-		const startNodeId = startAt ?? this.findDefaultStartNodeId(wf);
-		const scheduled = await this.engine.runWorkflow(wf, startNodeId, items, parent);
-		if (scheduled.status !== "pending") return scheduled;
-		return await this.engine.waitForCompletion(scheduled.runId);
-	}
-	findDefaultStartNodeId(wf) {
-		return createWorkflowExecutableNodeClassifier(wf).findDefaultExecutableStartNodeId(wf);
-	}
-};
-EngineWorkflowRunnerService = __decorate([
-	injectable(),
-	__decorateParam(0, inject(Engine)),
-	__decorateParam(1, inject(CoreTokens.WorkflowRepository)),
-	__decorateMetadata("design:paramtypes", [typeof (_ref$1 = typeof Engine !== "undefined" && Engine) === "function" ? _ref$1 : Object, Object])
-], EngineWorkflowRunnerService);
-
-//#endregion
-//#region src/runtime/RunIntentService.ts
-var _ref;
-let RunIntentService = class RunIntentService$1 {
-	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, {
-			localOnly: true,
-			webhook: true
-		});
-		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
-			};
-		})]);
-	}
-};
-RunIntentService = __decorate([
-	injectable(),
-	__decorateParam(0, inject(Engine)),
-	__decorateParam(1, inject(CoreTokens.WorkflowRepository)),
-	__decorateMetadata("design:paramtypes", [typeof (_ref = typeof Engine !== "undefined" && Engine) === "function" ? _ref : Object, Object])
-], RunIntentService);
-
-//#endregion
-export { createWorkflowExecutableNodeClassifier as $, DefaultExecutionBinaryService as A, __decorate as B, __decorateMetadata as C, MissingRuntimeTriggerToken as D, MissingRuntimeTrigger as E, tool as F, inject as G, CoreTokens as H, InjectableRuntimeDecoratorComposer as I, instanceCachingFactory as J, injectAll as K, PersistedRuntimeTypeMetadataStore as L, chatModel as M, getPersistedRuntimeTypeMetadata as N, InProcessRetryRunner as O, node as P, singleton as Q, StackTraceCallSitePathResolver as R, __decorateParam as S, MissingRuntimeNodeToken as T, container as U, NodeEventPublisher as V, delay as W, predicateAwareClassFactory as X, instancePerContainerCachingFactory as Y, registry as Z, HintOnlyOffloadPolicy as _, RunFinishedAtFactory as a, RunPolicySnapshotFactory as b, WorkflowStoragePolicyEvaluator as c, ENGINE_EXECUTION_LIMITS_DEFAULTS as d, WorkflowExecutableNodeClassifier as et, EngineExecutionLimitsPolicy as f, InlineDrivingScheduler as g, LocalOnlyScheduler as h, Engine as i, UnavailableBinaryStorage as j, DefaultAsyncSleeper as k, WorkflowPolicyErrorServices as l, CredentialResolverFactory as m, EngineWorkflowRunnerService as n, InMemoryRunDataFactory as o, DefaultExecutionContextFactory as p, injectable as q, EngineFactory as r, InMemoryBinaryStorage as s, RunIntentService as t, ConnectionNodeIdFactory as tt, RunTerminalPersistenceCoordinator as u, DefaultDrivingScheduler as v, MissingRuntimeNode as w, NodeExecutor as x, ConfigDrivenOffloadPolicy as y, PersistedRuntimeTypeNameResolver as z };
-//# sourceMappingURL=runtime-vc76SSAa.js.map