@codemation/core 0.0.18 → 0.2.0

package/dist/{RunIntentService-BB4nqX3-.js → RunIntentService-BFA48UpH.js}

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { container, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
+import { container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
 import { createHash } from "node:crypto";
 import { ReadableStream } from "node:stream/web";
 
@@ -157,6 +157,25 @@ var ConnectionNodeIdFactory = class {
 	static isToolConnectionNodeId(nodeId) {
 		return nodeId.includes(`${this.connectionSegment}tool${this.connectionSegment}`);
 	}
+	static parseLanguageModelConnectionNodeId(nodeId) {
+		if (!this.isLanguageModelConnectionNodeId(nodeId)) return;
+		const suffix = `${this.connectionSegment}llm`;
+		const parentNodeId = nodeId.slice(0, -suffix.length);
+		return parentNodeId ? { parentNodeId } : void 0;
+	}
+	static parseToolConnectionNodeId(nodeId) {
+		if (!this.isToolConnectionNodeId(nodeId)) return;
+		const marker = `${this.connectionSegment}tool${this.connectionSegment}`;
+		const idx = nodeId.lastIndexOf(marker);
+		if (idx < 0) return;
+		const parentNodeId = nodeId.slice(0, idx);
+		const normalizedToolName = nodeId.slice(idx + marker.length);
+		if (!parentNodeId || !normalizedToolName) return;
+		return {
+			parentNodeId,
+			normalizedToolName
+		};
+	}
 	/** True when `nodeId` is a connection-owned child of `parentNodeId` (LLM or tool slot). */
 	static isConnectionOwnedDescendantOf(parentNodeId, nodeId) {
 		return nodeId.startsWith(`${parentNodeId}${this.connectionSegment}`);
@@ -479,7 +498,7 @@ var ActivationEnqueueService = class {
 		return result;
 	}
 	async enqueueActivationWithSnapshot(args) {
-		const receipt = await this.activationScheduler.enqueue(args.request);
+		const preparedDispatch = await this.activationScheduler.prepareDispatch(args.request);
 		const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
 		const itemsIn = args.request.kind === "multi" ? args.planner.sumItemsByPort(args.request.inputsByPort) : args.request.input.length;
 		const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -490,8 +509,8 @@ var ActivationEnqueueService = class {
 			nodeId: args.request.nodeId,
 			itemsIn,
 			inputsByPort,
-			receiptId: receipt.receiptId,
-			queue: receipt.queue,
+			receiptId: preparedDispatch.receipt.receiptId,
+			queue: preparedDispatch.receipt.queue,
 			batchId: args.request.batchId,
 			enqueuedAt
 		};
@@ -525,7 +544,7 @@ var ActivationEnqueueService = class {
 				[args.request.nodeId]: queuedSnapshot
 			}
 		});
-		this.notifyPendingStatePersisted(args.runId);
+		await this.dispatchPreparedActivation(preparedDispatch);
 		return {
 			result: {
 				runId: args.runId,
@@ -537,8 +556,8 @@ var ActivationEnqueueService = class {
 			queuedSnapshot
 		};
 	}
-	notifyPendingStatePersisted(runId) {
-		this.activationScheduler.notifyPendingStatePersisted?.(runId);
+	async dispatchPreparedActivation(preparedDispatch) {
+		await preparedDispatch.dispatch();
 	}
 };
 
@@ -959,6 +978,127 @@ var PersistedWorkflowTokenRegistry = class {
 	}
 };
 
+//#endregion
+//#region src/workflowSnapshots/WorkflowSnapshotCodec.ts
+var WorkflowSnapshotCodec = class {
+	constructor(tokenRegistry) {
+		this.tokenRegistry = tokenRegistry;
+	}
+	create(workflow) {
+		return {
+			id: workflow.id,
+			name: workflow.name,
+			workflowErrorHandlerConfigured: workflow.workflowErrorHandler !== void 0,
+			...workflow.connections !== void 0 && workflow.connections.length > 0 ? { connections: workflow.connections } : {},
+			nodes: workflow.nodes.map((node$1) => ({
+				id: node$1.id,
+				kind: node$1.kind,
+				name: node$1.name,
+				nodeTokenId: this.resolveTokenId(node$1.type),
+				configTokenId: this.resolveTokenId(node$1.config.type),
+				tokenName: this.resolveTokenName(node$1.type),
+				configTokenName: this.resolveTokenName(node$1.config.type),
+				config: this.serializeConfig(node$1.config)
+			})),
+			edges: workflow.edges.map((edge) => ({
+				from: {
+					nodeId: edge.from.nodeId,
+					output: edge.from.output
+				},
+				to: {
+					nodeId: edge.to.nodeId,
+					input: edge.to.input
+				}
+			}))
+		};
+	}
+	hydrate(snapshotNode, liveConfig) {
+		const hydrated = this.mergeValue(liveConfig, snapshotNode.config);
+		const configToken = this.tokenRegistry.resolve(snapshotNode.configTokenId);
+		Object.assign(hydrated, {
+			type: configToken ?? liveConfig.type,
+			kind: snapshotNode.kind
+		});
+		if (snapshotNode.name && !("name" in hydrated && hydrated.name)) Object.assign(hydrated, { name: snapshotNode.name });
+		return hydrated;
+	}
+	serializeConfig(config) {
+		try {
+			const cloned = JSON.parse(JSON.stringify(config));
+			this.injectTokenIds(cloned, config);
+			return cloned;
+		} catch {
+			const fallback = {
+				kind: config.kind,
+				name: config.name,
+				id: config.id,
+				icon: config.icon,
+				execution: config.execution
+			};
+			this.injectTokenIds(fallback, config);
+			return fallback;
+		}
+	}
+	injectTokenIds(target, source) {
+		const type = this.asTypeToken(source.type);
+		if (type) target.tokenId = this.tokenRegistry.getTokenId(type) ?? this.resolveTokenName(type) ?? "unknown";
+		for (const [key, value] of Object.entries(source)) {
+			if (key === "type" || value == null) continue;
+			if (Array.isArray(value)) {
+				const targetArray = target[key];
+				if (Array.isArray(targetArray)) value.forEach((item, index) => {
+					if (item && typeof item === "object" && targetArray[index] && typeof targetArray[index] === "object") this.injectTokenIds(targetArray[index], item);
+				});
+				continue;
+			}
+			if (typeof value === "object") {
+				const targetValue = target[key];
+				if (targetValue && typeof targetValue === "object") this.injectTokenIds(targetValue, value);
+			}
+		}
+	}
+	mergeValue(liveValue, snapshotValue) {
+		const liveRecord = this.asRecord(liveValue);
+		const snapshotRecord = this.asRecord(snapshotValue);
+		const hydrated = Object.create(liveValue && typeof liveValue === "object" ? Object.getPrototypeOf(liveValue) ?? Object.prototype : Object.prototype);
+		for (const [key, value] of Object.entries(snapshotRecord)) hydrated[key] = this.mergeNestedValue(liveRecord[key], value);
+		this.restoreNonSerializableProperties(liveRecord, hydrated);
+		this.restoreTypeProperty(hydrated);
+		return hydrated;
+	}
+	mergeNestedValue(liveValue, snapshotValue) {
+		if (Array.isArray(snapshotValue)) {
+			const liveArray = Array.isArray(liveValue) ? liveValue : [];
+			return snapshotValue.map((entry, index) => this.mergeNestedValue(liveArray[index], entry));
+		}
+		if (snapshotValue && typeof snapshotValue === "object") return this.mergeValue(liveValue, snapshotValue);
+		return snapshotValue;
+	}
+	restoreNonSerializableProperties(liveRecord, hydrated) {
+		for (const [key, value] of Object.entries(liveRecord)) if (typeof value === "function" || typeof value === "symbol") hydrated[key] = value;
+	}
+	restoreTypeProperty(record) {
+		const tokenId = typeof record.tokenId === "string" ? record.tokenId : void 0;
+		if (!tokenId) return;
+		const type = this.tokenRegistry.resolve(tokenId);
+		if (type) record.type = type;
+	}
+	resolveTokenId(token) {
+		return this.tokenRegistry.getTokenId(token) ?? this.resolveTokenName(token) ?? "unknown";
+	}
+	resolveTokenName(token) {
+		if (typeof token === "function" && token.name) return token.name;
+		if (typeof token === "string") return token;
+	}
+	asTypeToken(value) {
+		if (typeof value === "function" || typeof value === "string" || typeof value === "symbol") return value;
+	}
+	asRecord(value) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+		return { ...value };
+	}
+};
+
 //#endregion
 //#region src/workflowSnapshots/WorkflowSnapshotResolver.ts
 var WorkflowSnapshotResolver = class {
@@ -1208,7 +1348,8 @@ var PersistedRunStateTerminalBuilder = class {
 			pending: void 0,
 			queue: args.queue,
 			outputsByNode: args.outputsByNode,
-			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId
+			nodeSnapshotsByNodeId: args.nodeSnapshotsByNodeId,
+			finishedAt: args.finishedAtIso ?? args.state.finishedAt
 		};
 	}
 };
@@ -1398,9 +1539,10 @@ var RunContinuationService = class {
 		this.executionLimitsPolicy = executionLimitsPolicy;
 	}
 	async markNodeRunning(args) {
-		const state = await this.workflowExecutionRepository.load(args.runId);
-		if (!state?.pending) return;
-		if (state.pending.activationId !== args.activationId || state.pending.nodeId !== args.nodeId) return;
+		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(args.runId), this.workflowExecutionRepository.loadSchedulingState(args.runId)]);
+		const pendingExecution = schedulingState?.pending;
+		if (!state || !pendingExecution) return;
+		if (pendingExecution.activationId !== args.activationId || pendingExecution.nodeId !== args.nodeId) return;
 		const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
 		const snapshot = NodeExecutionSnapshotFactory.running({
@@ -1423,11 +1565,11 @@ var RunContinuationService = class {
 		await this.nodeEventPublisher.publish("nodeStarted", snapshot);
 	}
 	async resumeFromNodeResult(args) {
-		const state = await this.workflowExecutionRepository.load(args.runId);
+		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(args.runId), this.workflowExecutionRepository.loadSchedulingState(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 pendingExecution = this.requirePendingExecution(args.runId, args.activationId, args.nodeId, state, schedulingState);
+		if (pendingExecution.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
+		if (pendingExecution.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);
@@ -1455,7 +1597,7 @@ var RunContinuationService = class {
 			activationId: args.activationId,
 			parent: state.parent,
 			finishedAt: completedAt,
-			inputsByPort: state.pending.inputsByPort,
+			inputsByPort: pendingExecution.inputsByPort,
 			outputs: args.outputs
 		});
 		const completedActivations = (state.engineCounters?.completedNodeActivations ?? 0) + 1;
@@ -1471,7 +1613,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...state.nodeSnapshotsByNodeId ?? {},
 					[args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1491,8 +1634,8 @@ var RunContinuationService = class {
 			this.waiters.resolveRunCompletion(result$1);
 			return result$1;
 		}
-		const batchId = state.pending.batchId ?? "batch_1";
-		const queue = (state.queue ?? []).map((q) => ({
+		const batchId = pendingExecution.batchId ?? "batch_1";
+		const queue = (schedulingState?.queue ?? []).map((q) => ({
 			...q,
 			batchId: q.batchId ?? batchId
 		}));
@@ -1537,7 +1680,8 @@ var RunContinuationService = class {
 				status: "completed",
 				queue: [],
 				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
+				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+				finishedAtIso: completedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1565,7 +1709,8 @@ var RunContinuationService = class {
 				status: "failed",
 				queue: queue.map((q) => ({ ...q })),
 				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId
+				nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+				finishedAtIso: completedAt
 			});
 			await this.workflowExecutionRepository.save(failedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1619,17 +1764,19 @@ var RunContinuationService = class {
 		return result;
 	}
 	async resumeFromNodeError(args) {
-		const state = await this.workflowExecutionRepository.load(args.runId);
+		const [state, schedulingState] = await Promise.all([this.workflowExecutionRepository.load(args.runId), this.workflowExecutionRepository.loadSchedulingState(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 pendingExecution = this.requirePendingExecution(args.runId, args.activationId, args.nodeId, state, schedulingState);
+		if (pendingExecution.activationId !== args.activationId) throw new Error(`activationId mismatch for run ${args.runId}`);
+		if (pendingExecution.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,
+			schedulingState,
+			pendingExecution,
 			workflow: wf,
 			args,
 			signal: webhookControlSignal
@@ -1637,8 +1784,8 @@ var RunContinuationService = class {
 		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 ctx = this.buildNodeExecutionContextForPending(state, pendingExecution, wf, failedDefinition, args.nodeId);
+				const inputsByPort = pendingExecution.inputsByPort;
 				const portKeys = Object.keys(inputsByPort);
 				const kind = portKeys.length === 1 && portKeys[0] === "in" ? "single" : "multi";
 				const items = inputsByPort.in ?? [];
@@ -1667,19 +1814,20 @@ var RunContinuationService = class {
 			activationId: args.activationId,
 			parent: state.parent,
 			finishedAt,
-			inputsByPort: state.pending.inputsByPort,
+			inputsByPort: pendingExecution.inputsByPort,
 			error: args.error
 		});
 		const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
 			state,
 			engineCounters: state.engineCounters ?? { completedNodeActivations: 0 },
 			status: "failed",
-			queue: (state.queue ?? []).map((q) => ({ ...q })),
+			queue: (schedulingState?.queue ?? []).map((q) => ({ ...q })),
 			outputsByNode: state.outputsByNode,
 			nodeSnapshotsByNodeId: {
 				...state.nodeSnapshotsByNodeId ?? {},
 				[args.nodeId]: failedSnapshot
-			}
+			},
+			finishedAtIso: finishedAt
 		});
 		await this.workflowExecutionRepository.save(failedState);
 		await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
@@ -1756,7 +1904,7 @@ var RunContinuationService = class {
 			activationId: args.args.activationId,
 			parent: args.state.parent,
 			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			inputsByPort: args.state.pending?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+			inputsByPort: args.pendingExecution.inputsByPort,
 			outputs: triggerOutputs
 		});
 		const completedActivations = (args.state.engineCounters?.completedNodeActivations ?? 0) + 1;
@@ -1772,7 +1920,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...args.state.nodeSnapshotsByNodeId ?? {},
 					[args.args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1809,7 +1958,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...args.state.nodeSnapshotsByNodeId ?? {},
 					[args.args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1836,8 +1986,8 @@ var RunContinuationService = class {
 			this.waiters.resolveRunCompletion(result$1);
 			return result$1;
 		}
-		const batchId = args.state.pending?.batchId ?? "batch_1";
-		const queue = (args.state.queue ?? []).map((entry) => ({
+		const batchId = args.pendingExecution.batchId ?? "batch_1";
+		const queue = (args.schedulingState?.queue ?? []).map((entry) => ({
 			...entry,
 			batchId: entry.batchId ?? batchId
 		}));
@@ -1859,7 +2009,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...args.state.nodeSnapshotsByNodeId ?? {},
 					[args.args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1897,7 +2048,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...args.state.nodeSnapshotsByNodeId ?? {},
 					[args.args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
 			});
 			await this.workflowExecutionRepository.save(failedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1992,7 +2144,7 @@ var RunContinuationService = class {
 			workflowSnapshot: state.workflowSnapshot
 		});
 	}
-	buildNodeExecutionContextForPending(state, wf, def, nodeId) {
+	buildNodeExecutionContextForPending(state, pendingExecution, wf, def, nodeId) {
 		const data = this.runDataFactory.create(state.outputsByNode);
 		const limits = this.resolveEngineLimitsFromState(state);
 		const base = this.runExecutionContextFactory.create({
@@ -2006,7 +2158,7 @@ var RunContinuationService = class {
 			data,
 			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent)
 		});
-		const activationId = state.pending.activationId;
+		const activationId = pendingExecution.activationId;
 		return {
 			...base,
 			data,
@@ -2020,6 +2172,14 @@ var RunContinuationService = class {
 			getCredential: this.credentialResolverFactory.create(wf.id, nodeId, def.config)
 		};
 	}
+	requirePendingExecution(runId, activationId, nodeId, state, schedulingState) {
+		if (state.status !== "pending") throw new Error(`Run ${runId} is not pending`);
+		const pendingExecution = schedulingState?.pending;
+		if (!pendingExecution) throw new Error(`Run ${runId} is not pending`);
+		if (pendingExecution.activationId !== activationId) throw new Error(`activationId mismatch for run ${runId}`);
+		if (pendingExecution.nodeId !== nodeId) throw new Error(`nodeId mismatch for run ${runId}`);
+		return pendingExecution;
+	}
 	resolveEngineLimitsFromState(state) {
 		const fb = this.executionLimitsPolicy.createRootExecutionOptions();
 		return {
@@ -2236,7 +2396,10 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	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);
+		if (!this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output)) return false;
+		if (this.usesCollect(nodeId)) return true;
+		if (this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output).length > 0) return true;
+		return this.shouldContinueAfterEmptyOutputFromSource(incomingEdge.from.nodeId);
 	}
 	resolveInput(currentState, nodeId, input) {
 		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
@@ -2258,6 +2421,15 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	resolveOutputItems(currentState, nodeId, output) {
 		return currentState.outputsByNode[nodeId]?.[output] ?? [];
 	}
+	usesCollect(nodeId) {
+		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
+		return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+	}
+	shouldContinueAfterEmptyOutputFromSource(nodeId) {
+		const definition = this.topology.defsById.get(nodeId);
+		if (!definition) return false;
+		return definition.config.continueWhenEmptyOutput === true;
+	}
 	getPinnedOutputs(currentState, nodeId) {
 		return currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort;
 	}
@@ -2664,7 +2836,7 @@ var DefaultDrivingScheduler = class {
 	setContinuation(continuation) {
 		this.inline.setContinuation(continuation);
 	}
-	async enqueue(request) {
+	async prepareDispatch(request) {
 		const selection = await this.selectScheduler(request);
 		if (selection.mode === "worker") {
 			if (request.kind === "multi") throw new Error(`Multi-input node ${request.nodeId} cannot be scheduled to worker (insert local placement)`);
@@ -2679,15 +2851,17 @@ var DefaultDrivingScheduler = class {
 				executionOptions: request.executionOptions
 			};
 			return {
-				receiptId: (await this.workerScheduler.enqueue(workerRequest)).receiptId,
-				mode: "worker",
-				queue: selection.queue
+				receipt: {
+					receiptId: request.activationId,
+					mode: "worker",
+					queue: selection.queue
+				},
+				dispatch: async () => {
+					await this.workerScheduler.enqueue(workerRequest);
+				}
 			};
 		}
-		return await this.enqueueInline(request);
-	}
-	notifyPendingStatePersisted(runId) {
-		this.inline.notifyPendingStatePersisted(runId);
+		return await this.prepareInlineDispatch(request);
 	}
 	/**
 	* Scheduler precedence is explicit:
@@ -2719,10 +2893,16 @@ var DefaultDrivingScheduler = class {
 	hasNodeSchedulingPreference(request) {
 		return request.ctx.config.execution?.hint !== void 0 || request.ctx.config.execution?.queue !== void 0;
 	}
-	async enqueueInline(request) {
+	async prepareInlineDispatch(request) {
+		const prepared = await this.inline.prepareDispatch(request);
 		return {
-			...await this.inline.enqueue(request),
-			mode: "local"
+			receipt: {
+				...prepared.receipt,
+				mode: "local"
+			},
+			dispatch: async () => {
+				await prepared.dispatch();
+			}
 		};
 	}
 };
@@ -2746,29 +2926,29 @@ var InlineDrivingScheduler = class {
 	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) {
+	async prepareDispatch(request) {
 		const receipt = {
-			receiptId: `inline_${++this.seq}`,
+			receiptId: request.activationId,
 			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);
+		return {
+			receipt,
+			dispatch: async () => {
+				const queue = this.queuesByRunId.get(request.runId) ?? [];
+				queue.push({
+					request,
+					receipt
+				});
+				this.queuesByRunId.set(request.runId, queue);
+				this.scheduleDrain(request.runId);
+			}
+		};
 	}
 	async drainRun(runId) {
 		if (this.drainingRuns.has(runId)) return;
@@ -3034,9 +3214,10 @@ var InMemoryRunDataFactory = class {
 
 //#endregion
 //#region src/contracts/runFinishedAtFactory.ts
-/** Derives workflow end time from node snapshots for run listings. */
+/** Derives workflow end time from persisted run root or node snapshots for run listings. */
 var RunFinishedAtFactory = class {
 	static resolveIso(state) {
+		if (state.finishedAt && state.status !== "running" && state.status !== "pending") return state.finishedAt;
 		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;
@@ -3044,6 +3225,22 @@ var RunFinishedAtFactory = class {
 	}
 };
 
+//#endregion
+//#region src/runtime/InMemoryLiveWorkflowRepository.ts
+var InMemoryLiveWorkflowRepository = class {
+	workflowsById = /* @__PURE__ */ new Map();
+	setWorkflows(workflows) {
+		this.workflowsById.clear();
+		for (const workflow of workflows) this.workflowsById.set(workflow.id, workflow);
+	}
+	list() {
+		return [...this.workflowsById.values()];
+	}
+	get(workflowId) {
+		return this.workflowsById.get(workflowId);
+	}
+};
+
 //#endregion
 //#region src/runtime/RunIntentService.ts
 var RunIntentService = class {
@@ -3052,13 +3249,14 @@ var RunIntentService = class {
 		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, {
+		const items = await this.resolveStartWorkflowItems(args);
+		if (args.startAt && !args.currentState && !args.stopCondition && !args.reset) return await this.engine.runWorkflow(args.workflow, args.startAt, items, args.parent, args.executionOptions, {
 			workflowSnapshot: args.workflowSnapshot,
 			mutableState: args.mutableState
 		});
 		return await this.engine.runWorkflowFromState({
 			workflow: args.workflow,
-			items: args.items,
+			items,
 			parent: args.parent,
 			executionOptions: args.executionOptions,
 			workflowSnapshot: args.workflowSnapshot,
@@ -3069,7 +3267,8 @@ var RunIntentService = class {
 		});
 	}
 	async rerunFromNode(args) {
-		if (args.items) return await this.engine.runWorkflow(args.workflow, args.nodeId, args.items, args.parent, args.executionOptions, {
+		const items = await this.resolveRerunItems(args);
+		if (items) return await this.engine.runWorkflow(args.workflow, args.nodeId, items, args.parent, args.executionOptions, {
 			workflowSnapshot: args.workflowSnapshot,
 			mutableState: args.mutableState
 		});
@@ -3084,6 +3283,44 @@ var RunIntentService = class {
 			reset: { clearFromNodeId: args.nodeId }
 		});
 	}
+	async resolveStartWorkflowItems(args) {
+		if (this.hasNonEmptyItems(args.items)) return args.items;
+		const triggerNodeId = this.resolveStartWorkflowTriggerNodeId(args);
+		if (!triggerNodeId) return args.items;
+		return await this.engine.createTriggerTestItems({
+			workflow: args.workflow,
+			nodeId: triggerNodeId
+		}) ?? args.items;
+	}
+	async resolveRerunItems(args) {
+		if (this.hasNonEmptyItems(args.items)) return args.items;
+		const triggerNodeId = this.resolveRerunTriggerNodeId(args);
+		if (!triggerNodeId) return args.items;
+		return await this.engine.createTriggerTestItems({
+			workflow: args.workflow,
+			nodeId: triggerNodeId
+		}) ?? args.items;
+	}
+	resolveStartWorkflowTriggerNodeId(args) {
+		if (args.stopCondition?.kind === "nodeCompleted" && this.isTriggerNode(args.workflow, args.stopCondition.nodeId)) return args.stopCondition.nodeId;
+		if (!args.synthesizeTriggerItems) return;
+		if (args.startAt && this.isTriggerNode(args.workflow, args.startAt)) return args.startAt;
+		return this.firstTriggerNodeId(args.workflow);
+	}
+	resolveRerunTriggerNodeId(args) {
+		if (this.isTriggerNode(args.workflow, args.nodeId)) return args.nodeId;
+		if (!args.synthesizeTriggerItems) return;
+		return this.firstTriggerNodeId(args.workflow);
+	}
+	firstTriggerNodeId(workflow) {
+		return workflow.nodes.find((node$1) => node$1.kind === "trigger")?.id;
+	}
+	isTriggerNode(workflow, nodeId) {
+		return workflow.nodes.find((node$1) => node$1.id === nodeId)?.kind === "trigger";
+	}
+	hasNonEmptyItems(items) {
+		return (items?.length ?? 0) > 0;
+	}
 	resolveWebhookTrigger(args) {
 		return this.engine.resolveWebhookTrigger(args);
 	}
@@ -3132,5 +3369,5 @@ var RunIntentService = class {
 };
 
 //#endregion
-export { injectAll as $, InProcessRetryRunnerFactory as A, WorkflowExecutableNodeClassifier as B, PersistedWorkflowTokenRegistry as C, NodeExecutorFactory as D, MissingRuntimeExecutionMarker as E, ActivationEnqueueService as F, tool as G, chatModel as H, DefaultExecutionBinaryService as I, StackTraceCallSitePathResolver as J, InjectableRuntimeDecoratorComposer as K, UnavailableBinaryStorage as L, DefaultExecutionContextFactory as M, DefaultAsyncSleeper as N, NodeExecutor as O, CredentialResolverFactory as P, inject as Q, NodeEventPublisher as R, WorkflowSnapshotResolver as S, MissingRuntimeTriggerToken as T, getPersistedRuntimeTypeMetadata as U, ConnectionNodeIdFactory as V, node as W, container as X, PersistedRuntimeTypeNameResolver as Y, delay as Z, RunStateSemantics as _, ENGINE_EXECUTION_LIMITS_DEFAULTS as a, singleton as at, NodeInstanceFactoryFactory as b, InlineDrivingScheduler as c, ConfigDrivenOffloadPolicy as d, injectable as et, RunStartService as f, WorkflowRunExecutionContextFactory as g, WorkflowTopology as h, InMemoryBinaryStorage as i, registry as it, InProcessRetryRunner as j, NodeActivationRequestComposer as k, HintOnlyOffloadPolicy as l, RunContinuationService as m, RunFinishedAtFactory as n, instancePerContainerCachingFactory as nt, EngineExecutionLimitsPolicy as o, CoreTokens as ot, RunPolicySnapshotFactory as p, PersistedRuntimeTypeMetadataStore as q, InMemoryRunDataFactory as r, predicateAwareClassFactory as rt, LocalOnlyScheduler as s, RunIntentService as t, instanceCachingFactory as tt, DefaultDrivingScheduler as u, PersistedRunStateTerminalBuilder as v, MissingRuntimeFallbacks as w, NodeInstanceFactory as x, NodeRunStateWriterFactory as y, WorkflowExecutableNodeClassifierFactory as z };
-//# sourceMappingURL=RunIntentService-BB4nqX3-.js.map
+export { delay as $, NodeExecutor as A, NodeEventPublisher as B, WorkflowSnapshotResolver as C, MissingRuntimeTriggerToken as D, MissingRuntimeFallbacks as E, DefaultAsyncSleeper as F, getPersistedRuntimeTypeMetadata as G, WorkflowExecutableNodeClassifier as H, CredentialResolverFactory as I, InjectableRuntimeDecoratorComposer as J, node as K, ActivationEnqueueService as L, InProcessRetryRunnerFactory as M, InProcessRetryRunner as N, MissingRuntimeExecutionMarker as O, DefaultExecutionContextFactory as P, container$1 as Q, DefaultExecutionBinaryService as R, NodeInstanceFactory as S, PersistedWorkflowTokenRegistry as T, ConnectionNodeIdFactory as U, WorkflowExecutableNodeClassifierFactory as V, chatModel as W, StackTraceCallSitePathResolver as X, PersistedRuntimeTypeMetadataStore as Y, PersistedRuntimeTypeNameResolver as Z, WorkflowRunExecutionContextFactory as _, InMemoryBinaryStorage as a, predicateAwareClassFactory as at, NodeRunStateWriterFactory as b, LocalOnlyScheduler as c, CoreTokens as ct, DefaultDrivingScheduler as d, inject as et, ConfigDrivenOffloadPolicy as f, WorkflowTopology as g, RunContinuationService as h, InMemoryRunDataFactory as i, instancePerContainerCachingFactory as it, NodeActivationRequestComposer as j, NodeExecutorFactory as k, InlineDrivingScheduler as l, RunPolicySnapshotFactory as m, InMemoryLiveWorkflowRepository as n, injectable as nt, ENGINE_EXECUTION_LIMITS_DEFAULTS as o, registry as ot, RunStartService as p, tool as q, RunFinishedAtFactory as r, instanceCachingFactory as rt, EngineExecutionLimitsPolicy as s, singleton as st, RunIntentService as t, injectAll as tt, HintOnlyOffloadPolicy as u, RunStateSemantics as v, WorkflowSnapshotCodec as w, NodeInstanceFactoryFactory as x, PersistedRunStateTerminalBuilder as y, UnavailableBinaryStorage as z };
+//# sourceMappingURL=RunIntentService-BFA48UpH.js.map