@oomol-lab/open-flow 0.1.0-beta.55 → 0.1.0-beta.56

package/dist/common/scheduler.js

@@ -2796,6 +2796,9 @@ function handlePipeResult(left, next, ctx) {
 		issues: left.issues
 	}, ctx);
 }
+var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
@@ -5411,7 +5414,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function record$1(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string(),
@@ -5620,6 +5623,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5663,11 +5670,18 @@ function json$1(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record(string(), jsonSchema)
+			record$1(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -9226,7 +9240,7 @@ var isObject = (x) => x !== null && typeof x === "object";
 var isPlainObject = (x) => isObject(x) && !isArray(x);
 var toPlainObject = (x) => isPlainObject(x) ? x : void 0;
 //#endregion
-//#region src/manifest/common/schemaComparer.ts
+//#region src/flow/common/schemaComparer.ts
 function isStringLikeSchema(value) {
 	return toPlainObject(value)?.type === "string";
 }
@@ -9495,24 +9509,15 @@ var group = object({
 	collapsed: boolean().optional(),
 	group: text
 });
-var nodeSource = object({
+var source = union([object({
 	kind: literal("node"),
 	nodeId: text,
 	output: text,
 	field: text.optional()
-});
-var flowSource = object({
-	kind: literal("flow"),
-	input: text
-});
-var source = union([
-	nodeSource,
-	flowSource,
-	object({
-		kind: literal("binding"),
-		bindingId: text
-	})
-]);
+}), object({
+	kind: literal("binding"),
+	bindingId: text
+})]);
 var fixedInput = union([object({ kind: literal("unset") }), object({
 	kind: literal("value"),
 	value: json
@@ -9521,7 +9526,7 @@ var mapping = union([fixedInput, object({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
-var inputs = record(text, mapping);
+var inputs = record$1(text, mapping);
 var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
@@ -9649,9 +9654,11 @@ var managed = object({
 				inputs: array(input.extend({ source: agentInput$1 }))
 			})),
 			notification: object({
-				taskId: text,
+				action: text,
+				connectionId: text.optional(),
+				inputDefinitions: array(input),
 				messageHandle: text,
-				inputs: record(text, agentValue)
+				inputs: record$1(text, agentValue)
 			}).optional()
 		})
 	])
@@ -9706,7 +9713,7 @@ var webhookOptions = object({
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
 	responseData: text.optional(),
-	responseHeaders: record(text, text).optional(),
+	responseHeaders: record$1(text, text).optional(),
 	responseStatusCode: number().int().min(200).max(599).optional()
 });
 var webhook = {
@@ -9762,7 +9769,7 @@ var base = {
 var node = union([
 	object({
 		...base,
-		inputs: record(text, never()),
+		inputs: record$1(text, never()),
 		kind: literal("condition"),
 		...condition
 	}),
@@ -9772,21 +9779,10 @@ var node = union([
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object({
-		...base,
-		kind: literal("subflow"),
-		subflowId: text
-	}),
-	object({
-		...base,
-		kind: literal("task"),
-		task: inline,
-		additionalInputs: array(input).optional()
-	}),
 	object({
 		...base,
 		kind: literal("task"),
-		taskId: text,
+		task: union([inline, managed]),
 		additionalInputs: array(input).optional()
 	}),
 	strictObject({
@@ -9822,7 +9818,7 @@ var node = union([
 		...trigger,
 		kind: literal("poll"),
 		connectionId: text.min(1).optional(),
-		config: record(text, fixedInput),
+		config: record$1(text, fixedInput),
 		definition: object({
 			...definition,
 			type: literal("poll")
@@ -9833,7 +9829,7 @@ var node = union([
 		...trigger,
 		kind: literal("integration"),
 		connectionId: text.min(1).optional(),
-		config: record(text, fixedInput),
+		config: record$1(text, fixedInput),
 		definition: object({
 			...definition,
 			type: literal("integration"),
@@ -9841,10 +9837,6 @@ var node = union([
 		})
 	})
 ]);
-var target = union([object({ kind: literal("flow") }), object({
-	kind: literal("subflow"),
-	id: text
-})]);
 var edge = object({
 	source: text,
 	target: text,
@@ -9852,15 +9844,10 @@ var edge = object({
 });
 var at = {
 	nodeId: text,
-	target
+	target: never().optional()
 };
-var subflow = object({
-	name: text,
-	inputs: array(input),
-	outputs: array(port.extend({ sources: array(union([nodeSource, flowSource])) }))
-});
 var graph = object({
-	nodes: record(text, node),
+	nodes: record$1(text, node),
 	edges: array(edge).default([])
 });
 var binding = object({
@@ -9872,24 +9859,35 @@ var module = object({
 	imports: strings,
 	source: text
 });
-var document = object({
-	bindings: record(text, binding),
-	graph,
-	subflows: record(text, subflow.extend({ graph })),
-	tasks: record(text, managed)
-});
+var document = preprocess(rejectRetiredDefinitions, object({
+	bindings: record$1(text, binding),
+	graph
+}));
 object({
 	modelVersion: union([
 		literal(2),
 		literal(4),
-		literal(5)
+		literal(5),
+		literal(6)
 	]),
 	document,
-	modules: record(text, module)
+	modules: record$1(text, module)
 }).extend({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
+function rejectRetiredDefinitions(value) {
+	const candidate = record(value);
+	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
+	const subflows = candidate.subflows;
+	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	return value;
+}
+function record(value) {
+	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+}
 var shapes = {
 	"graph.trigger.sources.set": {
 		nodeId: text,
@@ -9907,12 +9905,12 @@ var shapes = {
 		value: text
 	},
 	"graph.edge.connect": {
-		target,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.edge.disconnect": {
-		target,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.node.create": {
 		...at,
@@ -9976,13 +9974,11 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
 		before: object(wait),
 		value: object(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
 		before: object(webhook),
 		value: object(webhook)
 	},
@@ -10029,50 +10025,10 @@ var shapes = {
 		imports: strings,
 		source: text
 	},
-	"subflow.create": {
-		subflowId: text,
-		subflow: subflow.extend({ graph })
-	},
-	"subflow.definition.set": {
-		subflowId: text,
-		before: subflow,
-		definition: subflow
-	},
-	"subflow.delete": { subflowId: text },
-	"task.create": {
-		taskId: text,
-		task: managed
-	},
-	"task.delete": { taskId: text },
-	"task.connector.connection.set": {
-		taskId: text,
-		before: text.optional(),
-		value: text.optional()
-	},
-	"task.decision.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.openapi.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.agent.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.llm.mode.set": {
-		taskId: text,
-		before: _enum(["chat", "json"]),
-		value: _enum(["chat", "json"])
-	},
-	"task.name.set": {
-		taskId: text,
-		before: text,
-		value: text
+	"graph.node.task.set": {
+		...at,
+		before: union([inline, managed]),
+		value: union([inline, managed])
 	}
 };
 array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
@@ -10311,8 +10267,8 @@ var schema = lazy(() => union([boolean(), strictObject({
 		"https://json-schema.org/draft/2019-09/schema",
 		"https://json-schema.org/draft/2020-12/schema"
 	]).optional(),
-	$defs: record(string(), schema).optional(),
-	definitions: record(string(), schema).optional(),
+	$defs: record$1(string(), schema).optional(),
+	definitions: record$1(string(), schema).optional(),
 	pattern: string().refine((value) => {
 		try {
 			return new RegExp(value, "u").source.length > 0;
@@ -10329,16 +10285,16 @@ var schema = lazy(() => union([boolean(), strictObject({
 	minProperties: number().int().nonnegative().optional(),
 	maxProperties: number().int().nonnegative().optional(),
 	propertyNames: schema.optional(),
-	patternProperties: record(string().refine((value) => {
+	patternProperties: record$1(string().refine((value) => {
 		try {
 			return new RegExp(value, "u").source.length > 0;
 		} catch {
 			return false;
 		}
 	}, "Invalid regular expression."), schema).optional(),
-	dependentRequired: record(string(), array(string())).optional(),
-	dependentSchemas: record(string(), schema).optional(),
-	dependencies: record(string(), union([schema, array(string())])).optional(),
+	dependentRequired: record$1(string(), array(string())).optional(),
+	dependentSchemas: record$1(string(), schema).optional(),
+	dependencies: record$1(string(), union([schema, array(string())])).optional(),
 	prefixItems: array(schema).optional(),
 	additionalItems: schema.optional(),
 	unevaluatedItems: schema.optional(),
@@ -10352,7 +10308,7 @@ var schema = lazy(() => union([boolean(), strictObject({
 	deprecated: boolean().optional(),
 	$comment: string().optional(),
 	enum: array(json$1()).min(1).optional(),
-	properties: record(string(), schema).optional(),
+	properties: record$1(string(), schema).optional(),
 	required: array(string()).optional(),
 	additionalProperties: schema.optional(),
 	items: union([schema, array(schema)]).optional(),
@@ -10607,12 +10563,11 @@ function resolutionOutputPorts(node) {
 		})]))
 	};
 }
-function nodeOutputPorts(document, node) {
+function nodeOutputPorts(node) {
 	switch (node.kind) {
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
-		case "subflow": return portsByHandle(document.subflows[node.subflowId]?.outputs ?? []);
-		case "task": return portsByHandle(node.task != null ? node.task.outputs : document.tasks[node.taskId]?.outputs ?? []);
+		case "task": return portsByHandle(node.task.outputs);
 		case "approval":
 		case "wait": return resolutionOutputPorts(node);
 		case "cron":
@@ -10643,30 +10598,28 @@ function nodeFailure(error, project) {
 		message: error instanceof Error ? error.message : String(error)
 	};
 }
-function nodePorts(prepared, node) {
+function nodePorts(node) {
 	switch (node.kind) {
 		case "condition": return conditionInputPorts(node);
 		case "value": return {};
-		case "subflow": return portsByHandle(prepared.subflows[node.subflowId].inputs);
-		case "task": return portsByHandle([...node.task != null ? node.task.inputs : prepared.tasks[node.taskId].inputs, ...node.additionalInputs ?? []]);
+		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
 		case "approval":
 		case "wait": return portsByHandle(node.inputDefinitions);
 	}
 }
-function nodeTitle(prepared, node) {
+function nodeTitle(node) {
 	if (node.name != null) return node.name;
 	switch (node.kind) {
 		case "condition": return;
 		case "value": return "Fixed Values";
-		case "subflow": return prepared.subflows[node.subflowId].name;
-		case "task": return node.task != null ? node.task.name : prepared.tasks[node.taskId].name;
+		case "task": return node.task.name;
 		case "approval": return "Approval";
 		case "wait": return "Wait";
 	}
 }
-function nodeKind(prepared, node) {
+function nodeKind(node) {
 	if (node.kind != "task") return node.kind;
-	return node.task != null ? "javascript" : prepared.tasks[node.taskId].executor.kind;
+	return "moduleId" in node.task ? "javascript" : node.task.executor.kind;
 }
 function checkpointRecord(value, description) {
 	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error(`${description} must be an object.`);
@@ -10692,7 +10645,7 @@ var agentCheckpointSchema = strictObject({
 	state: json$1(),
 	callId: string().min(1),
 	toolId: string().min(1),
-	input: record(string(), json$1()),
+	input: record$1(string(), json$1()),
 	rounds: number().int().nonnegative(),
 	version: literal(1)
 });
@@ -10729,8 +10682,8 @@ function decodeFlowRunCheckpoint(input) {
 			outputs: Object.fromEntries(Object.entries(checkpointRecord(result.outputs, "Checkpoint outputs")).map(([handle, item]) => [handle, checkpointJson(item, "Checkpoint output")]))
 		}];
 	}));
-	const counts = record(string(), record(string(), number().int().positive().max(Number.MAX_SAFE_INTEGER))).parse(source.counts);
-	const frames = record(string(), record(string(), record(string(), json$1()))).parse(source.frames);
+	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 = {
 		jobId: string().min(1),
 		nodeId: string().min(1),
@@ -10747,9 +10700,9 @@ function decodeFlowRunCheckpoint(input) {
 		...wait,
 		pending: notification
 	}))])).min(1).parse(source.waits);
-	const agents = record(string(), strictObject({
+	const agents = record$1(string(), strictObject({
 		invocationId: string().min(1),
-		input: record(string(), json$1()),
+		input: record$1(string(), json$1()),
 		remainingMs: number().positive().optional(),
 		checkpoint: agentCheckpointSchema
 	})).parse(source.agents);
@@ -10787,18 +10740,16 @@ function outputRecord(value, nodeId) {
 	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error(`Node "${nodeId}" must return an object.`);
 	return value;
 }
-function agentConfig(prepared, node) {
-	const task = node.kind == "task" && node.taskId != null ? prepared.tasks[node.taskId] : void 0;
+function agentConfig(node) {
+	const task = node.kind == "task" && "executor" in node.task ? node.task : void 0;
 	return task?.executor.kind == "agent" ? task.executor : void 0;
 }
-function agentNotice(prepared, node, values) {
-	const notification = agentConfig(prepared, node)?.notification;
+function agentNotice(node, values) {
+	const notification = agentConfig(node)?.notification;
 	if (notification == null) return void 0;
-	const task = prepared.tasks[notification.taskId];
 	return {
-		taskId: notification.taskId,
 		messageHandle: notification.messageHandle,
-		input: Object.fromEntries(task.inputs.flatMap((port) => {
+		input: Object.fromEntries(notification.inputDefinitions.flatMap((port) => {
 			if (!("handle" in port) || port.handle == notification.messageHandle) return [];
 			const source = notification.inputs[port.handle];
 			return [[port.handle, source == null ? port.value ?? null : agentInput(source, values)]];
@@ -10822,10 +10773,10 @@ function agentApproval(config, checkpoint, inputs) {
 		input: checkpoint.input
 	};
 }
-function validateOutputs(prepared, nodeId, node, value) {
+function validateOutputs(nodeId, node, value) {
 	const raw = outputRecord(value, nodeId);
-	const discardUndeclared = node.kind == "task" && node.taskId != null && prepared.tasks[node.taskId].executor.kind == "connector";
-	const ports = isResolutionNode(node) ? resolutionOutputPorts(node) : node.kind == "task" ? portsByHandle(node.task != null ? node.task.outputs : prepared.tasks[node.taskId].outputs) : node.kind == "subflow" ? portsByHandle(prepared.subflows[node.subflowId].outputs) : node.kind == "value" ? portsByHandle(node.values) : {};
+	const discardUndeclared = node.kind == "task" && "executor" in node.task && node.task.executor.kind == "connector";
+	const ports = isResolutionNode(node) ? resolutionOutputPorts(node) : node.kind == "task" ? portsByHandle(node.task.outputs) : node.kind == "value" ? portsByHandle(node.values) : {};
 	const outputs = outputRecord(checkpointJson(Object.fromEntries(Object.entries(raw).map(([handle, item]) => [handle, Object.hasOwn(ports, handle) && item === void 0 ? null : item])), `Node "${nodeId}" outputs`), nodeId);
 	const complete = node.kind == "condition" || isResolutionNode(node) ? outputs : {
 		...Object.fromEntries(Object.keys(ports).map((handle) => [handle, null])),
@@ -10843,12 +10794,12 @@ function validateOutputs(prepared, nodeId, node, value) {
 	}
 	return validated;
 }
-function validateCheckpoint(prepared, target, checkpoint, resolveInputs) {
+function validateCheckpoint(target, checkpoint, resolveInputs) {
 	const launch = checkpoint.inputs;
 	const agents = checkpoint.agents;
 	if ([...Object.keys(checkpoint.results), ...Object.keys(launch)].some((id) => target.graph.nodes[id] == null)) throw new Error("Checkpoint nodes do not match the prepared graph.");
 	for (const [scope, counts] of Object.entries(checkpoint.counts)) {
-		const graph = scope == "" ? target.graph : prepared.subflows[scope]?.graph;
+		const graph = scope == "" ? target.graph : void 0;
 		if (graph == null) throw new Error("Checkpoint execution counts reference an unknown graph.");
 		for (const [id, count] of Object.entries(counts)) {
 			const node = graph.nodes[id];
@@ -10863,7 +10814,7 @@ function validateCheckpoint(prepared, target, checkpoint, resolveInputs) {
 				if (!matchesTriggerOutputs(node, outputs)) throw new Error("Checkpoint Trigger output is invalid.");
 			} else {
 				if (checkpoint.counts[""]?.[id] == null) throw new Error("Checkpoint execution count is missing.");
-				if (!jsonEqual(validateOutputs(prepared, id, node, outputs), outputs)) throw new Error("Checkpoint node outputs are incomplete.");
+				if (!jsonEqual(validateOutputs(id, node, outputs), outputs)) throw new Error("Checkpoint node outputs are incomplete.");
 				const count = Object.keys(outputs).length;
 				if (node.kind == "condition" && count != 0 || isResolutionNode(node) && (resolutionActions(node).filter((action) => Object.hasOwn(outputs, action)).length > 1 || !resolutionActions(node).some((action) => Object.hasOwn(outputs, action)) && !(frame && Object.hasOwn(outputs, "pending")))) throw new Error("Checkpoint branch result is invalid.");
 			}
@@ -10882,12 +10833,12 @@ function validateCheckpoint(prepared, target, checkpoint, resolveInputs) {
 	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.");
 	for (const [id, values] of Object.entries(launch)) {
 		const node = target.graph.nodes[id];
-		if (!("inputs" in node) || Object.keys(values).some((handle) => nodePorts(prepared, node)[handle] == null)) throw new Error("Checkpoint launch inputs do not match the prepared graph.");
+		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 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 config = agentConfig(prepared, node);
+		const config = agentConfig(node);
 		const saved = agents[waiting.jobId];
 		if (!isResolutionNode(node) && config == null) throw new Error("Checkpoint waiting node cannot suspend.");
 		if (config != null) {
@@ -10900,34 +10851,28 @@ function validateCheckpoint(prepared, target, checkpoint, resolveInputs) {
 			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 (usesPending(target.graph, waiting.nodeId) != (waiting.pending != null)) throw new Error("Checkpoint Wait pending output is missing or unexpected.");
-			if (waiting.pending != null) validateOutputs(prepared, waiting.nodeId, node, { pending: waiting.pending });
+			if (waiting.pending != null) validateOutputs(waiting.nodeId, node, { pending: waiting.pending });
 		}
 		if (checkpoint.counts[""]?.[waiting.nodeId] == null) throw new Error("Checkpoint waiting execution count is missing.");
 	}
 }
-function runGraph(context, target, runId, inputs, parent, launchInputs = {}, trigger, resume) {
+function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 	return Effect.scoped(Effect.gen(function* () {
 		if (resume == null) yield* context.emit({
 			flowId: target.flowId,
-			...parent == null ? {} : {
-				parentJobId: parent.jobId,
-				parentRunId: parent.runId
-			},
 			runId,
 			type: "run.started"
 		});
 		const order = Object.keys(target.graph.nodes).filter((id) => "inputs" in target.graph.nodes[id]);
-		const incoming = /* @__PURE__ */ new Set();
 		const outgoing = /* @__PURE__ */ new Map();
 		for (const edge of target.graph.edges) {
-			incoming.add(edge.target);
 			const targets = outgoing.get(edge.source) ?? [];
 			targets.push(edge);
 			outgoing.set(edge.source, targets);
 		}
 		const resultNodes = order.filter((id) => !outgoing.has(id)).toSorted();
 		const completed = new Map(Object.entries(resume?.checkpoint.results ?? {}));
-		const counts = context.counts[target.kind == "flow" ? "" : target.flowId] ??= {};
+		const counts = context.counts[""] ??= {};
 		const frames = { ...resume?.checkpoint.frames };
 		const launch = resume?.checkpoint.inputs ?? launchInputs;
 		if (resume == null) {
@@ -10958,7 +10903,6 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 			if (mapping?.kind == "sources") {
 				const values = mapping.sources.flatMap((source) => {
 					if (source.kind == "binding") return Object.hasOwn(context.bindingValues, source.bindingId) ? [context.bindingValues[source.bindingId]] : [];
-					if (source.kind == "flow") return Object.hasOwn(inputs, source.input) ? [inputs[source.input]] : [];
 					const outputs = valuesByNode[source.nodeId];
 					if (outputs == null || !Object.hasOwn(outputs, source.output)) return [];
 					const output = outputs[source.output];
@@ -10976,7 +10920,7 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 		};
 		const resolveInputs = (nodeId, node, jobId) => {
 			const mappings = nodeInputMappings(node);
-			return Object.fromEntries(Object.entries(nodePorts(context.prepared, node)).map(([handle, port]) => [handle, resolveInput(mappings[handle], port, launch[nodeId]?.[handle], `Node "${nodeId}" input "${handle}"`, frames[jobId], node.kind == "condition")]));
+			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 commit = (nodeId, jobId, outputs, releasedHandles = Object.keys(outputs)) => Effect.uninterruptible(Effect.gen(function* () {
 			yield* context.emit({
@@ -11009,15 +10953,15 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 			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 config = agentConfig(context.prepared, node);
+			const config = agentConfig(node);
 			const saved = agents[jobId];
 			const nodeRemainingMs = saved?.remainingMs ?? node.timeoutMs;
 			const startedAt = performance.now();
 			const execution = Effect.gen(function* () {
-				const kind = nodeKind(context.prepared, node);
-				const title = nodeTitle(context.prepared, node);
+				const kind = nodeKind(node);
+				const title = nodeTitle(node);
 				const projectedInputs = Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => {
-					if (node.kind == "task" && node.taskId != null && context.prepared.tasks[node.taskId]?.executor.kind == "openapi" && handle.startsWith("auth.")) return false;
+					if (node.kind == "task" && "executor" in node.task && node.task?.executor.kind == "openapi" && handle.startsWith("auth.")) return false;
 					const mapping = nodeInputMappings(node)[handle];
 					return mapping?.kind != "sources" || mapping.sources.every((source) => source.kind != "binding");
 				}));
@@ -11040,28 +10984,16 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 					case "value":
 						outputs = Object.fromEntries(node.values.map((port) => [port.handle, port.value ?? null]));
 						break;
-					case "subflow": {
-						const subflow = context.prepared.subflows[node.subflowId];
-						outputs = yield* runGraph(context, {
-							flowId: node.subflowId,
-							graph: subflow.graph,
-							kind: "subflow"
-						}, context.createId(), nodeInputs, {
-							jobId,
-							runId
-						});
-						break;
-					}
 					case "task": {
 						const frame = frames[jobId];
 						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))),
-							blockId: node.task != null ? node.task.moduleId : node.taskId,
+							blockId: "moduleId" in node.task ? node.task.moduleId : nodeId,
 							flowId: target.flowId,
 							input: Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => {
 								if (additional.has(handle)) return false;
-								const task = node.taskId == null ? void 0 : context.prepared.tasks[node.taskId];
+								const task = "executor" in node.task ? node.task : void 0;
 								if (task?.executor.kind != "openapi") return true;
 								const mapping = node.inputs[handle];
 								return mapping?.kind != "unset" && (mapping != null || task.inputs.some((port) => "handle" in port && port.handle == handle && port.value !== void 0));
@@ -11074,7 +11006,7 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 							jobId,
 							nodeId,
 							runId,
-							...node.task != null ? {
+							..."moduleId" in node.task ? {
 								capabilities: node.task.capabilities ?? [],
 								moduleId: node.task.moduleId,
 								getPrevious: () => {
@@ -11082,21 +11014,20 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 									const previous = target.graph.nodes[previousId];
 									return {
 										id: previousId,
-										name: previous.name ?? ("inputs" in previous ? nodeTitle(context.prepared, previous) : void 0) ?? previousId,
+										name: previous.name ?? ("inputs" in previous ? nodeTitle(previous) : void 0) ?? previousId,
 										outputs: frame[previousId],
-										outputDefs: Object.entries(nodeOutputPorts(context.prepared, previous)).map(([handle, definition]) => Object.assign({
+										outputDefs: Object.entries(nodeOutputPorts(previous)).map(([handle, definition]) => Object.assign({
 											handle,
 											jsonSchema: definition.jsonSchema,
 											nullable: definition.nullable
 										}, definition.description == null ? {} : { description: definition.description }))
 									};
 								}
-							} : { taskId: node.taskId }
+							} : { kind: "managed" }
 						});
 						if (config != null) {
 							const response = agentResultSchema.parse(result);
 							if (response.kind == "suspended") {
-								if (target.kind != "flow") return yield* Effect.fail(/* @__PURE__ */ new Error("Subflow Agent is not supported."));
 								const checkpoint = response.checkpoint;
 								const value = agentApproval(config, checkpoint, nodeInputs);
 								const left = nodeRemainingMs == null ? void 0 : nodeRemainingMs - (performance.now() - startedAt);
@@ -11122,7 +11053,7 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 				return yield* Effect.try({
 					try: () => ({
 						kind: "completed",
-						outputs: validateOutputs(context.prepared, nodeId, node, outputs)
+						outputs: validateOutputs(nodeId, node, outputs)
 					}),
 					catch: (error) => error instanceof Error ? error : new Error(String(error))
 				});
@@ -11133,7 +11064,7 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 			}));
 		};
 		const createWait = (nodeId, jobId, value) => Effect.gen(function* () {
-			if (target.kind != "flow" || context.waits == null) return yield* Effect.fail(/* @__PURE__ */ new Error("Wait host is unavailable."));
+			if (context.waits == null) return yield* Effect.fail(/* @__PURE__ */ new Error("Wait host is unavailable."));
 			const node = target.graph.nodes[nodeId];
 			const waitId = nanoid$1();
 			const notify = isResolutionNode(node) && usesPending(target.graph, nodeId);
@@ -11145,10 +11076,10 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 				notify,
 				actions: isResolutionNode(node) ? resolutionActions(node) : ["approve", "reject"],
 				prompt: isResolutionNode(node) ? node.prompt : JSON.stringify(value, null, 2),
-				...isResolutionNode(node) ? {} : { notification: agentNotice(context.prepared, node, agents[jobId].input) }
+				...isResolutionNode(node) ? {} : { notification: agentNotice(node, agents[jobId].input) }
 			});
 			if (notify) {
-				validateOutputs(context.prepared, nodeId, node, { pending });
+				validateOutputs(nodeId, node, { pending });
 				const frame = {
 					...frames[jobId],
 					[nodeId]: { pending }
@@ -11228,12 +11159,11 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 			})).pipe(Effect.ensuring(Queue.offer(changes, void 0))));
 		};
 		if (resume != null) yield* Effect.try({
-			try: () => validateCheckpoint(context.prepared, target, resume.checkpoint, resolveInputs),
+			try: () => validateCheckpoint(target, resume.checkpoint, resolveInputs),
 			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 });
-			else for (const nodeId of order) if (!incoming.has(nodeId)) scheduleReady(nodeId, {});
 		}
 		const applyResolutions = (resolutions, now) => {
 			for (const saved of pendingWaits.values()) {
@@ -11249,7 +11179,7 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 				runNode(observe(saved.nodeId, saved.jobId, Effect.gen(function* () {
 					if (isResolutionNode(node)) {
 						if (!resolutionActions(node).some((candidate) => candidate == action)) return yield* Effect.fail(/* @__PURE__ */ new Error("Resolution does not match node actions."));
-						yield* commit(saved.nodeId, saved.jobId, validateOutputs(context.prepared, saved.nodeId, node, {
+						yield* commit(saved.nodeId, saved.jobId, validateOutputs(saved.nodeId, node, {
 							...saved.pending == null ? {} : { pending: saved.pending },
 							[action]: {
 								inputs: saved.value,
@@ -11318,26 +11248,6 @@ function runGraph(context, target, runId, inputs, parent, launchInputs = {}, tri
 			runId,
 			type: "run.progress"
 		});
-		if (target.kind == "subflow") {
-			const subflow = context.prepared.subflows[target.flowId];
-			const outputs = yield* Effect.try({
-				try: () => Object.fromEntries(subflow.outputs.map((port) => [port.handle, resolveInput({
-					kind: "sources",
-					sources: port.sources
-				}, port, void 0, `Subflow output "${port.handle}"`, Object.fromEntries([...completed].map(([id, result]) => [id, result.outputs])))])),
-				catch: (error) => error instanceof Error ? error : new Error(String(error))
-			});
-			yield* context.emit({
-				result: {
-					kind: "function-outputs",
-					outputs,
-					target: "subflow"
-				},
-				runId,
-				type: "run.completed"
-			});
-			return outputs;
-		}
 		const result = {
 			kind: "node-results",
 			nodes: resultNodes.flatMap((nodeId) => {
@@ -11380,9 +11290,8 @@ function runFlow(prepared, options) {
 			remainingMs: options.remainingMs
 		}, {
 			flowId: options.flowId,
-			graph: prepared.graph,
-			kind: "flow"
-		}, options.runId, {}, void 0, options.inputs, options.trigger, checkpoint == null ? void 0 : { checkpoint });
+			graph: prepared.graph
+		}, options.runId, options.inputs, options.trigger, checkpoint == null ? void 0 : { checkpoint });
 	});
 }
 //#endregion