@codemation/core 0.0.5 → 0.0.11

package/dist/RunIntentService-CSk3ETyn.js

@@ -1,858 +0,0 @@
-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"),
-	LiveWorkflowRepository: 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"),
-	WorkflowExecutionRepository: Symbol.for("codemation.core.RunStateStore"),
-	TriggerSetupStateStore: Symbol.for("codemation.core.TriggerSetupStateStore"),
-	TriggerSetupStateRepository: 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 src/runtime-types/persistedRuntimeTypeModelRegistry.ts
-/** Shared metadata key used to attach persisted runtime-type information to decorated classes. */
-const persistedRuntimeTypeMetadataKey = Symbol.for("codemation.core.persistedRuntimeTypeMetadata");
-/** Normalizes decorator options so persistence metadata has stable defaults. */
-var PersistedRuntimeTypeDecoratorDefaults = class {
-	static appPackageName = "app";
-	static apply(options) {
-		return {
-			...options,
-			packageName: options.packageName ?? this.appPackageName
-		};
-	}
-};
-
-//#endregion
-//#region src/runtime-types/PersistedRuntimeTypeNameResolver.ts
-/** Resolves the persisted type name from either an explicit override or the class name itself. */
-var PersistedRuntimeTypeNameResolver = class {
-	static resolve(target, override) {
-		const resolved = override ?? target.name;
-		if (!resolved) throw new Error("Persisted runtime token metadata requires a named class or an explicit decorator name override.");
-		return resolved;
-	}
-};
-
-//#endregion
-//#region src/runtime-types/StackTraceCallSitePathResolver.ts
-var StackTraceCallSitePathResolver = class {
-	static resolve(decoratorFileUrl) {
-		const stack = (/* @__PURE__ */ new Error()).stack ?? "";
-		for (const line of stack.split("\n")) {
-			const candidate = this.extractPath(line.trim());
-			if (!candidate) continue;
-			if (candidate === decoratorFileUrl || candidate.includes("runtimeTypeDecorators")) continue;
-			return candidate;
-		}
-	}
-	static extractPath(line) {
-		const fileUrlMatch = line.match(/file:\/\/[^\s)]+/);
-		if (fileUrlMatch) return fileUrlMatch[0];
-		const parenMatch = line.match(/\((\/[^)]+)\)/);
-		if (parenMatch) return parenMatch[1];
-		return line.match(/at (\/[^\s]+)/)?.[1];
-	}
-};
-
-//#endregion
-//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.ts
-/**
-* Defines and retrieves persisted runtime metadata on decorated classes.
-* The metadata is attached as a non-enumerable property so runtime objects stay serializable.
-*/
-var PersistedRuntimeTypeMetadataStore = class {
-	static define(target, kind, options, decoratorFileUrl) {
-		const normalizedOptions = PersistedRuntimeTypeDecoratorDefaults.apply(options);
-		const metadata = {
-			persistedName: PersistedRuntimeTypeNameResolver.resolve(target, normalizedOptions.name),
-			kind,
-			packageName: normalizedOptions.packageName ?? PersistedRuntimeTypeDecoratorDefaults.appPackageName,
-			sourceHint: normalizedOptions.moduleUrl ?? StackTraceCallSitePathResolver.resolve(decoratorFileUrl)
-		};
-		Object.defineProperty(target, persistedRuntimeTypeMetadataKey, {
-			configurable: false,
-			enumerable: false,
-			writable: false,
-			value: metadata
-		});
-	}
-	static get(target) {
-		if (!target || typeof target !== "function" && typeof target !== "object") return;
-		return target[persistedRuntimeTypeMetadataKey];
-	}
-};
-
-//#endregion
-//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.ts
-/**
-* Applies both tsyringe injectability and persisted runtime metadata in one decorator.
-* This keeps runtime-type decorators thin while still recording enough data for snapshot hydration.
-*/
-var InjectableRuntimeDecoratorComposer = class {
-	static compose(kind, options, decoratorFileUrl) {
-		return (target) => {
-			injectable()(target);
-			PersistedRuntimeTypeMetadataStore.define(target, kind, options, decoratorFileUrl);
-		};
-	}
-};
-
-//#endregion
-//#region src/runtime-types/runtimeTypeDecorators.types.ts
-/** Reads persisted runtime metadata from a decorated class or object. */
-function getPersistedRuntimeTypeMetadata(target) {
-	return PersistedRuntimeTypeMetadataStore.get(target);
-}
-/** Marks a class as a persisted node runtime type and an injectable tsyringe service. */
-function node(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("node", options, import.meta.url);
-}
-/** Marks a class as a persisted tool runtime type and an injectable tsyringe service. */
-function tool(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("tool", options, import.meta.url);
-}
-/** Marks a class as a persisted chat-model runtime type and an injectable tsyringe service. */
-function chatModel(options = {}) {
-	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, import.meta.url);
-}
-
-//#endregion
-//#region src/binaries/DefaultNodeBinaryAttachmentServiceFactory.ts
-var DefaultNodeBinaryAttachmentService = class DefaultNodeBinaryAttachmentService {
-	constructor(storage, workflowId, runId, nodeId, activationId, now) {
-		this.storage = storage;
-		this.workflowId = workflowId;
-		this.runId = runId;
-		this.nodeId = nodeId;
-		this.activationId = activationId;
-		this.now = now;
-	}
-	async attach(args) {
-		const attachmentId = this.createAttachmentId();
-		const createdAt = this.now().toISOString();
-		const storageKey = this.createStorageKey(args, attachmentId);
-		const stored = await this.storage.write({
-			storageKey,
-			body: args.body
-		});
-		return {
-			id: attachmentId,
-			storageKey: stored.storageKey,
-			mimeType: args.mimeType,
-			size: stored.size,
-			storageDriver: this.storage.driverName,
-			previewKind: args.previewKind ?? this.resolvePreviewKind(args.mimeType),
-			createdAt,
-			runId: this.runId,
-			workflowId: this.workflowId,
-			nodeId: this.nodeId,
-			activationId: this.activationId,
-			filename: args.filename,
-			sha256: stored.sha256
-		};
-	}
-	withAttachment(item, name, attachment) {
-		return {
-			...item,
-			binary: {
-				...item.binary ?? {},
-				[name]: attachment
-			}
-		};
-	}
-	forNode(args) {
-		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
-	}
-	async openReadStream(attachment) {
-		return await this.storage.openReadStream(attachment.storageKey);
-	}
-	createAttachmentId() {
-		return DefaultNodeBinaryAttachmentService.createAttachmentIdValue(`${this.activationId}-${this.now().getTime()}`);
-	}
-	static createAttachmentIdValue(fallbackValue) {
-		const cryptoObject = globalThis.crypto;
-		if (cryptoObject && typeof cryptoObject.randomUUID === "function") return cryptoObject.randomUUID();
-		return fallbackValue;
-	}
-	createStorageKey(args, attachmentId) {
-		const safeName = this.sanitizeSegment(args.name);
-		const safeFilename = this.sanitizeFilename(args.filename);
-		const filenameSuffix = safeFilename ? `-${safeFilename}` : "";
-		return `${this.sanitizeSegment(this.workflowId)}/${this.sanitizeSegment(this.runId)}/${this.sanitizeSegment(this.nodeId)}/${this.sanitizeSegment(this.activationId)}/${attachmentId}-${safeName}${filenameSuffix}`;
-	}
-	sanitizeSegment(value) {
-		const normalized = value.trim();
-		if (!normalized) return "item";
-		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
-	}
-	sanitizeFilename(value) {
-		if (!value) return;
-		const normalized = value.trim().split("/").at(-1)?.split("\\").at(-1) ?? value.trim();
-		if (!normalized) return;
-		return normalized.replace(/[^a-zA-Z0-9._-]+/g, "_");
-	}
-	resolvePreviewKind(mimeType) {
-		if (mimeType.startsWith("image/")) return "image";
-		if (mimeType.startsWith("audio/")) return "audio";
-		if (mimeType.startsWith("video/")) return "video";
-		return "download";
-	}
-};
-
-//#endregion
-//#region src/binaries/UnavailableBinaryStorage.ts
-var UnavailableBinaryStorage = class {
-	driverName = "unavailable";
-	async write() {
-		throw new Error("Binary storage is not configured for this runtime.");
-	}
-	async openReadStream() {}
-	async stat() {
-		return { exists: false };
-	}
-	async delete() {}
-};
-
-//#endregion
-//#region src/binaries/DefaultExecutionBinaryServiceFactory.ts
-var DefaultExecutionBinaryService = class {
-	constructor(storage, workflowId, runId, now) {
-		this.storage = storage;
-		this.workflowId = workflowId;
-		this.runId = runId;
-		this.now = now;
-	}
-	forNode(args) {
-		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
-	}
-	async openReadStream(attachment) {
-		return await this.storage.openReadStream(attachment.storageKey);
-	}
-};
-
-//#endregion
-//#region src/execution/CredentialResolverFactory.ts
-var CredentialResolverFactory = class {
-	constructor(credentialSessions) {
-		this.credentialSessions = credentialSessions;
-	}
-	create(workflowId, nodeId, config) {
-		const acceptedTypesBySlot = /* @__PURE__ */ new Map();
-		for (const requirement of config?.getCredentialRequirements?.() ?? []) acceptedTypesBySlot.set(requirement.slotKey, requirement.acceptedTypes);
-		return async (slotKey) => {
-			try {
-				return await this.credentialSessions.getSession({
-					workflowId,
-					nodeId,
-					slotKey
-				});
-			} catch (error) {
-				const acceptedTypes = acceptedTypesBySlot.get(slotKey) ?? [];
-				const message = error instanceof Error ? error.message : String(error);
-				const alreadyListsAcceptedTypes = message.includes("Accepted types:") || message.includes("Accepted credential types:") || message.includes("binding points at an unknown type");
-				const acceptedTypesSuffix = acceptedTypes.length > 0 && !alreadyListsAcceptedTypes ? ` Accepted types: ${acceptedTypes.join(", ")}.` : "";
-				throw new Error(`Failed to resolve credential for workflow ${workflowId} node ${nodeId} slot "${slotKey}". ${message}${acceptedTypesSuffix}`, { cause: error });
-			}
-		};
-	}
-};
-
-//#endregion
-//#region src/execution/DefaultAsyncSleeper.ts
-var DefaultAsyncSleeper = class {
-	sleep(ms) {
-		return new Promise((resolve) => {
-			setTimeout(resolve, ms);
-		});
-	}
-};
-
-//#endregion
-//#region src/execution/DefaultExecutionContextFactory.ts
-var DefaultExecutionContextFactory = class {
-	constructor(binaryStorage = new UnavailableBinaryStorage(), currentDate = () => /* @__PURE__ */ new Date()) {
-		this.binaryStorage = binaryStorage;
-		this.currentDate = currentDate;
-	}
-	create(args) {
-		return {
-			runId: args.runId,
-			workflowId: args.workflowId,
-			parent: args.parent,
-			subworkflowDepth: args.subworkflowDepth,
-			engineMaxNodeActivations: args.engineMaxNodeActivations,
-			engineMaxSubworkflowDepth: args.engineMaxSubworkflowDepth,
-			now: this.currentDate,
-			data: args.data,
-			nodeState: args.nodeState,
-			binary: new DefaultExecutionBinaryService(this.binaryStorage, args.workflowId, args.runId, this.currentDate),
-			getCredential: args.getCredential
-		};
-	}
-};
-
-//#endregion
-//#region src/execution/InProcessRetryRunner.ts
-var InProcessRetryRunner = class InProcessRetryRunner {
-	constructor(sleeper) {
-		this.sleeper = sleeper;
-	}
-	async run(policy, work) {
-		const spec = InProcessRetryRunner.normalizePolicy(policy);
-		let lastError;
-		for (let attempt = 1; attempt <= spec.maxAttempts; attempt++) try {
-			return await work();
-		} catch (error) {
-			lastError = error;
-			if (attempt >= spec.maxAttempts) break;
-			const delayMs = InProcessRetryRunner.delayAfterFailureMs(spec, attempt);
-			await this.sleeper.sleep(delayMs);
-		}
-		throw lastError instanceof Error ? lastError : new Error(String(lastError));
-	}
-	static delayAfterFailureMs(spec, failedAttempt) {
-		if (spec.kind === "none") return 0;
-		if (spec.kind === "fixed") return spec.delayMs;
-		const exponent = failedAttempt - 1;
-		let ms = spec.initialDelayMs * Math.pow(spec.multiplier, exponent);
-		if (spec.jitter === true) ms *= 1 + Math.random() * .2;
-		if (spec.maxDelayMs !== void 0 && ms > spec.maxDelayMs) ms = spec.maxDelayMs;
-		return Math.max(0, Math.floor(ms));
-	}
-	static normalizePolicy(policy) {
-		if (policy === void 0) return {
-			kind: "none",
-			maxAttempts: 1
-		};
-		if (typeof policy !== "object" || policy === null) return {
-			kind: "none",
-			maxAttempts: 1
-		};
-		const kind = policy.kind;
-		if (kind === "none") return {
-			kind: "none",
-			maxAttempts: 1
-		};
-		if (kind === "fixed") {
-			const p = policy;
-			return {
-				kind: "fixed",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "fixed.maxAttempts"),
-				delayMs: InProcessRetryRunner.assertNonNegativeFinite(p.delayMs, "fixed.delayMs")
-			};
-		}
-		if (kind === "exponential") {
-			const p = policy;
-			return {
-				kind: "exponential",
-				maxAttempts: InProcessRetryRunner.assertPositiveInt(p.maxAttempts, "exponential.maxAttempts"),
-				initialDelayMs: InProcessRetryRunner.assertNonNegativeFinite(p.initialDelayMs, "exponential.initialDelayMs"),
-				multiplier: InProcessRetryRunner.assertMultiplier(p.multiplier),
-				maxDelayMs: p.maxDelayMs === void 0 ? void 0 : InProcessRetryRunner.assertNonNegativeFinite(p.maxDelayMs, "exponential.maxDelayMs"),
-				jitter: p.jitter === true
-			};
-		}
-		return {
-			kind: "none",
-			maxAttempts: 1
-		};
-	}
-	static assertPositiveInt(value, label) {
-		if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || !Number.isInteger(value)) throw new Error(`Retry policy ${label} must be a positive integer`);
-		return value;
-	}
-	static assertNonNegativeFinite(value, label) {
-		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`Retry policy ${label} must be a non-negative finite number`);
-		return value;
-	}
-	static assertMultiplier(value) {
-		if (typeof value !== "number" || !Number.isFinite(value) || value < 1) throw new Error(`Retry policy exponential.multiplier must be >= 1`);
-		return value;
-	}
-};
-
-//#endregion
-//#region src/policies/executionLimits/EngineExecutionLimitsPolicy.ts
-/** Framework defaults for {@link EngineExecutionLimitsPolicy} (merged with host `runtime.engineExecutionLimits`). */
-const ENGINE_EXECUTION_LIMITS_DEFAULTS = {
-	defaultMaxNodeActivations: 1e5,
-	hardMaxNodeActivations: 1e5,
-	defaultMaxSubworkflowDepth: 32,
-	hardMaxSubworkflowDepth: 32
-};
-/**
-* Resolves per-run execution limits: defaults, hard ceilings, and subworkflow depth for new runs.
-*/
-var EngineExecutionLimitsPolicy = class {
-	constructor(config = ENGINE_EXECUTION_LIMITS_DEFAULTS) {
-		this.config = config;
-	}
-	/**
-	* Effective options for a new root run (depth 0): defaults merged with engine ceilings.
-	* Replaces a separate one-method factory for root-run bootstrap.
-	*/
-	createRootExecutionOptions() {
-		return this.mergeExecutionOptionsForNewRun(void 0, void 0);
-	}
-	mergeExecutionOptionsForNewRun(parent, user) {
-		const subworkflowDepth = parent === void 0 ? 0 : (parent.subworkflowDepth ?? 0) + 1;
-		const inheritedMaxNode = parent?.engineMaxNodeActivations;
-		const inheritedMaxSub = parent?.engineMaxSubworkflowDepth;
-		const maxNodeActivations = this.capNumber(user?.maxNodeActivations ?? inheritedMaxNode, this.config.defaultMaxNodeActivations, this.config.hardMaxNodeActivations);
-		const maxSubworkflowDepth = this.capNumber(user?.maxSubworkflowDepth ?? inheritedMaxSub, this.config.defaultMaxSubworkflowDepth, this.config.hardMaxSubworkflowDepth);
-		if (subworkflowDepth > maxSubworkflowDepth) throw new Error(`Subworkflow nesting depth ${subworkflowDepth} exceeds maxSubworkflowDepth ${maxSubworkflowDepth} (run would be a child of parent run).`);
-		return {
-			...user,
-			subworkflowDepth,
-			maxNodeActivations,
-			maxSubworkflowDepth
-		};
-	}
-	capNumber(requested, defaultValue, hardCeiling) {
-		const base = requested === void 0 ? defaultValue : requested;
-		return Math.min(base, hardCeiling);
-	}
-};
-
-//#endregion
-//#region src/runStorage/BinaryBodyBufferReader.ts
-var BinaryBodyBufferReader = class {
-	async read(body) {
-		if (body instanceof Uint8Array) return body;
-		if (body instanceof ArrayBuffer) return new Uint8Array(body);
-		if (body instanceof ReadableStream) return await this.readReadableStream(body);
-		return await this.readAsyncIterable(body);
-	}
-	async readReadableStream(body) {
-		const reader = body.getReader();
-		const chunks = [];
-		let totalSize = 0;
-		try {
-			while (true) {
-				const result = await reader.read();
-				if (result.done) break;
-				chunks.push(result.value);
-				totalSize += result.value.byteLength;
-			}
-		} finally {
-			reader.releaseLock();
-		}
-		return this.joinChunks(chunks, totalSize);
-	}
-	async readAsyncIterable(body) {
-		const chunks = [];
-		let totalSize = 0;
-		for await (const chunk of body) {
-			chunks.push(chunk);
-			totalSize += chunk.byteLength;
-		}
-		return this.joinChunks(chunks, totalSize);
-	}
-	joinChunks(chunks, totalSize) {
-		const bytes = new Uint8Array(totalSize);
-		let offset = 0;
-		for (const chunk of chunks) {
-			bytes.set(chunk, offset);
-			offset += chunk.byteLength;
-		}
-		return bytes;
-	}
-};
-
-//#endregion
-//#region src/runStorage/BinaryBodyReadableStreamFactory.ts
-var BinaryBodyReadableStreamFactory = class {
-	constructor(bytes) {
-		this.bytes = bytes;
-	}
-	create() {
-		const value = this.bytes;
-		let consumed = false;
-		return new ReadableStream({ pull(controller) {
-			if (consumed) {
-				controller.close();
-				return;
-			}
-			consumed = true;
-			controller.enqueue(value);
-			controller.close();
-		} });
-	}
-};
-
-//#endregion
-//#region src/runStorage/InMemoryBinaryStorageRegistry.ts
-var InMemoryBinaryStorage = class {
-	driverName = "memory";
-	values = /* @__PURE__ */ new Map();
-	async write(args) {
-		const bytes = await new BinaryBodyBufferReader().read(args.body);
-		this.values.set(args.storageKey, bytes);
-		return {
-			storageKey: args.storageKey,
-			size: bytes.byteLength,
-			sha256: createHash("sha256").update(bytes).digest("hex")
-		};
-	}
-	async openReadStream(storageKey) {
-		const bytes = this.values.get(storageKey);
-		if (!bytes) return;
-		return {
-			body: new BinaryBodyReadableStreamFactory(bytes).create(),
-			size: bytes.byteLength
-		};
-	}
-	async stat(storageKey) {
-		const bytes = this.values.get(storageKey);
-		if (!bytes) return { exists: false };
-		return {
-			exists: true,
-			size: bytes.byteLength
-		};
-	}
-	async delete(storageKey) {
-		this.values.delete(storageKey);
-	}
-};
-
-//#endregion
-//#region src/runStorage/InMemoryRunData.ts
-var InMemoryRunData = class {
-	byNode = /* @__PURE__ */ new Map();
-	constructor(initial) {
-		if (initial) for (const [nodeId, outputs] of Object.entries(initial)) this.byNode.set(nodeId, outputs);
-	}
-	setOutputs(nodeId, outputs) {
-		this.byNode.set(nodeId, outputs);
-	}
-	getOutputs(nodeId) {
-		return this.byNode.get(nodeId);
-	}
-	getOutputItems(nodeId, output = "main") {
-		return this.byNode.get(nodeId)?.[output] ?? [];
-	}
-	getOutputItem(nodeId, itemIndex, output = "main") {
-		return this.getOutputItems(nodeId, output)[itemIndex];
-	}
-	dump() {
-		const out = {};
-		for (const [nodeId, outputs] of this.byNode.entries()) out[nodeId] = outputs;
-		return out;
-	}
-};
-
-//#endregion
-//#region src/runStorage/InMemoryRunDataFactory.ts
-var InMemoryRunDataFactory = class {
-	create(initial) {
-		return new InMemoryRunData(initial);
-	}
-};
-
-//#endregion
-//#region src/contracts/runFinishedAtFactory.ts
-/** Derives workflow end time from node snapshots for run listings. */
-var RunFinishedAtFactory = class {
-	static resolveIso(state) {
-		if (state.status === "running" || state.status === "pending") return;
-		let max;
-		for (const snap of Object.values(state.nodeSnapshotsByNodeId)) if (snap?.finishedAt && (!max || snap.finishedAt > max)) max = snap.finishedAt;
-		return max;
-	}
-};
-
-//#endregion
-//#region src/runStorage/RunSummaryMapper.ts
-/** Maps persisted run state to API run summaries for listings. */
-var RunSummaryMapper = class {
-	static fromPersistedState(state) {
-		return {
-			runId: state.runId,
-			workflowId: state.workflowId,
-			startedAt: state.startedAt,
-			status: state.status,
-			finishedAt: RunFinishedAtFactory.resolveIso(state),
-			parent: state.parent,
-			executionOptions: state.executionOptions
-		};
-	}
-};
-
-//#endregion
-//#region src/runStorage/InMemoryWorkflowExecutionRepository.ts
-var InMemoryWorkflowExecutionRepository = class {
-	runs = /* @__PURE__ */ new Map();
-	async createRun(args) {
-		this.runs.set(args.runId, {
-			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,
-			status: "running",
-			queue: [],
-			outputsByNode: {},
-			nodeSnapshotsByNodeId: {},
-			connectionInvocations: []
-		});
-	}
-	async load(runId) {
-		return this.runs.get(runId);
-	}
-	async save(state) {
-		this.runs.set(state.runId, state);
-	}
-	async deleteRun(runId) {
-		this.runs.delete(runId);
-	}
-	async listRuns(args) {
-		const limit = args?.limit ?? 50;
-		return [...this.runs.values()].filter((s) => args?.workflowId ? s.workflowId === args.workflowId : true).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, limit).map((s) => RunSummaryMapper.fromPersistedState(s));
-	}
-	async listRunsOlderThan(args) {
-		const limit = args.limit ?? 100;
-		const out = [];
-		for (const s of this.runs.values()) {
-			if (s.status !== "completed" && s.status !== "failed") continue;
-			const finishedAt = RunFinishedAtFactory.resolveIso(s);
-			if (!finishedAt || finishedAt >= args.beforeIso) continue;
-			out.push({
-				runId: s.runId,
-				workflowId: s.workflowId,
-				startedAt: s.startedAt,
-				finishedAt
-			});
-		}
-		out.sort((a, b) => a.finishedAt.localeCompare(b.finishedAt));
-		return out.slice(0, limit);
-	}
-};
-
-//#endregion
-//#region src/runtime/RunIntentService.ts
-var RunIntentService = class {
-	constructor(engine, workflowRepository) {
-		this.engine = engine;
-		this.workflowRepository = workflowRepository;
-	}
-	async startWorkflow(args) {
-		if (args.startAt && !args.currentState && !args.stopCondition && !args.reset) return await this.engine.runWorkflow(args.workflow, args.startAt, args.items, args.parent, args.executionOptions, {
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState
-		});
-		return await this.engine.runWorkflowFromState({
-			workflow: args.workflow,
-			items: args.items,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState,
-			currentState: args.currentState,
-			stopCondition: args.stopCondition ?? { kind: "workflowCompleted" },
-			reset: args.reset
-		});
-	}
-	async rerunFromNode(args) {
-		if (args.items) return await this.engine.runWorkflow(args.workflow, args.nodeId, args.items, args.parent, args.executionOptions, {
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState
-		});
-		return await this.engine.runWorkflowFromState({
-			workflow: args.workflow,
-			parent: args.parent,
-			executionOptions: args.executionOptions,
-			workflowSnapshot: args.workflowSnapshot,
-			mutableState: args.mutableState,
-			currentState: args.currentState,
-			stopCondition: { kind: "workflowCompleted" },
-			reset: { clearFromNodeId: args.nodeId }
-		});
-	}
-	resolveWebhookTrigger(args) {
-		return this.engine.resolveWebhookTrigger(args);
-	}
-	async runMatchedWebhook(args) {
-		const resolution = this.resolveWebhookTrigger(args);
-		if (resolution.status === "notFound") throw new Error("Unknown webhook endpoint");
-		if (resolution.status === "methodNotAllowed") throw new Error("Method not allowed");
-		return await this.runWebhookMatch({
-			match: resolution.match,
-			requestItem: args.requestItem
-		});
-	}
-	async runWebhookMatch(args) {
-		const workflow = this.workflowRepository.get(args.match.workflowId);
-		if (!workflow) throw new Error(`Unknown workflowId: ${args.match.workflowId}`);
-		const scheduled = await this.engine.runWorkflow(workflow, args.match.nodeId, [args.requestItem], void 0, this.createWebhookExecutionOptions());
-		if (scheduled.status === "failed") throw new Error(scheduled.error.message);
-		if (scheduled.status === "completed") return {
-			runId: scheduled.runId,
-			workflowId: scheduled.workflowId,
-			startedAt: scheduled.startedAt,
-			runStatus: "completed",
-			response: scheduled.outputs
-		};
-		return await Promise.race([this.engine.waitForWebhookResponse(scheduled.runId), this.engine.waitForCompletion(scheduled.runId).then((completed) => {
-			if (completed.status === "failed") throw new Error(completed.error.message);
-			return {
-				runId: completed.runId,
-				workflowId: completed.workflowId,
-				startedAt: completed.startedAt,
-				runStatus: "completed",
-				response: completed.outputs
-			};
-		})]);
-	}
-	/**
-	* Webhook-triggered runs always force inline execution first.
-	* This is the highest-precedence scheduler override: it wins over node hints and container defaults.
-	*/
-	createWebhookExecutionOptions() {
-		return {
-			localOnly: true,
-			webhook: true
-		};
-	}
-};
-
-//#endregion
-export { instanceCachingFactory as A, NodeEventPublisher as C, inject as D, delay as E, createWorkflowExecutableNodeClassifier as F, WorkflowExecutableNodeClassifier as I, ConnectionNodeIdFactory as L, predicateAwareClassFactory as M, registry as N, injectAll as O, singleton as P, PersistedRuntimeTypeNameResolver as S, container as T, node as _, InMemoryRunDataFactory as a, PersistedRuntimeTypeMetadataStore as b, EngineExecutionLimitsPolicy as c, DefaultAsyncSleeper as d, CredentialResolverFactory as f, getPersistedRuntimeTypeMetadata as g, chatModel as h, RunFinishedAtFactory as i, instancePerContainerCachingFactory as j, injectable as k, InProcessRetryRunner as l, UnavailableBinaryStorage as m, InMemoryWorkflowExecutionRepository as n, InMemoryBinaryStorage as o, DefaultExecutionBinaryService as p, RunSummaryMapper as r, ENGINE_EXECUTION_LIMITS_DEFAULTS as s, RunIntentService as t, DefaultExecutionContextFactory as u, tool as v, CoreTokens as w, StackTraceCallSitePathResolver as x, InjectableRuntimeDecoratorComposer as y };
-//# sourceMappingURL=RunIntentService-CSk3ETyn.js.map