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

package/dist/common/flow-agent.d.ts

@@ -2,7 +2,7 @@ import type { AgentInput, AgentTool, JsonValue, ManagedTaskDefinition, ManagedTa
 export type AgentConfig = Extract<ManagedTaskExecutor, {
     readonly kind: 'agent';
 }>;
-export declare function agentConfigIssues(task: ManagedTaskDefinition, tasks: Readonly<Record<string, ManagedTaskDefinition>>): readonly string[];
+export declare function agentConfigIssues(task: ManagedTaskDefinition): readonly string[];
 export declare function agentInput(source: Exclude<AgentInput, {
     readonly kind: 'model';
 }>, input: Readonly<Record<string, JsonValue>>): JsonValue;

package/dist/common/flow-connectionUsage.d.ts

@@ -1,4 +1,4 @@
-import type { FlowDocument, GraphTarget, RevisionContent } from '../browser/flow-change.js';
+import type { FlowDocument, RevisionContent } from '../browser/flow-change.js';
 export interface ConnectionUsage {
     readonly providerId: string;
     readonly connectionId?: string;
@@ -6,7 +6,6 @@ export interface ConnectionUsage {
     readonly triggerId?: string;
     readonly nodeId: string;
     readonly name: string;
-    readonly target: GraphTarget;
     readonly kind: 'connector' | 'agent' | 'trigger' | 'notification' | 'code';
 }
 export declare function connectionUsage(document: FlowDocument): readonly ConnectionUsage[];

package/dist/common/flow-encoding.d.ts

@@ -1,14 +1,12 @@
-import type { CodeModule, FlowDocument, Graph, Group, InputPort, JsonValue, OutputMapping, Port, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
+import type { CodeModule, FlowDocument, Graph, Group, InputPort, JsonValue, ManagedTaskDefinition, Port, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
 export { maxJsonDepth } from './flow-json.js';
 export { decodeFlowDocument, decodeRevisionContent } from '../browser/flow-change-schema.js';
 export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;
 export declare function digestBytes(bytes: Uint8Array): Promise<string>;
 export declare function canonicalPorts(value: readonly (InputPort | Port | Group)[]): JsonValue;
-export declare function canonicalOutputs(value: readonly (OutputMapping & Port)[]): JsonValue;
 export declare function canonicalGraph(value: Graph): JsonValue;
 export declare function canonicalRevisionGraph(content: RevisionContent, graph: Graph): JsonValue;
-export declare function canonicalRevisionOutputs(content: RevisionContent, value: readonly (OutputMapping & Port)[], graph: Graph): JsonValue;
-export declare function canonicalTask(task: FlowDocument['tasks'][string]): JsonValue;
+export declare function canonicalTask(task: ManagedTaskDefinition): JsonValue;
 export declare function triggerRuntimeJson(trigger: TriggerNode): string;
 export declare function canonicalDocument(document: FlowDocument): JsonValue;
 export declare function canonicalModule(module: CodeModule): JsonValue;

package/dist/common/flow-encoding.js

@@ -1,9 +1,9 @@
 //#region src/openapi/common/authBindings.ts
 /** Never allow credentials to enter a Revision as literal node inputs. */
 function assertOpenApiAuthBindings(document) {
-	for (const graph of [document.graph, ...Object.values(document.subflows).map((subflow) => subflow.graph)]) for (const node of Object.values(graph.nodes)) {
-		if (node.kind != "task" || node.taskId == null || document.tasks[node.taskId]?.executor.kind != "openapi") continue;
-		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && (mapping.kind == "value" || mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "flow"))) throw new TypeError("OpenAPI authentication accepts deployment variables and upstream outputs only.");
+	for (const node of Object.values(document.graph.nodes)) {
+		if (node.kind != "task" || !("executor" in node.task) || node.task.executor.kind != "openapi") continue;
+		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("OpenAPI authentication accepts deployment variables and upstream outputs only.");
 	}
 }
 //#endregion
@@ -2813,6 +2813,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);
@@ -5637,6 +5640,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);
@@ -5685,6 +5692,13 @@ function json$1(params) {
 	});
 	return jsonSchema;
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
@@ -8332,7 +8346,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";
 }
@@ -8578,24 +8592,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
@@ -8732,7 +8737,9 @@ var managed = object({
 				inputs: array(input.extend({ source: agentInput }))
 			})),
 			notification: object({
-				taskId: text,
+				action: text,
+				connectionId: text.optional(),
+				inputDefinitions: array(input),
 				messageHandle: text,
 				inputs: record$1(text, agentValue)
 			}).optional()
@@ -8855,21 +8862,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({
@@ -8924,10 +8920,6 @@ var node = union([
 		})
 	})
 ]);
-var target = union([object({ kind: literal("flow") }), object({
-	kind: literal("subflow"),
-	id: text
-})]);
 var edge = object({
 	source: text,
 	target: text,
@@ -8935,13 +8927,8 @@ 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$1(text, node),
 	edges: array(edge).default([])
@@ -8955,17 +8942,16 @@ var module = object({
 	imports: strings,
 	source: text
 });
-var document = object({
+var document = preprocess(rejectRetiredDefinitions, object({
 	bindings: record$1(text, binding),
-	graph,
-	subflows: record$1(text, subflow.extend({ graph })),
-	tasks: record$1(text, managed)
-});
+	graph
+}));
 var revision = object({
 	modelVersion: union([
 		literal(2),
 		literal(4),
-		literal(5)
+		literal(5),
+		literal(6)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -8974,6 +8960,15 @@ var envelope = revision.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 : {};
 }
@@ -9042,26 +9037,9 @@ function upgradeLegacyGraph(value) {
 function upgradeLegacyDocument(value) {
 	const candidate = record(value);
 	const root = upgradeLegacyGraph(candidate.graph);
-	const subflows = Object.fromEntries(Object.entries(record(candidate.subflows)).map(([id, subflowCandidate]) => {
-		const legacySubflow = record(subflowCandidate);
-		const upgraded = upgradeLegacyGraph(legacySubflow.graph);
-		const outputs = Array.isArray(legacySubflow.outputs) ? legacySubflow.outputs.map((outputCandidate) => {
-			const output = record(outputCandidate);
-			return {
-				...output,
-				sources: upgradeLegacySources(output.sources, upgraded.resolutionIds)
-			};
-		}) : legacySubflow.outputs;
-		return [id, {
-			...legacySubflow,
-			graph: upgraded.graph,
-			outputs
-		}];
-	}));
 	return {
 		...candidate,
-		graph: root.graph,
-		subflows
+		graph: root.graph
 	};
 }
 function repairedEntries(value, schema, repair) {
@@ -9121,30 +9099,66 @@ function repairGraph(value, bindings) {
 		edges: Array.isArray(candidate.edges) ? candidate.edges.flatMap((edgeCandidate) => edge.safeParse(edgeCandidate).data ?? []) : []
 	};
 }
+function upgradeTaskNodes(candidateDocument) {
+	const definitions = record(candidateDocument.tasks);
+	const sourceGraph = record(candidateDocument.graph);
+	const nodes = Object.fromEntries(Object.entries(record(sourceGraph.nodes)).map(([id, value]) => {
+		const candidateNode = record(value);
+		if (candidateNode.kind != "task" || !Object.hasOwn(candidateNode, "taskId")) return [id, value];
+		if (typeof candidateNode.taskId != "string" || candidateNode.task !== void 0) throw new TypeError("Invalid legacy Task reference.");
+		const task = record(definitions[candidateNode.taskId]);
+		const executor = record(task.executor);
+		let upgraded = task;
+		if (executor.kind == "agent" && executor.notification != null) {
+			const notice = record(executor.notification);
+			const connector = record(definitions[String(notice.taskId)]);
+			const config = record(connector.executor);
+			if (config.kind != "connector") throw new TypeError("Invalid legacy Agent notification reference.");
+			const { taskId: _, ...rest } = notice;
+			upgraded = {
+				...task,
+				executor: {
+					...executor,
+					notification: {
+						...rest,
+						action: config.action,
+						connectionId: config.connectionId,
+						inputDefinitions: Array.isArray(connector.inputs) ? connector.inputs.filter((candidatePort) => Object.hasOwn(record(candidatePort), "handle")) : connector.inputs
+					}
+				}
+			};
+		}
+		const { taskId: _, ...rest } = candidateNode;
+		return [id, {
+			...rest,
+			task: managed.parse(upgraded)
+		}];
+	}));
+	const { tasks: _, ...rest } = candidateDocument;
+	return {
+		...rest,
+		graph: {
+			...sourceGraph,
+			nodes
+		}
+	};
+}
 /** Best-effort recovery for a parseable Revision envelope. Invalid collection entries are discarded. */
 function repairRevisionEnvelope(value) {
 	checkJsonDepth(value);
 	const envelopeSource = record(value);
 	if (envelopeSource.kind != "open-flow-flow-revision" || envelopeSource.version != 1) throw new TypeError("The value is not an Open Flow Revision envelope.");
-	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 5) throw new TypeError("The Flow model is newer than this package.");
-	const sourceDocument = record(envelopeSource.modelVersion == 1 || envelopeSource.modelVersion == 2 ? upgradeLegacyDocument(envelopeSource.document) : envelopeSource.document);
+	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 6) throw new TypeError("The Flow model is newer than this package.");
+	let sourceDocument = record(envelopeSource.modelVersion == 1 || envelopeSource.modelVersion == 2 ? upgradeLegacyDocument(envelopeSource.document) : envelopeSource.document);
+	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion < 6) sourceDocument = upgradeTaskNodes(sourceDocument);
+	rejectRetiredDefinitions(sourceDocument);
 	const bindings = record(sourceDocument.bindings);
 	const sourceGraph = repairGraph(sourceDocument.graph, bindings);
-	const subflows = Object.fromEntries(Object.entries(record(sourceDocument.subflows)).flatMap(([id, subflowCandidate]) => {
-		const legacySubflow = record(subflowCandidate);
-		const result = subflow.extend({ graph }).safeParse({
-			...legacySubflow,
-			graph: repairGraph(legacySubflow.graph, bindings)
-		});
-		return result.success ? [[id, result.data]] : [];
-	}));
 	return decodeRevisionContent({
-		modelVersion: 5,
+		modelVersion: 6,
 		document: {
 			bindings: repairedEntries(sourceDocument.bindings, binding),
-			graph: sourceGraph,
-			subflows,
-			tasks: repairedEntries(sourceDocument.tasks, managed)
+			graph: sourceGraph
 		},
 		modules: repairedEntries(envelopeSource.modules, module)
 	});
@@ -9156,7 +9170,7 @@ function decodeFlowDocument(value) {
 function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
-	checkErrorModelVersion(content);
+	checkModelVersion(content);
 	assertOpenApiAuthBindings(content.document);
 	return content;
 }
@@ -9168,7 +9182,7 @@ function decodeRevisionEnvelope(value) {
 		document: upgradeLegacyDocument(revisionSource.document)
 	} : value;
 	const content = envelope.parse(candidate);
-	checkErrorModelVersion(content);
+	checkModelVersion(content);
 	assertOpenApiAuthBindings(content.document);
 	return {
 		modelVersion: content.modelVersion,
@@ -9193,12 +9207,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,
@@ -9262,13 +9276,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)
 	},
@@ -9315,58 +9327,19 @@ 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({
 	kind: literal(kind),
 	...shape
 })])).values()])).min(1);
-function checkErrorModelVersion(content) {
-	if (content.modelVersion < 5 && [content.document.graph, ...Object.values(content.document.subflows).map((item) => item.graph)].some((item) => Object.values(item.nodes).some((itemNode) => itemNode.kind == "error"))) throw new TypeError("Error workflows require Flow model version 5.");
+function checkModelVersion(content) {
+	if (content.modelVersion < 6 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task)) throw new TypeError("Node-owned managed Tasks require Flow model version 6.");
+	if (content.modelVersion < 5 && Object.values(content.document.graph.nodes).some((itemNode) => itemNode.kind == "error")) throw new TypeError("Error workflows require Flow model version 5.");
 }
 //#endregion
 //#region src/flow/common/encoding.ts
@@ -9420,15 +9393,6 @@ function canonicalInputMapping(value) {
 function canonicalInputs(value) {
 	return Object.fromEntries(entries(value).map(([handle, mapping]) => [handle, canonicalInputMapping(mapping)]));
 }
-function canonicalOutputs(value) {
-	return value.map((output) => ({
-		...output.description == null ? {} : { description: output.description },
-		handle: output.handle,
-		jsonSchema: output.jsonSchema,
-		nullable: output.nullable,
-		sources: output.sources.map((source) => ({ ...source }))
-	}));
-}
 function canonicalOperand(operand) {
 	return operand.kind === "source" ? {
 		kind: "source",
@@ -9464,18 +9428,13 @@ function canonicalNode(value) {
 			matchMode: value.matchMode,
 			kind: value.kind
 		};
-		case "subflow": return {
-			...common,
-			kind: value.kind,
-			subflowId: value.subflowId
-		};
 		case "task": {
-			const node = value.task != null ? Object.assign({}, common, {
+			const node = "moduleId" in value.task ? Object.assign({}, common, {
 				kind: value.kind,
 				task: canonicalInlineTask(value.task)
 			}) : Object.assign({}, common, {
 				kind: value.kind,
-				taskId: value.taskId
+				task: canonicalTask(value.task)
 			});
 			if (value.additionalInputs != null) node.additionalInputs = canonicalPorts(value.additionalInputs);
 			return node;
@@ -9557,22 +9516,9 @@ function canonicalLegacyGraph(graph) {
 		}))
 	};
 }
-function canonicalLegacyOutputs(value, graph) {
-	const resolutionIds = resolutionNodeIds(graph);
-	return value.map((output) => ({
-		...output.description == null ? {} : { description: output.description },
-		handle: output.handle,
-		jsonSchema: output.jsonSchema,
-		nullable: output.nullable,
-		sources: output.sources.map((source) => canonicalLegacySource(source, resolutionIds))
-	}));
-}
 function canonicalRevisionGraph(content, graph) {
 	return content.modelVersion == 2 ? canonicalLegacyGraph(graph) : canonicalGraph(graph);
 }
-function canonicalRevisionOutputs(content, value, graph) {
-	return content.modelVersion == 2 ? canonicalLegacyOutputs(value, graph) : canonicalOutputs(value);
-}
 function canonicalTask(task) {
 	return {
 		executor: task.executor,
@@ -9682,29 +9628,22 @@ function triggerRuntimeJson(trigger) {
 function canonicalDocument(document) {
 	return {
 		bindings: Object.fromEntries(entries(document.bindings)),
-		graph: canonicalGraph(document.graph),
-		subflows: Object.fromEntries(entries(document.subflows).map(([id, subflow]) => [id, {
-			graph: canonicalGraph(subflow.graph),
-			inputs: canonicalPorts(subflow.inputs),
-			name: subflow.name,
-			outputs: canonicalOutputs(subflow.outputs)
-		}])),
-		tasks: Object.fromEntries(entries(document.tasks).map(([id, task]) => [id, canonicalTask(task)]))
+		graph: canonicalGraph(document.graph)
 	};
 }
 function canonicalRevisionDocument(content) {
-	if (content.modelVersion != 2) return canonicalDocument(content.document);
+	if (content.modelVersion >= 6) return canonicalDocument(content.document);
+	if (content.modelVersion != 2) return {
+		...canonicalDocument(content.document),
+		subflows: {},
+		tasks: {}
+	};
 	const { document } = content;
 	return {
 		bindings: Object.fromEntries(entries(document.bindings)),
 		graph: canonicalLegacyGraph(document.graph),
-		subflows: Object.fromEntries(entries(document.subflows).map(([id, subflow]) => [id, {
-			graph: canonicalLegacyGraph(subflow.graph),
-			inputs: canonicalPorts(subflow.inputs),
-			name: subflow.name,
-			outputs: canonicalLegacyOutputs(subflow.outputs, subflow.graph)
-		}])),
-		tasks: Object.fromEntries(entries(document.tasks).map(([id, task]) => [id, canonicalTask(task)]))
+		subflows: {},
+		tasks: {}
 	};
 }
 function canonicalModule(module) {
@@ -9745,10 +9684,10 @@ function revisionRepairKind(bytes) {
 		return;
 	}
 	const source = value;
-	return typeof source.modelVersion == "number" && source.modelVersion < 5 ? "upgrade" : "repair";
+	return typeof source.modelVersion == "number" && source.modelVersion < 6 ? "upgrade" : "repair";
 }
 function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));
 }
 //#endregion
-export { canonicalDocument, canonicalGraph, canonicalJsonBytes, canonicalModule, canonicalOutputs, canonicalPorts, canonicalRevisionGraph, canonicalRevisionOutputs, canonicalTask, decodeFlowDocument, decodeRevision, decodeRevisionContent, digestBytes, encodeRevision, maxJsonDepth, repairRevision, revisionRepairKind, triggerRuntimeJson };
+export { canonicalDocument, canonicalGraph, canonicalJsonBytes, canonicalModule, canonicalPorts, canonicalRevisionGraph, canonicalTask, decodeFlowDocument, decodeRevision, decodeRevisionContent, digestBytes, encodeRevision, maxJsonDepth, repairRevision, revisionRepairKind, triggerRuntimeJson };

package/dist/common/flow-graph.d.ts

@@ -1,17 +1,17 @@
-import type { FlowDocument, Graph, GraphNode, InputPortDefinition, NodeSource, PortDefinition, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
-import type { Diagnostic, SemanticClosure } from './flow-semantics.js';
+import type { Graph, GraphNode, InputPortDefinition, NodeSource, PortDefinition, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
+import type { Diagnostic } from './flow-semantics.js';
 export declare function isResolutionNode(node: GraphNode | undefined): node is Extract<GraphNode, {
     readonly kind: 'approval' | 'wait';
 }>;
-export declare function nodeInputPorts(document: FlowDocument, node: GraphNode): Readonly<Record<string, InputPortDefinition>>;
+export declare function nodeInputPorts(node: GraphNode): Readonly<Record<string, InputPortDefinition>>;
 export declare function resolutionActions(node: Extract<GraphNode, {
     readonly kind: 'approval' | 'wait';
 }>): readonly ['continue'] | readonly ['approve', 'reject'];
 export declare function resolutionOutputPorts(node: Extract<GraphNode, {
     readonly kind: 'approval' | 'wait';
 }>): Readonly<Record<string, PortDefinition>>;
-export declare function nodeOutputPorts(document: Pick<FlowDocument, 'tasks' | 'subflows'>, node: GraphNode): Readonly<Record<string, PortDefinition>>;
-export declare function nodeOutputDescription(document: FlowDocument, graph: Graph, nodeId: string, output: string): string | undefined;
+export declare function nodeOutputPorts(node: GraphNode): Readonly<Record<string, PortDefinition>>;
+export declare function nodeOutputDescription(graph: Graph, nodeId: string, output: string): string | undefined;
 export declare function graphOrder(graph: Graph): readonly string[];
 export type InputSourceCheck = {
     readonly kind: 'available';
@@ -50,10 +50,10 @@ export interface InputSourcesCheck {
     readonly sources: readonly InputSourceCheck[];
 }
 /** Check one saved binding without enumerating candidate ports. */
-export declare function checkInputSource(document: FlowDocument, graph: Graph, target: string, handle: string, source: Pick<NodeSource, 'nodeId' | 'output' | 'field'>): InputSourceCheck;
-export declare function checkInputSources(document: FlowDocument, graph: Graph, target: string, handle: string, sources: readonly Pick<NodeSource, 'nodeId' | 'output' | 'field'>[]): InputSourcesCheck;
+export declare function checkInputSource(graph: Graph, target: string, handle: string, source: Pick<NodeSource, 'nodeId' | 'output' | 'field'>): InputSourceCheck;
+export declare function checkInputSources(graph: Graph, target: string, handle: string, sources: readonly Pick<NodeSource, 'nodeId' | 'output' | 'field'>[]): InputSourcesCheck;
 /** Enumerate structurally available outputs while retaining their compatibility with one input. */
-export declare function inputSourceCandidates(document: FlowDocument, graph: Graph, target: string, handle: string): Readonly<Record<string, readonly InputSourceCandidate[]>>;
-export declare function availableOutputs(document: FlowDocument, graph: Graph, target: string, handle?: string): Readonly<Record<string, readonly string[]>>;
-export declare function validateFlowGraph(revision: RevisionContent, closure: SemanticClosure): readonly Diagnostic[];
+export declare function inputSourceCandidates(graph: Graph, target: string, handle: string): Readonly<Record<string, readonly InputSourceCandidate[]>>;
+export declare function availableOutputs(graph: Graph, target: string, handle?: string): Readonly<Record<string, readonly string[]>>;
+export declare function validateFlowGraph(revision: RevisionContent): readonly Diagnostic[];
 export {};

package/dist/common/flow-semantics.d.ts

@@ -3,7 +3,7 @@ export { connectionUsage, removeConnectionUsage } from './flow-connectionUsage.j
 export { matchesTriggerOutputs, triggerOutputDefinitions, triggerOutputPorts } from './trigger-contract.js';
 import type { EngineContract } from './engine-contract.js';
 import type { RuntimeProgram } from './runtime-contract.js';
-import type { ConnectorActionCapability, ConnectorCapability, FlowDocument, Graph, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
+import type { ConnectorActionCapability, ConnectorCapability, Graph, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
 export { availableOutputs, graphOrder, nodeInputPorts } from './flow-graph.js';
 export { validateModules } from './flow-modules.js';
 export { matchesSchema, schemaValidationErrors, variableInputCompatible } from './flow-schema.js';
@@ -11,10 +11,8 @@ export { agentInput, agentToolInput, agentToolSchema } from './flow-agent.js';
 export interface SemanticClosure {
     readonly dependencies: {
         readonly bindings: ReadonlySet<string>;
-        readonly inputBindings: ReadonlySet<string>;
+        readonly nodes: ReadonlySet<string>;
         readonly modules: ReadonlySet<string>;
-        readonly subflows: ReadonlySet<string>;
-        readonly tasks: ReadonlySet<string>;
     };
     readonly digest: string;
 }
@@ -45,8 +43,6 @@ export interface PreparedFlow {
     readonly engineContract: string;
     readonly graph: Graph;
     readonly modules: RevisionContent['modules'];
-    readonly subflows: FlowDocument['subflows'];
-    readonly tasks: FlowDocument['tasks'];
 }
 export type PrepareFlowResult = {
     readonly kind: 'engine-unsupported';
@@ -60,6 +56,5 @@ export type PrepareFlowResult = {
 };
 export declare function prepareFlow(revision: RevisionContent, engineContract: string, triggerId?: string): Promise<PrepareFlowResult>;
 export declare function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined;
-export declare function referencedTaskIds(flow: Pick<FlowDocument, 'graph' | 'subflows' | 'tasks'>): ReadonlySet<string>;
-export declare function agentActions(flow: Pick<PreparedFlow, 'tasks'>): readonly ConnectorActionCapability[];
-export declare function codeActions(flow: Pick<PreparedFlow, 'graph' | 'subflows'>): readonly ConnectorCapability[];
+export declare function agentActions(flow: Pick<PreparedFlow, 'graph'>): readonly ConnectorActionCapability[];
+export declare function codeActions(flow: Pick<PreparedFlow, 'graph'>): readonly ConnectorCapability[];