@oomol-lab/open-flow 0.1.0-beta.56 → 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 = {};
@@ -5506,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);
@@ -5584,7 +5584,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record$1(keyType, valueType, params) {
+function record$3(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string(),
@@ -5832,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),
@@ -5840,7 +5840,7 @@ function json$3(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record$1(string(), jsonSchema)
+			record$3(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
@@ -5853,19 +5853,6 @@ function preprocess(fn, schema) {
 	});
 }
 //#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
-	}]));
-}
-//#endregion
 //#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
 var has = Object.prototype.hasOwnProperty;
 function dequal(foo, bar) {
@@ -5914,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
@@ -6770,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() {
@@ -7189,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,
@@ -9177,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,
@@ -9705,16 +10346,19 @@ 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
@@ -9730,13 +10374,13 @@ var source = union([object$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$1(text$1, mapping);
+var inputs$1 = record$3(text$1, mapping);
 var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
@@ -9781,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
@@ -9813,7 +10457,7 @@ var decisionQuestion = discriminatedUnion("type", [
 		criteria: strings
 	})
 ]);
-var managed = object$1({
+var managedFields = object$1({
 	...ports,
 	name: text$1,
 	executor: union([
@@ -9828,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([
@@ -9868,15 +10512,16 @@ var managed = object$1({
 				connectionId: text$1.optional(),
 				inputDefinitions: array(input),
 				messageHandle: text$1,
-				inputs: record$1(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
@@ -9887,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([
 				"!=",
 				"<",
@@ -9910,7 +10555,7 @@ var condition = {
 				"notHasValue",
 				"startsWith"
 			]),
-			right: operand.optional()
+			right: operand$1.optional()
 		})) }))
 	}))
 };
@@ -9923,7 +10568,7 @@ var webhookOptions = object$1({
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
 	responseData: text$1.optional(),
-	responseHeaders: record$1(text$1, text$1).optional(),
+	responseHeaders: record$3(text$1, text$1).optional(),
 	responseStatusCode: number().int().min(200).max(599).optional()
 });
 var webhook = {
@@ -9979,7 +10624,7 @@ var base = {
 var node = union([
 	object$1({
 		...base,
-		inputs: record$1(text$1, never()),
+		inputs: record$3(text$1, never()),
 		kind: literal("condition"),
 		...condition
 	}),
@@ -10028,7 +10673,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("poll"),
 		connectionId: text$1.min(1).optional(),
-		config: record$1(text$1, fixedInput),
+		config: record$3(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("poll")
@@ -10039,7 +10684,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("integration"),
 		connectionId: text$1.min(1).optional(),
-		config: record$1(text$1, fixedInput),
+		config: record$3(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("integration"),
@@ -10047,6 +10692,25 @@ var node = union([
 		})
 	})
 ]);
+/** 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,
@@ -10057,7 +10721,7 @@ var at = {
 	target: never().optional()
 };
 var graph = object$1({
-	nodes: record$1(text$1, node),
+	nodes: record$3(text$1, node),
 	edges: array(edge).default([])
 });
 var binding = object$1({
@@ -10070,7 +10734,7 @@ var module = object$1({
 	source: text$1
 });
 var document = preprocess(rejectRetiredDefinitions, object$1({
-	bindings: record$1(text$1, binding),
+	bindings: record$3(text$1, binding),
 	graph
 }));
 object$1({
@@ -10081,21 +10745,21 @@ object$1({
 		literal(6)
 	]),
 	document,
-	modules: record$1(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(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(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references 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(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes 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(value) {
+function record$2(value) {
 	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
 }
 var shapes = {
@@ -10126,6 +10790,11 @@ var shapes = {
 		...at,
 		node
 	},
+	"graph.node.replace": {
+		...at,
+		before: node,
+		node
+	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
 		object$1({
@@ -10260,310 +10929,90 @@ 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";
-	}
-	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(name)) return "specialCharacter";
-}
 //#endregion
-//#region src/flow/common/nodeChanges.ts
-var codeTaskTemplate = `export default async function (inputs, context) {
-  return { result: inputs.value }
+//#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;
+	}
+	return config;
 }
-`;
-function createCodeTask(identity, name, module = void 0, ports = {
-	inputs: [{
-		handle: "value",
-		jsonSchema: { type: "string" },
-		nullable: true,
-		value: "foo"
-	}],
-	outputs: [{
-		handle: "result",
-		jsonSchema: {},
-		nullable: true
-	}]
-}) {
-	return [{
-		kind: "module.create",
-		module: {
-			...module ?? {
-				imports: [],
-				source: codeTaskTemplate
-			},
-			name
-		},
-		moduleId: identity.moduleId
-	}, {
-		kind: "graph.node.create",
-		node: {
-			inputs: defaultInputs(ports.inputs),
-			kind: "task",
-			name,
-			task: {
-				capabilities: ports.capabilities ?? [{
-					kind: "connector",
-					mode: "independent",
-					actions: []
-				}],
-				inputs: ports.inputs,
-				moduleId: identity.moduleId,
-				name,
-				outputs: ports.outputs
-			}
+/** 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
 		},
-		nodeId: identity.nodeId
-	}];
+		inputs,
+		outputs: dequal(old.resultSchema, config.resultSchema) ? previous.outputs : previous.outputs.map((port) => "handle" in port ? {
+			...port,
+			jsonSchema: config.resultSchema
+		} : port)
+	};
 }
-function createManagedTask(identity, task) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputs: defaultInputs(task.inputs),
-			kind: "task",
-			name: task.name,
-			task
-		},
-		nodeId: identity.nodeId
-	}];
-}
-function createLlmTask(identity, name, mode, outputDescription, options = {}) {
-	const values = options.inputs ?? {};
-	return createManagedTask(identity, {
-		executor: {
-			kind: "llm",
-			mode
-		},
-		inputs: [
-			{
-				handle: "messages",
-				jsonSchema: {
-					items: { type: "object" },
-					type: "array"
-				},
-				nullable: true,
-				value: llmInputValue(values, "messages", null)
-			},
-			{
-				handle: "input",
-				jsonSchema: { type: "string" },
-				nullable: false,
-				value: llmInputValue(values, "input", "Alex")
-			},
-			{
-				handle: "template",
-				jsonSchema: {
-					items: { type: "object" },
-					minItems: 1,
-					type: "array"
-				},
-				nullable: false,
-				value: llmInputValue(values, "template", [{
-					content: "Hello, I'm {{input}}",
-					role: "user"
-				}])
-			},
-			{
-				handle: "model",
-				jsonSchema: { type: "object" },
-				nullable: false,
-				value: llmInputValue(values, "model", { model: "deepseek-v4-flash" })
-			}
-		],
-		name,
-		outputs: [{
-			...options.output,
-			description: options.output?.description ?? outputDescription,
-			handle: "output",
-			jsonSchema: options.output?.jsonSchema ?? (mode == "chat" ? { type: "string" } : {}),
-			nullable: options.output?.nullable ?? false
-		}]
-	});
-}
-function createCondition(nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			cases: [{
-				groups: [{ expressions: [{
-					left: { kind: "value" },
-					operator: "==",
-					right: { kind: "value" }
-				}] }],
-				output: "case"
-			}],
-			matchMode: "first",
-			inputs: {},
-			kind: "condition",
-			name
-		},
-		nodeId
-	}];
-}
-function createValue(nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputs: {},
-			kind: "value",
-			name,
-			values: [{
-				handle: "value",
-				jsonSchema: {},
-				nullable: true,
-				value: null
-			}]
-		},
-		nodeId
-	}];
-}
-function createWait(nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputDefinitions: [],
-			inputs: {},
-			kind: "wait",
-			name,
-			prompt: name
-		},
-		nodeId
-	}];
-}
-function createApproval(nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputDefinitions: [],
-			inputs: {},
-			kind: "approval",
-			name,
-			prompt: name
-		},
-		nodeId
-	}];
-}
-function createBuiltinTrigger(nodeId, node) {
-	return [{
-		kind: "graph.node.create",
-		node,
-		nodeId
-	}];
-}
-function createProviderTrigger(nodeId, definition, options) {
-	const name = options.name ?? definition.displayName;
-	return [{
-		kind: "graph.node.create",
-		node: definition.type == "poll" ? {
-			...options.connectionId == null ? {} : { connectionId: options.connectionId },
-			config: inputValues(options.config),
-			definition,
-			kind: "poll",
-			name,
-			pollTimes: options.schedule ?? [{
-				type: "every",
-				unit: "minute",
-				value: 5
-			}]
-		} : {
-			...options.connectionId == null ? {} : { connectionId: options.connectionId },
-			config: inputValues(options.config),
-			definition,
-			kind: "integration",
-			name
-		},
-		nodeId
-	}];
-}
-function defaultInputs(ports) {
-	return Object.fromEntries(ports.flatMap((port) => "handle" in port && Object.hasOwn(port, "value") ? [[port.handle, {
-		kind: "value",
-		value: port.value
-	}]] : []));
-}
-function llmInputValue(values, handle, fallback) {
-	return values != null && Object.hasOwn(values, handle) ? values[handle] : fallback;
-}
-function createDecisionTask(identity, name = "AI Decision", questions) {
-	return createManagedTask(identity, decisionTask(questions, name));
-}
-//#endregion
-//#region src/control/common/draftOperations.ts
-var text = string().min(1);
-var json$1 = json$3();
-var triggerCreate = strictObject({
-	kind: literal("graph.trigger.create"),
-	nodeId: text,
-	key: text,
-	connectionId: text.optional(),
-	name: text.optional(),
-	config: record$1(text, json$1),
-	schedule: triggerScheduleSchema.readonly().optional()
-});
-function decodeDraftOperations(value) {
-	checkJsonDepth(value);
-	return array(unknown()).min(1).parse(value).map((candidate, index) => {
-		const { kind } = parseOperation(candidate, index, object$1({ kind: text }).parse);
-		return kind == "graph.trigger.create" ? parseOperation(candidate, index, triggerCreate.parse) : decodeChangeOperation(candidate, index);
-	});
-}
-function draftOperationsSchema(kind) {
-	if (kind != null && kind != "graph.trigger.create") return changeOperationsSchema(kind);
-	const trigger = toJSONSchema(triggerCreate);
-	if (kind == "graph.trigger.create") return trigger;
-	const schema = changeOperationsSchema();
+/** 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 {
-		...schema,
-		items: { anyOf: [schema.items, trigger] }
+		...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];
+		})
 	};
 }
-function resolveDraftOperations(operations, definition) {
-	return operations.flatMap((operation) => {
-		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(operation.nodeId, snapshot, operation);
-	});
-}
-//#endregion
-//#region src/control/common/eventSourceSchemas.ts
-var id$1 = string().min(1).max(256);
-var eventType = string().regex(/^[a-z][a-z0-9_.]{0,127}$/);
-var name = string().trim().min(1).max(128);
-var secret = string().min(1).max(256);
-var createEventSourceSchema = strictObject({
-	version: literal(1),
-	name,
-	connectionId: id$1,
-	teamId: id$1.nullable(),
-	verificationToken: secret,
-	encryptKey: secret,
-	eventTypes: array(eventType).min(1).max(200).refine((values) => new Set(values).size == values.length),
-	manageSubscriptions: boolean()
-});
-var updateEventSourceSchema = strictObject({
-	version: literal(1),
-	expectedRevision: int().positive(),
-	name,
-	enabled: boolean(),
-	eventTypes: array(eventType).min(1).max(200).refine((values) => new Set(values).size == values.length),
-	verificationToken: secret.optional(),
-	encryptKey: secret.optional()
-});
-var eventSourceRevisionSchema = strictObject({
-	version: literal(1),
-	expectedRevision: int().positive()
-});
 //#endregion
 //#region src/openapi/common/openapi.ts
 var methods = [
@@ -10948,6 +11397,2323 @@ function selectOperation(value, sourceUrl, path, method) {
 	return config;
 }
 //#endregion
+//#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 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 { 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
+	}),
+	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()
+	}),
+	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
+	}),
+	integration: strictObject({
+		key: id$2,
+		connectionId: id$2.optional()
+	}),
+	code: strictObject({
+		inputs: inputFields,
+		outputs: outputFields,
+		capabilities: authoringDefinitionSchemas.capabilities.optional()
+	}),
+	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
+		}))
+	}),
+	value: strictObject({
+		values: patch,
+		outputs: outputFields
+	}),
+	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()
+	}),
+	strictObject({
+		op: literal("node.update"),
+		node: referenceSchema,
+		set: updates.optional(),
+		clear: array(array(id$2).min(1)).optional()
+	}),
+	strictObject({
+		op: literal("node.remove"),
+		node: referenceSchema
+	}),
+	strictObject({
+		op: literal("input.set"),
+		node: referenceSchema,
+		input: id$2,
+		source: authoringSourceSchema
+	}),
+	strictObject({
+		op: _enum(["edge.connect", "edge.disconnect"]),
+		source: referenceSchema,
+		target: referenceSchema,
+		branch: id$2.optional()
+	}),
+	strictObject({
+		op: literal("text.edit"),
+		node: referenceSchema,
+		field: _enum(["code", "prompt"]),
+		oldText: id$2,
+		newText: string()
+	}),
+	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()
+	}),
+	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()
+	}),
+	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()
+	}),
+	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 }
+}
+`;
+var defaultCodeTaskPorts = {
+	inputs: [{
+		handle: "value",
+		jsonSchema: { type: "string" },
+		nullable: true,
+		value: "foo"
+	}],
+	outputs: [{
+		handle: "result",
+		jsonSchema: {},
+		nullable: true
+	}]
+};
+function createCodeTask(identity, name, module = void 0, ports = defaultCodeTaskPorts) {
+	return [{
+		kind: "module.create",
+		module: {
+			...module ?? {
+				imports: [],
+				source: codeTaskTemplate
+			},
+			name
+		},
+		moduleId: identity.moduleId
+	}, {
+		kind: "graph.node.create",
+		node: {
+			inputs: defaultInputs(ports.inputs),
+			kind: "task",
+			name,
+			task: {
+				capabilities: ports.capabilities ?? [{
+					kind: "connector",
+					mode: "independent",
+					actions: []
+				}],
+				inputs: ports.inputs,
+				moduleId: identity.moduleId,
+				name,
+				outputs: ports.outputs
+			}
+		},
+		nodeId: identity.nodeId
+	}];
+}
+function createManagedTask(identity, task) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputs: defaultInputs(task.inputs),
+			kind: "task",
+			name: task.name,
+			task
+		},
+		nodeId: identity.nodeId
+	}];
+}
+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(identity, {
+		executor: {
+			kind: "llm",
+			mode
+		},
+		inputs: [
+			{
+				handle: "messages",
+				jsonSchema: {
+					items: { type: "object" },
+					type: "array"
+				},
+				nullable: true,
+				value: llmInputValue(values, "messages", null)
+			},
+			{
+				handle: "input",
+				jsonSchema: { type: "string" },
+				nullable: false,
+				value: llmInputValue(values, "input", "Alex")
+			},
+			{
+				handle: "template",
+				jsonSchema: {
+					items: { type: "object" },
+					minItems: 1,
+					type: "array"
+				},
+				nullable: false,
+				value: llmInputValue(values, "template", [{
+					content: "Hello, I'm {{input}}",
+					role: "user"
+				}])
+			},
+			{
+				handle: "model",
+				jsonSchema: { type: "object" },
+				nullable: false,
+				value: llmInputValue(values, "model", { model: "deepseek-v4-flash" })
+			}
+		],
+		name,
+		outputs: [{
+			...options.output,
+			description: options.output?.description ?? outputDescription,
+			handle: "output",
+			jsonSchema: options.output?.jsonSchema ?? (mode == "chat" ? { type: "string" } : {}),
+			nullable: options.output?.nullable ?? false
+		}]
+	});
+}
+function createCondition(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			cases: [{
+				groups: [{ expressions: [{
+					left: { kind: "value" },
+					operator: "==",
+					right: { kind: "value" }
+				}] }],
+				output: "case"
+			}],
+			matchMode: "first",
+			inputs: {},
+			kind: "condition",
+			name
+		},
+		nodeId
+	}];
+}
+function createValue(nodeId, name, values = [{
+	handle: "value",
+	jsonSchema: {},
+	nullable: true,
+	value: null
+}]) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputs: {},
+			kind: "value",
+			name,
+			values
+		},
+		nodeId
+	}];
+}
+function createWait(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputDefinitions: [],
+			inputs: {},
+			kind: "wait",
+			name,
+			prompt: name
+		},
+		nodeId
+	}];
+}
+function createApproval(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputDefinitions: [],
+			inputs: {},
+			kind: "approval",
+			name,
+			prompt: name
+		},
+		nodeId
+	}];
+}
+function createBuiltinTrigger(nodeId, node) {
+	return [{
+		kind: "graph.node.create",
+		node,
+		nodeId
+	}];
+}
+function createProviderTrigger(nodeId, definition, options) {
+	const name = options.name ?? definition.displayName;
+	return [{
+		kind: "graph.node.create",
+		node: definition.type == "poll" ? {
+			...options.connectionId == null ? {} : { connectionId: options.connectionId },
+			config: inputValues(options.config),
+			definition,
+			kind: "poll",
+			name,
+			pollTimes: options.schedule ?? [{
+				type: "every",
+				unit: "minute",
+				value: 5
+			}]
+		} : {
+			...options.connectionId == null ? {} : { connectionId: options.connectionId },
+			config: inputValues(options.config),
+			definition,
+			kind: "integration",
+			name
+		},
+		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",
+		value: port.value
+	}]] : []));
+}
+function llmInputValue(values, handle, fallback) {
+	return values != null && Object.hasOwn(values, handle) ? values[handle] : fallback;
+}
+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$5();
+var triggerCreate = strictObject({
+	kind: literal("graph.trigger.create"),
+	nodeId: text,
+	key: text,
+	connectionId: text.optional(),
+	name: text.optional(),
+	config: record$3(text, json$1),
+	schedule: triggerScheduleSchema.readonly().optional()
+});
+function decodeDraftOperations(value) {
+	checkJsonDepth(value);
+	return array(unknown()).min(1).parse(value).map((candidate, index) => {
+		const { kind } = parseOperation(candidate, index, object$1({ kind: text }).parse);
+		return kind == "graph.trigger.create" ? parseOperation(candidate, index, triggerCreate.parse) : decodeChangeOperation(candidate, index);
+	});
+}
+function draftOperationsSchema(kind) {
+	if (kind != null && kind != "graph.trigger.create") return changeOperationsSchema(kind);
+	const trigger = toJSONSchema(triggerCreate);
+	if (kind == "graph.trigger.create") return trigger;
+	const schema = changeOperationsSchema();
+	return {
+		...schema,
+		items: { anyOf: [schema.items, trigger] }
+	};
+}
+function resolveDraftOperations(operations, definition) {
+	return operations.flatMap((operation) => {
+		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(operation.nodeId, snapshot, operation);
+	});
+}
+//#endregion
+//#region src/control/common/eventSourceSchemas.ts
+var id$1 = string().min(1).max(256);
+var eventType = string().regex(/^[a-z][a-z0-9_.]{0,127}$/);
+var name = string().trim().min(1).max(128);
+var secret = string().min(1).max(256);
+var createEventSourceSchema = strictObject({
+	version: literal(1),
+	name,
+	connectionId: id$1,
+	teamId: id$1.nullable(),
+	verificationToken: secret,
+	encryptKey: secret,
+	eventTypes: array(eventType).min(1).max(200).refine((values) => new Set(values).size == values.length),
+	manageSubscriptions: boolean()
+});
+var updateEventSourceSchema = strictObject({
+	version: literal(1),
+	expectedRevision: int().positive(),
+	name,
+	enabled: boolean(),
+	eventTypes: array(eventType).min(1).max(200).refine((values) => new Set(values).size == values.length),
+	verificationToken: secret.optional(),
+	encryptKey: secret.optional()
+});
+var eventSourceRevisionSchema = strictObject({
+	version: literal(1),
+	expectedRevision: int().positive()
+});
+//#endregion
 //#region src/control/common/authoringExamples.ts
 var descriptions = {
 	"manual": "A Manual start node.",
@@ -11212,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$1(string(), record$1(string(), json));
+var inputs = record$3(string(), record$3(string(), json));
 var trigger = strictObject({
 	nodeId: id,
-	outputs: record$1(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
@@ -11254,7 +14025,7 @@ var schemas = {
 	}),
 	updatePresentation: strictObject({
 		expectedRevision: int().positive(),
-		value: record$1(string(), json),
+		value: record$3(string(), json),
 		version
 	}),
 	checkFlow: strictObject({
@@ -11322,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),
@@ -11353,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: {
@@ -11364,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 };