@codemation/core 0.0.19 → 0.2.1

package/dist/{RunIntentService-ZkjpY7MS.cjs → RunIntentService-DcxXf_AM.cjs}

@@ -183,6 +183,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}`);
@@ -505,7 +524,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();
@@ -516,8 +535,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
 		};
@@ -551,7 +570,7 @@ var ActivationEnqueueService = class {
 				[args.request.nodeId]: queuedSnapshot
 			}
 		});
-		this.notifyPendingStatePersisted(args.runId);
+		await this.dispatchPreparedActivation(preparedDispatch);
 		return {
 			result: {
 				runId: args.runId,
@@ -563,8 +582,8 @@ var ActivationEnqueueService = class {
 			queuedSnapshot
 		};
 	}
-	notifyPendingStatePersisted(runId) {
-		this.activationScheduler.notifyPendingStatePersisted?.(runId);
+	async dispatchPreparedActivation(preparedDispatch) {
+		await preparedDispatch.dispatch();
 	}
 };
 
@@ -985,6 +1004,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 {
@@ -1234,7 +1374,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
 		};
 	}
 };
@@ -1424,9 +1565,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({
@@ -1449,11 +1591,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);
@@ -1481,7 +1623,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;
@@ -1497,7 +1639,8 @@ var RunContinuationService = class {
 				nodeSnapshotsByNodeId: {
 					...state.nodeSnapshotsByNodeId ?? {},
 					[args.nodeId]: completedSnapshot
-				}
+				},
+				finishedAtIso: completedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -1517,8 +1660,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
 		}));
@@ -1563,7 +1706,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);
@@ -1591,7 +1735,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);
@@ -1645,17 +1790,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
@@ -1663,8 +1810,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 ?? [];
@@ -1693,19 +1840,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);
@@ -1782,7 +1930,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;
@@ -1798,7 +1946,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);
@@ -1835,7 +1984,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);
@@ -1862,8 +2012,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
 		}));
@@ -1885,7 +2035,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);
@@ -1923,7 +2074,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);
@@ -2018,7 +2170,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({
@@ -2032,7 +2184,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,
@@ -2046,6 +2198,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 {
@@ -2702,7 +2862,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)`);
@@ -2717,15 +2877,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:
@@ -2757,10 +2919,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();
+			}
 		};
 	}
 };
@@ -2784,29 +2952,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;
@@ -3072,9 +3240,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;
@@ -3082,6 +3251,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 {
@@ -3288,6 +3473,12 @@ Object.defineProperty(exports, 'InMemoryBinaryStorage', {
     return InMemoryBinaryStorage;
   }
 });
+Object.defineProperty(exports, 'InMemoryLiveWorkflowRepository', {
+  enumerable: true,
+  get: function () {
+    return InMemoryLiveWorkflowRepository;
+  }
+});
 Object.defineProperty(exports, 'InMemoryRunDataFactory', {
   enumerable: true,
   get: function () {
@@ -3474,6 +3665,12 @@ Object.defineProperty(exports, 'WorkflowRunExecutionContextFactory', {
     return WorkflowRunExecutionContextFactory;
   }
 });
+Object.defineProperty(exports, 'WorkflowSnapshotCodec', {
+  enumerable: true,
+  get: function () {
+    return WorkflowSnapshotCodec;
+  }
+});
 Object.defineProperty(exports, 'WorkflowSnapshotResolver', {
   enumerable: true,
   get: function () {
@@ -3516,4 +3713,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=RunIntentService-ZkjpY7MS.cjs.map
+//# sourceMappingURL=RunIntentService-DcxXf_AM.cjs.map