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

package/dist/common/control-requests.js

@@ -265,7 +265,7 @@ function safeExtend(schema, shape) {
 	if (!isPlainObject$1(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
 	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
 }
-function merge(a, b) {
+function merge$1(a, b) {
 	if (!b?._zod?.def) throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
 	if (a._zod.def.checks?.length) throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
 	const newShape = {};
@@ -2780,6 +2780,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);
@@ -5503,7 +5506,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		return safeExtend(this, incoming);
 	},
 	merge(other) {
-		return merge(this, other);
+		return merge$1(this, other);
 	},
 	pick(mask) {
 		return pick$1(this, mask);
@@ -5581,7 +5584,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function record$3(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string(),
@@ -5790,6 +5793,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);
@@ -5825,7 +5832,7 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
-function json$3(params) {
+function json$5(params) {
 	const jsonSchema = lazy(() => {
 		return union([
 			string(params),
@@ -5833,23 +5840,17 @@ function json$3(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record(string(), jsonSchema)
+			record$3(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
 }
-//#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();
-//#endregion
-//#region src/flow/common/inputValue.ts
-/** Converts explicit user values at authoring boundaries, never persisted legacy data. */
-function inputValues(values) {
-	return Object.fromEntries(Object.entries(values).map(([name, value]) => [name, {
-		kind: "value",
-		value
-	}]));
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
 }
 //#endregion
 //#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
@@ -5900,9 +5901,9 @@ function deepCompareStrict(a, b) {
 //#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/pointer.js
 function encodePointer(p) {
-	return encodeURI(escapePointer(p));
+	return encodeURI(escapePointer$1(p));
 }
-function escapePointer(p) {
+function escapePointer$1(p) {
 	return p.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 //#endregion
@@ -6756,6 +6757,660 @@ var Validator = class {
 	}
 };
 //#endregion
+//#region src/openapi/common/authBindings.ts
+/** Never allow credentials to enter a Revision as literal node inputs. */
+function assertOpenApiAuthBindings(document) {
+	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
+//#region src/flow/common/inputValue.ts
+/** Converts explicit user values at authoring boundaries, never persisted legacy data. */
+function inputValues(values) {
+	return Object.fromEntries(Object.entries(values).map(([name, value]) => [name, {
+		kind: "value",
+		value
+	}]));
+}
+//#endregion
+//#region src/flow/common/condition.ts
+var unaryOperator = (operator) => operator.startsWith("is");
+var operandHandle = (caseIndex, groupIndex, expressionIndex, side) => `${caseIndex}/${groupIndex}/${expressionIndex}/${side}`;
+/** Derived addresses let operand bindings use the ordinary input analysis and editor. Never persisted as node inputs. */
+function conditionOperands(node) {
+	return node.cases.flatMap((item, c) => item.groups.flatMap((group, g) => group.expressions.flatMap((expression, e) => [{
+		handle: operandHandle(c, g, e, "left"),
+		operand: expression.left,
+		expression,
+		side: "left"
+	}, ...!unaryOperator(expression.operator) ? [{
+		handle: operandHandle(c, g, e, "right"),
+		operand: expression.right ?? { kind: "value" },
+		expression,
+		side: "right"
+	}] : []])));
+}
+function nodeInputMappings(node) {
+	if (node.kind != "condition") return "inputs" in node ? node.inputs : {};
+	return Object.fromEntries(conditionOperands(node).flatMap(({ handle, operand }) => operand.kind == "source" ? [[handle, {
+		kind: "sources",
+		sources: [operand.source]
+	}]] : operand.value === void 0 ? [] : [[handle, {
+		kind: "value",
+		value: operand.value
+	}]]));
+}
+function conditionInputPorts(node) {
+	return Object.fromEntries(conditionOperands(node).map(({ handle, operand }) => [handle, {
+		jsonSchema: operand.kind === "value" ? operand.jsonSchema ?? {} : {},
+		nullable: operand.kind === "value" ? operand.value === null : true
+	}]));
+}
+function setConditionInput(node, handle, mapping) {
+	const entry = conditionOperands(node).find((item) => item.handle == handle);
+	if (entry == null) throw new Error("Condition operand does not exist.");
+	if (mapping?.kind == "sources" && mapping.sources.length != 1) throw new Error("A Condition operand requires one Source.");
+	const value = mapping?.kind == "sources" ? {
+		kind: "source",
+		source: mapping.sources[0]
+	} : {
+		kind: "value",
+		...entry.operand.kind === "value" && entry.operand.jsonSchema != null ? { jsonSchema: entry.operand.jsonSchema } : {},
+		...mapping?.kind == "value" ? { value: mapping.value } : {}
+	};
+	const [c, g, e] = handle.split("/").map(Number);
+	return {
+		...node,
+		cases: node.cases.map((item, ci) => ci != c ? item : {
+			...item,
+			groups: item.groups.map((group, gi) => gi != g ? group : {
+				...group,
+				expressions: group.expressions.map((expression, ei) => ei != e ? expression : {
+					...expression,
+					[entry.side]: value
+				})
+			})
+		})
+	};
+}
+function resourceNameIssue(value) {
+	const name = value.trim();
+	if (name.length == 0) return "empty";
+	if (name.length > 80) return "tooLong";
+	for (const character of name) {
+		const code = character.charCodeAt(0);
+		if (code <= 31 || code >= 127 && code <= 159) return "controlCharacter";
+	}
+	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(name)) return "specialCharacter";
+}
+function portsByHandle(ports) {
+	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
+}
+function decodeConnectorCapabilities(value) {
+	if (!Array.isArray(value)) throw new TypeError("Connector capabilities must be an array.");
+	if (value.length == 0) return [];
+	if (value.some((item) => item != null && typeof item == "object" && !Array.isArray(item) && Object.hasOwn(item, "mode"))) {
+		if (value.length != 1) throw new TypeError("Connector capability is declared more than once.");
+		const source = value[0];
+		if (source.mode == "shared") {
+			if (source.kind != "connector" || Object.keys(source).some((key) => !["kind", "mode"].includes(key))) throw new TypeError("Invalid shared Connector permission capability.");
+			return [{
+				kind: "connector",
+				mode: "shared"
+			}];
+		}
+		if (Object.keys(source).some((key) => ![
+			"kind",
+			"mode",
+			"actions"
+		].includes(key)) || source.kind != "connector" || source.mode != "independent" || !Array.isArray(source.actions)) throw new TypeError("Invalid Connector permission capability.");
+		const actions = source.actions.map((entry) => {
+			if (entry == null || typeof entry != "object" || Array.isArray(entry)) throw new TypeError("Invalid Connector Action.");
+			const action = entry;
+			if (Object.keys(action).some((key) => !["action", "connectionId"].includes(key)) || typeof action.action != "string" || !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(action.action) || Object.hasOwn(action, "connectionId") && (typeof action.connectionId != "string" || action.connectionId.length == 0)) throw new TypeError("Invalid Connector Action permission.");
+			return action.connectionId == null ? { action: action.action } : {
+				action: action.action,
+				connectionId: action.connectionId
+			};
+		});
+		if (new Set(actions.map((action) => action.action)).size != actions.length) throw new TypeError("Duplicate Connector Action permission.");
+		return [{
+			kind: "connector",
+			mode: "independent",
+			actions
+		}];
+	}
+	if (value.some((item) => item != null && typeof item == "object" && !Array.isArray(item) && !Object.hasOwn(item, "action"))) {
+		if (value.length != 1) throw new TypeError("Connector capability is declared more than once.");
+		const item = value[0];
+		if (item == null || typeof item != "object" || Array.isArray(item)) throw new TypeError("Invalid Connector capability.");
+		const source = item;
+		if (Object.keys(source).some((key) => ![
+			"kind",
+			"actionHints",
+			"connectionHints"
+		].includes(key)) || source.kind != "connector" || Object.hasOwn(source, "actionHints") && !Array.isArray(source.actionHints) || Object.hasOwn(source, "connectionHints") && !Array.isArray(source.connectionHints)) throw new TypeError("Invalid Connector capability.");
+		const actionHints = (source.actionHints ?? []).map((action) => {
+			if (typeof action != "string" || !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(action)) throw new TypeError("Invalid Connector Action hint.");
+			return action;
+		});
+		if (new Set(actionHints).size != actionHints.length) throw new TypeError("Duplicate Connector Action hint.");
+		const keys = /* @__PURE__ */ new Set();
+		const connectionHints = (source.connectionHints ?? []).map((entry) => {
+			if (entry == null || typeof entry != "object" || Array.isArray(entry)) throw new TypeError("Invalid Connector Connection hint.");
+			const hint = entry;
+			if (Object.keys(hint).some((key) => ![
+				"action",
+				"connectionId",
+				"alias"
+			].includes(key)) || typeof hint.action != "string" || !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(hint.action) || typeof hint.connectionId != "string" || hint.connectionId.length == 0 || Object.hasOwn(hint, "alias") && (typeof hint.alias != "string" || hint.alias.length == 0)) throw new TypeError("Invalid Connector Connection hint.");
+			const key = `${hint.action}\0${hint.alias ?? ""}`;
+			if (keys.has(key)) throw new TypeError("Duplicate Connector Connection hint.");
+			keys.add(key);
+			return hint.alias == null ? {
+				action: hint.action,
+				connectionId: hint.connectionId
+			} : {
+				action: hint.action,
+				connectionId: hint.connectionId,
+				alias: hint.alias
+			};
+		});
+		return [{
+			kind: "connector",
+			...actionHints.length == 0 ? {} : { actionHints },
+			...connectionHints.length == 0 ? {} : { connectionHints }
+		}];
+	}
+	const actions = /* @__PURE__ */ new Set();
+	return value.map((item) => {
+		if (item == null || typeof item != "object" || Array.isArray(item)) throw new TypeError("Invalid Connector capability.");
+		const source = item;
+		if (Object.keys(source).some((key) => ![
+			"kind",
+			"action",
+			"connections",
+			"connectionId"
+		].includes(key)) || source.kind != "connector" || typeof source.action != "string" || !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(source.action) || !Array.isArray(source.connections)) throw new TypeError("Invalid Connector capability.");
+		if (actions.has(source.action)) throw new TypeError("Connector Action is declared more than once.");
+		actions.add(source.action);
+		const ids = /* @__PURE__ */ new Set();
+		const aliases = /* @__PURE__ */ new Set();
+		const connections = source.connections.map((entry) => {
+			if (entry == null || typeof entry != "object" || Array.isArray(entry)) throw new TypeError("Invalid Connector Connection.");
+			const connection = entry;
+			if (Object.keys(connection).some((key) => !["connectionId", "alias"].includes(key)) || typeof connection.connectionId != "string" || connection.connectionId.length == 0 || ids.has(connection.connectionId)) throw new TypeError("Invalid or duplicate Connector Connection ID.");
+			ids.add(connection.connectionId);
+			if (Object.hasOwn(connection, "alias")) {
+				if (typeof connection.alias != "string" || connection.alias.length == 0 || aliases.has(connection.alias)) throw new TypeError("Invalid or duplicate Connector alias.");
+				aliases.add(connection.alias);
+			}
+			return {
+				connectionId: connection.connectionId,
+				...connection.alias == null ? {} : { alias: connection.alias }
+			};
+		});
+		if (Object.hasOwn(source, "connectionId") && (typeof source.connectionId != "string" || !ids.has(source.connectionId))) throw new TypeError("The default Connector Connection must be declared.");
+		return {
+			kind: "connector",
+			action: source.action,
+			connections,
+			...source.connectionId == null ? {} : { connectionId: source.connectionId }
+		};
+	});
+}
+function normalizeNodeName(value) {
+	return value.trim().normalize("NFC");
+}
+function nodeNameIssue(graph, nodeId, value) {
+	const name = normalizeNodeName(value);
+	if (name.length == 0) return "empty";
+	return Object.entries(graph.nodes).some(([candidateId, node]) => candidateId != nodeId && node.name != null && normalizeNodeName(node.name) == name) ? "duplicate" : void 0;
+}
+var FlowChangeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FlowChangeError";
+	}
+};
+function invalid(message) {
+	throw new FlowChangeError(message);
+}
+function applyFlowChanges(content, operations) {
+	const document = { ...content.document };
+	const modules = { ...content.modules };
+	for (const operation of operations) switch (operation.kind) {
+		case "graph.trigger.sources.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "error") invalid("The Flow Error node does not exist.");
+			if (!dequal(node.sourceFlowIds, operation.before)) invalid("The Flow Error node’s sources changed before this operation was applied.");
+			const { sourceFlowIds: _, ...base } = node;
+			const updated = operation.value == null ? base : {
+				...base,
+				sourceFlowIds: operation.value
+			};
+			document.graph = {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			};
+			break;
+		}
+		case "binding.create":
+			if (document.bindings[operation.bindingId] != null) invalid("A Binding with this ID already exists.");
+			document.bindings = {
+				...document.bindings,
+				[operation.bindingId]: operation.binding
+			};
+			break;
+		case "binding.delete": {
+			if (document.bindings[operation.bindingId] == null) invalid("The Binding does not exist.");
+			const bindings = { ...document.bindings };
+			delete bindings[operation.bindingId];
+			document.bindings = bindings;
+			break;
+		}
+		case "binding.target.set": {
+			const binding = document.bindings[operation.bindingId];
+			if (binding == null) invalid("The Binding does not exist.");
+			if (binding.target != operation.before) invalid("The Binding target changed before this operation was applied.");
+			document.bindings = {
+				...document.bindings,
+				[operation.bindingId]: {
+					...binding,
+					target: operation.value
+				}
+			};
+			break;
+		}
+		case "graph.edge.connect": {
+			const graph = document.graph;
+			if (graph.nodes[operation.edge.source] == null) invalid("The source Node does not exist.");
+			const node = graph.nodes[operation.edge.target];
+			if (node == null || !("inputs" in node)) invalid("The target Node does not accept execution dependencies.");
+			if (graph.edges.some((edge) => dequal(edge, operation.edge))) invalid("The Nodes are already connected.");
+			Object.assign(document, { graph: {
+				...graph,
+				edges: [...graph.edges, operation.edge]
+			} });
+			break;
+		}
+		case "graph.edge.disconnect": {
+			const graph = document.graph;
+			const edges = graph.edges.filter((edge) => !dequal(edge, operation.edge));
+			if (edges.length == graph.edges.length) invalid("The Nodes are not connected.");
+			Object.assign(document, { graph: {
+				...graph,
+				edges
+			} });
+			break;
+		}
+		case "graph.node.additional-inputs.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "task") invalid("The Task Node does not exist.");
+			if (!dequal(node.additionalInputs, operation.before)) invalid("The Task Node inputs changed before this operation was applied.");
+			const { additionalInputs: _, ...rest } = node;
+			const updated = operation.value == null ? rest : {
+				...rest,
+				additionalInputs: operation.value
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.node.condition.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "condition") invalid("The Condition Node does not exist.");
+			if (!dequal(node.cases, operation.before.cases) || node.matchMode != operation.before.matchMode) invalid("The Condition Node changed before this operation was applied.");
+			const updated = {
+				...node,
+				...operation.value
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.node.replace": {
+			const graph = document.graph;
+			if (!dequal(graph.nodes[operation.nodeId], operation.before)) invalid("The Node changed before this operation was applied.");
+			if (operation.node.kind != operation.before.kind) invalid("Replacing a Node cannot change its kind.");
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			const name = normalizeNodeName(operation.node.name ?? "");
+			const issue = nodeNameIssue(graph, operation.nodeId, name);
+			if (issue != null) invalid(`Node name is ${issue}.`);
+			const node = name == operation.node.name ? operation.node : {
+				...operation.node,
+				name
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: node
+				}
+			} });
+			break;
+		}
+		case "graph.node.create": {
+			const graph = document.graph;
+			if (graph.nodes[operation.nodeId] != null) invalid("A Node with this ID already exists in the target graph.");
+			if (operation.node.kind == "error" && Object.values(graph.nodes).some((node) => node.kind == "error")) invalid("A graph can contain only one Flow Error node.");
+			if (operation.node.kind == "manual" && Object.values(graph.nodes).some((node) => node.kind == "manual")) invalid("A graph can contain only one manual Trigger.");
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			if (operation.node.name == null) invalid("A Node name cannot be empty.");
+			const name = normalizeNodeName(operation.node.name);
+			const issue = nodeNameIssue(graph, operation.nodeId, name);
+			if (issue == "empty") invalid("A Node name cannot be empty.");
+			if (issue == "duplicate") invalid("A Node with this name already exists in the target graph.");
+			const node = name == operation.node.name ? operation.node : {
+				...operation.node,
+				name
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: node
+				}
+			} });
+			break;
+		}
+		case "graph.node.delete": {
+			const graph = document.graph;
+			if (graph.nodes[operation.nodeId] == null) invalid("The Node does not exist in the target graph.");
+			const removed = /* @__PURE__ */ new Set([operation.nodeId]);
+			const nodes = Object.fromEntries(Object.entries(graph.nodes).filter(([nodeId]) => !removed.has(nodeId)));
+			Object.assign(document, { graph: {
+				...graph,
+				edges: graph.edges.filter((edge) => !removed.has(edge.source) && !removed.has(edge.target)),
+				nodes
+			} });
+			break;
+		}
+		case "graph.node.field.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node == null) invalid("The Node does not exist in the target graph.");
+			if (operation.field == "connectionId" && node.kind != "poll" && node.kind != "integration") invalid("Only provider Triggers select a node Connection.");
+			if (!dequal(Reflect.get(node, operation.field), operation.before)) invalid("The Node field changed before this operation was applied.");
+			const updated = { ...node };
+			if (operation.field == "name") {
+				if (typeof operation.value != "string") invalid("A Node name cannot be empty.");
+				const name = normalizeNodeName(operation.value);
+				const issue = nodeNameIssue(graph, operation.nodeId, name);
+				if (issue == "empty") invalid("A Node name cannot be empty.");
+				if (issue == "duplicate") invalid("A Node with this name already exists in the target graph.");
+				Object.assign(updated, { name });
+			} else if (operation.value == null) Reflect.deleteProperty(updated, operation.field);
+			else Object.assign(updated, { [operation.field]: operation.value });
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.node.input.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node == null || !("inputs" in node)) invalid("The Node does not accept inputs.");
+			if (!dequal(nodeInputMappings(node)[operation.handle], operation.before)) invalid("The Node input changed before this operation was applied.");
+			const inputs = { ...node.inputs };
+			if (operation.value == null) delete inputs[operation.handle];
+			else inputs[operation.handle] = operation.value;
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: node.kind == "condition" ? setConditionInput(node, operation.handle, operation.value) : {
+						...node,
+						inputs
+					}
+				}
+			} });
+			break;
+		}
+		case "graph.node.task.capabilities.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "task" || !("moduleId" in node.task)) invalid("The inline Task Node does not exist.");
+			if (!dequal(node.task.capabilities, operation.before)) invalid("The inline Task capabilities changed before this operation was applied.");
+			const task = { ...node.task };
+			if (operation.value === void 0) delete task.capabilities;
+			else task.capabilities = decodeConnectorCapabilities(operation.value);
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: {
+						...node,
+						task
+					}
+				}
+			} });
+			break;
+		}
+		case "graph.node.task.name.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "task" || !("moduleId" in node.task)) invalid("The inline Task Node does not exist.");
+			if (node.task.name != operation.before) invalid("The inline Task name changed before this operation was applied.");
+			const updated = {
+				...node,
+				task: {
+					...node.task,
+					name: operation.value
+				}
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.node.task.ports.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "task" || !("moduleId" in node.task)) invalid("The inline Task Node does not exist.");
+			if (!dequal({
+				inputs: node.task.inputs,
+				outputs: node.task.outputs
+			}, operation.before)) invalid("The inline Task ports changed before this operation was applied.");
+			const updated = {
+				...node,
+				task: {
+					...node.task,
+					inputs: operation.value.inputs,
+					outputs: operation.value.outputs
+				}
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.node.values.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "value") invalid("The Value Node does not exist.");
+			if (!dequal(node.values, operation.before)) invalid("The Value Node changed before this operation was applied.");
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: {
+						...node,
+						values: operation.value
+					}
+				}
+			} });
+			break;
+		}
+		case "graph.node.resolution.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "wait" && node?.kind != "approval" || !dequal({
+				inputDefinitions: node.inputDefinitions,
+				prompt: node.prompt
+			}, operation.before)) invalid("The resolution node changed before this operation was applied.");
+			const updated = {
+				...node,
+				...operation.value
+			};
+			document.graph = {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			};
+			break;
+		}
+		case "graph.node.webhook.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "webhook") invalid("The Webhook Node does not exist.");
+			if (node.method != operation.before.method || !dequal(node.bodyFields, operation.before.bodyFields) || !dequal(node.options, operation.before.options)) invalid("The Webhook Node changed before this operation was applied.");
+			const { options: _, ...rest } = node;
+			const updated = operation.value.options == null ? {
+				...rest,
+				bodyFields: operation.value.bodyFields,
+				method: operation.value.method
+			} : {
+				...node,
+				...operation.value
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			} });
+			break;
+		}
+		case "graph.trigger.config.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node == null || node.kind != "integration" && node.kind != "poll") invalid("The configurable Trigger Node does not exist.");
+			if (!dequal(node.config[operation.name], operation.before)) invalid("The Trigger configuration changed before this operation was applied.");
+			const config = { ...node.config };
+			if (operation.value === void 0) delete config[operation.name];
+			else config[operation.name] = operation.value;
+			document.graph = {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: {
+						...node,
+						config
+					}
+				}
+			};
+			break;
+		}
+		case "graph.trigger.schedule.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node == null || node.kind != "cron" && node.kind != "poll") invalid("The scheduled Trigger Node does not exist.");
+			if (!dequal(node.kind == "cron" ? node.cronTimes : node.pollTimes, operation.before)) invalid("The Trigger schedule changed before this operation was applied.");
+			const updated = node.kind == "cron" ? {
+				...node,
+				cronTimes: operation.value
+			} : {
+				...node,
+				pollTimes: operation.value
+			};
+			document.graph = {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: updated
+				}
+			};
+			break;
+		}
+		case "module.create":
+			if (modules[operation.moduleId] != null) invalid("A CodeModule with this ID already exists.");
+			modules[operation.moduleId] = operation.module;
+			break;
+		case "module.delete":
+			if (modules[operation.moduleId] == null) invalid("The CodeModule does not exist.");
+			delete modules[operation.moduleId];
+			break;
+		case "module.rename": {
+			const module = modules[operation.moduleId];
+			if (module == null) invalid("The CodeModule does not exist.");
+			if (module.name != operation.before) invalid("The CodeModule name changed before this operation was applied.");
+			modules[operation.moduleId] = {
+				...module,
+				name: operation.name
+			};
+			break;
+		}
+		case "module.source.replace": {
+			const module = modules[operation.moduleId];
+			if (module == null) invalid("The CodeModule does not exist.");
+			if (module.source != operation.beforeSource || !dequal(module.imports, operation.beforeImports)) invalid("The CodeModule source changed before this operation was applied.");
+			modules[operation.moduleId] = {
+				...module,
+				imports: operation.imports,
+				source: operation.source
+			};
+			break;
+		}
+		case "graph.node.task.set": {
+			const graph = document.graph;
+			const node = graph.nodes[operation.nodeId];
+			if (node?.kind != "task") invalid("The Task Node does not exist.");
+			if (!dequal(node.task, operation.before)) invalid("The Task configuration changed before this operation was applied.");
+			document.graph = {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: {
+						...node,
+						task: operation.value
+					}
+				}
+			};
+			break;
+		}
+	}
+	assertOpenApiAuthBindings(document);
+	return {
+		document,
+		modelVersion: 6,
+		modules
+	};
+}
+//#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
 function createId() {
@@ -7175,7 +7830,7 @@ var ExpressionKind = Object.freeze({
 });
 //#endregion
 //#region src/json-schema-subset/expression/expression.ts
-var expression = (delegate) => (e1, e2) => {
+var expression$1 = (delegate) => (e1, e2) => {
 	const rootNode = {
 		parent: null,
 		swapped: false,
@@ -9163,7 +9818,7 @@ function checkWithResult(extendsContext, schema1, schema2) {
 	const describe = describer();
 	const equals = schemaEqualsChecker(extendsContext);
 	context.isEquals = wrapEqualsCheckerWithCache(isDeepEquals);
-	context.calculate = expression({
+	context.calculate = expression$1({
 		describe,
 		equals,
 		calculate,
@@ -9402,7 +10057,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";
 }
@@ -9691,47 +10346,41 @@ var webhookMethods = [
 	"PATCH",
 	"DELETE"
 ];
+function webhookSupportsBody(method) {
+	return method !== "GET";
+}
 var text$1 = string();
-var json$2 = json$3();
+var json$4 = json$5();
 var strings = array(text$1);
 var port = object$1({
 	description: text$1.optional(),
-	jsonSchema: json$2,
+	jsonSchema: json$4,
 	nullable: boolean(),
 	handle: text$1
 });
-var input = port.extend({ value: json$2.optional() });
+var input = port.extend({ value: json$4.optional() });
 var group = object$1({
 	collapsed: boolean().optional(),
 	group: text$1
 });
-var nodeSource = object$1({
+var source = union([object$1({
 	kind: literal("node"),
 	nodeId: text$1,
 	output: text$1,
 	field: text$1.optional()
-});
-var flowSource = object$1({
-	kind: literal("flow"),
-	input: text$1
-});
-var source = union([
-	nodeSource,
-	flowSource,
-	object$1({
-		kind: literal("binding"),
-		bindingId: text$1
-	})
-]);
+}), object$1({
+	kind: literal("binding"),
+	bindingId: text$1
+})]);
 var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
 	kind: literal("value"),
-	value: json$2
+	value: json$4
 })]);
 var mapping = union([fixedInput, object$1({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
-var inputs$1 = record(text$1, mapping);
+var inputs$1 = record$3(text$1, mapping);
 var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
@@ -9776,7 +10425,7 @@ var inline = object$1({
 });
 var agentValue = union([object$1({
 	kind: literal("value"),
-	value: json$2
+	value: json$4
 }), object$1({
 	kind: literal("input"),
 	input: text$1
@@ -9808,7 +10457,7 @@ var decisionQuestion = discriminatedUnion("type", [
 		criteria: strings
 	})
 ]);
-var managed = object$1({
+var managedFields = object$1({
 	...ports,
 	name: text$1,
 	executor: union([
@@ -9823,7 +10472,7 @@ var managed = object$1({
 			method: text$1,
 			path: text$1,
 			serverUrl: text$1,
-			document: json$2,
+			document: json$4,
 			auth: array(object$1({
 				id: text$1,
 				type: _enum([
@@ -9859,17 +10508,20 @@ var managed = object$1({
 				inputs: array(input.extend({ source: agentInput }))
 			})),
 			notification: object$1({
-				taskId: text$1,
+				action: text$1,
+				connectionId: text$1.optional(),
+				inputDefinitions: array(input),
 				messageHandle: text$1,
-				inputs: record(text$1, agentValue)
+				inputs: record$3(text$1, agentValue)
 			}).optional()
 		})
 	])
-}).transform(limitDecisionTask);
-var operand = union([object$1({
+});
+var managed = managedFields.transform(limitDecisionTask);
+var operand$1 = union([object$1({
 	kind: literal("value"),
-	value: json$2.optional(),
-	jsonSchema: json$2.optional()
+	value: json$4.optional(),
+	jsonSchema: json$4.optional()
 }), object$1({
 	kind: literal("source"),
 	source
@@ -9880,7 +10532,7 @@ var condition = {
 		description: text$1.optional(),
 		output: text$1,
 		groups: array(object$1({ expressions: array(object$1({
-			left: operand,
+			left: operand$1,
 			operator: _enum([
 				"!=",
 				"<",
@@ -9903,7 +10555,7 @@ var condition = {
 				"notHasValue",
 				"startsWith"
 			]),
-			right: operand.optional()
+			right: operand$1.optional()
 		})) }))
 	}))
 };
@@ -9916,7 +10568,7 @@ var webhookOptions = object$1({
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
 	responseData: text$1.optional(),
-	responseHeaders: record(text$1, text$1).optional(),
+	responseHeaders: record$3(text$1, text$1).optional(),
 	responseStatusCode: number().int().min(200).max(599).optional()
 });
 var webhook = {
@@ -9972,7 +10624,7 @@ var base = {
 var node = union([
 	object$1({
 		...base,
-		inputs: record(text$1, never()),
+		inputs: record$3(text$1, never()),
 		kind: literal("condition"),
 		...condition
 	}),
@@ -9982,21 +10634,10 @@ var node = union([
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object$1({
-		...base,
-		kind: literal("subflow"),
-		subflowId: text$1
-	}),
-	object$1({
-		...base,
-		kind: literal("task"),
-		task: inline,
-		additionalInputs: array(input).optional()
-	}),
 	object$1({
 		...base,
 		kind: literal("task"),
-		taskId: text$1,
+		task: union([inline, managed]),
 		additionalInputs: array(input).optional()
 	}),
 	strictObject({
@@ -10032,7 +10673,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("poll"),
 		connectionId: text$1.min(1).optional(),
-		config: record(text$1, fixedInput),
+		config: record$3(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("poll")
@@ -10043,7 +10684,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("integration"),
 		connectionId: text$1.min(1).optional(),
-		config: record(text$1, fixedInput),
+		config: record$3(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("integration"),
@@ -10051,10 +10692,25 @@ var node = union([
 		})
 	})
 ]);
-var target$1 = union([object$1({ kind: literal("flow") }), object$1({
-	kind: literal("subflow"),
-	id: text$1
-})]);
+/** Configuration schemas shared by the node authoring boundary. */
+var authoringDefinitionSchemas = {
+	input,
+	port,
+	ports,
+	condition: strictObject(condition),
+	wait: strictObject(wait),
+	webhook: strictObject(webhook),
+	schedule: triggerScheduleSchema,
+	capabilities: array(capability),
+	connector: managedFields.shape.executor.options[0].omit({ kind: true }).strict(),
+	openapi: managedFields.shape.executor.options[1].omit({ kind: true }).strict(),
+	decision: managedFields.shape.executor.options[2].omit({ kind: true }).strict(),
+	llm: managedFields.shape.executor.options[3].omit({ kind: true }).strict(),
+	agent: managedFields.shape.executor.options[4].omit({
+		kind: true,
+		notification: true
+	}).strict()
+};
 var edge = object$1({
 	source: text$1,
 	target: text$1,
@@ -10062,15 +10718,10 @@ var edge = object$1({
 });
 var at = {
 	nodeId: text$1,
-	target: target$1
+	target: never().optional()
 };
-var subflow = object$1({
-	name: text$1,
-	inputs: array(input),
-	outputs: array(port.extend({ sources: array(union([nodeSource, flowSource])) }))
-});
 var graph = object$1({
-	nodes: record(text$1, node),
+	nodes: record$3(text$1, node),
 	edges: array(edge).default([])
 });
 var binding = object$1({
@@ -10082,24 +10733,35 @@ var module = object$1({
 	imports: strings,
 	source: text$1
 });
-var document = object$1({
-	bindings: record(text$1, binding),
-	graph,
-	subflows: record(text$1, subflow.extend({ graph })),
-	tasks: record(text$1, managed)
-});
+var document = preprocess(rejectRetiredDefinitions, object$1({
+	bindings: record$3(text$1, binding),
+	graph
+}));
 object$1({
 	modelVersion: union([
 		literal(2),
 		literal(4),
-		literal(5)
+		literal(5),
+		literal(6)
 	]),
 	document,
-	modules: record(text$1, module)
+	modules: record$3(text$1, module)
 }).extend({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
+function rejectRetiredDefinitions(value) {
+	const candidate = record$2(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$2(record$2(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record$2(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$2(record$2(candidate.graph).nodes)).some((candidateNode) => record$2(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	return value;
+}
+function record$2(value) {
+	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+}
 var shapes = {
 	"graph.trigger.sources.set": {
 		nodeId: text$1,
@@ -10117,17 +10779,22 @@ var shapes = {
 		value: text$1
 	},
 	"graph.edge.connect": {
-		target: target$1,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.edge.disconnect": {
-		target: target$1,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.node.create": {
 		...at,
 		node
 	},
+	"graph.node.replace": {
+		...at,
+		before: node,
+		node
+	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
 		object$1({
@@ -10186,13 +10853,11 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object$1({ kind: literal("flow") }),
 		before: object$1(wait),
 		value: object$1(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object$1({ kind: literal("flow") }),
 		before: object$1(webhook),
 		value: object$1(webhook)
 	},
@@ -10239,50 +10904,10 @@ var shapes = {
 		imports: strings,
 		source: text$1
 	},
-	"subflow.create": {
-		subflowId: text$1,
-		subflow: subflow.extend({ graph })
-	},
-	"subflow.definition.set": {
-		subflowId: text$1,
-		before: subflow,
-		definition: subflow
-	},
-	"subflow.delete": { subflowId: text$1 },
-	"task.create": {
-		taskId: text$1,
-		task: managed
-	},
-	"task.delete": { taskId: text$1 },
-	"task.connector.connection.set": {
-		taskId: text$1,
-		before: text$1.optional(),
-		value: text$1.optional()
-	},
-	"task.decision.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.openapi.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.agent.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.llm.mode.set": {
-		taskId: text$1,
-		before: _enum(["chat", "json"]),
-		value: _enum(["chat", "json"])
-	},
-	"task.name.set": {
-		taskId: text$1,
-		before: text$1,
-		value: text$1
+	"graph.node.task.set": {
+		...at,
+		before: union([inline, managed]),
+		value: union([inline, managed])
 	}
 };
 var variants = new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
@@ -10304,20 +10929,89 @@ function decodeChangeOperation(candidate, index) {
 	if (schema == null) throw new TypeError(`operations[${index}]: Unknown operation ${JSON.stringify(kind)}.`);
 	return parseOperation(candidate, index, schema.parse);
 }
+function decodeChangeOperations(value) {
+	checkJsonDepth(value);
+	return array(unknown()).min(1).parse(value).map(decodeChangeOperation);
+}
 function changeOperationsSchema(kind) {
 	const schema = kind == null ? operations : variants.get(kind);
 	if (schema == null) throw new TypeError(`Unknown operation ${JSON.stringify(kind)}.`);
 	return toJSONSchema(schema, { io: "input" });
 }
-function resourceNameIssue(value) {
-	const name = value.trim();
-	if (name.length == 0) return "empty";
-	if (name.length > 80) return "tooLong";
-	for (const character of name) {
-		const code = character.charCodeAt(0);
-		if (code <= 31 || code >= 127 && code <= 159) return "controlCharacter";
+//#endregion
+//#region src/control/common/authoringLlm.ts
+var authoringLlmConfiguration = strictObject({
+	mode: _enum(["chat", "json"]),
+	resultSchema: json$5(),
+	model: json$5().optional().describe("Default model settings: {model, temperature?, top_p?, max_tokens?}. A bound model input takes precedence."),
+	template: json$5().optional().describe("Default message templates: [{role: \"system\" | \"user\" | \"assistant\", content: \"Text with {{namedInput}}\"}]."),
+	messages: json$5().optional().describe("Default conversation history, prepended without template interpolation; an array of {role, content} or null.")
+});
+var defaults = {
+	model: "model",
+	template: "template",
+	messages: "messages"
+};
+/** Read defaults only. Node bindings remain independently visible and editable. */
+function llmConfigurationView(task) {
+	if (task.executor.kind != "llm") throw new TypeError("Expected an LLM task.");
+	const config = {
+		mode: task.executor.mode,
+		resultSchema: task.outputs.find((port) => "handle" in port)?.jsonSchema ?? {}
+	};
+	for (const [name, handle] of Object.entries(defaults)) {
+		const port = task.inputs.find((candidate) => "handle" in candidate && candidate.handle == handle);
+		if (port != null && Object.hasOwn(port, "value")) config[name] = port.value;
 	}
-	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(name)) return "specialCharacter";
+	return config;
+}
+/** Update default values without altering port contracts, groups, or node bindings. */
+function prepareLlmConfiguration(config, previous, name) {
+	if (previous.executor.kind != "llm") throw new TypeError("Expected an LLM task.");
+	const old = llmConfigurationView(previous);
+	const changed = Object.keys(defaults).filter((key) => Object.hasOwn(old, key) != Object.hasOwn(config, key) || !dequal(old[key], config[key]));
+	const inputs = previous.inputs.map((port) => {
+		if (!("handle" in port)) return port;
+		const key = changed.find((candidate) => defaults[candidate] == port.handle);
+		if (key == null) return port;
+		const { value: _value, ...withoutDefault } = port;
+		return Object.hasOwn(config, key) ? {
+			...withoutDefault,
+			value: config[key]
+		} : withoutDefault;
+	});
+	return {
+		...previous,
+		name,
+		executor: {
+			...previous.executor,
+			mode: config.mode
+		},
+		inputs,
+		outputs: dequal(old.resultSchema, config.resultSchema) ? previous.outputs : previous.outputs.map((port) => "handle" in port ? {
+			...port,
+			jsonSchema: config.resultSchema
+		} : port)
+	};
+}
+/** Keep the production LLM factory's contracts while removing sample business data. */
+function initialAuthoringLlmTask(task) {
+	if (task.executor.kind != "llm") throw new TypeError("Expected an LLM task.");
+	return {
+		...task,
+		inputs: task.inputs.flatMap((port) => {
+			if (!("handle" in port)) return [port];
+			if (port.handle == "input") return [];
+			if (port.handle == "template") return [{
+				...port,
+				value: [{
+					role: "user",
+					content: ""
+				}]
+			}];
+			return [port];
+		})
+	};
 }
 //#endregion
 //#region src/openapi/common/openapi.ts
@@ -10485,7 +11179,7 @@ function snapshot(documentValue, path, method) {
 	for (const entry of security) for (const name of Object.keys(object(entry))) copy(`#/components/securitySchemes/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`);
 	return structuredClone(result);
 }
-function schema$1(doc, schemaValue) {
+function schema(doc, schemaValue) {
 	const defs = {};
 	const ids = /* @__PURE__ */ new Map();
 	function convert(value) {
@@ -10590,7 +11284,7 @@ function jsonContent(doc, value) {
 	const json = mediaType == null ? void 0 : media[mediaType];
 	if (json == null) throw new Error("Only JSON request and response bodies are supported.");
 	return {
-		schema: schema$1(doc, object(json).schema ?? {}),
+		schema: schema(doc, object(json).schema ?? {}),
 		required: content.required === true,
 		mediaType
 	};
@@ -10609,7 +11303,7 @@ function openApiTask(config, name = "OpenAPI") {
 	const { op } = operation(doc, config.path, config.method);
 	const params = parameters(config);
 	const inputs = params.map((p) => {
-		const jsonSchema = schema$1(doc, p.schema ?? {});
+		const jsonSchema = schema(doc, p.schema ?? {});
 		const defaultValue = typeof jsonSchema == "boolean" ? void 0 : object(jsonSchema).default;
 		return {
 			handle: `${p.in}.${p.name}`,
@@ -10647,7 +11341,7 @@ function openApiTask(config, name = "OpenAPI") {
 		if (r.content == null) schemas.push({ type: "null" });
 		else {
 			jsonContent(doc, r);
-			for (const [mediaType, media] of Object.entries(object(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema$1(doc, object(media).schema ?? {}));
+			for (const [mediaType, media] of Object.entries(object(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema(doc, object(media).schema ?? {}));
 		}
 	}
 	if (!schemas.length) throw new Error("A successful JSON response definition is required.");
@@ -10702,943 +11396,845 @@ function selectOperation(value, sourceUrl, path, method) {
 	openApiTask(config);
 	return config;
 }
-`${JSON.stringify("open-flow-engine/v5")}`, new Set([
-	"assert",
-	"assert/strict",
-	"buffer",
-	"console",
-	"constants",
-	"crypto",
-	"events",
-	"fs",
-	"fs/promises",
-	"os",
-	"path",
-	"path/posix",
-	"process",
-	"punycode",
-	"querystring",
-	"stream",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"timers",
-	"timers/promises",
-	"url",
-	"util",
-	"zlib"
-].flatMap((name) => [name, `node:${name}`])), `${JSON.stringify("open-flow-engine/v5/nodejs-compat-v1")}`;
-//#endregion
-//#region src/flow/common/agent.ts
-var schema = lazy(() => union([boolean(), strictObject({
-	type: union([_enum([
-		"array",
-		"boolean",
-		"integer",
-		"null",
-		"number",
-		"object",
-		"string"
-	]), array(_enum([
-		"array",
-		"boolean",
-		"integer",
-		"null",
-		"number",
-		"object",
-		"string"
-	])).min(1)]).optional(),
-	const: json$3().optional(),
-	allOf: array(schema).min(1).optional(),
-	anyOf: array(schema).min(1).optional(),
-	oneOf: array(schema).min(1).optional(),
-	not: schema.optional(),
-	if: schema.optional(),
-	then: schema.optional(),
-	else: schema.optional(),
-	$ref: string().optional(),
-	$schema: _enum([
-		"http://json-schema.org/draft-07/schema#",
-		"https://json-schema.org/draft-07/schema",
-		"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(),
-	pattern: string().refine((value) => {
-		try {
-			return new RegExp(value, "u").source.length > 0;
-		} catch {
-			return false;
-		}
-	}, "Invalid regular expression.").optional(),
-	format: string().refine((value) => Object.hasOwn(format, value), "Unsupported string format.").optional(),
-	multipleOf: number().positive().optional(),
-	uniqueItems: boolean().optional(),
-	contains: schema.optional(),
-	minContains: number().int().nonnegative().optional(),
-	maxContains: number().int().nonnegative().optional(),
-	minProperties: number().int().nonnegative().optional(),
-	maxProperties: number().int().nonnegative().optional(),
-	propertyNames: schema.optional(),
-	patternProperties: record(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(),
-	prefixItems: array(schema).optional(),
-	additionalItems: schema.optional(),
-	unevaluatedItems: schema.optional(),
-	unevaluatedProperties: schema.optional(),
-	description: string().optional(),
-	title: string().optional(),
-	default: json$3().optional(),
-	examples: array(json$3()).optional(),
-	readOnly: boolean().optional(),
-	writeOnly: boolean().optional(),
-	deprecated: boolean().optional(),
-	$comment: string().optional(),
-	enum: array(json$3()).min(1).optional(),
-	properties: record(string(), schema).optional(),
-	required: array(string()).optional(),
-	additionalProperties: schema.optional(),
-	items: union([schema, array(schema)]).optional(),
-	minItems: number().int().nonnegative().optional(),
-	maxItems: number().int().nonnegative().optional(),
-	minLength: number().int().nonnegative().optional(),
-	maxLength: number().int().nonnegative().optional(),
-	minimum: number().optional(),
-	maximum: number().optional(),
-	exclusiveMinimum: number().optional(),
-	exclusiveMaximum: number().optional()
-}).transform(({ title: _title, default: _default, examples: _examples, readOnly: _readOnly, writeOnly: _writeOnly, deprecated: _deprecated, $comment: _comment, ...value }) => value)]));
-new TextEncoder();
 //#endregion
-//#region ../../node_modules/.bun/@babel+parser@8.0.4/node_modules/@babel/parser/lib/index.js
-var Position = class {
-	constructor(line, col, index) {
-		this.line = void 0;
-		this.column = void 0;
-		if (index !== void 0) this.index = void 0;
-		this.line = line;
-		this.column = col;
-		if (index !== void 0) this.index = index;
-	}
-};
-var SourceLocation = class {
-	start;
-	end;
-	filename;
-	identifierName;
-	constructor(start, end) {
-		this.start = start;
-		this.end = end;
-	}
-};
-var code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
-var ModuleErrors = {
-	ImportMetaOutsideModule: {
-		message: `import.meta may appear only with 'sourceType: "module"'`,
-		code
-	},
-	ImportOutsideModule: {
-		message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-		code
-	}
-};
-var NodeDescriptions = {
-	ArrayPattern: "array destructuring pattern",
-	AssignmentExpression: "assignment expression",
-	AssignmentPattern: "assignment expression",
-	ArrowFunctionExpression: "arrow function expression",
-	ConditionalExpression: "conditional expression",
-	CatchClause: "catch clause",
-	ForOfStatement: "for-of statement",
-	ForInStatement: "for-in statement",
-	ForStatement: "for-loop",
-	FormalParameters: "function parameter list",
-	Identifier: "identifier",
-	ImportSpecifier: "import specifier",
-	ImportDefaultSpecifier: "import default specifier",
-	ImportNamespaceSpecifier: "import namespace specifier",
-	ObjectPattern: "object destructuring pattern",
-	ParenthesizedExpression: "parenthesized expression",
-	RestElement: "rest element",
-	UpdateExpression: {
-		true: "prefix operation",
-		false: "postfix operation"
-	},
-	VariableDeclarator: "variable declaration",
-	YieldExpression: "yield expression"
-};
-var toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
-var StandardErrors = {
-	AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
-	ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
-	AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
-	AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
-	AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
-	AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
-	AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
-	AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
-	BadGetterArity: "A 'get' accessor must not have any formal parameters.",
-	BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
-	BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
-	ConstructorClassField: "Classes may not have a field named 'constructor'.",
-	ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
-	ConstructorIsAccessor: "Class constructor may not be an accessor.",
-	ConstructorIsAsync: "Constructor can't be an async function.",
-	ConstructorIsGenerator: "Constructor can't be a generator.",
-	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
-	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
-	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
-	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
-	DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
-	DecoratorStaticBlock: "Decorators can't be used with a static block.",
-	DeferImportRequiresNamespace: "Only `import defer * as x from \"./module\"` is valid.",
-	DeletePrivateField: "Deleting a private field is not allowed.",
-	DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
-	DuplicateConstructor: "Duplicate constructor in the same class.",
-	DuplicateDefaultExport: "Only one default export allowed per module.",
-	DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
-	DuplicateProto: "Redefinition of __proto__ property.",
-	DuplicateRegExpFlags: "Duplicate regular expression flag.",
-	ElementAfterRest: "Rest element must be last element.",
-	EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
-	ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
-	ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
-	ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
-	ForInUsing: "For-in loop may not start with 'using' declaration.",
-	ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
-	ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
-	GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
-	IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
-	IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
-	IllegalReturn: "'return' outside of function.",
-	ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
-	ImportCallArity: ({ phase }) => `\`import${phase ? `.${phase}` : ""}()\` requires exactly one or two arguments.`,
-	ImportCallNotNewExpression: ({ phase }) => `Cannot use new with import${phase ? `.${phase}` : ""}().`,
-	ImportCallSpreadArgument: ({ phase }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : ""}()\`.`,
-	IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
-	InvalidBigIntLiteral: "Invalid BigIntLiteral.",
-	InvalidCodePoint: "Code point out of bounds.",
-	InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
-	InvalidCoverInitializedName: "Invalid shorthand property initializer.",
-	InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`,
-	InvalidEscapeSequence: "Bad character escape sequence.",
-	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
-	InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
-	InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
-	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
-	InvalidNumber: "Invalid number.",
-	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
-	InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
-	InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
-	InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`,
-	InvalidPropertyBindingPattern: "Binding member expression.",
-	InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
-	LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`,
-	LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
-	LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
-	MalformedRegExpFlags: "Invalid regular expression flag.",
-	MissingClassName: "A class name is required.",
-	MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
-	MissingSemicolon: "Missing semicolon.",
-	MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
-	MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
-	ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
-	ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`,
-	ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
-	ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`,
-	MultipleDefaultsInSwitch: "Multiple default clauses.",
-	NewlineAfterThrow: "Illegal newline after throw.",
-	NoCatchOrFinally: "Missing catch or finally clause.",
-	NumberIdentifier: "Identifier directly after number.",
-	NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
-	ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
-	OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
-	OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
-	OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
-	ParamDupe: "Argument name clash.",
-	PatternHasAccessor: "Object pattern can't contain getter or setter.",
-	PatternHasMethod: "Object pattern can't contain methods.",
-	PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
-	PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`,
-	RestTrailingComma: "Unexpected trailing comma after rest element.",
-	SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
-	SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
-	SourcePhaseImportRequiresDefault: "Only `import source x from \"./module\"` is valid.",
-	StaticPrototype: "Classes may not have static property named prototype.",
-	SuperCallNotNewExpression: "Cannot use new with super(...).",
-	SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
-	SuperPrivateField: "Private fields can't be accessed on super.",
-	TrailingDecorator: "Decorators must be attached to a class element.",
-	UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
-	UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
-	UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
-	UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`,
-	UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
-	UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
-	UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
-	UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
-	UnexpectedPrivateField: "Unexpected private name.",
-	UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`,
-	UnexpectedSuper: "'super' is only allowed in object methods and classes.",
-	UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
-	UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
-	UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
-	UnexpectedVoidPattern: "Unexpected void binding.",
-	UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
-	UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
-	UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
-	UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
-	UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
-	UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
-	UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
-	UnterminatedComment: "Unterminated comment.",
-	UnterminatedRegExp: "Unterminated regular expression.",
-	UnterminatedString: "Unterminated string constant.",
-	UnterminatedTemplate: "Unterminated template.",
-	UsingDeclarationExport: "Using declaration cannot be exported.",
-	UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
-	VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`,
-	VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
-	VoidPatternInitializer: "A void binding may not have an initializer.",
-	YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
-	YieldInParameter: "Yield expression is not allowed in formal parameters.",
-	YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
-	ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
-};
-var StrictModeErrors = {
-	StrictDelete: "Deleting local variable in strict mode.",
-	StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
-	StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
-	StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
-	StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
-	StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
-	StrictWith: "'with' in strict mode."
-};
-var ParseExpressionErrors = {
-	ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
-	ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
-};
-var PipelineOperatorErrors = {
-	PipeTopicRequiresHackPipes: "Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.",
-	PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
-	PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
-	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
-	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`,
-	PipelineUnparenthesized: "Cannot mix binary operator with solo-await F#-style pipeline. Please wrap the pipeline in parentheses."
-};
-var FunctionBindErrors = {
-	UnsupportedBind: "Binding should be performed on object property.",
-	UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
-};
-function defineHidden(obj, key, value) {
-	Object.defineProperty(obj, key, {
-		enumerable: false,
-		configurable: true,
-		value
-	});
+//#region src/control/common/authoringOpenApi.ts
+var authenticationSchema = union([
+	strictObject({ schemes: array(string().min(1)).describe("One complete security alternative advertised by this operation; [] selects no authentication.") }),
+	strictObject({ type: _enum(["bearer", "basic"]) }),
+	strictObject({
+		type: literal("apiKey"),
+		name: string().min(1),
+		in: _enum(["header", "query"])
+	})
+]);
+var authoringOpenApiSchema = strictObject({
+	sourceUrl: string().min(1),
+	path: string().min(1),
+	method: string().min(1),
+	serverUrl: string().optional(),
+	authentication: authenticationSchema.optional().describe("Omit to use the operation default. Bind credentials through the advertised node inputs.")
+});
+function openApiAuthenticationChoices(config) {
+	try {
+		return securityOptions(config.document, config.path, config.method).map(({ label, auth, error }) => Object.assign({ label }, auth == null ? { error } : { authentication: { schemes: auth.map((item) => item.id) } }));
+	} catch (error) {
+		return [{
+			label: "Saved operation",
+			error: error.message
+		}];
+	}
 }
-function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
-	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
-	return function constructor(loc, pos, details) {
-		const error = /* @__PURE__ */ new SyntaxError();
-		error.code = code;
-		error.reasonCode = reasonCode;
-		error.loc = loc;
-		error.pos = pos;
-		error.syntaxPlugin = syntaxPlugin;
-		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
-		defineHidden(error, "clone", function clone(overrides = {}) {
-			const { line, column, index = pos } = overrides.loc ?? loc;
-			return constructor(new Position(line, column), index, {
-				...details,
-				...overrides.details
-			});
-		});
-		defineHidden(error, "details", details);
-		Object.defineProperty(error, "message", {
-			configurable: true,
-			get() {
-				const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
-				this.message = message;
-				return message;
-			},
-			set(value) {
-				Object.defineProperty(this, "message", {
-					value,
-					writable: true
-				});
-			}
-		});
-		return error;
-	};
-}
-function ParseErrorEnum(argument, syntaxPlugin) {
-	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
-	const ParseErrorConstructors = {};
-	for (const reasonCode of Object.keys(argument)) {
-		const template = argument[reasonCode];
-		const { message, ...rest } = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template;
-		ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
-			code: "BABEL_PARSER_SYNTAX_ERROR",
-			reasonCode,
-			toMessage: typeof message === "string" ? () => message : message,
-			...syntaxPlugin ? { syntaxPlugin } : {},
-			...rest
-		});
+function authenticationView(config) {
+	const schemes = config.auth.map((item) => item.id);
+	if (!openApiAuthenticationChoices(config).some((option) => "authentication" in option && dequal(option.authentication?.schemes, schemes)) && config.auth.length == 1) {
+		const { id: _id, ...manual } = config.auth[0];
+		return manual;
 	}
-	return ParseErrorConstructors;
-}
-({
-	...ParseErrorEnum(ModuleErrors),
-	...ParseErrorEnum(StandardErrors),
-	...ParseErrorEnum(StrictModeErrors),
-	...ParseErrorEnum(ParseExpressionErrors),
-	...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
-	...ParseErrorEnum`functionBind`(FunctionBindErrors)
-});
-var beforeExpr = true;
-var startsExpr = true;
-var isLoop = true;
-var isAssign = true;
-var prefix = true;
-var postfix = true;
-var ExportedTokenType = class {
-	label;
-	keyword;
-	beforeExpr;
-	startsExpr;
-	rightAssociative;
-	isLoop;
-	isAssign;
-	prefix;
-	postfix;
-	binop;
-	constructor(label, conf = {}) {
-		this.label = label;
-		this.keyword = conf.keyword;
-		this.beforeExpr = !!conf.beforeExpr;
-		this.startsExpr = !!conf.startsExpr;
-		this.rightAssociative = !!conf.rightAssociative;
-		this.isLoop = !!conf.isLoop;
-		this.isAssign = !!conf.isAssign;
-		this.prefix = !!conf.prefix;
-		this.postfix = !!conf.postfix;
-		this.binop = conf.binop != null ? conf.binop : null;
-	}
-};
-var keywords$1 = /* @__PURE__ */ new Map();
-function createKeyword(name, options = {}) {
-	options.keyword = name;
-	const token = createToken(name, options);
-	keywords$1.set(name, token);
-	return token;
-}
-function createBinop(name, binop) {
-	return createToken(name, {
-		beforeExpr,
-		binop
-	});
-}
-var tokenTypeCounter = -1;
-var tokenTypes = [];
-var tokenLabels = [];
-var tokenBinops = [];
-var tokenBeforeExprs = [];
-var tokenStartsExprs = [];
-var tokenPrefixes = [];
-function createToken(name, options = {}) {
-	++tokenTypeCounter;
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType(name, options));
-	return tokenTypeCounter;
-}
-function createKeywordLike(name, options = {}) {
-	++tokenTypeCounter;
-	keywords$1.set(name, tokenTypeCounter);
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType("name", options));
-	return tokenTypeCounter;
-}
-var tt = {
-	bracketL: createToken("[", {
-		beforeExpr,
-		startsExpr
-	}),
-	bracketR: createToken("]"),
-	braceL: createToken("{", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceBarL: createToken("{|", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceR: createToken("}"),
-	braceBarR: createToken("|}"),
-	parenL: createToken("(", {
-		beforeExpr,
-		startsExpr
-	}),
-	parenR: createToken(")"),
-	comma: createToken(",", { beforeExpr }),
-	semi: createToken(";", { beforeExpr }),
-	colon: createToken(":", { beforeExpr }),
-	doubleColon: createToken("::", { beforeExpr }),
-	dot: createToken("."),
-	question: createToken("?", { beforeExpr }),
-	questionDot: createToken("?."),
-	arrow: createToken("=>", { beforeExpr }),
-	template: createToken("template"),
-	ellipsis: createToken("...", { beforeExpr }),
-	backQuote: createToken("`", { startsExpr }),
-	dollarBraceL: createToken("${", {
-		beforeExpr,
-		startsExpr
-	}),
-	templateTail: createToken("...`", { startsExpr }),
-	templateNonTail: createToken("...${", {
-		beforeExpr,
-		startsExpr
-	}),
-	at: createToken("@"),
-	hash: createToken("#", { startsExpr }),
-	interpreterDirective: createToken("#!..."),
-	eq: createToken("=", {
-		beforeExpr,
-		isAssign
-	}),
-	assign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	slashAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	xorAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
+	return { schemes };
+}
+function openApiConfigView(config) {
+	return {
+		sourceUrl: config.sourceUrl,
+		path: config.path,
+		method: config.method,
+		serverUrl: config.serverUrl,
+		authentication: authenticationView(config)
+	};
+}
+var AuthoringOpenApiAuthenticationError = class extends Error {
+	constructor(config) {
+		super("Choose one complete authentication alternative advertised by this operation, or configure manual authentication.");
+		this.code = "openapi.authentication-invalid";
+		this.name = "AuthoringOpenApiAuthenticationError";
+		this.details = {
+			field: "config.authentication",
+			choices: openApiAuthenticationChoices(config)
+		};
+	}
+};
+function prepareAuthentication(config, choice) {
+	if (!("schemes" in choice)) return [{
+		id: "manual",
+		...choice
+	}];
+	const names = new Set(choice.schemes);
+	const matched = securityOptions(config.document, config.path, config.method).find((option) => option.auth != null && names.size == choice.schemes.length && option.auth.length == names.size && option.auth.every((auth) => names.has(auth.id)));
+	if (matched?.auth == null) throw new AuthoringOpenApiAuthenticationError(config);
+	return matched.auth;
+}
+/** Operation snapshots and credential handles remain stable until their business selection changes. */
+async function prepareOpenApiTask(config, previous, fetch, name, explicit = {}) {
+	const current = previous?.executor.kind == "openapi" ? previous.executor : void 0;
+	const changed = current == null || config.sourceUrl != current.sourceUrl || config.path != current.path || config.method != current.method;
+	const authentication = changed && current != null && !explicit.authentication ? void 0 : config.authentication;
+	let selected;
+	if (!changed) selected = current;
+	else {
+		const document = await fetch(config.sourceUrl);
+		if (authentication != null && !("schemes" in authentication)) {
+			const saved = snapshot(document, config.path, config.method);
+			selected = {
+				kind: "openapi",
+				sourceUrl: httpUrl(config.sourceUrl),
+				path: config.path,
+				method: config.method,
+				serverUrl: serverAddress(servers(saved, config.path, config.method)[0], config.sourceUrl),
+				document: saved,
+				auth: []
+			};
+		} else selected = selectOperation(document, config.sourceUrl, config.path, config.method);
+	}
+	const defaultAuth = () => {
+		const defaultSelection = securityOptions(current.document, current.path, current.method).find((option) => option.auth != null)?.auth;
+		if (defaultSelection == null) throw new AuthoringOpenApiAuthenticationError(current);
+		return defaultSelection;
+	};
+	const auth = authentication == null ? !changed && explicit.authentication ? defaultAuth() : selected.auth : !changed && dequal(authentication, authenticationView(current)) ? current.auth : prepareAuthentication(selected, authentication);
+	const serverUrl = !changed && explicit.serverUrl && config.serverUrl == null ? serverAddress(servers(current.document, current.path, current.method)[0], current.sourceUrl) : changed && current != null && !explicit.serverUrl ? selected.serverUrl : config.serverUrl ?? selected.serverUrl;
+	const executor = {
+		...selected,
+		auth,
+		serverUrl
+	};
+	if (previous != null && !changed && dequal(auth, current.auth)) return {
+		...previous,
+		name,
+		executor
+	};
+	return openApiTask(executor, name);
+}
+//#endregion
+//#region src/control/common/authoringSchema.ts
+var id$2 = string().min(1);
+var json$3 = json$5();
+var patch = record$3(id$2, json$3);
+var authoringTypes = [
+	"manual",
+	"webhook",
+	"cron",
+	"error",
+	"poll",
+	"integration",
+	"code",
+	"connector",
+	"agent",
+	"llm",
+	"decision",
+	"openapi",
+	"condition",
+	"value",
+	"wait",
+	"approval"
+];
+var type = _enum(authoringTypes);
+var referenceSchema = id$2.describe("An existing node reference returned by read/search, or $alias for a preceding node.add in this edit batch. For node.add.as \"step\", reference \"$step\", never bare \"step\". Aliases are local to one batch.");
+var output = strictObject({
+	kind: literal("output"),
+	node: referenceSchema,
+	port: id$2.optional().describe("Omit for a node with one output. For multiple outputs, choose a name from node details."),
+	field: string().optional()
+});
+var variable = strictObject({
+	kind: literal("variable"),
+	name: id$2
+});
+var authoringSourceSchema = union([
+	output,
+	variable,
+	strictObject({
+		kind: literal("value"),
+		value: json$3
 	}),
-	moduloAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
+	strictObject({ kind: literal("unset") }),
+	strictObject({ kind: literal("default") }),
+	strictObject({
+		kind: literal("sources"),
+		sources: array(union([output, variable])).min(1)
+	})
+]);
+var operand = union([
+	strictObject({
+		kind: literal("value"),
+		value: json$3.optional(),
+		schema: json$3.optional()
 	}),
-	incDec: createToken("++/--", {
-		prefix,
-		postfix,
-		startsExpr
+	output,
+	variable
+]);
+var agentTool = authoringDefinitionSchemas.agent.shape.tools.element.omit({
+	id: true,
+	inputs: true
+}).extend({ inputs: record$3(id$2, authoringDefinitionSchemas.agent.shape.tools.element.shape.inputs.element.shape.source).optional().describe("Action input sources by name. The tool resolves types from the Action. New inputs default to model-provided; existing sources are preserved when omitted.") }).strict();
+var notification = strictObject({
+	...authoringDefinitionSchemas.connector.shape,
+	messageHandle: id$2,
+	inputs: record$3(id$2, union([strictObject({
+		kind: literal("value"),
+		value: json$3
+	}), strictObject({
+		kind: literal("input"),
+		input: id$2
+	})]))
+});
+var field = strictObject({
+	schema: json$3.optional(),
+	nullable: boolean().optional(),
+	description: string().optional()
+});
+var inputFields = record$3(id$2, field.extend({ default: json$3.optional() })).describe("Optional business input constraints by name. A binding to a new Code, Agent, LLM, Wait or Approval input automatically declares an input accepting any JSON. Existing constraints are preserved. Omitted schema accepts any JSON; omitted nullable is true. Use default for inherited values; input.set supplies data.");
+var outputFields = record$3(id$2, field).describe("Code return fields by name. Omitted schema accepts any JSON; omitted nullable is true.");
+var expression = strictObject({
+	left: operand,
+	operator: authoringDefinitionSchemas.condition.shape.cases.element.shape.groups.element.shape.expressions.element.shape.operator,
+	right: operand.optional()
+});
+var all = strictObject({ all: array(expression) });
+var when = union([
+	expression,
+	all,
+	strictObject({ any: array(union([expression, all])) })
+]);
+var authoringConfigurations = {
+	manual: strictObject({}),
+	error: strictObject({ sourceFlowIds: array(id$2).optional() }),
+	webhook: authoringDefinitionSchemas.webhook.omit({ bodyFields: true }).extend({ body: inputFields }).strict(),
+	cron: strictObject({ schedule: authoringDefinitionSchemas.schedule }),
+	poll: strictObject({
+		key: id$2,
+		connectionId: id$2.optional(),
+		schedule: authoringDefinitionSchemas.schedule
 	}),
-	bang: createToken("!", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	integration: strictObject({
+		key: id$2,
+		connectionId: id$2.optional()
 	}),
-	tilde: createToken("~", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	code: strictObject({
+		inputs: inputFields,
+		outputs: outputFields,
+		capabilities: authoringDefinitionSchemas.capabilities.optional()
 	}),
-	doubleCaret: createToken("^^", { startsExpr }),
-	doubleAt: createToken("@@", { startsExpr }),
-	pipeline: createBinop("|>", 0),
-	nullishCoalescing: createBinop("??", 1),
-	logicalOR: createBinop("||", 1),
-	logicalAND: createBinop("&&", 2),
-	bitwiseOR: createBinop("|", 3),
-	bitwiseXOR: createBinop("^", 4),
-	bitwiseAND: createBinop("&", 5),
-	equality: createBinop("==/!=/===/!==", 6),
-	lt: createBinop("</>/<=/>=", 7),
-	gt: createBinop("</>/<=/>=", 7),
-	relational: createBinop("</>/<=/>=", 7),
-	bitShift: createBinop("<</>>/>>>", 8),
-	bitShiftL: createBinop("<</>>/>>>", 8),
-	bitShiftR: createBinop("<</>>/>>>", 8),
-	plusMin: createToken("+/-", {
-		beforeExpr,
-		binop: 9,
-		prefix,
-		startsExpr
+	connector: authoringDefinitionSchemas.connector.strict(),
+	openapi: authoringOpenApiSchema,
+	agent: authoringDefinitionSchemas.agent.omit({
+		prompt: true,
+		tools: true
+	}).extend({
+		inputs: inputFields,
+		resultSchema: json$3.describe("JSON schema of the final result. Defaults to text. The tool manages the output definition; references can omit port."),
+		tools: array(agentTool),
+		notification: notification.optional()
+	}).strict(),
+	llm: authoringLlmConfiguration.extend({ inputs: inputFields }),
+	decision: authoringDefinitionSchemas.decision,
+	condition: strictObject({
+		match: _enum(["first", "all"]),
+		branches: array(strictObject({
+			name: id$2,
+			description: string().optional(),
+			when
+		}))
 	}),
-	modulo: createToken("%", {
-		binop: 10,
-		startsExpr
+	value: strictObject({
+		values: patch,
+		outputs: outputFields
 	}),
-	star: createToken("*", { binop: 10 }),
-	slash: createBinop("/", 10),
-	exponent: createToken("**", {
-		beforeExpr,
-		binop: 11,
-		rightAssociative: true
+	wait: strictObject({ inputs: inputFields }),
+	approval: strictObject({ inputs: inputFields })
+};
+var updates = strictObject({
+	name: id$2.optional(),
+	description: string().optional(),
+	icon: string().optional(),
+	maxExecutions: int().positive().optional(),
+	timeoutMs: number().nonnegative().optional(),
+	config: patch.optional().describe("Recursively merge configuration; omitted fields remain unchanged and arrays replace as a whole. This includes schema objects: {} does not clear an existing schema. Use clear paths to remove fields, e.g. [\"config\",\"inputs\",\"amount\",\"schema\",\"type\"].")
+});
+var authoringEditSchema = discriminatedUnion("op", [
+	strictObject({
+		op: literal("node.add"),
+		as: id$2.regex(/^[A-Za-z][\w-]*$/).describe("Unique batch-local alias without the $ prefix. Later edits must reference this new node as $alias; the bare alias is not its node ID."),
+		type,
+		name: id$2,
+		config: patch.optional(),
+		inputs: record$3(id$2, authoringSourceSchema).optional().describe("Input data sources, applied after creation, as input.set operations. Execution edges are separate."),
+		code: string().optional(),
+		prompt: string().optional()
 	}),
-	_in: createKeyword("in", {
-		beforeExpr,
-		binop: 7
+	strictObject({
+		op: literal("node.update"),
+		node: referenceSchema,
+		set: updates.optional(),
+		clear: array(array(id$2).min(1)).optional()
 	}),
-	_instanceof: createKeyword("instanceof", {
-		beforeExpr,
-		binop: 7
+	strictObject({
+		op: literal("node.remove"),
+		node: referenceSchema
 	}),
-	_break: createKeyword("break"),
-	_case: createKeyword("case", { beforeExpr }),
-	_catch: createKeyword("catch"),
-	_continue: createKeyword("continue"),
-	_debugger: createKeyword("debugger"),
-	_default: createKeyword("default", { beforeExpr }),
-	_else: createKeyword("else", { beforeExpr }),
-	_finally: createKeyword("finally"),
-	_function: createKeyword("function", { startsExpr }),
-	_if: createKeyword("if"),
-	_return: createKeyword("return", { beforeExpr }),
-	_switch: createKeyword("switch"),
-	_throw: createKeyword("throw", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	strictObject({
+		op: literal("input.set"),
+		node: referenceSchema,
+		input: id$2,
+		source: authoringSourceSchema
 	}),
-	_try: createKeyword("try"),
-	_var: createKeyword("var"),
-	_const: createKeyword("const"),
-	_with: createKeyword("with"),
-	_new: createKeyword("new", {
-		beforeExpr,
-		startsExpr
+	strictObject({
+		op: _enum(["edge.connect", "edge.disconnect"]),
+		source: referenceSchema,
+		target: referenceSchema,
+		branch: id$2.optional()
 	}),
-	_this: createKeyword("this", { startsExpr }),
-	_super: createKeyword("super", { startsExpr }),
-	_class: createKeyword("class", { startsExpr }),
-	_extends: createKeyword("extends", { beforeExpr }),
-	_export: createKeyword("export"),
-	_import: createKeyword("import", { startsExpr }),
-	_null: createKeyword("null", { startsExpr }),
-	_true: createKeyword("true", { startsExpr }),
-	_false: createKeyword("false", { startsExpr }),
-	_typeof: createKeyword("typeof", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	strictObject({
+		op: literal("text.edit"),
+		node: referenceSchema,
+		field: _enum(["code", "prompt"]),
+		oldText: id$2,
+		newText: string()
 	}),
-	_void: createKeyword("void", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	strictObject({
+		op: literal("text.set"),
+		node: referenceSchema,
+		field: _enum(["code", "prompt"]),
+		text: string()
+	})
+]);
+var authoringRequestSchema = strictObject({
+	baseRevision: id$2,
+	requestId: id$2.max(256),
+	edits: array(authoringEditSchema).min(1).max(1e3)
+});
+var authoringReadSchema = strictObject({
+	revision: id$2.optional().describe("Fixed revision from a previous read; omit to read the current draft."),
+	nodes: array(id$2).min(1).max(100).optional().describe("Node references to read in one batch. Mutually exclusive with text. Long texts return metadata."),
+	text: strictObject({
+		node: id$2,
+		field: _enum(["code", "prompt"]),
+		start: int().positive().default(1),
+		lines: int().min(1).max(200).default(80)
+	}).optional().describe("Read code or prompt by line (1-based). Mutually exclusive with nodes. Follow nextStart at the same revision until truncated is false.")
+}).refine((v) => v.nodes == null || v.text == null, "Choose nodes or text.").meta({
+	not: { required: ["nodes", "text"] },
+	description: "Omit nodes and text for an outline; provide nodes for details, or text for an excerpt."
+});
+var authoringCheckSchema = strictObject({ revisionId: id$2 });
+var authoringSearchSchema = strictObject({
+	revision: id$2.optional(),
+	query: id$2.max(1e3),
+	type: type.optional(),
+	offset: int().nonnegative().default(0),
+	limit: int().min(1).max(100).default(20)
+});
+var authoringSchemaQuery = strictObject({
+	type: type.optional(),
+	action: id$2.optional()
+}).refine((v) => v.type == null || v.action == null, "Choose type or action.");
+var requestContracts = {
+	read: {
+		schema: authoringReadSchema,
+		guidance: "Choose one mode: outline (omit nodes and text), node details (nodes), or text excerpt (text). nodes and text are mutually exclusive. Text defaults to 80 lines, at most 200 lines and 24000 characters. For the complete text, repeat at nextStart with the same revision until truncated is false.",
+		examples: [
+			{},
+			{
+				revision: "REVISION",
+				nodes: ["NODE"]
+			},
+			{
+				revision: "REVISION",
+				text: {
+					node: "NODE",
+					field: "prompt",
+					start: 1,
+					lines: 80
+				}
+			}
+		]
+	},
+	search: {
+		schema: authoringSearchSchema,
+		guidance: "Search names, configurations and text. Keep the returned revision when following nextOffset or reading a match.",
+		examples: [{
+			query: "Customer summary",
+			type: "agent"
+		}]
+	},
+	edit: {
+		schema: authoringRequestSchema,
+		guidance: "Use the observed revision as baseRevision and a stable requestId. Edits are ordered and atomic. node.add.as declares a batch-local alias without $. Every later reference to that new node must use $alias, including node, edge source/target and output source node fields; a bare alias is not the node ID. Use returned node references in later batches. Updates recursively merge objects (including schemas); {} preserves existing fields. Arrays replace as a whole. Remove fields with clear paths. Text replacement requires exactly one match. Read the target text first. A saved draft can have validation diagnostics.",
+		examples: [{
+			baseRevision: "REVISION",
+			requestId: "CREATE_REQUEST",
+			edits: [
+				{
+					op: "node.add",
+					as: "start",
+					type: "manual",
+					name: "Start"
+				},
+				{
+					op: "node.add",
+					as: "step",
+					type: "code",
+					name: "Process",
+					code: "export default ({value}) => ({result:value})"
+				},
+				{
+					op: "edge.connect",
+					source: "$start",
+					target: "$step"
+				},
+				{
+					op: "node.update",
+					node: "$step",
+					set: { description: "Created and connected in one atomic edit." }
+				}
+			]
+		}, {
+			baseRevision: "REVISION",
+			requestId: "REQUEST",
+			edits: [{
+				op: "text.edit",
+				node: "NODE",
+				field: "prompt",
+				oldText: "Original rule.",
+				newText: "Updated rule."
+			}]
+		}]
+	},
+	check: {
+		schema: authoringCheckSchema,
+		guidance: "Check a fixed revision. In the CLI, pass this identity with --revision REVISION.",
+		examples: [{ revisionId: "REVISION" }]
+	}
+};
+/** Transport-independent discovery of the same requests the service validates. */
+function authoringRequestContract(name) {
+	if (!Object.hasOwn(requestContracts, name)) return void 0;
+	const contract = requestContracts[name];
+	return {
+		request: toJSONSchema(contract.schema, { io: "input" }),
+		guidance: contract.guidance,
+		examples: contract.examples
+	};
+}
+function authoringSchema(kind) {
+	return kind == null ? {
+		types: authoringTypes,
+		request: toJSONSchema(authoringRequestSchema),
+		guidance: "Read a node type schema before creating or configuring it. Use $alias to reference a preceding node.add in the same batch. Read returns stable node references. Long code and prompt fields use text reads and edits. Changes use the observed baseRevision and a stable requestId."
+	} : {
+		type: kind,
+		inputSources: ["poll", "integration"].includes(kind) ? [
+			"value",
+			"unset",
+			"default"
+		] : [
+			"manual",
+			"error",
+			"cron",
+			"webhook",
+			"value",
+			"condition"
+		].includes(kind) ? [] : [
+			"value",
+			"unset",
+			"default",
+			"output",
+			"variable",
+			"sources"
+		],
+		extensibleInputs: [
+			"code",
+			"agent",
+			"llm",
+			"wait",
+			"approval"
+		].includes(kind),
+		guidance: kind == "condition" ? "Edit branch operands through config.branches. A branch can test one expression, all expressions, or any alternatives. Unmatched execution uses branch otherwise." : ["poll", "integration"].includes(kind) ? "Configure static parameters with node.add.inputs or input.set. Definitions come from the selected Trigger key; execution output and variable sources are unavailable." : kind == "llm" ? "Configure model settings, message templates and history as defaults. Input bindings with the same names override these defaults; named business inputs can be bound directly. Template strings interpolate {{name}}." : kind == "openapi" ? "Select an operation; the tool resolves its ports and authentication. Read authenticationChoices from node details. authentication is replaced as a complete choice. Bind advertised credentials through inputs." : "Supply business configuration and input data. Fixed definitions are assembled by the tool. Existing constraints and defaults are preserved on partial updates.",
+		example: {
+			op: "node.add",
+			as: "step",
+			type: kind,
+			name: "Step",
+			...{
+				connector: { config: {
+					action: "<Action ID>",
+					connectionId: "<Connection ID>"
+				} },
+				poll: { config: {
+					key: "<Trigger key>",
+					schedule: [{
+						type: "every",
+						unit: "minute",
+						value: 5
+					}]
+				} },
+				integration: { config: { key: "<Trigger key>" } },
+				openapi: { config: {
+					sourceUrl: "https://example.com/openapi.json",
+					path: "/items",
+					method: "get"
+				} },
+				code: {
+					code: "export default ({value}) => ({result:value})",
+					inputs: { value: {
+						kind: "value",
+						value: "Hello"
+					} }
+				},
+				condition: { config: {
+					match: "first",
+					branches: [{
+						name: "yes",
+						when: {
+							left: {
+								kind: "value",
+								value: 120
+							},
+							operator: ">",
+							right: {
+								kind: "value",
+								value: 100
+							}
+						}
+					}]
+				} },
+				value: { config: { values: {
+					threshold: 100,
+					region: "EU"
+				} } },
+				webhook: { config: {
+					method: "POST",
+					body: { orderId: {
+						schema: { type: "string" },
+						nullable: false
+					} }
+				} },
+				wait: {
+					prompt: "Continue processing this order?",
+					inputs: { order: {
+						kind: "value",
+						value: { orderId: "A-1" }
+					} }
+				},
+				approval: {
+					prompt: "Approve this order?",
+					inputs: { order: {
+						kind: "value",
+						value: { orderId: "A-1" }
+					} }
+				},
+				llm: {
+					config: {
+						model: { model: "deepseek-v4-flash" },
+						template: [{
+							role: "user",
+							content: "Summarize {{order}}."
+						}]
+					},
+					inputs: { order: {
+						kind: "value",
+						value: {
+							orderId: "A-1",
+							total: 42
+						}
+					} }
+				},
+				agent: {
+					config: { model: "deepseek-v4-flash" },
+					inputs: { orders: {
+						kind: "value",
+						value: [{
+							orderId: "A-1",
+							total: 42
+						}]
+					} },
+					prompt: "Summarize {{orders}}."
+				}
+			}[kind]
+		},
+		configuration: toJSONSchema(authoringConfigurations[kind].partial()),
+		texts: kind == "code" ? ["code"] : [
+			"agent",
+			"wait",
+			"approval"
+		].includes(kind) ? ["prompt"] : []
+	};
+}
+var authoringDiagnosticSchema = object$1({
+	code: id$2,
+	message: string(),
+	nodes: array(id$2),
+	field: string().optional(),
+	line: number().optional(),
+	column: number().optional()
+});
+var authoringCheckResponse = object$1({
+	flowId: id$2,
+	revisionId: id$2,
+	valid: boolean(),
+	diagnostics: array(authoringDiagnosticSchema),
+	version: literal(1)
+});
+var authoringEditResponse = object$1({
+	flowId: id$2,
+	saved: literal(true),
+	revision: id$2,
+	nodes: record$3(id$2, id$2),
+	changes: array(object$1({
+		index: int(),
+		op: id$2,
+		node: id$2.optional()
+	})),
+	validation: object$1({
+		status: _enum([
+			"valid",
+			"invalid",
+			"unavailable"
+		]),
+		diagnostics: array(authoringDiagnosticSchema).optional()
 	}),
-	_delete: createKeyword("delete", {
-		beforeExpr,
-		prefix,
-		startsExpr
+	version: literal(1)
+});
+var authoringReadResponse = object$1({
+	flowId: id$2,
+	revision: id$2,
+	data: object$1({
+		nodes: array(record$3(string(), json$3)).optional(),
+		edges: array(json$3).optional(),
+		text: record$3(string(), json$3).optional()
 	}),
-	_do: createKeyword("do", {
-		isLoop,
-		beforeExpr
+	version: literal(1)
+});
+var authoringSearchResponse = object$1({
+	flowId: id$2,
+	revision: id$2,
+	data: object$1({
+		matches: array(object$1({
+			node: id$2,
+			field: id$2,
+			line: int().optional(),
+			excerpt: string()
+		})),
+		total: int(),
+		nextOffset: int().optional()
 	}),
-	_for: createKeyword("for", { isLoop }),
-	_while: createKeyword("while", { isLoop }),
-	_as: createKeywordLike("as", { startsExpr }),
-	_assert: createKeywordLike("assert", { startsExpr }),
-	_async: createKeywordLike("async", { startsExpr }),
-	_await: createKeywordLike("await", { startsExpr }),
-	_defer: createKeywordLike("defer", { startsExpr }),
-	_from: createKeywordLike("from", { startsExpr }),
-	_get: createKeywordLike("get", { startsExpr }),
-	_let: createKeywordLike("let", { startsExpr }),
-	_meta: createKeywordLike("meta", { startsExpr }),
-	_of: createKeywordLike("of", { startsExpr }),
-	_sent: createKeywordLike("sent", { startsExpr }),
-	_set: createKeywordLike("set", { startsExpr }),
-	_source: createKeywordLike("source", { startsExpr }),
-	_static: createKeywordLike("static", { startsExpr }),
-	_using: createKeywordLike("using", { startsExpr }),
-	_yield: createKeywordLike("yield", { startsExpr }),
-	_asserts: createKeywordLike("asserts", { startsExpr }),
-	_checks: createKeywordLike("checks", { startsExpr }),
-	_exports: createKeywordLike("exports", { startsExpr }),
-	_global: createKeywordLike("global", { startsExpr }),
-	_implements: createKeywordLike("implements", { startsExpr }),
-	_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
-	_infer: createKeywordLike("infer", { startsExpr }),
-	_is: createKeywordLike("is", { startsExpr }),
-	_mixins: createKeywordLike("mixins", { startsExpr }),
-	_proto: createKeywordLike("proto", { startsExpr }),
-	_require: createKeywordLike("require", { startsExpr }),
-	_satisfies: createKeywordLike("satisfies", { startsExpr }),
-	_keyof: createKeywordLike("keyof", { startsExpr }),
-	_readonly: createKeywordLike("readonly", { startsExpr }),
-	_unique: createKeywordLike("unique", { startsExpr }),
-	_abstract: createKeywordLike("abstract", { startsExpr }),
-	_declare: createKeywordLike("declare", { startsExpr }),
-	_enum: createKeywordLike("enum", { startsExpr }),
-	_module: createKeywordLike("module", { startsExpr }),
-	_namespace: createKeywordLike("namespace", { startsExpr }),
-	_interface: createKeywordLike("interface", { startsExpr }),
-	_type: createKeywordLike("type", { startsExpr }),
-	_opaque: createKeywordLike("opaque", { startsExpr }),
-	name: createToken("name", { startsExpr }),
-	placeholder: createToken("%%", { startsExpr }),
-	string: createToken("string", { startsExpr }),
-	num: createToken("num", { startsExpr }),
-	bigint: createToken("bigint", { startsExpr }),
-	regexp: createToken("regexp", { startsExpr }),
-	privateName: createToken("#name", { startsExpr }),
-	eof: createToken("eof"),
-	jsxName: createToken("jsxName"),
-	jsxText: createToken("jsxText", { beforeExpr }),
-	jsxTagStart: createToken("jsxTagStart", { startsExpr }),
-	jsxTagEnd: createToken("jsxTagEnd")
-};
-function getExportedToken(token) {
-	return tokenTypes[token];
-}
-var TokContext = class {
-	constructor(token, preserveSpace) {
-		this.token = token;
-		this.preserveSpace = !!preserveSpace;
-	}
-	token;
-	preserveSpace;
-};
-new TokContext("{"), new TokContext("<tag"), new TokContext("</tag"), new TokContext("<tag>...</tag>", true);
-var reservedWords = {
-	keyword: [
-		"break",
-		"case",
-		"catch",
-		"continue",
-		"debugger",
-		"default",
-		"do",
-		"else",
-		"finally",
-		"for",
-		"function",
-		"if",
-		"return",
-		"switch",
-		"throw",
-		"try",
-		"var",
-		"const",
-		"while",
-		"with",
-		"new",
-		"this",
-		"super",
-		"class",
-		"extends",
-		"export",
-		"import",
-		"null",
-		"true",
-		"false",
-		"in",
-		"instanceof",
-		"typeof",
-		"void",
-		"delete"
-	],
-	strict: [
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield"
-	],
-	strictBind: ["eval", "arguments"]
-};
-new Set(reservedWords.keyword);
-new Set(reservedWords.strict);
-new Set(reservedWords.strictBind);
-ParseErrorEnum`flow`({
-	AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
-	AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
-	AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
-	DeclareClassElement: "The `declare` modifier can only appear on class fields.",
-	DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
-	DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
-	EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
-	EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
-	EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
-	EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
-	EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
-	EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
-	EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
-	EnumStringMemberInconsistentlyInitialized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
-	GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
-	ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
-	InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
-	InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
-	InexactVariance: "Explicit inexact syntax cannot have variance.",
-	InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
-	MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
-	NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
-	NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
-	PatternIsOptional: { message: "A binding pattern parameter cannot be optional in an implementation signature." },
-	SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
-	SpreadVariance: "Spread properties cannot have variance.",
-	ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
-	ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
-	ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
-	ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
-	ThisParamNoDefault: "The `this` parameter may not have a default value.",
-	TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
-	UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
-	UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`,
-	UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
-	UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
-	UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
-	UnexpectedSubtractionOperand: "Unexpected token, expected \"number\" or \"bigint\".",
-	UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
-	UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
-	UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
-	UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
-	UnterminatedFlowComment: "Unterminated flow-comment."
-});
-new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
-ParseErrorEnum`jsx`({
-	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
-	MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
-	MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
-	UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
-	UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
-	UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
-	UnterminatedJsxContent: "Unterminated JSX contents.",
-	UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
-});
-var Node = class {
-	constructor(optionFlags, filename, pos, loc) {
-		this.start = pos;
-		this.end = 0;
-		if (loc !== void 0) this.loc = new SourceLocation(loc);
-		if (optionFlags & 128) this.range = [pos, 0];
-		if (loc !== void 0 && filename) this.loc.filename = filename;
-	}
-	type = "";
-};
-Node.prototype;
-ParseErrorEnum`typescript`({
-	AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
-	AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
-	AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
-	AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
-	AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
-	ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
-	ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
-	ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
-	ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
-	DeclaratorDefiniteAssertionRequiresTypeAnnotation: "Declarations with definite assignment assertions must also have type annotations.",
-	DeclaratorDefiniteAssertionWithInitializer: "Declarations with initializers cannot also have definite assignment assertions.",
-	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
-	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
-	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
-	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
-	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
-	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
-	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
-	EmptyNamespaceName: "Namespace must be given a name.",
-	EmptyTypeArguments: "Type argument list cannot be empty.",
-	EmptyTypeParameters: "Type parameter list cannot be empty.",
-	ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
-	ExportAssignmentInTSNamespace: "An export assignment cannot be used in a namespace.",
-	ExportInTSNamespace: "Export declarations are not permitted in a namespace.",
-	ImportAliasHasImportType: "An import alias can not use 'import type'.",
-	ImportInTSNamespace: "Import declarations in a namespace cannot reference a module.",
-	IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
-	IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
-	IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
-	IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
-	IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
-	IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
-	InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
-	InlineModuleDeclarationMustUseString: "`module ... {}` declarations must have a string name. Use `namespace ... {}` instead.",
-	InvalidHeritageClauseType: ({ token }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
-	InvalidModifierOnAwaitUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on an await using declaration.`,
-	InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`,
-	InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`,
-	InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
-	InvalidModifierOnUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on a using declaration.`,
-	InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
-	InvalidNamespaceName: (value) => `Namespace name cannot be '${value}'.`,
-	InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
-	InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
-	MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
-	NamespaceExportInTSNamespace: "Global module exports may only appear at top level.",
-	NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
-	NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
-	OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
-	OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
-	PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
-	PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
-	PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
-	ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
-	ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
-	ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
-	SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
-	SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
-	SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
-	SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
-	StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
-	TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
-	TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
-	TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
-	TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
-	UnexpectedParameterInitializer: "A parameter initializer is only allowed in a function or constructor implementation.",
-	UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
-	UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
-	UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
-	UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
-	UnexpectedTypeDeclaration: (type) => `'${type}' declarations can only be declared inside a block.`,
-	UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
-	UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
-	UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
-	UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`
-});
-ParseErrorEnum`placeholders`({
-	ClassNameIsRequired: "A class name is required.",
-	UnexpectedSpace: "Unexpected space in placeholder."
-});
-function generateExportedTokenTypes(internalTokenTypes) {
-	const tokenTypes = {};
-	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
-	return tokenTypes;
-}
-generateExportedTokenTypes(tt);
+	version: literal(1)
+});
+//#endregion
+//#region src/trigger/common/contract.ts
+var errorOutputs = [
+	{
+		handle: "workflow",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"flowId",
+				"name",
+				"revisionId",
+				"publicationId"
+			],
+			properties: {
+				flowId: { type: "string" },
+				name: { type: "string" },
+				revisionId: { type: "string" },
+				publicationId: { type: ["string", "null"] }
+			}
+		}
+	},
+	{
+		handle: "execution",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"runId",
+				"status",
+				"startedAt",
+				"finishedAt"
+			],
+			properties: {
+				runId: { type: "string" },
+				status: { enum: ["failed", "indeterminate"] },
+				startedAt: { type: ["string", "null"] },
+				finishedAt: { type: "string" }
+			}
+		}
+	},
+	{
+		handle: "error",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: ["code", "message"],
+			properties: {
+				code: { type: "string" },
+				message: { type: "string" },
+				nodeId: { type: "string" },
+				jobId: { type: "string" },
+				path: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}
+	}
+];
+var webhookOutputs = [
+	{
+		handle: "headers",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		},
+		nullable: false
+	},
+	{
+		handle: "query",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: {
+				type: ["string", "array"],
+				items: { type: "string" }
+			}
+		},
+		nullable: false
+	},
+	{
+		handle: "body",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: true
+		},
+		nullable: false
+	},
+	{
+		handle: "webhookUrl",
+		jsonSchema: { type: "string" },
+		nullable: false
+	}
+];
+var cronOutputs = [{
+	handle: "scheduledAt",
+	jsonSchema: {
+		type: "string",
+		format: "date-time"
+	},
+	nullable: false
+}];
+function triggerOutputDefinitions(trigger) {
+	switch (trigger.kind) {
+		case "error": return errorOutputs;
+		case "manual": return [];
+		case "cron": return cronOutputs;
+		case "poll":
+		case "integration": return trigger.definition.outputs;
+		case "webhook": return webhookOutputs.filter((port) => port.handle !== "body" || webhookSupportsBody(trigger.method)).map((port) => port.handle === "body" ? Object.assign({}, port, { jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: Object.fromEntries(trigger.bodyFields.map((field) => [field.handle, field.jsonSchema])),
+			required: trigger.bodyFields.filter((field) => !field.nullable && !Object.hasOwn(field, "value")).map((field) => field.handle)
+		} }) : port);
+	}
+}
+function triggerOutputPorts(trigger) {
+	return Object.fromEntries(triggerOutputDefinitions(trigger).map(({ handle, ...port }) => [handle, port]));
+}
+//#endregion
+//#region src/flow/common/graph.ts
+function nodeInputPorts(node) {
+	switch (node.kind) {
+		case "condition": return conditionInputPorts(node);
+		case "value": return {};
+		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
+		case "approval":
+		case "wait": return portsByHandle(node.inputDefinitions);
+		case "cron":
+		case "integration":
+		case "poll":
+		case "error":
+		case "manual":
+		case "webhook": return {};
+	}
+}
+function resolutionActions(node) {
+	return node.kind == "wait" ? ["continue"] : ["approve", "reject"];
+}
+var objectPort = (properties) => ({
+	nullable: false,
+	jsonSchema: {
+		type: "object",
+		properties,
+		required: Object.keys(properties),
+		additionalProperties: false
+	}
+});
+function resolutionOutputPorts(node) {
+	const actions = resolutionActions(node);
+	const inputs = {
+		type: "object",
+		properties: Object.fromEntries(node.inputDefinitions.map((port) => [port.handle, {}])),
+		required: node.inputDefinitions.map((port) => port.handle),
+		additionalProperties: false
+	};
+	return {
+		pending: objectPort({
+			inputs,
+			prompt: { type: "string" },
+			...Object.fromEntries(actions.map((action) => [`${action}Url`, { type: "string" }])),
+			expiresAt: { type: "string" }
+		}),
+		...Object.fromEntries(actions.map((action) => [action, objectPort({
+			inputs,
+			action: { const: action },
+			resolvedAt: { type: "string" },
+			comment: { type: ["string", "null"] }
+		})]))
+	};
+}
+function nodeOutputPorts(node) {
+	switch (node.kind) {
+		case "condition": return {};
+		case "value": return portsByHandle(node.values);
+		case "task": return portsByHandle(node.task.outputs);
+		case "approval":
+		case "wait": return resolutionOutputPorts(node);
+		case "cron":
+		case "integration":
+		case "poll":
+		case "error":
+		case "manual":
+		case "webhook": return triggerOutputPorts(node);
+	}
+}
+//#endregion
+//#region src/flow/common/moduleChanges.ts
+async function imports(source) {
+	try {
+		const { parse } = await import("./lib-DrKav3HG.js");
+		const program = parse(source, {
+			errorRecovery: true,
+			sourceType: "module"
+		}).program;
+		const dependencies = /* @__PURE__ */ new Set();
+		for (const statement of program.body) {
+			if (statement.type != "ImportDeclaration") continue;
+			const match = /^\.\/(.+)\.mjs$/.exec(statement.source.value);
+			if (match?.[1] != null) dependencies.add(match[1]);
+		}
+		return [...dependencies].toSorted();
+	} catch {
+		return [];
+	}
+}
 //#endregion
 //#region src/flow/common/nodeChanges.ts
 var codeTaskTemplate = `export default async function (inputs, context) {
   return { result: inputs.value }
 }
 `;
-function createCodeTask(target, identity, name, module = void 0, ports = {
+var defaultCodeTaskPorts = {
 	inputs: [{
 		handle: "value",
 		jsonSchema: { type: "string" },
@@ -11650,7 +12246,8 @@ function createCodeTask(target, identity, name, module = void 0, ports = {
 		jsonSchema: {},
 		nullable: true
 	}]
-}) {
+};
+function createCodeTask(identity, name, module = void 0, ports = defaultCodeTaskPorts) {
 	return [{
 		kind: "module.create",
 		module: {
@@ -11679,30 +12276,48 @@ function createCodeTask(target, identity, name, module = void 0, ports = {
 				outputs: ports.outputs
 			}
 		},
-		nodeId: identity.nodeId,
-		target
+		nodeId: identity.nodeId
 	}];
 }
-function createManagedTask(target, identity, task) {
+function createManagedTask(identity, task) {
 	return [{
-		kind: "task.create",
-		task,
-		taskId: identity.taskId
-	}, {
 		kind: "graph.node.create",
 		node: {
 			inputs: defaultInputs(task.inputs),
 			kind: "task",
 			name: task.name,
-			taskId: identity.taskId
+			task
 		},
-		nodeId: identity.nodeId,
-		target
+		nodeId: identity.nodeId
 	}];
 }
-function createLlmTask(target, identity, name, mode, outputDescription, options = {}) {
+function createAgentTask(identity, name, defaults = {}) {
+	return createManagedTask(identity, {
+		name,
+		inputs: defaults.inputs ?? [{
+			handle: "input",
+			jsonSchema: { type: "string" },
+			nullable: false,
+			value: ""
+		}],
+		outputs: [{
+			handle: "output",
+			jsonSchema: { type: "string" },
+			nullable: false,
+			description: defaults.outputDescription ?? "The final result produced by the Agent."
+		}],
+		executor: {
+			kind: "agent",
+			model: "deepseek-v4-flash",
+			prompt: defaults.prompt ?? "Summarize the following content, highlighting key points and next steps.\n\n{{input}}",
+			maxRounds: 10,
+			tools: []
+		}
+	});
+}
+function createLlmTask(identity, name, mode, outputDescription, options = {}) {
 	const values = options.inputs ?? {};
-	return createManagedTask(target, identity, {
+	return createManagedTask(identity, {
 		executor: {
 			kind: "llm",
 			mode
@@ -11753,7 +12368,7 @@ function createLlmTask(target, identity, name, mode, outputDescription, options
 		}]
 	});
 }
-function createCondition(target, nodeId, name) {
+function createCondition(nodeId, name) {
 	return [{
 		kind: "graph.node.create",
 		node: {
@@ -11770,29 +12385,27 @@ function createCondition(target, nodeId, name) {
 			kind: "condition",
 			name
 		},
-		nodeId,
-		target
+		nodeId
 	}];
 }
-function createValue(target, nodeId, name) {
+function createValue(nodeId, name, values = [{
+	handle: "value",
+	jsonSchema: {},
+	nullable: true,
+	value: null
+}]) {
 	return [{
 		kind: "graph.node.create",
 		node: {
 			inputs: {},
 			kind: "value",
 			name,
-			values: [{
-				handle: "value",
-				jsonSchema: {},
-				nullable: true,
-				value: null
-			}]
+			values
 		},
-		nodeId,
-		target
+		nodeId
 	}];
 }
-function createWait(target, nodeId, name) {
+function createWait(nodeId, name) {
 	return [{
 		kind: "graph.node.create",
 		node: {
@@ -11802,11 +12415,10 @@ function createWait(target, nodeId, name) {
 			name,
 			prompt: name
 		},
-		nodeId,
-		target
+		nodeId
 	}];
 }
-function createApproval(target, nodeId, name) {
+function createApproval(nodeId, name) {
 	return [{
 		kind: "graph.node.create",
 		node: {
@@ -11816,19 +12428,17 @@ function createApproval(target, nodeId, name) {
 			name,
 			prompt: name
 		},
-		nodeId,
-		target
+		nodeId
 	}];
 }
-function createBuiltinTrigger(target, nodeId, node) {
+function createBuiltinTrigger(nodeId, node) {
 	return [{
 		kind: "graph.node.create",
 		node,
-		nodeId,
-		target
+		nodeId
 	}];
 }
-function createProviderTrigger(target, nodeId, definition, options) {
+function createProviderTrigger(nodeId, definition, options) {
 	const name = options.name ?? definition.displayName;
 	return [{
 		kind: "graph.node.create",
@@ -11850,10 +12460,33 @@ function createProviderTrigger(target, nodeId, definition, options) {
 			kind: "integration",
 			name
 		},
-		nodeId,
-		target
+		nodeId
 	}];
 }
+function cleanVariableBindings(content, operations) {
+	const before = bindingReferences(content.document);
+	const changed = applyFlowChanges(content, operations);
+	const after = bindingReferences(changed.document);
+	return [...operations, ...[...before.keys()].flatMap((bindingId) => after.has(bindingId) || changed.document.bindings[bindingId]?.kind != "variable" ? [] : [{
+		bindingId,
+		kind: "binding.delete"
+	}])];
+}
+function bindingReferences(document) {
+	const references = /* @__PURE__ */ new Map();
+	const add = (bindingId) => {
+		references.set(bindingId, (references.get(bindingId) ?? 0) + 1);
+	};
+	for (const node of Object.values(document.graph.nodes)) {
+		if (!("inputs" in node)) continue;
+		const inputs = Object.values(nodeInputMappings(node));
+		for (const mapping of inputs) {
+			if (mapping.kind != "sources") continue;
+			for (const source of mapping.sources) if (source.kind == "binding") add(source.bindingId);
+		}
+	}
+	return references;
+}
 function defaultInputs(ports) {
 	return Object.fromEntries(ports.flatMap((port) => "handle" in port && Object.hasOwn(port, "value") ? [[port.handle, {
 		kind: "value",
@@ -11863,20 +12496,1167 @@ function defaultInputs(ports) {
 function llmInputValue(values, handle, fallback) {
 	return values != null && Object.hasOwn(values, handle) ? values[handle] : fallback;
 }
-function createDecisionTask(target, identity, name = "AI Decision", questions) {
-	return createManagedTask(target, identity, decisionTask(questions, name));
+function createDecisionTask(identity, name = "AI Decision", questions) {
+	return createManagedTask(identity, decisionTask(questions, name));
 }
 //#endregion
+//#region src/control/common/authoringCondition.ts
+/** Preserve empty groups in invalid drafts; do not turn them into unconditional branches. */
+function conditionConfigurationView(node, source) {
+	const operand = (value) => value.kind == "source" ? source(value.source) : {
+		kind: "value",
+		...value.value === void 0 ? {} : { value: value.value },
+		...value.jsonSchema === void 0 ? {} : { schema: value.jsonSchema }
+	};
+	const expression = (value) => ({
+		left: operand(value.left),
+		operator: value.operator,
+		...value.right === void 0 ? {} : { right: operand(value.right) }
+	});
+	return {
+		match: node.matchMode,
+		branches: node.cases.map((branch) => {
+			const groups = branch.groups.map((group) => group.expressions.length == 1 ? expression(group.expressions[0]) : { all: group.expressions.map(expression) });
+			return {
+				name: branch.output,
+				...branch.description === void 0 ? {} : { description: branch.description },
+				when: groups.length == 1 ? groups[0] : { any: groups }
+			};
+		})
+	};
+}
+function prepareConditionConfiguration(config, source) {
+	const operand = (value) => value.kind == "value" ? {
+		kind: "value",
+		...value.value === void 0 ? {} : { value: value.value },
+		...value.schema === void 0 ? {} : { jsonSchema: value.schema }
+	} : {
+		kind: "source",
+		source: source(value)
+	};
+	const expression = (value) => ({
+		left: operand(value.left),
+		operator: value.operator,
+		...value.right === void 0 ? {} : { right: operand(value.right) }
+	});
+	return {
+		matchMode: config.match,
+		cases: config.branches.map((branch) => {
+			const groups = "any" in branch.when ? branch.when.any : [branch.when];
+			return {
+				output: branch.name,
+				...branch.description === void 0 ? {} : { description: branch.description },
+				groups: groups.map((group) => ({ expressions: ("all" in group ? group.all : [group]).map(expression) }))
+			};
+		})
+	};
+}
+/** Map a path relative to a persisted Condition configuration into its normalized public config. */
+function conditionConfigurationFieldPath(node, path) {
+	if (path[0] == "matchMode") return ["match", ...path.slice(1)];
+	if (path[0] != "cases") return path;
+	if (path.length == 1) return ["branches"];
+	const branchIndex = Number(path[1]), branch = node.cases[branchIndex], base = ["branches", path[1]];
+	if (path[2] == "output") return [
+		...base,
+		"name",
+		...path.slice(3)
+	];
+	if (path[2] != "groups") return [...base, ...path.slice(2)];
+	base.push("when");
+	if (branch == null || path.length == 3) return base;
+	const groupIndex = Number(path[3]), group = branch.groups[groupIndex];
+	if (branch.groups.length != 1) base.push("any", path[3]);
+	if (path[4] != "expressions") return [...base, ...path.slice(4)];
+	if (group == null || path.length == 5) return group?.expressions.length == 1 ? base : [...base, "all"];
+	if (group.expressions.length != 1) base.push("all", path[5]);
+	const remaining = path.slice(6).filter((part, index) => !(index == 1 && part == "source"));
+	if (remaining[0] == "left" || remaining[0] == "right") switch (remaining[1]) {
+		case "jsonSchema":
+			remaining[1] = "schema";
+			break;
+		case "nodeId":
+			remaining[1] = "node";
+			break;
+		case "output":
+			remaining[1] = "port";
+			break;
+		case "bindingId": remaining[1] = "name";
+	}
+	return [...base, ...remaining];
+}
+//#endregion
+//#region src/control/common/authoringDiagnosticFields.ts
+var metadata = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"icon",
+	"timeoutMs",
+	"maxExecutions"
+]);
+function portField(ports, path, parent) {
+	const port = ports[Number(path[0])];
+	if (port == null || !("handle" in port)) return parent;
+	const field = `${parent}.${port.handle}`;
+	switch (path[1]) {
+		case "jsonSchema": return [
+			field,
+			"schema",
+			...path.slice(2)
+		].join(".");
+		case "value": return [
+			field,
+			"default",
+			...path.slice(2)
+		].join(".");
+		case "nullable":
+		case "description": return [field, ...path.slice(1)].join(".");
+		default: return field;
+	}
+}
+/** Accept a decoded JSON Pointer, including or omitting its initial empty component. */
+function authoringDiagnosticField(_content, node, parts) {
+	const path = parts[0] == "" ? parts.slice(1) : parts;
+	if (path[0] == "modules") return "code";
+	let location = path[0] == "document" && path[1] == "graph" && path[2] == "nodes" ? path.slice(4) : path;
+	const inlineDefinition = node.kind == "task" && location[0] == "task";
+	if (inlineDefinition) location = location.slice(1);
+	if (location.length == 0) return "config";
+	const head = location[0];
+	if (!inlineDefinition && metadata.has(head)) return location.join(".");
+	if (head == "prompt") return "prompt";
+	if (head == "inputs" && !inlineDefinition) {
+		if (node.kind == "condition" && location[1] != null) {
+			const [branch, group, expression, side] = location[1].split("/");
+			if (branch != null && group != null && expression != null && (side == "left" || side == "right")) return ["config", ...conditionConfigurationFieldPath(node, [
+				"cases",
+				branch,
+				"groups",
+				group,
+				"expressions",
+				expression,
+				side
+			])].join(".");
+			return "config.branches";
+		}
+		return location[1] == null ? "inputs" : `inputs.${location[1]}`;
+	}
+	if (node.kind == "task") {
+		const task = node.task;
+		if (task == null) return "config";
+		const executor = "executor" in task ? task.executor : void 0;
+		if (head == "additionalInputs") return portField(node.additionalInputs ?? [], location.slice(1), "config.inputs");
+		if (head == "inputs" || head == "outputs") {
+			const ports = task[head];
+			const port = ports[Number(location[1])];
+			if (head == "outputs" && (executor?.kind == "agent" || executor?.kind == "llm")) return location[2] == "jsonSchema" ? [
+				"config",
+				"resultSchema",
+				...location.slice(3)
+			].join(".") : "config.resultSchema";
+			if (head == "inputs" && executor?.kind == "llm" && port != null && "handle" in port && [
+				"model",
+				"template",
+				"messages"
+			].includes(port.handle)) return [
+				"config",
+				port.handle,
+				...location[2] == "value" ? location.slice(3) : []
+			].join(".");
+			const custom = executor == null || executor.kind == "agent" || executor.kind == "llm";
+			return portField(ports, location.slice(1), custom ? `config.${head}` : head == "inputs" ? "inputPorts" : "outputPorts");
+		}
+		if (head == "executor") {
+			const field = location[1];
+			if (field == null || field == "kind") return "config";
+			if (field == "prompt") return "prompt";
+			if (executor?.kind == "openapi") {
+				if (field == "document") return "config";
+				if (field == "auth") return "config.authentication";
+			}
+			if (executor?.kind == "agent") {
+				if (field == "tools") {
+					const tool = executor.tools[Number(location[2])];
+					if (tool == null) return "config.tools";
+					const base = `config.tools.${location[2]}`;
+					if (location[3] == "id") return base;
+					if (location[3] == "inputs") {
+						const input = tool.inputs[Number(location[4])];
+						if (input == null) return `${base}.inputs`;
+						return location[5] == "source" ? [
+							base,
+							"inputs",
+							input.handle,
+							...location.slice(6)
+						].join(".") : `${base}.inputs.${input.handle}`;
+					}
+				}
+				if (field == "notification" && location[2] == "inputDefinitions") return "config.notification.inputs";
+			}
+			return ["config", ...location.slice(1)].join(".");
+		}
+		if (head == "capabilities") return ["config", ...location].join(".");
+		if (head == "name") return "name";
+		return "config";
+	}
+	switch (node.kind) {
+		case "condition": return head == "cases" || head == "matchMode" ? ["config", ...conditionConfigurationFieldPath(node, location)].join(".") : "config";
+		case "wait":
+		case "approval": return head == "inputDefinitions" ? portField(node.inputDefinitions, location.slice(1), "config.inputs") : "config";
+		case "webhook":
+			if (head == "bodyFields") return portField(node.bodyFields, location.slice(1), "config.body");
+			return head == "method" || head == "options" ? ["config", ...location].join(".") : "config";
+		case "value": {
+			if (head != "values") return "config";
+			const port = node.values[Number(location[1])];
+			if (port == null) return "config.values";
+			if (location[2] == "value") return [
+				"config",
+				"values",
+				port.handle,
+				...location.slice(3)
+			].join(".");
+			return portField(node.values, location.slice(1), "config.outputs");
+		}
+		case "cron": return head == "cronTimes" ? [
+			"config",
+			"schedule",
+			...location.slice(1)
+		].join(".") : "config";
+		case "poll":
+		case "integration":
+			if (head == "config") return location[1] == null ? "inputs" : `inputs.${location[1]}`;
+			if (head == "definition") return location[1] == "configInputs" ? portField(node.definition.configInputs, location.slice(2), "inputPorts") : "config.key";
+			if (head == "pollTimes") return [
+				"config",
+				"schedule",
+				...location.slice(1)
+			].join(".");
+			return head == "connectionId" ? "config.connectionId" : "config";
+		case "error": return head == "sourceFlowIds" ? ["config", ...location].join(".") : "config";
+		default: return "config";
+	}
+}
+//#endregion
+//#region src/control/common/authoringFields.ts
+var record$1 = (value) => value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+/** Business field contracts, independent of storage handles and presentation groups. */
+function fieldsView(ports) {
+	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, {
+		schema: port.jsonSchema,
+		nullable: port.nullable,
+		...port.description == null ? {} : { description: port.description },
+		...Object.hasOwn(port, "value") ? { default: port.value } : {}
+	}]] : []));
+}
+function fieldsToPorts(fields, previous) {
+	const remaining = new Map(Object.entries(record$1(fields)));
+	function port(handle, value) {
+		const field = record$1(value);
+		return {
+			handle,
+			jsonSchema: Object.hasOwn(field, "schema") ? field.schema : {},
+			nullable: field.nullable ?? true,
+			...field.description == null ? {} : { description: String(field.description) },
+			...Object.hasOwn(field, "default") ? { value: field.default } : {}
+		};
+	}
+	return [...previous.flatMap((old) => {
+		if (!("handle" in old)) return [old];
+		if (!remaining.has(old.handle)) return [];
+		const value = remaining.get(old.handle);
+		remaining.delete(old.handle);
+		return [dequal(fieldsView([old])[old.handle], value) ? old : port(old.handle, value)];
+	}), ...Array.from(remaining, ([handle, value]) => port(handle, value))];
+}
+//#endregion
+//#region src/control/common/authoringTools.ts
+var AuthoringToolInputError = class extends Error {
+	constructor(details) {
+		super(`Unknown input ${JSON.stringify(details.input)} for tool ${JSON.stringify(details.tool)}. Choose from: ${details.choices.join(", ") || "(none)"}.`);
+		this.code = "tool.input-not-found";
+		this.name = "AuthoringToolInputError";
+		this.details = details;
+	}
+};
+function outwardAgentTools(tools) {
+	return tools.map(({ id: _id, inputs, ...tool }) => ({
+		...tool,
+		inputs: Object.fromEntries(inputs.map((input) => [input.handle, input.source]))
+	}));
+}
+/** Keep persisted Action contracts until the caller selects a different Action. */
+async function prepareAgentTools(tools, previous, action, id) {
+	const prepared = [];
+	for (const tool of tools) {
+		const old = previous.find((item) => item.name == tool.name);
+		const retained = old?.action == tool.action ? old : void 0;
+		const definition = retained == null ? await action(tool.action) : void 0;
+		const ports = retained?.inputs ?? Object.entries(definition.inputs).map(([handle, port]) => Object.assign({}, port, {
+			handle,
+			source: { kind: "model" }
+		}));
+		const choices = ports.map((port) => port.handle);
+		for (const input of Object.keys(tool.inputs ?? {})) if (!choices.includes(input)) throw new AuthoringToolInputError({
+			tool: tool.name,
+			action: tool.action,
+			input,
+			choices
+		});
+		const { inputs: sources, ...settings } = tool;
+		prepared.push({
+			...settings,
+			id: old?.id ?? id(),
+			action: definition?.actionId ?? tool.action,
+			inputs: ports.map((port) => sources != null && Object.hasOwn(sources, port.handle) ? Object.assign({}, port, { source: sources[port.handle] }) : port)
+		});
+	}
+	return prepared;
+}
+//#endregion
+//#region src/control/common/authoring.ts
+var record = (value) => value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+var json$2 = (value) => JSON.parse(JSON.stringify(value));
+var AuthoringError = class extends Error {
+	constructor(code, message, details = {}) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "AuthoringError";
+	}
+};
+function fail(code, message, details = {}) {
+	throw new AuthoringError(code, message, details);
+}
+function nodeAt(content, ref) {
+	return (Object.hasOwn(content.document.graph.nodes, ref) ? content.document.graph.nodes[ref] : void 0) ?? fail("node.not-found", `Node ${JSON.stringify(ref)} does not exist.`, { node: ref });
+}
+function taskAt(node) {
+	return node.kind == "task" ? node.task : void 0;
+}
+var llmReservedInputs = [
+	"model",
+	"template",
+	"messages"
+];
+function inputDefinitions(node) {
+	if (node.kind == "condition") return {};
+	if (node.kind == "poll" || node.kind == "integration") return Object.fromEntries(node.definition.configInputs.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
+	return nodeInputPorts(node);
+}
+function inputMappings(node) {
+	return node.kind == "condition" ? {} : node.kind == "poll" || node.kind == "integration" ? node.config : nodeInputMappings(node);
+}
+function typeOf(node) {
+	const task = taskAt(node);
+	return node.kind != "task" ? node.kind : task != null && "executor" in task ? task.executor.kind : "code";
+}
+function outwardSource(content, value) {
+	if (Array.isArray(value)) return value.map((v) => outwardSource(content, v));
+	if (value == null || typeof value != "object") return value;
+	const v = record(value);
+	if (v.kind == "node" && typeof v.nodeId == "string" && typeof v.output == "string") return {
+		kind: "output",
+		node: v.nodeId,
+		port: v.output,
+		...v.field == null ? {} : { field: v.field }
+	};
+	if (v.kind == "binding" && typeof v.bindingId == "string") return {
+		kind: "variable",
+		name: content.document.bindings[v.bindingId]?.target ?? "[missing variable]"
+	};
+	if (v.kind == "value") return value;
+	return Object.fromEntries(Object.entries(v).map(([k, item]) => [k, outwardSource(content, item)]));
+}
+function authoringEdges(edges) {
+	return edges.map((edge) => edge.sourceHandle == null ? {
+		source: edge.source,
+		target: edge.target
+	} : {
+		source: edge.source,
+		target: edge.target,
+		branch: edge.sourceHandle
+	});
+}
+function authoringNode(content, ref) {
+	const node = nodeAt(content, ref), type = typeOf(node), task = taskAt(node);
+	let config = {};
+	const texts = {};
+	if (task != null && "executor" in task) {
+		const { kind: _, ...executor } = task.executor;
+		config = { ...executor };
+		if (task.executor.kind == "agent") {
+			const { prompt, tools, notification, ...rest } = task.executor;
+			const { kind: _agentKind, ...settings } = rest;
+			config = {
+				...settings,
+				inputs: fieldsView([...task.inputs, ...node.kind == "task" ? node.additionalInputs ?? [] : []]),
+				resultSchema: task.outputs.find((port) => "handle" in port)?.jsonSchema ?? { type: "string" },
+				tools: outwardAgentTools(tools)
+			};
+			texts.prompt = prompt;
+			if (notification != null) {
+				const { inputDefinitions: _definitions, ...noticeSettings } = notification;
+				config.notification = noticeSettings;
+			}
+		} else if (task.executor.kind == "llm") config = {
+			...llmConfigurationView(task),
+			inputs: fieldsView([...task.inputs, ...node.kind == "task" ? node.additionalInputs ?? [] : []].filter((port) => !("handle" in port) || !llmReservedInputs.includes(port.handle)))
+		};
+		else if (task.executor.kind == "openapi") config = { ...openApiConfigView(task.executor) };
+	} else if (node.kind == "task" && "moduleId" in node.task) {
+		config = {
+			inputs: fieldsView([...node.task.inputs, ...node.additionalInputs ?? []]),
+			outputs: fieldsView(node.task.outputs),
+			...node.task.capabilities == null ? {} : { capabilities: node.task.capabilities }
+		};
+		texts.code = content.modules[node.task.moduleId]?.source ?? "";
+	} else switch (node.kind) {
+		case "condition":
+			config = { ...conditionConfigurationView(node, (value) => outwardSource(content, value)) };
+			break;
+		case "value":
+			config = {
+				values: Object.fromEntries(node.values.filter((port) => Object.hasOwn(port, "value")).map((port) => [port.handle, port.value])),
+				outputs: fieldsView(node.values.map(({ value: _value, ...port }) => port))
+			};
+			break;
+		case "wait":
+		case "approval":
+			config = { inputs: fieldsView(node.inputDefinitions) };
+			texts.prompt = node.prompt;
+			break;
+		case "webhook":
+			config = {
+				body: fieldsView(node.bodyFields),
+				method: node.method,
+				...node.options == null ? {} : { options: node.options }
+			};
+			break;
+		case "cron":
+			config = { schedule: node.cronTimes };
+			break;
+		case "error":
+			config = node.sourceFlowIds == null ? {} : { sourceFlowIds: node.sourceFlowIds };
+			break;
+		case "poll":
+		case "integration": config = {
+			key: node.definition.key,
+			...node.connectionId == null ? {} : { connectionId: node.connectionId },
+			...node.kind == "poll" ? { schedule: node.pollTimes } : {}
+		};
+	}
+	const edges = authoringEdges(content.document.graph.edges);
+	return {
+		ref,
+		type,
+		name: node.name ?? ref,
+		readOnly: false,
+		...node.description == null ? {} : { description: node.description },
+		...node.icon == null ? {} : { icon: node.icon },
+		..."timeoutMs" in node && node.timeoutMs != null ? { timeoutMs: node.timeoutMs } : {},
+		..."maxExecutions" in node && node.maxExecutions != null ? { maxExecutions: node.maxExecutions } : {},
+		config: json$2(config),
+		texts: Object.fromEntries(Object.entries(texts).map(([field, text]) => [field, {
+			lines: text.split("\n").length,
+			characters: text.length
+		}])),
+		inputs: outwardSource(content, inputMappings(node)),
+		inputPorts: fieldsView(Object.entries(inputDefinitions(node)).map(([handle, port]) => Object.assign({}, port, { handle }))),
+		outputPorts: fieldsView(Object.entries(nodeOutputPorts(node)).map(([handle, port]) => Object.assign({}, port, { handle }))),
+		...task != null && "executor" in task && task.executor.kind == "openapi" ? { authenticationChoices: openApiAuthenticationChoices(task.executor) } : {},
+		incoming: edges.filter((e) => e.target == ref),
+		outgoing: edges.filter((e) => e.source == ref)
+	};
+}
+function textAt(content, node, field) {
+	if (field == "code" && node.kind == "task" && "moduleId" in node.task) return content.modules[node.task.moduleId]?.source ?? fail("text.missing", "Node source is missing.");
+	const task = taskAt(node);
+	if (field == "prompt" && task != null && "executor" in task && task.executor.kind == "agent") return task.executor.prompt;
+	if (field == "prompt" && (node.kind == "wait" || node.kind == "approval")) return node.prompt;
+	return fail("text.unsupported", `This node has no ${field} field.`);
+}
+function readAuthoring(content, query = {}) {
+	const q = authoringReadSchema.parse(query);
+	if (q.text != null) {
+		const lines = textAt(content, nodeAt(content, q.text.node), q.text.field).split("\n");
+		const selected = lines.slice(q.text.start - 1, q.text.start - 1 + q.text.lines);
+		let count = 0, characters = 0;
+		for (const line of selected) {
+			if (characters + line.length + 1 > 24e3) break;
+			characters += line.length + 1;
+			count++;
+		}
+		if (count == 0 && selected.length > 0) fail("text.line-too-large", "Selected line exceeds 24000 characters; use search to locate a smaller edit.", {
+			node: q.text.node,
+			field: q.text.field
+		});
+		const end = q.text.start - 1 + count;
+		return { text: {
+			...q.text,
+			content: selected.slice(0, count).join("\n"),
+			totalLines: lines.length,
+			...end < lines.length ? { nextStart: end + 1 } : {},
+			truncated: end < lines.length
+		} };
+	}
+	if (q.nodes != null) return { nodes: q.nodes.map((ref) => authoringNode(content, ref)) };
+	return {
+		nodes: Object.keys(content.document.graph.nodes).map((ref) => {
+			const node = authoringNode(content, ref);
+			return {
+				ref,
+				type: node.type,
+				name: node.name,
+				readOnly: node.readOnly,
+				inputHandles: Object.keys(node.inputPorts),
+				outputHandles: Object.keys(node.outputPorts),
+				inputs: compactValue(node.inputs),
+				texts: node.texts
+			};
+		}),
+		edges: authoringEdges(content.document.graph.edges)
+	};
+}
+function compactValue(value, depth = 0) {
+	if (depth >= 4 && value != null && typeof value == "object") return { truncated: true };
+	if (typeof value == "string") return value.length > 160 ? {
+		preview: value.slice(0, 160),
+		truncated: true
+	} : value;
+	if (Array.isArray(value)) return value.length > 8 ? {
+		preview: value.slice(0, 8).map((v) => compactValue(v, depth + 1)),
+		truncated: true
+	} : value.map((v) => compactValue(v, depth + 1));
+	if (value != null && typeof value == "object") return Object.fromEntries([...Object.entries(value).slice(0, 8).map(([key, v]) => [key, compactValue(v, depth + 1)]), ...Object.keys(value).length > 8 ? [["truncated", true]] : []]);
+	return value;
+}
+function searchAuthoring(content, query) {
+	const q = authoringSearchSchema.parse(query), needle = q.query.toLowerCase();
+	const matches = [];
+	for (const [ref, node] of Object.entries(content.document.graph.nodes)) {
+		const view = authoringNode(content, ref);
+		if (q.type != null && q.type != view.type) continue;
+		const fields = {
+			name: view.name,
+			description: view.description ?? "",
+			inputs: JSON.stringify(view.inputs),
+			config: JSON.stringify(view.config),
+			...Object.fromEntries(Object.keys(view.texts).map((field) => [field, textAt(content, node, field)]))
+		};
+		for (const [field, value] of Object.entries(fields)) for (const [index, line] of value.split("\n").entries()) {
+			const at = line.toLowerCase().indexOf(needle);
+			if (at >= 0) matches.push({
+				node: ref,
+				field,
+				line: index + 1,
+				excerpt: line.slice(Math.max(0, at - 100), at + Math.max(needle.length, 100))
+			});
+		}
+	}
+	const end = q.offset + q.limit;
+	return {
+		matches: matches.slice(q.offset, end),
+		total: matches.length,
+		...end < matches.length ? { nextOffset: end } : {}
+	};
+}
+function merge(base, patch) {
+	if (patch == null || typeof patch != "object" || Array.isArray(patch)) return patch;
+	const result = { ...record(base) };
+	for (const [key, value] of Object.entries(patch)) {
+		if ([
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key)) fail("edit.invalid-field", `Invalid field ${key}.`);
+		Object.defineProperty(result, key, {
+			value: merge(result[key], value),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	return result;
+}
+function clearPath(value, path) {
+	let current = value;
+	for (const part of path.slice(0, -1)) {
+		if (!Object.hasOwn(current, part) || Array.isArray(current[part]) || current[part] == null || typeof current[part] != "object") fail("edit.invalid-field", `Cannot clear ${path.join(".")}.`);
+		current = record(current[part]);
+	}
+	const last = path.at(-1);
+	if (!Object.hasOwn(current, last)) fail("edit.invalid-field", `Cannot clear absent field ${path.join(".")}.`);
+	delete current[last];
+}
+async function compileAuthoring(base, request, host) {
+	const parsed = authoringRequestSchema.parse(request);
+	let content = base, index = 0, sequence = 0;
+	const operations = [], aliases = {};
+	const touchedModules = /* @__PURE__ */ new Set();
+	function fresh(label) {
+		return host.id(`${index}:${label}:${sequence++}`);
+	}
+	function apply(changes) {
+		const checked = decodeChangeOperations(changes);
+		content = applyFlowChanges(content, checked);
+		operations.push(...checked);
+	}
+	function resolve(ref) {
+		return ref.startsWith("$") ? (Object.hasOwn(aliases, ref.slice(1)) ? aliases[ref.slice(1)] : void 0) ?? fail("node.alias-missing", `Unknown alias ${ref}.`) : ref;
+	}
+	function source(value) {
+		if (value.kind == "output") {
+			const ref = resolve(value.node);
+			const choices = Object.keys(nodeOutputPorts(nodeAt(content, ref)));
+			const port = value.port ?? (choices.length == 1 ? choices[0] : void 0);
+			if (port == null) fail("source.port-required", "Choose an output name; this node does not have exactly one output.", {
+				node: ref,
+				choices
+			});
+			return {
+				kind: "node",
+				nodeId: ref,
+				output: port,
+				...value.field == null ? {} : { field: value.field }
+			};
+		}
+		const existing = Object.entries(content.document.bindings).find(([, binding]) => binding.target == value.name);
+		const bindingId = existing?.[0] ?? fresh("binding");
+		if (existing == null) apply([{
+			kind: "binding.create",
+			bindingId,
+			binding: {
+				kind: "variable",
+				target: value.name
+			}
+		}]);
+		return {
+			kind: "binding",
+			bindingId
+		};
+	}
+	function replace(ref, node) {
+		const before = nodeAt(content, ref);
+		if (!dequal(before, node)) apply([{
+			kind: "graph.node.replace",
+			nodeId: ref,
+			before,
+			node
+		}]);
+	}
+	function taskNode(ref, task) {
+		const node = nodeAt(content, ref);
+		if (node.kind != "task" || !("executor" in node.task)) fail("node.invalid-type", "Expected a managed node.");
+		replace(ref, {
+			...node,
+			task
+		});
+	}
+	async function connectorTask(config, name) {
+		const action = await host.action(String(config.action));
+		return {
+			name,
+			executor: {
+				kind: "connector",
+				action: action.actionId,
+				...config.connectionId == null ? {} : { connectionId: String(config.connectionId) }
+			},
+			inputs: Object.entries(action.inputs).map(([handle, port]) => Object.assign({ handle }, port)),
+			outputs: Object.entries(action.outputs).map(([handle, port]) => Object.assign({ handle }, port))
+		};
+	}
+	async function configure(ref, patch = {}, clear = []) {
+		const node = nodeAt(content, ref), view = authoringNode(content, ref), type = view.type;
+		const update = record(merge({
+			name: view.name,
+			...view.description == null ? {} : { description: view.description },
+			...view.icon == null ? {} : { icon: view.icon },
+			...view.timeoutMs == null ? {} : { timeoutMs: view.timeoutMs },
+			...view.maxExecutions == null ? {} : { maxExecutions: view.maxExecutions },
+			config: view.config
+		}, patch));
+		const explicit = (key) => Object.hasOwn(record(patch.config), key) || clear.some((path) => path[0] == "config" && path[1] == key);
+		if (type == "openapi" && Object.hasOwn(record(patch.config), "authentication")) record(update.config).authentication = record(patch.config).authentication;
+		for (const path of clear) clearPath(update, path);
+		if (typeof update.name != "string") fail("node.name-required", "Node name cannot be cleared.");
+		const config = authoringConfigurations[type].parse(update.config);
+		const { config: _, ...metadata } = update;
+		const { name: _name, description: _description, icon: _icon, ...rest } = node;
+		let next = {
+			...rest,
+			...metadata
+		};
+		if ("inputs" in node) {
+			const clean = { ...next };
+			if (!Object.hasOwn(update, "timeoutMs")) delete clean.timeoutMs;
+			if (!Object.hasOwn(update, "maxExecutions")) delete clean.maxExecutions;
+			next = clean;
+		} else if (update.timeoutMs != null || update.maxExecutions != null) fail("node.invalid-field", "Trigger nodes do not have execution limits.");
+		function taskInputs(task, reserved = []) {
+			if (node.kind != "task") throw new Error("Expected a task.");
+			const fields = record(config.inputs);
+			for (const key of reserved) if (Object.hasOwn(fields, key)) fail("input.reserved", `Configure ${key} through config.${key} or input.set.`, {
+				node: ref,
+				input: key
+			});
+			const extraNames = new Set(node.additionalInputs?.map((port) => port.handle) ?? []);
+			const main = Object.fromEntries(Object.entries(fields).filter(([key]) => !extraNames.has(key)));
+			for (const port of task.inputs) if ("handle" in port && (reserved.includes(port.handle) || extraNames.has(port.handle) && Object.hasOwn(fields, port.handle))) main[port.handle] = fieldsView([port])[port.handle];
+			if (node.additionalInputs != null) {
+				const extra = Object.fromEntries(Object.entries(fields).filter(([key]) => extraNames.has(key)));
+				for (const port of node.additionalInputs) if (reserved.includes(port.handle)) extra[port.handle] = fieldsView([port])[port.handle];
+				next = {
+					...next,
+					additionalInputs: fieldsToPorts(extra, node.additionalInputs)
+				};
+			}
+			return fieldsToPorts(main, task.inputs);
+		}
+		if (node.kind == "task" && "moduleId" in node.task) {
+			const inputs = taskInputs(node.task);
+			next = {
+				...next,
+				task: {
+					moduleId: node.task.moduleId,
+					name: String(update.name),
+					...config,
+					inputs,
+					outputs: fieldsToPorts(config.outputs, node.task.outputs)
+				}
+			};
+		} else if (node.kind == "task" && "executor" in node.task) {
+			const before = node.task;
+			let task;
+			if (type == "connector") task = config.action == (before.executor.kind == "connector" ? before.executor.action : "") ? {
+				...before,
+				name: String(update.name),
+				executor: {
+					kind: "connector",
+					...config
+				}
+			} : await connectorTask(config, String(update.name));
+			else if (type == "decision") task = decisionTask(config.questions, String(update.name));
+			else if (type == "openapi") task = await prepareOpenApiTask(config, before, (url) => host.openapi(url), String(update.name), {
+				authentication: explicit("authentication"),
+				serverUrl: explicit("serverUrl")
+			});
+			else if (type == "llm") {
+				task = prepareLlmConfiguration(config, before, String(update.name));
+				task = {
+					...task,
+					inputs: taskInputs(task, llmReservedInputs)
+				};
+			} else {
+				const { inputs: _inputs, resultSchema, notification, tools, ...executor } = config;
+				const prepared = {
+					...executor,
+					kind: type,
+					...before.executor.kind == "agent" ? { prompt: before.executor.prompt } : {}
+				};
+				if (type == "agent") {
+					const previous = before.executor.kind == "agent" ? before.executor : void 0;
+					Object.assign(prepared, { tools: await prepareAgentTools(tools, previous?.tools ?? [], (id) => host.action(id), () => fresh("tool")) });
+					Reflect.deleteProperty(prepared, "notification");
+					if (notification != null) {
+						if (dequal(record(view.config).notification, notification) && previous?.notification != null) Object.assign(prepared, { notification: previous.notification });
+						else {
+							const settings = record(notification);
+							const definition = await connectorTask(settings, `${update.name} notification`);
+							Object.assign(prepared, { notification: {
+								action: settings.action,
+								...settings.connectionId == null ? {} : { connectionId: settings.connectionId },
+								inputDefinitions: definition.inputs,
+								messageHandle: settings.messageHandle,
+								inputs: settings.inputs
+							} });
+						}
+					}
+				}
+				const outputs = dequal(record(view.config).resultSchema, resultSchema) ? before.outputs : before.outputs.map((port) => "handle" in port ? {
+					...port,
+					jsonSchema: resultSchema
+				} : port);
+				task = {
+					name: String(update.name),
+					inputs: type == "agent" ? taskInputs(before) : before.inputs,
+					outputs,
+					executor: prepared
+				};
+			}
+			next = {
+				...next,
+				task
+			};
+		} else switch (node.kind) {
+			case "condition":
+				next = {
+					...next,
+					...prepareConditionConfiguration(config, source)
+				};
+				break;
+			case "value": {
+				const fields = { ...record(config.outputs) };
+				for (const key of Object.keys(record(config.values))) if (!Object.hasOwn(fields, key)) fields[key] = {};
+				const values = fieldsToPorts(fields, node.values.map(({ value: _value, ...port }) => port)).filter((port) => "handle" in port).map((port) => Object.assign({}, port, Object.hasOwn(record(config.values), port.handle) ? { value: record(config.values)[port.handle] } : {}));
+				next = {
+					...next,
+					values
+				};
+				break;
+			}
+			case "wait":
+			case "approval":
+				next = {
+					...next,
+					inputDefinitions: fieldsToPorts(config.inputs, node.inputDefinitions)
+				};
+				break;
+			case "webhook": {
+				const { body, ...settings } = config;
+				const { options: _options, ...withoutOptions } = next;
+				next = {
+					...withoutOptions,
+					...settings,
+					bodyFields: fieldsToPorts(body, node.bodyFields)
+				};
+				break;
+			}
+			case "cron":
+				next = {
+					...next,
+					cronTimes: config.schedule
+				};
+				break;
+			case "poll":
+			case "integration": {
+				if (config.key != node.definition.key) fail("trigger.key-immutable", "Create a new node to change its Trigger type.");
+				const { connectionId: _connection, ...withoutConnection } = next;
+				next = {
+					...withoutConnection,
+					...config.connectionId == null ? {} : { connectionId: config.connectionId },
+					...node.kind == "poll" ? { pollTimes: config.schedule } : {}
+				};
+				break;
+			}
+			default: {
+				const fields = { ...next };
+				for (const key of Object.keys(record(view.config))) delete fields[key];
+				next = {
+					...fields,
+					...config
+				};
+			}
+		}
+		replace(ref, next);
+	}
+	async function setText(ref, field, text) {
+		const node = nodeAt(content, ref), before = textAt(content, node, field);
+		if (before == text) return;
+		if (field == "code" && node.kind == "task" && "moduleId" in node.task) {
+			const moduleId = node.task.moduleId, module = content.modules[moduleId];
+			const shared = Object.values(content.document.graph.nodes).some((n) => n.kind == "task" && "moduleId" in n.task && n.task.moduleId == moduleId && n !== node) || Object.values(content.modules).some((m) => m.imports.includes(moduleId));
+			const imports$1 = await imports(text);
+			if (shared) {
+				const id = fresh("module");
+				apply([{
+					kind: "module.create",
+					moduleId: id,
+					module: {
+						...module,
+						source: text,
+						imports: imports$1
+					}
+				}]);
+				replace(ref, {
+					...node,
+					task: {
+						...node.task,
+						moduleId: id
+					}
+				});
+			} else apply([{
+				kind: "module.source.replace",
+				moduleId,
+				beforeSource: before,
+				beforeImports: module.imports,
+				source: text,
+				imports: imports$1
+			}]);
+		} else if (node.kind == "task" && "executor" in node.task) {
+			const task = node.task;
+			taskNode(ref, {
+				...task,
+				executor: {
+					...task.executor,
+					prompt: text
+				}
+			});
+		} else if (node.kind == "wait" || node.kind == "approval") replace(ref, {
+			...node,
+			prompt: text
+		});
+	}
+	async function setInput(ref, input, value) {
+		const node = nodeAt(content, ref);
+		if (node.kind == "condition") fail("input.unsupported", "Edit the branch condition operands through config.branches.", {
+			node: ref,
+			field: "config.branches"
+		});
+		if (node.kind == "poll" || node.kind == "integration") {
+			if (!Object.hasOwn(inputDefinitions(node), input)) fail("input.not-found", `Unknown input ${input}.`, {
+				node: ref,
+				input,
+				choices: Object.keys(inputDefinitions(node))
+			});
+			if (value.kind != "value" && value.kind != "unset" && value.kind != "default") fail("input.source-unsupported", "Trigger parameters accept only value, unset or default; they cannot depend on execution outputs or variables.", {
+				node: ref,
+				input,
+				allowed: [
+					"value",
+					"unset",
+					"default"
+				]
+			});
+			const config = { ...node.config };
+			if (value.kind == "default") delete config[input];
+			else config[input] = value;
+			replace(ref, {
+				...node,
+				config
+			});
+			return;
+		}
+		if (!Object.hasOwn(inputDefinitions(node), input)) {
+			const type = typeOf(node);
+			if (![
+				"agent",
+				"code",
+				"llm",
+				"wait",
+				"approval"
+			].includes(type)) fail("input.not-found", `Unknown input ${input}.`, {
+				node: ref,
+				input,
+				choices: Object.keys(inputDefinitions(node))
+			});
+			if (type == "llm" && llmReservedInputs.includes(input)) fail("input.not-found", `Missing built-in LLM input ${input}.`, {
+				node: ref,
+				input,
+				choices: Object.keys(inputDefinitions(node))
+			});
+			await configure(ref, { config: { inputs: { [input]: {} } } });
+		}
+		const mapping = value.kind == "default" ? void 0 : value.kind == "value" || value.kind == "unset" ? value : {
+			kind: "sources",
+			sources: (value.kind == "sources" ? value.sources : [value]).map(source)
+		};
+		const before = nodeInputMappings(nodeAt(content, ref))[input];
+		if (!dequal(before, mapping)) apply([{
+			kind: "graph.node.input.set",
+			nodeId: ref,
+			handle: input,
+			before,
+			...mapping == null ? {} : { value: mapping }
+		}]);
+	}
+	for (const edit of parsed.edits) {
+		try {
+			switch (edit.op) {
+				case "node.add": {
+					if (Object.hasOwn(aliases, edit.as)) fail("node.alias-duplicate", `Duplicate alias ${edit.as}.`);
+					const nodeId = host.id(`node:${edit.as}`), identity = {
+						nodeId,
+						moduleId: fresh("module")
+					}, name = edit.name;
+					aliases[edit.as] = nodeId;
+					const config = edit.config ?? {};
+					let changes;
+					switch (edit.type) {
+						case "code":
+							changes = createCodeTask(identity, name, void 0, {
+								inputs: [],
+								outputs: config.outputs == null ? defaultCodeTaskPorts.outputs : []
+							});
+							break;
+						case "agent":
+							changes = createAgentTask(identity, name, {
+								inputs: [],
+								prompt: edit.prompt ?? ""
+							});
+							break;
+						case "llm":
+							changes = createLlmTask(identity, name, "chat", "Generated response.").map((change) => change.kind == "graph.node.create" && change.node.kind == "task" && "executor" in change.node.task ? Object.assign({}, change, { node: Object.assign({}, change.node, { task: initialAuthoringLlmTask(change.node.task) }) }) : change);
+							break;
+						case "decision":
+							changes = createDecisionTask(identity, name);
+							break;
+						case "connector":
+							changes = createManagedTask(identity, await connectorTask(config, name));
+							break;
+						case "openapi":
+							changes = createManagedTask(identity, await prepareOpenApiTask(authoringConfigurations.openapi.parse(config), void 0, (url) => host.openapi(url), name));
+							break;
+						case "condition":
+							changes = createCondition(nodeId, name);
+							break;
+						case "value":
+							changes = createValue(nodeId, name, []);
+							break;
+						case "wait":
+							changes = createWait(nodeId, name);
+							break;
+						case "approval":
+							changes = createApproval(nodeId, name);
+							break;
+						case "poll":
+						case "integration": {
+							const definition = host.trigger(String(config.key));
+							if (definition.type != edit.type) fail("trigger.type-mismatch", "Trigger key has a different type.");
+							changes = createProviderTrigger(nodeId, definition, {
+								name,
+								config: {}
+							});
+							break;
+						}
+						default: changes = [{
+							kind: "graph.node.create",
+							nodeId,
+							node: {
+								kind: edit.type,
+								name,
+								...edit.type == "cron" ? { cronTimes: [{
+									type: "every",
+									unit: "hour",
+									value: 1
+								}] } : {},
+								...edit.type == "webhook" ? {
+									method: "POST",
+									bodyFields: []
+								} : {}
+							}
+						}];
+					}
+					apply(changes);
+					await configure(nodeId, { config });
+					const added = nodeAt(content, nodeId);
+					if (added.kind == "task") replace(nodeId, {
+						...added,
+						inputs: {}
+					});
+					if (edit.code != null) await setText(nodeId, "code", edit.code);
+					if (edit.prompt != null) await setText(nodeId, "prompt", edit.prompt);
+					for (const [input, binding] of Object.entries(edit.inputs ?? {})) await setInput(nodeId, input, binding);
+					break;
+				}
+				case "node.update":
+					await configure(resolve(edit.node), edit.set, edit.clear);
+					break;
+				case "node.remove": {
+					const ref = resolve(edit.node), node = nodeAt(content, ref);
+					if (node.kind == "task" && "moduleId" in node.task) touchedModules.add(node.task.moduleId);
+					apply([{
+						kind: "graph.node.delete",
+						nodeId: ref
+					}]);
+					break;
+				}
+				case "input.set":
+					await setInput(resolve(edit.node), edit.input, edit.source);
+					break;
+				case "edge.connect":
+				case "edge.disconnect": {
+					const from = resolve(edit.source), to = resolve(edit.target);
+					nodeAt(content, from);
+					nodeAt(content, to);
+					const edge = {
+						source: from,
+						target: to,
+						...edit.branch == null ? {} : { sourceHandle: edit.branch }
+					};
+					const exists = content.document.graph.edges.some((e) => dequal(e, edge));
+					if (edit.op == "edge.connect" != exists) apply([{
+						kind: edit.op == "edge.connect" ? "graph.edge.connect" : "graph.edge.disconnect",
+						edge
+					}]);
+					break;
+				}
+				case "text.set":
+					await setText(resolve(edit.node), edit.field, edit.text);
+					break;
+				case "text.edit": {
+					const ref = resolve(edit.node), value = textAt(content, nodeAt(content, ref), edit.field), count = value.split(edit.oldText).length - 1;
+					if (count != 1) fail("text.match-count", `Expected one exact match, found ${count}. Read the field and include more context.`, {
+						node: ref,
+						field: edit.field,
+						matches: count
+					});
+					await setText(ref, edit.field, value.replace(edit.oldText, () => edit.newText));
+					break;
+				}
+			}
+		} catch (error) {
+			if (error instanceof AuthoringError || error instanceof AuthoringToolInputError || error instanceof AuthoringOpenApiAuthenticationError) throw new AuthoringError(error.code, error.message, {
+				...error.details,
+				editIndex: index
+			});
+			throw new AuthoringError("edit.invalid", error instanceof Error ? error.message : String(error), { editIndex: index });
+		}
+		index++;
+	}
+	for (const moduleId of touchedModules) if (!Object.values(content.document.graph.nodes).some((n) => n.kind == "task" && "moduleId" in n.task && n.task.moduleId == moduleId) && !Object.values(content.modules).some((m) => m.imports.includes(moduleId))) apply([{
+		kind: "module.delete",
+		moduleId
+	}]);
+	const cleaned = cleanVariableBindings(base, operations);
+	return {
+		operations: cleaned,
+		content: cleaned.length == 0 ? base : applyFlowChanges(base, cleaned),
+		nodes: aliases
+	};
+}
+var escapePointer = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");
+function authoringDiagnostics(content, diagnostics) {
+	const nodes = Object.entries(content.document.graph.nodes);
+	return diagnostics.map((diagnostic) => {
+		const affected = nodes.filter(([id, node]) => {
+			const roots = [`/document/graph/nodes/${escapePointer(id)}`];
+			if (node.kind == "task" && "moduleId" in node.task) roots.push(`/modules/${escapePointer(node.task.moduleId)}`);
+			return roots.some((root) => diagnostic.path == root || diagnostic.path.startsWith(`${root}/`));
+		});
+		const message = diagnostic.message.replace(/(CodeModule|Managed Task|Task|Binding) "([^"\n]+)"/g, (_, kind, id) => {
+			if (kind == "Binding") return `Variable "${content.document.bindings[id]?.target ?? "unresolved"}"`;
+			const owners = nodes.filter(([, n]) => n.kind == "task" && kind == "CodeModule" && "moduleId" in n.task && n.task.moduleId == id);
+			return owners.length ? `${kind == "CodeModule" ? "Code for" : "Node"} ${owners.map(([ref, n]) => JSON.stringify(n.name ?? ref)).join(", ")}` : kind == "CodeModule" ? "Referenced code" : "Node configuration";
+		}).replaceAll("CodeModule", "Code");
+		const parts = diagnostic.path.split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
+		return {
+			code: diagnostic.code,
+			message,
+			nodes: affected.map(([id]) => id),
+			field: affected[0] == null ? "config" : authoringDiagnosticField(content, affected[0][1], parts),
+			...diagnostic.line ? {
+				line: diagnostic.line,
+				column: diagnostic.column
+			} : {}
+		};
+	});
+}
+//#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();
+//#endregion
 //#region src/control/common/draftOperations.ts
 var text = string().min(1);
-var json$1 = json$3();
+var json$1 = json$5();
 var triggerCreate = strictObject({
 	kind: literal("graph.trigger.create"),
 	nodeId: text,
 	key: text,
 	connectionId: text.optional(),
 	name: text.optional(),
-	config: record(text, json$1),
+	config: record$3(text, json$1),
 	schedule: triggerScheduleSchema.readonly().optional()
 });
 function decodeDraftOperations(value) {
@@ -11901,7 +13681,7 @@ function resolveDraftOperations(operations, definition) {
 		if (operation.kind != "graph.trigger.create") return [operation];
 		const snapshot = definition(operation.key);
 		if (snapshot.type != "poll" && operation.schedule != null) throw new Error("Only Poll triggers accept a schedule.");
-		return createProviderTrigger({ kind: "flow" }, operation.nodeId, snapshot, operation);
+		return createProviderTrigger(operation.nodeId, snapshot, operation);
 	});
 }
 //#endregion
@@ -11935,7 +13715,6 @@ var eventSourceRevisionSchema = strictObject({
 });
 //#endregion
 //#region src/control/common/authoringExamples.ts
-var target = { kind: "flow" };
 var descriptions = {
 	"manual": "A Manual start node.",
 	"error": "A Flow Error node. Select upstream Flows, then publish and enable this Flow to listen for failures in their automatic runs.",
@@ -11964,26 +13743,20 @@ function authoringExample(name) {
 	let operations;
 	switch (name) {
 		case "error":
-			operations = createBuiltinTrigger(target, "error", {
+			operations = createBuiltinTrigger("error", {
 				kind: "error",
 				name: "Flow Error"
 			});
 			break;
 		case "decision":
-			operations = createDecisionTask(target, {
-				nodeId: "decision",
-				taskId: "decision-task"
-			}, "AI Decision", [{
+			operations = createDecisionTask({ nodeId: "decision" }, "AI Decision", [{
 				name: "needs_support",
 				type: "noul",
 				instructions: "Does the customer need support?"
 			}]);
 			break;
 		case "openapi":
-			operations = createManagedTask(target, {
-				nodeId: "api",
-				taskId: "api-task"
-			}, openApiTask(selectOperation({
+			operations = createManagedTask({ nodeId: "api" }, openApiTask(selectOperation({
 				openapi: "3.1.0",
 				paths: { "/items": { get: { responses: { "200": { content: { "application/json": { schema: {
 					type: "array",
@@ -11992,13 +13765,13 @@ function authoringExample(name) {
 			}, "https://api.example.com/openapi.json", "/items", "get")));
 			break;
 		case "manual":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "manual",
 				name: "Start"
 			});
 			break;
 		case "webhook":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "webhook",
 				method: "POST",
 				name: "Webhook",
@@ -12006,7 +13779,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "cron":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "cron",
 				name: "Schedule",
 				cronTimes: [{
@@ -12040,10 +13813,7 @@ function authoringExample(name) {
 			}];
 			break;
 		case "agent":
-			operations = createManagedTask(target, {
-				nodeId: "agent",
-				taskId: "agent-task"
-			}, {
+			operations = createManagedTask({ nodeId: "agent" }, {
 				name: "Agent",
 				inputs: [{
 					handle: "input",
@@ -12067,10 +13837,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "connector":
-			operations = createManagedTask(target, {
-				nodeId: "notify",
-				taskId: "notify-task"
-			}, {
+			operations = createManagedTask({ nodeId: "notify" }, {
 				name: "Notify",
 				executor: {
 					kind: "connector",
@@ -12087,7 +13854,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "code":
-			operations = createCodeTask(target, {
+			operations = createCodeTask({
 				nodeId: "format",
 				moduleId: "format-module"
 			}, "Format", {
@@ -12112,10 +13879,9 @@ function authoringExample(name) {
 			break;
 		case "condition":
 			operations = [
-				...createCondition(target, "condition", "Condition"),
+				...createCondition("condition", "Condition"),
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "condition",
 					handle: "0/0/0/left",
 					value: {
@@ -12125,7 +13891,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "condition",
 					handle: "0/0/0/right",
 					value: {
@@ -12136,20 +13901,17 @@ function authoringExample(name) {
 			];
 			break;
 		case "value":
-			operations = createValue(target, "value", "Value");
+			operations = createValue("value", "Value");
 			break;
 		case "approval":
-			operations = createApproval(target, "approval", "Approve?");
+			operations = createApproval("approval", "Approve?");
 			break;
 		case "wait":
-			operations = createWait(target, "wait", "Continue?");
+			operations = createWait("wait", "Continue?");
 			break;
 		case "llm-chat":
 		case "llm-json":
-			operations = createLlmTask(target, {
-				nodeId: "llm",
-				taskId: "llm-task"
-			}, "LLM", name == "llm-chat" ? "chat" : "json", "Generated response.");
+			operations = createLlmTask({ nodeId: "llm" }, "LLM", name == "llm-chat" ? "chat" : "json", "Generated response.");
 			break;
 		case "poll-notification":
 			operations = [
@@ -12158,7 +13920,6 @@ function authoringExample(name) {
 				...authoringExample("connector").operations,
 				{
 					kind: "graph.edge.connect",
-					target,
 					edge: {
 						source: "mail",
 						target: "format"
@@ -12166,7 +13927,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.edge.connect",
-					target,
 					edge: {
 						source: "format",
 						target: "notify"
@@ -12174,7 +13934,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "format",
 					handle: "events",
 					before: {
@@ -12192,7 +13951,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "notify",
 					handle: "text",
 					before: {
@@ -12220,16 +13978,21 @@ function authoringExample(name) {
 //#endregion
 //#region src/control/common/requests.ts
 var waitActionBodySchema = strictObject({ comment: waitCommentSchema });
-var json = json$3();
+var json = json$5();
 var id = string().min(1);
 var version = literal(1);
 var flowName = id.refine((value) => value == value.trim() && resourceNameIssue(value) == null, "Flow name is invalid.");
-var inputs = record(string(), record(string(), json));
+var inputs = record$3(string(), record$3(string(), json));
 var trigger = strictObject({
 	nodeId: id,
-	outputs: record(string(), json)
+	outputs: record$3(string(), json)
 });
 var schemas = {
+	authoringCheck: authoringCheckSchema,
+	authoringEdit: authoringRequestSchema,
+	authoringRead: authoringReadSchema,
+	authoringSearch: authoringSearchSchema,
+	authoringSchema: authoringSchemaQuery,
 	loadOpenApiDocument: strictObject({
 		url: string().min(1).max(8192),
 		version
@@ -12262,7 +14025,7 @@ var schemas = {
 	}),
 	updatePresentation: strictObject({
 		expectedRevision: int().positive(),
-		value: record(string(), json),
+		value: record$3(string(), json),
 		version
 	}),
 	checkFlow: strictObject({
@@ -12330,6 +14093,11 @@ function decoder(schema) {
 	return (value) => schema.parse(value);
 }
 var controlRequests = {
+	authoringCheck: decoder(schemas.authoringCheck),
+	authoringEdit: decoder(schemas.authoringEdit),
+	authoringRead: decoder(schemas.authoringRead),
+	authoringSearch: decoder(schemas.authoringSearch),
+	authoringSchema: decoder(schemas.authoringSchema),
 	loadOpenApiDocument: decoder(schemas.loadOpenApiDocument),
 	createEventSource: decoder(schemas.createEventSource),
 	updateEventSource: decoder(schemas.updateEventSource),
@@ -12361,7 +14129,7 @@ var controlRequests = {
 	versionOnly: decoder(schemas.versionOnly)
 };
 function controlRequestSchema(name) {
-	const schema = toJSONSchema(schemas[name]);
+	const schema = toJSONSchema(schemas[name], { io: "input" });
 	if (name == "changeDraft") return {
 		...schema,
 		properties: {
@@ -12372,4 +14140,4 @@ function controlRequestSchema(name) {
 	return schema;
 }
 //#endregion
-export { authoringExample, authoringExamples, controlRequestSchema, controlRequests, decodeDraftOperations, draftOperationsSchema, resolveDraftOperations, waitActionBodySchema };
+export { AuthoringError, authoringCheckResponse, authoringCheckSchema, authoringConfigurations, authoringDiagnosticSchema, authoringDiagnostics, authoringEditResponse, authoringEditSchema, authoringExample, authoringExamples, authoringNode, authoringReadResponse, authoringReadSchema, authoringRequestContract, authoringRequestSchema, authoringSchema, authoringSchemaQuery, authoringSearchResponse, authoringSearchSchema, authoringSourceSchema, authoringTypes, compileAuthoring, controlRequestSchema, controlRequests, decodeDraftOperations, draftOperationsSchema, readAuthoring, resolveDraftOperations, searchAuthoring, waitActionBodySchema };