@oomol-lab/open-flow 0.1.0-beta.62 → 0.1.0-beta.64

package/dist/common/scheduler.js

@@ -7543,10 +7543,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -7559,7 +7559,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -7954,7 +7954,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -8544,7 +8544,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -9110,7 +9110,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }
@@ -9610,7 +9610,8 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object({
 			kind: literal("openapi"),
@@ -10589,6 +10590,285 @@ function nodeOutputPorts(node) {
 	}
 }
 //#endregion
+//#region src/execution/common/dependencies.ts
+var outputsSchema = record$1(string(), json$1());
+var inputSchema = record$1(string(), strictObject({
+	execution: number().int().nonnegative(),
+	outputs: outputsSchema
+}));
+function dependencyValues(input) {
+	return Object.fromEntries(Object.entries(input).map(([id, result]) => [id, result.outputs]));
+}
+var stateSchema = strictObject({
+	id: number().int().nonnegative(),
+	status: _enum([
+		"pending",
+		"running",
+		"completed",
+		"skipped"
+	]),
+	input: inputSchema,
+	output: outputsSchema.optional(),
+	previous: array(string()),
+	released: array(string()),
+	jobId: string().optional(),
+	seeded: boolean()
+});
+var dependenciesSchema = strictObject({
+	nextId: number().int().nonnegative(),
+	iterations: record$1(string(), number().int().nonnegative()),
+	nodes: record$1(string(), stateSchema)
+});
+/** Dependency completion belongs to an invocation, never to a Run-wide latest-result table. */
+var Dependencies = class {
+	constructor(graph, saved) {
+		this.forward = [];
+		this.loops = /* @__PURE__ */ new Map();
+		this.outgoing = /* @__PURE__ */ new Map();
+		this.incoming = /* @__PURE__ */ new Map();
+		this.graph = graph;
+		const feedback = /* @__PURE__ */ new Map();
+		const visited = /* @__PURE__ */ new Set();
+		const stack = /* @__PURE__ */ new Set();
+		const outgoing = /* @__PURE__ */ new Map();
+		for (const edge of graph.edges) {
+			const edges = outgoing.get(edge.source) ?? [];
+			edges.push(edge);
+			outgoing.set(edge.source, edges);
+		}
+		for (const edges of outgoing.values()) edges.sort((a, b) => a.target.localeCompare(b.target) || (a.sourceHandle ?? "").localeCompare(b.sourceHandle ?? ""));
+		const visit = (id) => {
+			if (visited.has(id)) return;
+			visited.add(id);
+			stack.add(id);
+			for (const edge of outgoing.get(id) ?? []) if (stack.has(edge.target)) {
+				const edges = feedback.get(edge.target) ?? [];
+				edges.push(edge);
+				feedback.set(edge.target, edges);
+			} else {
+				this.forward.push(edge);
+				visit(edge.target);
+			}
+			stack.delete(id);
+		};
+		const ids = Object.keys(graph.nodes).toSorted();
+		for (const triggerId of ids.filter((id) => !("inputs" in graph.nodes[id]))) visit(triggerId);
+		for (const id of ids) visit(id);
+		for (const edge of this.forward) {
+			const edges = this.incoming.get(edge.target) ?? [];
+			edges.push(edge);
+			this.incoming.set(edge.target, edges);
+			const children = this.outgoing.get(edge.source) ?? [];
+			children.push(edge);
+			this.outgoing.set(edge.source, children);
+		}
+		for (const [header, edges] of feedback) {
+			const descendants = /* @__PURE__ */ new Set([header]);
+			const walk = (id) => {
+				for (const edge of this.outgoing.get(id) ?? []) {
+					if (descendants.has(edge.target)) continue;
+					descendants.add(edge.target);
+					walk(edge.target);
+				}
+			};
+			walk(header);
+			const body = /* @__PURE__ */ new Set([header]);
+			const backwards = (id) => {
+				if (!descendants.has(id) || body.has(id)) return;
+				body.add(id);
+				for (const edge of this.incoming.get(id) ?? []) backwards(edge.source);
+			};
+			for (const edge of edges) backwards(edge.source);
+			this.loops.set(header, {
+				header,
+				feedback: edges,
+				body,
+				continuation: descendants
+			});
+		}
+		this.innerLoopsFirst = [...this.loops.values()].toSorted((a, b) => a.body.size - b.body.size || a.header.localeCompare(b.header));
+		this.state = saved == null ? {
+			nextId: 0,
+			iterations: {},
+			nodes: {}
+		} : structuredClone(saved);
+		if (saved == null) for (const id of ids) this.state.nodes[id] = this.fresh();
+		else this.validate();
+	}
+	fresh() {
+		return {
+			id: this.state.nextId++,
+			status: "pending",
+			input: {},
+			previous: [],
+			released: [],
+			seeded: false
+		};
+	}
+	validate() {
+		const { nodes, nextId, iterations } = this.state;
+		if (Object.keys(nodes).length != Object.keys(this.graph.nodes).length) throw new Error("Checkpoint dependency nodes do not match the graph.");
+		const ids = /* @__PURE__ */ new Set();
+		for (const [id, state] of Object.entries(nodes)) {
+			if (this.graph.nodes[id] == null || state.id >= nextId || ids.has(state.id)) throw new Error("Checkpoint dependency identity is invalid.");
+			ids.add(state.id);
+			if (state.status == "running" && state.jobId == null) throw new Error("Checkpoint running dependency has no job.");
+			if ((state.status == "pending" || state.status == "skipped") && (state.jobId != null || state.output != null || state.released.length != 0)) throw new Error("Checkpoint inactive dependency contains an execution.");
+			if (state.status == "skipped" && (state.seeded || state.previous.length != 0 || Object.keys(state.input).length != 0)) throw new Error("Checkpoint skipped dependency contains values.");
+			if (state.seeded && (!this.loops.has(id) || state.previous.some((source) => !this.loops.get(id).feedback.some((edge) => edge.source == source)))) throw new Error("Checkpoint recurrence seed is invalid.");
+			if (state.released.length != new Set(state.released).size) throw new Error("Checkpoint released handles are duplicated.");
+			if (state.previous.some((source) => !this.graph.edges.some((edge) => edge.source == source && edge.target == id))) throw new Error("Checkpoint predecessor does not match the graph.");
+			if (state.previous.length != new Set(state.previous).size) throw new Error("Checkpoint predecessors are duplicated.");
+			if (state.status == "completed" && state.output == null) throw new Error("Checkpoint completed dependency has no output.");
+			if (state.previous.some((source) => state.input[source] == null)) throw new Error("Checkpoint predecessor has no input snapshot.");
+			for (const [source, result] of Object.entries(state.input)) if (nodes[source] == null || result.execution > nodes[source].id || result.execution >= nextId) throw new Error("Checkpoint dependency result identity is invalid.");
+		}
+		if (Object.keys(iterations).some((id) => !this.loops.has(id))) throw new Error("Checkpoint loop scope is invalid.");
+	}
+	start(nodeId, outputs) {
+		for (const [id, node] of Object.entries(this.graph.nodes)) {
+			if ("inputs" in node) continue;
+			const state = this.state.nodes[id];
+			state.status = id == nodeId ? "completed" : "skipped";
+			if (id == nodeId) {
+				state.output = outputs;
+				state.released = Object.keys(outputs);
+			}
+		}
+	}
+	edge(edge) {
+		const source = this.state.nodes[edge.source];
+		if (source.status == "skipped") return "skipped";
+		if (edge.sourceHandle != null && source.released.includes(edge.sourceHandle)) return "selected";
+		if (source.status != "completed") return "pending";
+		return edge.sourceHandle == null ? "selected" : "skipped";
+	}
+	collectInputs(edges) {
+		const input = {};
+		const merge = (id, result) => {
+			const previous = input[id];
+			if (previous == null || result.execution > previous.execution) input[id] = result;
+			else if (result.execution == previous.execution) input[id] = {
+				execution: result.execution,
+				outputs: {
+					...previous.outputs,
+					...result.outputs
+				}
+			};
+		};
+		for (const edge of edges) {
+			const source = this.state.nodes[edge.source];
+			for (const [id, result] of Object.entries(source.input)) merge(id, result);
+			const outputs = edge.sourceHandle != null && this.graph.nodes[edge.source].kind != "condition" ? Object.fromEntries(Object.entries(source.output).filter(([handle]) => handle == edge.sourceHandle)) : source.output;
+			merge(edge.source, {
+				execution: source.id,
+				outputs
+			});
+		}
+		for (const id of Object.keys(input)) if (this.state.nodes[id].status == "skipped") delete input[id];
+		return input;
+	}
+	inputValues(nodeId) {
+		return dependencyValues(this.state.nodes[nodeId].input);
+	}
+	loopSettled(loop) {
+		return [...loop.body].every((id) => {
+			const state = this.state.nodes[id];
+			return state.status == "completed" || state.status == "skipped";
+		});
+	}
+	blockedByLoop(edge) {
+		if (this.edge(edge) == "selected") return false;
+		for (const loop of this.loops.values()) {
+			const { body } = loop;
+			if (!body.has(edge.source) || body.has(edge.target)) continue;
+			if (!this.loopSettled(loop)) return true;
+			if (loop.feedback.some((back) => this.edge(back) == "selected")) return true;
+		}
+		return false;
+	}
+	continuationPending(loop) {
+		const { body } = loop;
+		const exitBlocked = /* @__PURE__ */ new Map();
+		const awaitsExit = (id) => {
+			if (exitBlocked.has(id)) return exitBlocked.get(id);
+			const blocked = (this.incoming.get(id) ?? []).some((edge) => this.edge(edge) != "selected" && (body.has(edge.source) && !body.has(id) && this.blockedByLoop(edge) || this.state.nodes[edge.source].status == "pending" && awaitsExit(edge.source)));
+			exitBlocked.set(id, blocked);
+			return blocked;
+		};
+		const visited = /* @__PURE__ */ new Set();
+		const visit = (id) => {
+			if (visited.has(id) || body.has(id)) return false;
+			visited.add(id);
+			const state = this.state.nodes[id];
+			if (state.status == "running") return true;
+			if (state.status == "pending") return !awaitsExit(id);
+			return (this.outgoing.get(id) ?? []).some((edge) => this.edge(edge) == "selected" && visit(edge.target));
+		};
+		return this.forward.some((edge) => body.has(edge.source) && !body.has(edge.target) && this.edge(edge) == "selected" && visit(edge.target));
+	}
+	selectedIncoming(nodeId) {
+		const edges = this.incoming.get(nodeId) ?? [];
+		if (edges.some((edge) => this.edge(edge) == "pending" || this.blockedByLoop(edge))) return void 0;
+		return edges.filter((edge) => this.edge(edge) == "selected");
+	}
+	/** Resolve skips and iteration boundaries before admitting another invocation. */
+	ready() {
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const loop of this.innerLoopsFirst) {
+				const { header, feedback: edges, continuation: affected } = loop;
+				if (!this.loopSettled(loop)) continue;
+				const selected = edges.filter((edge) => this.edge(edge) == "selected");
+				if (selected.length == 0) continue;
+				if (this.continuationPending(loop) || [...affected].some((id) => this.state.nodes[id].status == "running")) continue;
+				const input = this.collectInputs(selected);
+				this.state.iterations[header] = (this.state.iterations[header] ?? 0) + 1;
+				for (const nested of this.loops.keys()) if (nested != header && affected.has(nested)) delete this.state.iterations[nested];
+				for (const id of affected) this.state.nodes[id] = this.fresh();
+				const entry = this.state.nodes[header];
+				entry.input = input;
+				entry.previous = [...new Set(selected.map((edge) => edge.source))].toSorted();
+				entry.seeded = true;
+				changed = true;
+				break;
+			}
+			for (const [id, state] of Object.entries(this.state.nodes)) {
+				if (state.status != "pending" || state.seeded) continue;
+				if (this.selectedIncoming(id)?.length == 0) {
+					state.status = "skipped";
+					changed = true;
+				}
+			}
+		}
+		return Object.entries(this.state.nodes).flatMap(([id, state]) => {
+			if (state.status != "pending") return [];
+			if (state.seeded) return [id];
+			const selected = this.selectedIncoming(id);
+			if (selected == null || selected.length == 0) return [];
+			state.input = this.collectInputs(selected);
+			for (const member of this.loops.get(id)?.body ?? []) delete state.input[member];
+			state.previous = [...new Set(selected.map((edge) => edge.source))].toSorted();
+			return [id];
+		});
+	}
+	begin(nodeId, jobId) {
+		const state = this.state.nodes[nodeId];
+		state.status = "running";
+		state.jobId = jobId;
+	}
+	release(nodeId, outputs, handles, complete) {
+		const state = this.state.nodes[nodeId];
+		state.output = outputs;
+		state.released = [.../* @__PURE__ */ new Set([...state.released, ...handles])];
+		if (complete) state.status = "completed";
+	}
+	get incomplete() {
+		return Object.values(this.state.nodes).some((state) => state.status == "pending" || state.status == "running");
+	}
+};
+//#endregion
 //#region src/execution/common/wait.ts
 /** Shared by decision entry points, the editor, and durable decision storage. */
 var waitCommentSchema = string().trim().refine((value) => [...value].length <= 2e3, "Wait comment must contain at most 2,000 Unicode code points.").nullable().optional();
@@ -10598,6 +10878,7 @@ function normalizeWaitComment$1(value) {
 //#endregion
 //#region src/execution/common/scheduler.ts
 var normalizeWaitComment = normalizeWaitComment$1;
+var PortValidationError = class extends Error {};
 function usesPending(graph, nodeId) {
 	return graph.edges.some((edge) => edge.source == nodeId && edge.sourceHandle == "pending") || Object.values(graph.nodes).some((node) => "inputs" in node && Object.values(node.inputs).some((mapping) => mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "node" && source.nodeId == nodeId && source.output == "pending")));
 }
@@ -10672,7 +10953,7 @@ function decodeFlowRunCheckpoint(input) {
 		"agents",
 		"bindingValues",
 		"counts",
-		"frames",
+		"dependencies",
 		"inputs",
 		"results",
 		"version",
@@ -10693,23 +10974,14 @@ function decodeFlowRunCheckpoint(input) {
 		}];
 	}));
 	const counts = record$1(string(), record$1(string(), number().int().positive().max(Number.MAX_SAFE_INTEGER))).parse(source.counts);
-	const frames = record$1(string(), record$1(string(), record$1(string(), json$1()))).parse(source.frames);
-	const savedWaitFields = {
+	const dependencies = dependenciesSchema.parse(source.dependencies);
+	const pendingWaits = array(strictObject({
 		jobId: string().min(1),
 		nodeId: string().min(1),
 		value: json$1(),
-		waitId: string().min(1)
-	};
-	const pendingWaits = array(union([strictObject({
-		...savedWaitFields,
+		waitId: string().min(1),
 		pending: json$1().optional()
-	}), strictObject({
-		...savedWaitFields,
-		notification: json$1().optional()
-	}).transform(({ notification, ...wait }) => ({
-		...wait,
-		pending: notification
-	}))])).min(1).parse(source.waits);
+	})).min(1).parse(source.waits);
 	const agents = record$1(string(), strictObject({
 		invocationId: string().min(1),
 		input: record$1(string(), json$1()),
@@ -10719,17 +10991,17 @@ function decodeFlowRunCheckpoint(input) {
 	const jobs = /* @__PURE__ */ new Set();
 	const waits = /* @__PURE__ */ new Set();
 	for (const pending of pendingWaits) {
-		if (jobs.has(pending.jobId) || waits.has(pending.waitId) || frames[pending.jobId] == null || Object.values(results).some((result) => result.jobId == pending.jobId)) throw new Error("Checkpoint waiting execution states conflict.");
+		if (jobs.has(pending.jobId) || waits.has(pending.waitId) || dependencies.nodes[pending.nodeId]?.status != "running" || dependencies.nodes[pending.nodeId]?.jobId != pending.jobId || Object.values(results).some((result) => result.jobId == pending.jobId)) throw new Error("Checkpoint waiting execution states conflict.");
 		jobs.add(pending.jobId);
 		waits.add(pending.waitId);
 	}
-	if (Object.keys(frames).some((id) => !jobs.has(id))) throw new Error("Checkpoint frame has no waiting execution.");
+	if (Object.values(dependencies.nodes).some((state) => state.status == "running" && !jobs.has(state.jobId))) throw new Error("Checkpoint dependency has no waiting execution.");
 	if (Object.keys(agents).some((id) => !jobs.has(id))) throw new Error("Checkpoint Agent has no waiting execution.");
 	return {
 		agents,
 		bindingValues,
 		counts,
-		frames,
+		dependencies,
 		inputs,
 		results,
 		version: 5,
@@ -10797,9 +11069,9 @@ function validateOutputs(nodeId, node, value) {
 		const port = ports[handle];
 		if (port == null) {
 			if (discardUndeclared) continue;
-			throw new Error(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
+			throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
 		}
-		if (!(output === null && port.nullable) && !matchesSchema(output, port.jsonSchema)) throw new Error(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
+		if (!(output === null && port.nullable) && !matchesSchema(output, port.jsonSchema)) throw new PortValidationError(`Node "${nodeId}" output "${handle}" does not match its declaration.`);
 		validated[handle] = output;
 	}
 	return validated;
@@ -10833,11 +11105,6 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 	validateResults(Object.fromEntries(Object.entries(checkpoint.results).map(([id, result]) => [id, result.outputs])));
 	const triggerIds = Object.keys(checkpoint.results).filter((id) => !("inputs" in target.graph.nodes[id]));
 	if (triggerIds.length != 1) throw new Error("Checkpoint must contain exactly one selected Trigger.");
-	for (const frame of Object.values(checkpoint.frames)) {
-		validateResults(frame, true);
-		const triggers = Object.keys(frame).filter((id) => !("inputs" in target.graph.nodes[id]));
-		if (triggers.length != 1 || triggers[0] != triggerIds[0] || !jsonEqual(frame[triggers[0]], checkpoint.results[triggers[0]].outputs)) throw new Error("Checkpoint frame Trigger does not match the Run.");
-	}
 	const pendingCounts = /* @__PURE__ */ new Map();
 	for (const waiting of checkpoint.waits) pendingCounts.set(waiting.nodeId, (pendingCounts.get(waiting.nodeId) ?? 0) + 1);
 	for (const [id, count] of pendingCounts) if ((checkpoint.counts[""]?.[id] ?? 0) < count + (checkpoint.results[id] == null ? 0 : 1)) throw new Error("Checkpoint waiting execution count is incomplete.");
@@ -10845,9 +11112,25 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 		const node = target.graph.nodes[id];
 		if (!("inputs" in node) || Object.keys(values).some((handle) => nodePorts(node)[handle] == null)) throw new Error("Checkpoint launch inputs do not match the prepared graph.");
 	}
+	for (const [nodeId, state] of Object.entries(checkpoint.dependencies.nodes)) {
+		const frame = dependencyValues(state.input);
+		validateResults(frame, true);
+		if ("inputs" in target.graph.nodes[nodeId] && (state.status == "running" || state.status == "completed")) {
+			const triggers = Object.keys(frame).filter((id) => !("inputs" in target.graph.nodes[id]));
+			if (triggers.length != 1 || triggers[0] != triggerIds[0] || !jsonEqual(frame[triggers[0]], checkpoint.results[triggers[0]].outputs)) throw new Error("Checkpoint input Trigger does not match the Run.");
+		}
+		if (state.output != null) validateResults({ [nodeId]: state.output }, state.status == "running");
+		if (state.status == "completed") {
+			const result = checkpoint.results[nodeId];
+			if (result == null || state.jobId != null && state.jobId != result.jobId || !jsonEqual(state.output, result.outputs)) throw new Error("Checkpoint completed dependency conflicts with its result.");
+		}
+	}
 	for (const waiting of checkpoint.waits) {
 		const node = target.graph.nodes[waiting.nodeId];
 		if (node == null || !("inputs" in node)) throw new Error("Checkpoint waiting node is missing.");
+		const state = checkpoint.dependencies.nodes[waiting.nodeId];
+		const expectedOutput = waiting.pending == null ? void 0 : { pending: waiting.pending };
+		if (state.output == null != (expectedOutput == null) || state.output != null && !jsonEqual(state.output, expectedOutput)) throw new Error("Checkpoint waiting dependency output is inconsistent.");
 		const config = agentConfig(node);
 		const saved = agents[waiting.jobId];
 		if (!isResolutionNode(node) && config == null) throw new Error("Checkpoint waiting node cannot suspend.");
@@ -10856,10 +11139,10 @@ function validateCheckpoint(target, checkpoint, resolveInputs) {
 			if (saved == null || node.timeoutMs == null != (saved.remainingMs == null) || saved.remainingMs != null && saved.remainingMs > node.timeoutMs) throw new Error("Checkpoint Agent budget is invalid.");
 			const approval = agentApproval(config, saved.checkpoint, saved.input);
 			if (!jsonEqual(waiting.value, approval)) throw new Error("Checkpoint Agent approval does not match its saved call.");
-			if (!jsonEqual(resolveInputs(waiting.nodeId, node, waiting.jobId), saved.input)) throw new Error("Checkpoint Agent inputs changed.");
+			if (!jsonEqual(resolveInputs(waiting.nodeId, node), saved.input)) throw new Error("Checkpoint Agent inputs changed.");
 		} else {
 			if (saved != null) throw new Error("Checkpoint Wait contains Agent state.");
-			if (!isResolutionNode(node) || !jsonEqual(resolveInputs(waiting.nodeId, node, waiting.jobId), waiting.value)) throw new Error("Checkpoint resolution input changed.");
+			if (!isResolutionNode(node) || !jsonEqual(resolveInputs(waiting.nodeId, node), waiting.value)) throw new Error("Checkpoint resolution input changed.");
 			if (usesPending(target.graph, waiting.nodeId) != (waiting.pending != null)) throw new Error("Checkpoint Wait pending output is missing or unexpected.");
 			if (waiting.pending != null) validateOutputs(waiting.nodeId, node, { pending: waiting.pending });
 		}
@@ -10883,7 +11166,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		const resultNodes = order.filter((id) => !outgoing.has(id)).toSorted();
 		const completed = new Map(Object.entries(resume?.checkpoint.results ?? {}));
 		const counts = context.counts[""] ??= {};
-		const frames = { ...resume?.checkpoint.frames };
+		const dependencies = new Dependencies(target.graph, resume?.checkpoint.dependencies);
 		const launch = resume?.checkpoint.inputs ?? launchInputs;
 		if (resume == null) {
 			if (trigger != null) {
@@ -10925,12 +11208,13 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			}
 			if (required && value === void 0) throw new Error(`${description} is incomplete.`);
 			if (value === void 0) value = null;
-			if (!(value === null && port.nullable) && !matchesSchema(value, port.jsonSchema)) throw new Error(`${description} does not match its declared schema.`);
+			if (!(value === null && port.nullable) && !matchesSchema(value, port.jsonSchema)) throw new PortValidationError(`${description} does not match its declared schema.`);
 			return value;
 		};
-		const resolveInputs = (nodeId, node, jobId) => {
+		const resolveInputs = (nodeId, node) => {
 			const mappings = nodeInputMappings(node);
-			return Object.fromEntries(Object.entries(nodePorts(node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frames[jobId], node.kind == "condition")]));
+			const frame = dependencies.inputValues(nodeId);
+			return Object.fromEntries(Object.entries(nodePorts(node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frame, node.kind == "condition")]));
 		};
 		const commit = (nodeId, jobId, outputs, releasedHandles = Object.keys(outputs)) => Effect.uninterruptible(Effect.gen(function* () {
 			yield* context.emit({
@@ -10944,25 +11228,9 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				jobId,
 				outputs
 			});
-			const frame = {
-				...frames[jobId],
-				[nodeId]: outputs
-			};
-			delete frames[jobId];
-			dispatch(nodeId, releasedHandles, frame);
+			dependencies.release(nodeId, outputs, releasedHandles, true);
 		}));
-		const ready = [];
-		const scheduleReady = (nodeId, frame, previousId) => {
-			ready.push({
-				nodeId,
-				frame,
-				previousId
-			});
-		};
-		const dispatch = (nodeId, releasedHandles, frame) => {
-			for (const edge of outgoing.get(nodeId) ?? []) if (edge.sourceHandle == null || releasedHandles.includes(edge.sourceHandle)) scheduleReady(edge.target, frame, nodeId);
-		};
-		const executeNode = (nodeId, node, jobId, nodeInputs, resolution, previousId) => {
+		const executeNode = (nodeId, node, jobId, nodeInputs, resolution) => {
 			const config = agentConfig(node);
 			const saved = agents[jobId];
 			const nodeRemainingMs = saved?.remainingMs ?? node.timeoutMs;
@@ -10995,7 +11263,8 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 						outputs = Object.fromEntries(node.values.map((port) => [port.handle, port.value ?? null]));
 						break;
 					case "task": {
-						const frame = frames[jobId];
+						const frame = dependencies.inputValues(nodeId);
+						const previousIds = dependencies.state.nodes[nodeId].previous;
 						const additional = new Set((node.additionalInputs ?? []).map((port) => port.handle));
 						const result = yield* context.invokeTask({
 							additionalInputs: Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => additional.has(handle))),
@@ -11020,18 +11289,19 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 								capabilities: node.task.capabilities ?? [],
 								moduleId: node.task.moduleId,
 								getPrevious: () => {
-									if (previousId == null) return null;
-									const previous = target.graph.nodes[previousId];
-									return {
-										id: previousId,
-										name: previous.name ?? ("inputs" in previous ? nodeTitle(previous) : void 0) ?? previousId,
-										outputs: frame[previousId],
-										outputDefs: Object.entries(nodeOutputPorts(previous)).map(([handle, definition]) => Object.assign({
-											handle,
-											jsonSchema: definition.jsonSchema,
-											nullable: definition.nullable
-										}, definition.description == null ? {} : { description: definition.description }))
-									};
+									return previousIds.map((previousId) => {
+										const previous = target.graph.nodes[previousId];
+										return {
+											id: previousId,
+											name: previous.name ?? ("inputs" in previous ? nodeTitle(previous) : void 0) ?? previousId,
+											outputs: frame[previousId],
+											outputDefs: Object.entries(nodeOutputPorts(previous)).map(([handle, definition]) => Object.assign({
+												handle,
+												jsonSchema: definition.jsonSchema,
+												nullable: definition.nullable
+											}, definition.description == null ? {} : { description: definition.description }))
+										};
+									});
 								}
 							} : { kind: "managed" }
 						});
@@ -11054,7 +11324,8 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 								};
 							}
 							outputs = { output: response.output };
-						} else outputs = outputRecord(result, nodeId);
+						} else if ("executor" in node.task && node.task.executor.kind == "connector" && node.task.executor.outputMode == "value") outputs = { output: checkpointJson(result, `Node "${nodeId}" output`) };
+						else outputs = outputRecord(result, nodeId);
 						break;
 					}
 					case "approval":
@@ -11090,11 +11361,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			});
 			if (notify) {
 				validateOutputs(nodeId, node, { pending });
-				const frame = {
-					...frames[jobId],
-					[nodeId]: { pending }
-				};
-				dispatch(nodeId, ["pending"], frame);
+				dependencies.release(nodeId, { pending }, ["pending"], false);
 			}
 			pendingWaits.set(jobId, {
 				jobId,
@@ -11130,7 +11397,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		})), Effect.tapCause((cause) => Effect.sync(() => {
 			firstCause ??= cause;
 		})));
-		const executeReady = (nodeId, frame, previousId) => {
+		const executeReady = (nodeId) => {
 			if (firstCause != null) return;
 			const node = target.graph.nodes[nodeId];
 			if (!("inputs" in node)) return;
@@ -11142,10 +11409,10 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				return;
 			}
 			counts[nodeId] = count + 1;
-			frames[jobId] = frame;
+			dependencies.begin(nodeId, jobId);
 			runNode(observe(nodeId, jobId, Effect.gen(function* () {
 				const nodeInputs = yield* Effect.try({
-					try: () => resolveInputs(nodeId, node, jobId),
+					try: () => resolveInputs(nodeId, node),
 					catch: (error) => error instanceof Error ? error : new Error(String(error))
 				});
 				if (isResolutionNode(node)) {
@@ -11164,7 +11431,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 					yield* createWait(nodeId, jobId, nodeInputs);
 					return;
 				}
-				const result = yield* executeNode(nodeId, node, jobId, nodeInputs, void 0, previousId);
+				const result = yield* executeNode(nodeId, node, jobId, nodeInputs);
 				yield* settleNode(nodeId, jobId, result);
 			})).pipe(Effect.ensuring(Queue.offer(changes, void 0))));
 		};
@@ -11173,7 +11440,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			catch: (error) => error instanceof Error ? error : new Error(String(error))
 		});
 		if (resume == null) {
-			if (trigger != null) dispatch(trigger.nodeId, Object.keys(trigger.outputs), { [trigger.nodeId]: trigger.outputs });
+			if (trigger != null) dependencies.start(trigger.nodeId, trigger.outputs);
 		}
 		const applyResolutions = (resolutions, now) => {
 			for (const saved of pendingWaits.values()) {
@@ -11221,10 +11488,14 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				return yield* Effect.failCause(firstCause);
 			}
 			if (pendingWaits.size > 0 && context.waits != null) applyResolutions(yield* context.waits.resolutions([...pendingWaits.values()].map((wait) => wait.waitId), false), now);
-			for (const arrival of ready.splice(0)) executeReady(arrival.nodeId, arrival.frame, arrival.previousId);
+			const ready = dependencies.ready();
+			for (const nodeId of ready) executeReady(nodeId);
 			const running = yield* FiberSet.size(active);
 			if (firstCause != null) continue;
-			if (running == 0 && pendingWaits.size == 0 && ready.length == 0) break;
+			if (running == 0 && pendingWaits.size == 0 && ready.length == 0) {
+				if (dependencies.incomplete) return yield* Effect.fail(/* @__PURE__ */ new Error("Execution graph contains unresolved dependencies."));
+				break;
+			}
 			if (running > 0 || ready.length > 0) idleSince = void 0;
 			else idleSince ??= now;
 			const left = idleSince == null ? remainingMs : waitRetentionMs - (now - idleSince);
@@ -11234,7 +11505,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 					inputs: launch,
 					results: Object.fromEntries(completed),
 					counts: context.counts,
-					frames,
+					dependencies: dependencies.state,
 					version: 5,
 					agents,
 					waits: [...pendingWaits.values()]
@@ -11305,4 +11576,4 @@ function runFlow(prepared, options) {
 	});
 }
 //#endregion
-export { decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitRetentionMs };
+export { PortValidationError, decodeFlowRunCheckpoint, normalizeWaitComment, runFlow, waitRetentionMs };

package/dist/common/trigger-config.d.ts

@@ -1,4 +1,6 @@
 import type { Group, InputPort, InputValues, JsonValue } from '../browser/flow-change.js';
+/** Deployment-bound selections owned by the Trigger configuration contract. */
+export declare function clearTriggerExternalConfig(key: string, config: InputValues): InputValues;
 export declare function triggerConfigValue(input: InputPort, config: InputValues): JsonValue | undefined;
 /** Provider-specific controls consume values, never persistence wrappers. */
 export declare function triggerConfigValues(inputs: readonly (InputPort | Group)[], config: InputValues): Readonly<Record<string, JsonValue>>;