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

package/dist/common/control-requests.js

@@ -2780,6 +2780,9 @@ function handlePipeResult(left, next, ctx) {
 		issues: left.issues
 	}, ctx);
 }
+var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
@@ -5581,7 +5584,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function record$1(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string(),
@@ -5790,6 +5793,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5833,11 +5840,18 @@ function json$3(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record(string(), jsonSchema)
+			record$1(string(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
 }
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
 //#endregion
 //#region src/execution/common/wait.ts
 /** Shared by decision entry points, the editor, and durable decision storage. */
@@ -9402,7 +9416,7 @@ var isObject = (x) => x !== null && typeof x === "object";
 var isPlainObject = (x) => isObject(x) && !isArray(x);
 var toPlainObject = (x) => isPlainObject(x) ? x : void 0;
 //#endregion
-//#region src/manifest/common/schemaComparer.ts
+//#region src/flow/common/schemaComparer.ts
 function isStringLikeSchema(value) {
 	return toPlainObject(value)?.type === "string";
 }
@@ -9705,24 +9719,15 @@ var group = object$1({
 	collapsed: boolean().optional(),
 	group: text$1
 });
-var nodeSource = object$1({
+var source = union([object$1({
 	kind: literal("node"),
 	nodeId: text$1,
 	output: text$1,
 	field: text$1.optional()
-});
-var flowSource = object$1({
-	kind: literal("flow"),
-	input: text$1
-});
-var source = union([
-	nodeSource,
-	flowSource,
-	object$1({
-		kind: literal("binding"),
-		bindingId: text$1
-	})
-]);
+}), object$1({
+	kind: literal("binding"),
+	bindingId: text$1
+})]);
 var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
 	kind: literal("value"),
 	value: json$2
@@ -9731,7 +9736,7 @@ var mapping = union([fixedInput, object$1({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
-var inputs$1 = record(text$1, mapping);
+var inputs$1 = record$1(text$1, mapping);
 var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
@@ -9859,9 +9864,11 @@ var managed = object$1({
 				inputs: array(input.extend({ source: agentInput }))
 			})),
 			notification: object$1({
-				taskId: text$1,
+				action: text$1,
+				connectionId: text$1.optional(),
+				inputDefinitions: array(input),
 				messageHandle: text$1,
-				inputs: record(text$1, agentValue)
+				inputs: record$1(text$1, agentValue)
 			}).optional()
 		})
 	])
@@ -9916,7 +9923,7 @@ var webhookOptions = object$1({
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
 	responseData: text$1.optional(),
-	responseHeaders: record(text$1, text$1).optional(),
+	responseHeaders: record$1(text$1, text$1).optional(),
 	responseStatusCode: number().int().min(200).max(599).optional()
 });
 var webhook = {
@@ -9972,7 +9979,7 @@ var base = {
 var node = union([
 	object$1({
 		...base,
-		inputs: record(text$1, never()),
+		inputs: record$1(text$1, never()),
 		kind: literal("condition"),
 		...condition
 	}),
@@ -9982,21 +9989,10 @@ var node = union([
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object$1({
-		...base,
-		kind: literal("subflow"),
-		subflowId: text$1
-	}),
-	object$1({
-		...base,
-		kind: literal("task"),
-		task: inline,
-		additionalInputs: array(input).optional()
-	}),
 	object$1({
 		...base,
 		kind: literal("task"),
-		taskId: text$1,
+		task: union([inline, managed]),
 		additionalInputs: array(input).optional()
 	}),
 	strictObject({
@@ -10032,7 +10028,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("poll"),
 		connectionId: text$1.min(1).optional(),
-		config: record(text$1, fixedInput),
+		config: record$1(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("poll")
@@ -10043,7 +10039,7 @@ var node = union([
 		...trigger$1,
 		kind: literal("integration"),
 		connectionId: text$1.min(1).optional(),
-		config: record(text$1, fixedInput),
+		config: record$1(text$1, fixedInput),
 		definition: object$1({
 			...definition,
 			type: literal("integration"),
@@ -10051,10 +10047,6 @@ var node = union([
 		})
 	})
 ]);
-var target$1 = union([object$1({ kind: literal("flow") }), object$1({
-	kind: literal("subflow"),
-	id: text$1
-})]);
 var edge = object$1({
 	source: text$1,
 	target: text$1,
@@ -10062,15 +10054,10 @@ var edge = object$1({
 });
 var at = {
 	nodeId: text$1,
-	target: target$1
+	target: never().optional()
 };
-var subflow = object$1({
-	name: text$1,
-	inputs: array(input),
-	outputs: array(port.extend({ sources: array(union([nodeSource, flowSource])) }))
-});
 var graph = object$1({
-	nodes: record(text$1, node),
+	nodes: record$1(text$1, node),
 	edges: array(edge).default([])
 });
 var binding = object$1({
@@ -10082,24 +10069,35 @@ var module = object$1({
 	imports: strings,
 	source: text$1
 });
-var document = object$1({
-	bindings: record(text$1, binding),
-	graph,
-	subflows: record(text$1, subflow.extend({ graph })),
-	tasks: record(text$1, managed)
-});
+var document = preprocess(rejectRetiredDefinitions, object$1({
+	bindings: record$1(text$1, binding),
+	graph
+}));
 object$1({
 	modelVersion: union([
 		literal(2),
 		literal(4),
-		literal(5)
+		literal(5),
+		literal(6)
 	]),
 	document,
-	modules: record(text$1, module)
+	modules: record$1(text$1, module)
 }).extend({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
+function rejectRetiredDefinitions(value) {
+	const candidate = record(value);
+	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
+	const subflows = candidate.subflows;
+	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	return value;
+}
+function record(value) {
+	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+}
 var shapes = {
 	"graph.trigger.sources.set": {
 		nodeId: text$1,
@@ -10117,12 +10115,12 @@ var shapes = {
 		value: text$1
 	},
 	"graph.edge.connect": {
-		target: target$1,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.edge.disconnect": {
-		target: target$1,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.node.create": {
 		...at,
@@ -10186,13 +10184,11 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object$1({ kind: literal("flow") }),
 		before: object$1(wait),
 		value: object$1(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object$1({ kind: literal("flow") }),
 		before: object$1(webhook),
 		value: object$1(webhook)
 	},
@@ -10239,50 +10235,10 @@ var shapes = {
 		imports: strings,
 		source: text$1
 	},
-	"subflow.create": {
-		subflowId: text$1,
-		subflow: subflow.extend({ graph })
-	},
-	"subflow.definition.set": {
-		subflowId: text$1,
-		before: subflow,
-		definition: subflow
-	},
-	"subflow.delete": { subflowId: text$1 },
-	"task.create": {
-		taskId: text$1,
-		task: managed
-	},
-	"task.delete": { taskId: text$1 },
-	"task.connector.connection.set": {
-		taskId: text$1,
-		before: text$1.optional(),
-		value: text$1.optional()
-	},
-	"task.decision.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.openapi.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.agent.set": {
-		taskId: text$1,
-		before: managed,
-		value: managed
-	},
-	"task.llm.mode.set": {
-		taskId: text$1,
-		before: _enum(["chat", "json"]),
-		value: _enum(["chat", "json"])
-	},
-	"task.name.set": {
-		taskId: text$1,
-		before: text$1,
-		value: text$1
+	"graph.node.task.set": {
+		...at,
+		before: union([inline, managed]),
+		value: union([inline, managed])
 	}
 };
 var variants = new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
@@ -10320,81 +10276,370 @@ function resourceNameIssue(value) {
 	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(name)) return "specialCharacter";
 }
 //#endregion
-//#region src/openapi/common/openapi.ts
-var methods = [
-	"get",
-	"put",
-	"post",
-	"delete",
-	"options",
-	"head",
-	"patch",
-	"trace"
-];
-function object(value) {
-	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error("Expected an OpenAPI object.");
-	return value;
+//#region src/flow/common/nodeChanges.ts
+var codeTaskTemplate = `export default async function (inputs, context) {
+  return { result: inputs.value }
 }
-function httpUrl(value, base) {
-	const url = new URL(value, base);
-	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) throw new Error("An HTTP(S) URL without credentials or fragment is required.");
-	return url.href;
+`;
+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
+			}
+		},
+		nodeId: identity.nodeId
+	}];
 }
-function parseOpenApi(value) {
-	const doc = object(value);
-	if (typeof doc.openapi != "string" || !/^3\.[01]\.\d+$/.test(doc.openapi)) throw new Error("Only OpenAPI 3.0 and 3.1 JSON documents are supported.");
-	object(doc.paths);
-	return doc;
+function createManagedTask(identity, task) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputs: defaultInputs(task.inputs),
+			kind: "task",
+			name: task.name,
+			task
+		},
+		nodeId: identity.nodeId
+	}];
 }
-function pointer(doc, ref) {
-	if (!ref.startsWith("#/")) throw new Error("External OpenAPI references are not supported.");
-	let value = doc;
-	for (const key of decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))) {
-		const source = object(value);
-		if (!Object.hasOwn(source, key)) throw new Error("An OpenAPI reference is missing.");
-		value = source[key];
-	}
-	return value;
+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 resolved(doc, value) {
-	let result = object(value);
-	const seen = /* @__PURE__ */ new Set();
-	while (typeof result.$ref == "string") {
-		if (seen.has(result.$ref)) throw new Error("Circular non-schema reference is unsupported.");
-		seen.add(result.$ref);
-		const { $ref, ...siblings } = result;
-		result = {
-			...object(pointer(doc, $ref)),
-			...siblings
-		};
-	}
-	return result;
+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 operation(doc, path, method) {
-	const item = resolved(doc, object(doc.paths)[path]);
-	if (!methods.includes(method) || item[method] == null) throw new Error("The selected operation is no longer available.");
-	return {
-		item,
-		op: object(item[method])
-	};
+function createValue(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputs: {},
+			kind: "value",
+			name,
+			values: [{
+				handle: "value",
+				jsonSchema: {},
+				nullable: true,
+				value: null
+			}]
+		},
+		nodeId
+	}];
 }
-function servers(value, path, method) {
-	const doc = parseOpenApi(value);
-	const { item, op } = operation(doc, path, method);
-	const entries = op.servers ?? item.servers ?? doc.servers;
-	if (!Array.isArray(entries) || entries.length == 0) return [{ url: "/" }];
-	return entries.map(object);
+function createWait(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputDefinitions: [],
+			inputs: {},
+			kind: "wait",
+			name,
+			prompt: name
+		},
+		nodeId
+	}];
 }
-function serverAddress(server, sourceUrl, variables = {}) {
-	return httpUrl(String(server.url).replace(/\{([^}]+)\}/g, (_, name) => {
-		const definition = object(object(server.variables)[name]);
-		const value = variables[name] ?? definition.default;
-		if (typeof value != "string" || Array.isArray(definition.enum) && !definition.enum.includes(value)) throw new Error("A server variable is invalid.");
-		return value;
-	}), sourceUrl);
+function createApproval(nodeId, name) {
+	return [{
+		kind: "graph.node.create",
+		node: {
+			inputDefinitions: [],
+			inputs: {},
+			kind: "approval",
+			name,
+			prompt: name
+		},
+		nodeId
+	}];
 }
-function securityOptions(value, path, method) {
-	const doc = parseOpenApi(value);
+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();
+	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/openapi/common/openapi.ts
+var methods = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+function object(value) {
+	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error("Expected an OpenAPI object.");
+	return value;
+}
+function httpUrl(value, base) {
+	const url = new URL(value, base);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) throw new Error("An HTTP(S) URL without credentials or fragment is required.");
+	return url.href;
+}
+function parseOpenApi(value) {
+	const doc = object(value);
+	if (typeof doc.openapi != "string" || !/^3\.[01]\.\d+$/.test(doc.openapi)) throw new Error("Only OpenAPI 3.0 and 3.1 JSON documents are supported.");
+	object(doc.paths);
+	return doc;
+}
+function pointer(doc, ref) {
+	if (!ref.startsWith("#/")) throw new Error("External OpenAPI references are not supported.");
+	let value = doc;
+	for (const key of decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))) {
+		const source = object(value);
+		if (!Object.hasOwn(source, key)) throw new Error("An OpenAPI reference is missing.");
+		value = source[key];
+	}
+	return value;
+}
+function resolved(doc, value) {
+	let result = object(value);
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof result.$ref == "string") {
+		if (seen.has(result.$ref)) throw new Error("Circular non-schema reference is unsupported.");
+		seen.add(result.$ref);
+		const { $ref, ...siblings } = result;
+		result = {
+			...object(pointer(doc, $ref)),
+			...siblings
+		};
+	}
+	return result;
+}
+function operation(doc, path, method) {
+	const item = resolved(doc, object(doc.paths)[path]);
+	if (!methods.includes(method) || item[method] == null) throw new Error("The selected operation is no longer available.");
+	return {
+		item,
+		op: object(item[method])
+	};
+}
+function servers(value, path, method) {
+	const doc = parseOpenApi(value);
+	const { item, op } = operation(doc, path, method);
+	const entries = op.servers ?? item.servers ?? doc.servers;
+	if (!Array.isArray(entries) || entries.length == 0) return [{ url: "/" }];
+	return entries.map(object);
+}
+function serverAddress(server, sourceUrl, variables = {}) {
+	return httpUrl(String(server.url).replace(/\{([^}]+)\}/g, (_, name) => {
+		const definition = object(object(server.variables)[name]);
+		const value = variables[name] ?? definition.default;
+		if (typeof value != "string" || Array.isArray(definition.enum) && !definition.enum.includes(value)) throw new Error("A server variable is invalid.");
+		return value;
+	}), sourceUrl);
+}
+function securityOptions(value, path, method) {
+	const doc = parseOpenApi(value);
 	const { op } = operation(doc, path, method);
 	const requirements = op.security ?? doc.security ?? [];
 	if (!Array.isArray(requirements)) throw new Error("Invalid security requirements.");
@@ -10485,7 +10730,7 @@ function snapshot(documentValue, path, method) {
 	for (const entry of security) for (const name of Object.keys(object(entry))) copy(`#/components/securitySchemes/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`);
 	return structuredClone(result);
 }
-function schema$1(doc, schemaValue) {
+function schema(doc, schemaValue) {
 	const defs = {};
 	const ids = /* @__PURE__ */ new Map();
 	function convert(value) {
@@ -10590,7 +10835,7 @@ function jsonContent(doc, value) {
 	const json = mediaType == null ? void 0 : media[mediaType];
 	if (json == null) throw new Error("Only JSON request and response bodies are supported.");
 	return {
-		schema: schema$1(doc, object(json).schema ?? {}),
+		schema: schema(doc, object(json).schema ?? {}),
 		required: content.required === true,
 		mediaType
 	};
@@ -10609,7 +10854,7 @@ function openApiTask(config, name = "OpenAPI") {
 	const { op } = operation(doc, config.path, config.method);
 	const params = parameters(config);
 	const inputs = params.map((p) => {
-		const jsonSchema = schema$1(doc, p.schema ?? {});
+		const jsonSchema = schema(doc, p.schema ?? {});
 		const defaultValue = typeof jsonSchema == "boolean" ? void 0 : object(jsonSchema).default;
 		return {
 			handle: `${p.in}.${p.name}`,
@@ -10647,7 +10892,7 @@ function openApiTask(config, name = "OpenAPI") {
 		if (r.content == null) schemas.push({ type: "null" });
 		else {
 			jsonContent(doc, r);
-			for (const [mediaType, media] of Object.entries(object(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema$1(doc, object(media).schema ?? {}));
+			for (const [mediaType, media] of Object.entries(object(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema(doc, object(media).schema ?? {}));
 		}
 	}
 	if (!schemas.length) throw new Error("A successful JSON response definition is required.");
@@ -10702,1288 +10947,50 @@ function selectOperation(value, sourceUrl, path, method) {
 	openApiTask(config);
 	return config;
 }
-`${JSON.stringify("open-flow-engine/v5")}`, new Set([
-	"assert",
-	"assert/strict",
-	"buffer",
-	"console",
-	"constants",
-	"crypto",
-	"events",
-	"fs",
-	"fs/promises",
-	"os",
-	"path",
-	"path/posix",
-	"process",
-	"punycode",
-	"querystring",
-	"stream",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"timers",
-	"timers/promises",
-	"url",
-	"util",
-	"zlib"
-].flatMap((name) => [name, `node:${name}`])), `${JSON.stringify("open-flow-engine/v5/nodejs-compat-v1")}`;
-//#endregion
-//#region src/flow/common/agent.ts
-var schema = lazy(() => union([boolean(), strictObject({
-	type: union([_enum([
-		"array",
-		"boolean",
-		"integer",
-		"null",
-		"number",
-		"object",
-		"string"
-	]), array(_enum([
-		"array",
-		"boolean",
-		"integer",
-		"null",
-		"number",
-		"object",
-		"string"
-	])).min(1)]).optional(),
-	const: json$3().optional(),
-	allOf: array(schema).min(1).optional(),
-	anyOf: array(schema).min(1).optional(),
-	oneOf: array(schema).min(1).optional(),
-	not: schema.optional(),
-	if: schema.optional(),
-	then: schema.optional(),
-	else: schema.optional(),
-	$ref: string().optional(),
-	$schema: _enum([
-		"http://json-schema.org/draft-07/schema#",
-		"https://json-schema.org/draft-07/schema",
-		"https://json-schema.org/draft/2019-09/schema",
-		"https://json-schema.org/draft/2020-12/schema"
-	]).optional(),
-	$defs: record(string(), schema).optional(),
-	definitions: record(string(), schema).optional(),
-	pattern: string().refine((value) => {
-		try {
-			return new RegExp(value, "u").source.length > 0;
-		} catch {
-			return false;
-		}
-	}, "Invalid regular expression.").optional(),
-	format: string().refine((value) => Object.hasOwn(format, value), "Unsupported string format.").optional(),
-	multipleOf: number().positive().optional(),
-	uniqueItems: boolean().optional(),
-	contains: schema.optional(),
-	minContains: number().int().nonnegative().optional(),
-	maxContains: number().int().nonnegative().optional(),
-	minProperties: number().int().nonnegative().optional(),
-	maxProperties: number().int().nonnegative().optional(),
-	propertyNames: schema.optional(),
-	patternProperties: record(string().refine((value) => {
-		try {
-			return new RegExp(value, "u").source.length > 0;
-		} catch {
-			return false;
-		}
-	}, "Invalid regular expression."), schema).optional(),
-	dependentRequired: record(string(), array(string())).optional(),
-	dependentSchemas: record(string(), schema).optional(),
-	dependencies: record(string(), union([schema, array(string())])).optional(),
-	prefixItems: array(schema).optional(),
-	additionalItems: schema.optional(),
-	unevaluatedItems: schema.optional(),
-	unevaluatedProperties: schema.optional(),
-	description: string().optional(),
-	title: string().optional(),
-	default: json$3().optional(),
-	examples: array(json$3()).optional(),
-	readOnly: boolean().optional(),
-	writeOnly: boolean().optional(),
-	deprecated: boolean().optional(),
-	$comment: string().optional(),
-	enum: array(json$3()).min(1).optional(),
-	properties: record(string(), schema).optional(),
-	required: array(string()).optional(),
-	additionalProperties: schema.optional(),
-	items: union([schema, array(schema)]).optional(),
-	minItems: number().int().nonnegative().optional(),
-	maxItems: number().int().nonnegative().optional(),
-	minLength: number().int().nonnegative().optional(),
-	maxLength: number().int().nonnegative().optional(),
-	minimum: number().optional(),
-	maximum: number().optional(),
-	exclusiveMinimum: number().optional(),
-	exclusiveMaximum: number().optional()
-}).transform(({ title: _title, default: _default, examples: _examples, readOnly: _readOnly, writeOnly: _writeOnly, deprecated: _deprecated, $comment: _comment, ...value }) => value)]));
-new TextEncoder();
 //#endregion
-//#region ../../node_modules/.bun/@babel+parser@8.0.4/node_modules/@babel/parser/lib/index.js
-var Position = class {
-	constructor(line, col, index) {
-		this.line = void 0;
-		this.column = void 0;
-		if (index !== void 0) this.index = void 0;
-		this.line = line;
-		this.column = col;
-		if (index !== void 0) this.index = index;
-	}
-};
-var SourceLocation = class {
-	start;
-	end;
-	filename;
-	identifierName;
-	constructor(start, end) {
-		this.start = start;
-		this.end = end;
-	}
-};
-var code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
-var ModuleErrors = {
-	ImportMetaOutsideModule: {
-		message: `import.meta may appear only with 'sourceType: "module"'`,
-		code
-	},
-	ImportOutsideModule: {
-		message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-		code
-	}
-};
-var NodeDescriptions = {
-	ArrayPattern: "array destructuring pattern",
-	AssignmentExpression: "assignment expression",
-	AssignmentPattern: "assignment expression",
-	ArrowFunctionExpression: "arrow function expression",
-	ConditionalExpression: "conditional expression",
-	CatchClause: "catch clause",
-	ForOfStatement: "for-of statement",
-	ForInStatement: "for-in statement",
-	ForStatement: "for-loop",
-	FormalParameters: "function parameter list",
-	Identifier: "identifier",
-	ImportSpecifier: "import specifier",
-	ImportDefaultSpecifier: "import default specifier",
-	ImportNamespaceSpecifier: "import namespace specifier",
-	ObjectPattern: "object destructuring pattern",
-	ParenthesizedExpression: "parenthesized expression",
-	RestElement: "rest element",
-	UpdateExpression: {
-		true: "prefix operation",
-		false: "postfix operation"
-	},
-	VariableDeclarator: "variable declaration",
-	YieldExpression: "yield expression"
-};
-var toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
-var StandardErrors = {
-	AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
-	ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
-	AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
-	AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
-	AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
-	AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
-	AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
-	AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
-	BadGetterArity: "A 'get' accessor must not have any formal parameters.",
-	BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
-	BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
-	ConstructorClassField: "Classes may not have a field named 'constructor'.",
-	ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
-	ConstructorIsAccessor: "Class constructor may not be an accessor.",
-	ConstructorIsAsync: "Constructor can't be an async function.",
-	ConstructorIsGenerator: "Constructor can't be a generator.",
-	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
-	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
-	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
-	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
-	DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
-	DecoratorStaticBlock: "Decorators can't be used with a static block.",
-	DeferImportRequiresNamespace: "Only `import defer * as x from \"./module\"` is valid.",
-	DeletePrivateField: "Deleting a private field is not allowed.",
-	DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
-	DuplicateConstructor: "Duplicate constructor in the same class.",
-	DuplicateDefaultExport: "Only one default export allowed per module.",
-	DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
-	DuplicateProto: "Redefinition of __proto__ property.",
-	DuplicateRegExpFlags: "Duplicate regular expression flag.",
-	ElementAfterRest: "Rest element must be last element.",
-	EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
-	ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
-	ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
-	ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
-	ForInUsing: "For-in loop may not start with 'using' declaration.",
-	ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
-	ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
-	GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
-	IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
-	IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
-	IllegalReturn: "'return' outside of function.",
-	ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
-	ImportCallArity: ({ phase }) => `\`import${phase ? `.${phase}` : ""}()\` requires exactly one or two arguments.`,
-	ImportCallNotNewExpression: ({ phase }) => `Cannot use new with import${phase ? `.${phase}` : ""}().`,
-	ImportCallSpreadArgument: ({ phase }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : ""}()\`.`,
-	IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
-	InvalidBigIntLiteral: "Invalid BigIntLiteral.",
-	InvalidCodePoint: "Code point out of bounds.",
-	InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
-	InvalidCoverInitializedName: "Invalid shorthand property initializer.",
-	InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`,
-	InvalidEscapeSequence: "Bad character escape sequence.",
-	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
-	InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
-	InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
-	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
-	InvalidNumber: "Invalid number.",
-	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
-	InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
-	InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
-	InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`,
-	InvalidPropertyBindingPattern: "Binding member expression.",
-	InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
-	LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`,
-	LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
-	LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
-	MalformedRegExpFlags: "Invalid regular expression flag.",
-	MissingClassName: "A class name is required.",
-	MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
-	MissingSemicolon: "Missing semicolon.",
-	MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
-	MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
-	ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
-	ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`,
-	ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
-	ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`,
-	MultipleDefaultsInSwitch: "Multiple default clauses.",
-	NewlineAfterThrow: "Illegal newline after throw.",
-	NoCatchOrFinally: "Missing catch or finally clause.",
-	NumberIdentifier: "Identifier directly after number.",
-	NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
-	ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
-	OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
-	OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
-	OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
-	ParamDupe: "Argument name clash.",
-	PatternHasAccessor: "Object pattern can't contain getter or setter.",
-	PatternHasMethod: "Object pattern can't contain methods.",
-	PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
-	PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`,
-	RestTrailingComma: "Unexpected trailing comma after rest element.",
-	SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
-	SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
-	SourcePhaseImportRequiresDefault: "Only `import source x from \"./module\"` is valid.",
-	StaticPrototype: "Classes may not have static property named prototype.",
-	SuperCallNotNewExpression: "Cannot use new with super(...).",
-	SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
-	SuperPrivateField: "Private fields can't be accessed on super.",
-	TrailingDecorator: "Decorators must be attached to a class element.",
-	UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
-	UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
-	UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
-	UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`,
-	UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
-	UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
-	UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
-	UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
-	UnexpectedPrivateField: "Unexpected private name.",
-	UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`,
-	UnexpectedSuper: "'super' is only allowed in object methods and classes.",
-	UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
-	UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
-	UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
-	UnexpectedVoidPattern: "Unexpected void binding.",
-	UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
-	UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
-	UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
-	UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
-	UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
-	UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
-	UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
-	UnterminatedComment: "Unterminated comment.",
-	UnterminatedRegExp: "Unterminated regular expression.",
-	UnterminatedString: "Unterminated string constant.",
-	UnterminatedTemplate: "Unterminated template.",
-	UsingDeclarationExport: "Using declaration cannot be exported.",
-	UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
-	VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`,
-	VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
-	VoidPatternInitializer: "A void binding may not have an initializer.",
-	YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
-	YieldInParameter: "Yield expression is not allowed in formal parameters.",
-	YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
-	ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
-};
-var StrictModeErrors = {
-	StrictDelete: "Deleting local variable in strict mode.",
-	StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
-	StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
-	StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
-	StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
-	StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
-	StrictWith: "'with' in strict mode."
-};
-var ParseExpressionErrors = {
-	ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
-	ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
-};
-var PipelineOperatorErrors = {
-	PipeTopicRequiresHackPipes: "Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.",
-	PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
-	PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
-	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
-	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`,
-	PipelineUnparenthesized: "Cannot mix binary operator with solo-await F#-style pipeline. Please wrap the pipeline in parentheses."
-};
-var FunctionBindErrors = {
-	UnsupportedBind: "Binding should be performed on object property.",
-	UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
+//#region src/control/common/authoringExamples.ts
+var descriptions = {
+	"manual": "A Manual start node.",
+	"error": "A Flow Error node. Select upstream Flows, then publish and enable this Flow to listen for failures in their automatic runs.",
+	"webhook": "A Webhook start node.",
+	"cron": "An hourly scheduled start node.",
+	"poll": "Gmail polling by key; replace CONNECTION_ID with an active Gmail connection.",
+	"integration": "Telegram webhook integration by key; replace CONNECTION_ID with an active Telegram connection.",
+	"decision": "AI Decision evaluates named questions against target and returns a complete answer object per output. Configure target before running.",
+	"openapi": "A fixed JSON API operation. Replace the example document and URL before running.",
+	"connector": "A Connector Task and its node. Replace ACTION_ID, CONNECTION_ID and port definitions using connector_get / connector show.",
+	"code": "A JavaScript module and its node. Use Code for custom computation; use Connector Tasks for existing actions.",
+	"condition": "A condition with true and false execution branches.",
+	"value": "A fixed value node.",
+	"approval": "An Approval with approve and reject decision branches and a built-in notification output.",
+	"wait": "A Wait with a continue action and a built-in notification output.",
+	"agent": "An Agent with code computation enabled. Configure a model available in the deployment.",
+	"llm-chat": "An LLM chat Task and its node; configure a model available in the deployment.",
+	"llm-json": "An LLM JSON Task and its node; configure a model available in the deployment.",
+	"poll-notification": "Gmail events → JavaScript text formatting → Connector notification. Replace connection/action IDs and match the notification input ports."
 };
-function defineHidden(obj, key, value) {
-	Object.defineProperty(obj, key, {
-		enumerable: false,
-		configurable: true,
-		value
-	});
-}
-function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
-	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
-	return function constructor(loc, pos, details) {
-		const error = /* @__PURE__ */ new SyntaxError();
-		error.code = code;
-		error.reasonCode = reasonCode;
-		error.loc = loc;
-		error.pos = pos;
-		error.syntaxPlugin = syntaxPlugin;
-		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
-		defineHidden(error, "clone", function clone(overrides = {}) {
-			const { line, column, index = pos } = overrides.loc ?? loc;
-			return constructor(new Position(line, column), index, {
-				...details,
-				...overrides.details
-			});
-		});
-		defineHidden(error, "details", details);
-		Object.defineProperty(error, "message", {
-			configurable: true,
-			get() {
-				const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
-				this.message = message;
-				return message;
-			},
-			set(value) {
-				Object.defineProperty(this, "message", {
-					value,
-					writable: true
-				});
-			}
-		});
-		return error;
-	};
-}
-function ParseErrorEnum(argument, syntaxPlugin) {
-	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
-	const ParseErrorConstructors = {};
-	for (const reasonCode of Object.keys(argument)) {
-		const template = argument[reasonCode];
-		const { message, ...rest } = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template;
-		ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
-			code: "BABEL_PARSER_SYNTAX_ERROR",
-			reasonCode,
-			toMessage: typeof message === "string" ? () => message : message,
-			...syntaxPlugin ? { syntaxPlugin } : {},
-			...rest
-		});
-	}
-	return ParseErrorConstructors;
-}
-({
-	...ParseErrorEnum(ModuleErrors),
-	...ParseErrorEnum(StandardErrors),
-	...ParseErrorEnum(StrictModeErrors),
-	...ParseErrorEnum(ParseExpressionErrors),
-	...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
-	...ParseErrorEnum`functionBind`(FunctionBindErrors)
-});
-var beforeExpr = true;
-var startsExpr = true;
-var isLoop = true;
-var isAssign = true;
-var prefix = true;
-var postfix = true;
-var ExportedTokenType = class {
-	label;
-	keyword;
-	beforeExpr;
-	startsExpr;
-	rightAssociative;
-	isLoop;
-	isAssign;
-	prefix;
-	postfix;
-	binop;
-	constructor(label, conf = {}) {
-		this.label = label;
-		this.keyword = conf.keyword;
-		this.beforeExpr = !!conf.beforeExpr;
-		this.startsExpr = !!conf.startsExpr;
-		this.rightAssociative = !!conf.rightAssociative;
-		this.isLoop = !!conf.isLoop;
-		this.isAssign = !!conf.isAssign;
-		this.prefix = !!conf.prefix;
-		this.postfix = !!conf.postfix;
-		this.binop = conf.binop != null ? conf.binop : null;
-	}
-};
-var keywords$1 = /* @__PURE__ */ new Map();
-function createKeyword(name, options = {}) {
-	options.keyword = name;
-	const token = createToken(name, options);
-	keywords$1.set(name, token);
-	return token;
-}
-function createBinop(name, binop) {
-	return createToken(name, {
-		beforeExpr,
-		binop
-	});
-}
-var tokenTypeCounter = -1;
-var tokenTypes = [];
-var tokenLabels = [];
-var tokenBinops = [];
-var tokenBeforeExprs = [];
-var tokenStartsExprs = [];
-var tokenPrefixes = [];
-function createToken(name, options = {}) {
-	++tokenTypeCounter;
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType(name, options));
-	return tokenTypeCounter;
-}
-function createKeywordLike(name, options = {}) {
-	++tokenTypeCounter;
-	keywords$1.set(name, tokenTypeCounter);
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType("name", options));
-	return tokenTypeCounter;
-}
-var tt = {
-	bracketL: createToken("[", {
-		beforeExpr,
-		startsExpr
-	}),
-	bracketR: createToken("]"),
-	braceL: createToken("{", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceBarL: createToken("{|", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceR: createToken("}"),
-	braceBarR: createToken("|}"),
-	parenL: createToken("(", {
-		beforeExpr,
-		startsExpr
-	}),
-	parenR: createToken(")"),
-	comma: createToken(",", { beforeExpr }),
-	semi: createToken(";", { beforeExpr }),
-	colon: createToken(":", { beforeExpr }),
-	doubleColon: createToken("::", { beforeExpr }),
-	dot: createToken("."),
-	question: createToken("?", { beforeExpr }),
-	questionDot: createToken("?."),
-	arrow: createToken("=>", { beforeExpr }),
-	template: createToken("template"),
-	ellipsis: createToken("...", { beforeExpr }),
-	backQuote: createToken("`", { startsExpr }),
-	dollarBraceL: createToken("${", {
-		beforeExpr,
-		startsExpr
-	}),
-	templateTail: createToken("...`", { startsExpr }),
-	templateNonTail: createToken("...${", {
-		beforeExpr,
-		startsExpr
-	}),
-	at: createToken("@"),
-	hash: createToken("#", { startsExpr }),
-	interpreterDirective: createToken("#!..."),
-	eq: createToken("=", {
-		beforeExpr,
-		isAssign
-	}),
-	assign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	slashAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	xorAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	moduloAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	incDec: createToken("++/--", {
-		prefix,
-		postfix,
-		startsExpr
-	}),
-	bang: createToken("!", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	tilde: createToken("~", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	doubleCaret: createToken("^^", { startsExpr }),
-	doubleAt: createToken("@@", { startsExpr }),
-	pipeline: createBinop("|>", 0),
-	nullishCoalescing: createBinop("??", 1),
-	logicalOR: createBinop("||", 1),
-	logicalAND: createBinop("&&", 2),
-	bitwiseOR: createBinop("|", 3),
-	bitwiseXOR: createBinop("^", 4),
-	bitwiseAND: createBinop("&", 5),
-	equality: createBinop("==/!=/===/!==", 6),
-	lt: createBinop("</>/<=/>=", 7),
-	gt: createBinop("</>/<=/>=", 7),
-	relational: createBinop("</>/<=/>=", 7),
-	bitShift: createBinop("<</>>/>>>", 8),
-	bitShiftL: createBinop("<</>>/>>>", 8),
-	bitShiftR: createBinop("<</>>/>>>", 8),
-	plusMin: createToken("+/-", {
-		beforeExpr,
-		binop: 9,
-		prefix,
-		startsExpr
-	}),
-	modulo: createToken("%", {
-		binop: 10,
-		startsExpr
-	}),
-	star: createToken("*", { binop: 10 }),
-	slash: createBinop("/", 10),
-	exponent: createToken("**", {
-		beforeExpr,
-		binop: 11,
-		rightAssociative: true
-	}),
-	_in: createKeyword("in", {
-		beforeExpr,
-		binop: 7
-	}),
-	_instanceof: createKeyword("instanceof", {
-		beforeExpr,
-		binop: 7
-	}),
-	_break: createKeyword("break"),
-	_case: createKeyword("case", { beforeExpr }),
-	_catch: createKeyword("catch"),
-	_continue: createKeyword("continue"),
-	_debugger: createKeyword("debugger"),
-	_default: createKeyword("default", { beforeExpr }),
-	_else: createKeyword("else", { beforeExpr }),
-	_finally: createKeyword("finally"),
-	_function: createKeyword("function", { startsExpr }),
-	_if: createKeyword("if"),
-	_return: createKeyword("return", { beforeExpr }),
-	_switch: createKeyword("switch"),
-	_throw: createKeyword("throw", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_try: createKeyword("try"),
-	_var: createKeyword("var"),
-	_const: createKeyword("const"),
-	_with: createKeyword("with"),
-	_new: createKeyword("new", {
-		beforeExpr,
-		startsExpr
-	}),
-	_this: createKeyword("this", { startsExpr }),
-	_super: createKeyword("super", { startsExpr }),
-	_class: createKeyword("class", { startsExpr }),
-	_extends: createKeyword("extends", { beforeExpr }),
-	_export: createKeyword("export"),
-	_import: createKeyword("import", { startsExpr }),
-	_null: createKeyword("null", { startsExpr }),
-	_true: createKeyword("true", { startsExpr }),
-	_false: createKeyword("false", { startsExpr }),
-	_typeof: createKeyword("typeof", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_void: createKeyword("void", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_delete: createKeyword("delete", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_do: createKeyword("do", {
-		isLoop,
-		beforeExpr
-	}),
-	_for: createKeyword("for", { isLoop }),
-	_while: createKeyword("while", { isLoop }),
-	_as: createKeywordLike("as", { startsExpr }),
-	_assert: createKeywordLike("assert", { startsExpr }),
-	_async: createKeywordLike("async", { startsExpr }),
-	_await: createKeywordLike("await", { startsExpr }),
-	_defer: createKeywordLike("defer", { startsExpr }),
-	_from: createKeywordLike("from", { startsExpr }),
-	_get: createKeywordLike("get", { startsExpr }),
-	_let: createKeywordLike("let", { startsExpr }),
-	_meta: createKeywordLike("meta", { startsExpr }),
-	_of: createKeywordLike("of", { startsExpr }),
-	_sent: createKeywordLike("sent", { startsExpr }),
-	_set: createKeywordLike("set", { startsExpr }),
-	_source: createKeywordLike("source", { startsExpr }),
-	_static: createKeywordLike("static", { startsExpr }),
-	_using: createKeywordLike("using", { startsExpr }),
-	_yield: createKeywordLike("yield", { startsExpr }),
-	_asserts: createKeywordLike("asserts", { startsExpr }),
-	_checks: createKeywordLike("checks", { startsExpr }),
-	_exports: createKeywordLike("exports", { startsExpr }),
-	_global: createKeywordLike("global", { startsExpr }),
-	_implements: createKeywordLike("implements", { startsExpr }),
-	_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
-	_infer: createKeywordLike("infer", { startsExpr }),
-	_is: createKeywordLike("is", { startsExpr }),
-	_mixins: createKeywordLike("mixins", { startsExpr }),
-	_proto: createKeywordLike("proto", { startsExpr }),
-	_require: createKeywordLike("require", { startsExpr }),
-	_satisfies: createKeywordLike("satisfies", { startsExpr }),
-	_keyof: createKeywordLike("keyof", { startsExpr }),
-	_readonly: createKeywordLike("readonly", { startsExpr }),
-	_unique: createKeywordLike("unique", { startsExpr }),
-	_abstract: createKeywordLike("abstract", { startsExpr }),
-	_declare: createKeywordLike("declare", { startsExpr }),
-	_enum: createKeywordLike("enum", { startsExpr }),
-	_module: createKeywordLike("module", { startsExpr }),
-	_namespace: createKeywordLike("namespace", { startsExpr }),
-	_interface: createKeywordLike("interface", { startsExpr }),
-	_type: createKeywordLike("type", { startsExpr }),
-	_opaque: createKeywordLike("opaque", { startsExpr }),
-	name: createToken("name", { startsExpr }),
-	placeholder: createToken("%%", { startsExpr }),
-	string: createToken("string", { startsExpr }),
-	num: createToken("num", { startsExpr }),
-	bigint: createToken("bigint", { startsExpr }),
-	regexp: createToken("regexp", { startsExpr }),
-	privateName: createToken("#name", { startsExpr }),
-	eof: createToken("eof"),
-	jsxName: createToken("jsxName"),
-	jsxText: createToken("jsxText", { beforeExpr }),
-	jsxTagStart: createToken("jsxTagStart", { startsExpr }),
-	jsxTagEnd: createToken("jsxTagEnd")
-};
-function getExportedToken(token) {
-	return tokenTypes[token];
-}
-var TokContext = class {
-	constructor(token, preserveSpace) {
-		this.token = token;
-		this.preserveSpace = !!preserveSpace;
-	}
-	token;
-	preserveSpace;
-};
-new TokContext("{"), new TokContext("<tag"), new TokContext("</tag"), new TokContext("<tag>...</tag>", true);
-var reservedWords = {
-	keyword: [
-		"break",
-		"case",
-		"catch",
-		"continue",
-		"debugger",
-		"default",
-		"do",
-		"else",
-		"finally",
-		"for",
-		"function",
-		"if",
-		"return",
-		"switch",
-		"throw",
-		"try",
-		"var",
-		"const",
-		"while",
-		"with",
-		"new",
-		"this",
-		"super",
-		"class",
-		"extends",
-		"export",
-		"import",
-		"null",
-		"true",
-		"false",
-		"in",
-		"instanceof",
-		"typeof",
-		"void",
-		"delete"
-	],
-	strict: [
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield"
-	],
-	strictBind: ["eval", "arguments"]
-};
-new Set(reservedWords.keyword);
-new Set(reservedWords.strict);
-new Set(reservedWords.strictBind);
-ParseErrorEnum`flow`({
-	AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
-	AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
-	AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
-	DeclareClassElement: "The `declare` modifier can only appear on class fields.",
-	DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
-	DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
-	EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
-	EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
-	EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
-	EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
-	EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
-	EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
-	EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
-	EnumStringMemberInconsistentlyInitialized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
-	GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
-	ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
-	InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
-	InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
-	InexactVariance: "Explicit inexact syntax cannot have variance.",
-	InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
-	MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
-	NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
-	NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
-	PatternIsOptional: { message: "A binding pattern parameter cannot be optional in an implementation signature." },
-	SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
-	SpreadVariance: "Spread properties cannot have variance.",
-	ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
-	ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
-	ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
-	ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
-	ThisParamNoDefault: "The `this` parameter may not have a default value.",
-	TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
-	UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
-	UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`,
-	UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
-	UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
-	UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
-	UnexpectedSubtractionOperand: "Unexpected token, expected \"number\" or \"bigint\".",
-	UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
-	UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
-	UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
-	UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
-	UnterminatedFlowComment: "Unterminated flow-comment."
-});
-new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
-ParseErrorEnum`jsx`({
-	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
-	MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
-	MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
-	UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
-	UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
-	UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
-	UnterminatedJsxContent: "Unterminated JSX contents.",
-	UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
-});
-var Node = class {
-	constructor(optionFlags, filename, pos, loc) {
-		this.start = pos;
-		this.end = 0;
-		if (loc !== void 0) this.loc = new SourceLocation(loc);
-		if (optionFlags & 128) this.range = [pos, 0];
-		if (loc !== void 0 && filename) this.loc.filename = filename;
-	}
-	type = "";
-};
-Node.prototype;
-ParseErrorEnum`typescript`({
-	AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
-	AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
-	AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
-	AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
-	AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
-	ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
-	ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
-	ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
-	ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
-	DeclaratorDefiniteAssertionRequiresTypeAnnotation: "Declarations with definite assignment assertions must also have type annotations.",
-	DeclaratorDefiniteAssertionWithInitializer: "Declarations with initializers cannot also have definite assignment assertions.",
-	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
-	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
-	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
-	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
-	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
-	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
-	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
-	EmptyNamespaceName: "Namespace must be given a name.",
-	EmptyTypeArguments: "Type argument list cannot be empty.",
-	EmptyTypeParameters: "Type parameter list cannot be empty.",
-	ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
-	ExportAssignmentInTSNamespace: "An export assignment cannot be used in a namespace.",
-	ExportInTSNamespace: "Export declarations are not permitted in a namespace.",
-	ImportAliasHasImportType: "An import alias can not use 'import type'.",
-	ImportInTSNamespace: "Import declarations in a namespace cannot reference a module.",
-	IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
-	IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
-	IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
-	IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
-	IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
-	IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
-	InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
-	InlineModuleDeclarationMustUseString: "`module ... {}` declarations must have a string name. Use `namespace ... {}` instead.",
-	InvalidHeritageClauseType: ({ token }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
-	InvalidModifierOnAwaitUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on an await using declaration.`,
-	InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`,
-	InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`,
-	InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
-	InvalidModifierOnUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on a using declaration.`,
-	InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
-	InvalidNamespaceName: (value) => `Namespace name cannot be '${value}'.`,
-	InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
-	InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
-	MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
-	NamespaceExportInTSNamespace: "Global module exports may only appear at top level.",
-	NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
-	NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
-	OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
-	OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
-	PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
-	PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
-	PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
-	ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
-	ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
-	ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
-	SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
-	SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
-	SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
-	SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
-	StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
-	TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
-	TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
-	TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
-	TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
-	UnexpectedParameterInitializer: "A parameter initializer is only allowed in a function or constructor implementation.",
-	UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
-	UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
-	UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
-	UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
-	UnexpectedTypeDeclaration: (type) => `'${type}' declarations can only be declared inside a block.`,
-	UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
-	UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
-	UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
-	UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`
-});
-ParseErrorEnum`placeholders`({
-	ClassNameIsRequired: "A class name is required.",
-	UnexpectedSpace: "Unexpected space in placeholder."
-});
-function generateExportedTokenTypes(internalTokenTypes) {
-	const tokenTypes = {};
-	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
-	return tokenTypes;
-}
-generateExportedTokenTypes(tt);
-//#endregion
-//#region src/flow/common/nodeChanges.ts
-var codeTaskTemplate = `export default async function (inputs, context) {
-  return { result: inputs.value }
-}
-`;
-function createCodeTask(target, identity, name, module = void 0, ports = {
-	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
-			}
-		},
-		nodeId: identity.nodeId,
-		target
-	}];
-}
-function createManagedTask(target, identity, task) {
-	return [{
-		kind: "task.create",
-		task,
-		taskId: identity.taskId
-	}, {
-		kind: "graph.node.create",
-		node: {
-			inputs: defaultInputs(task.inputs),
-			kind: "task",
-			name: task.name,
-			taskId: identity.taskId
-		},
-		nodeId: identity.nodeId,
-		target
-	}];
-}
-function createLlmTask(target, identity, name, mode, outputDescription, options = {}) {
-	const values = options.inputs ?? {};
-	return createManagedTask(target, 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(target, 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,
-		target
-	}];
-}
-function createValue(target, nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputs: {},
-			kind: "value",
-			name,
-			values: [{
-				handle: "value",
-				jsonSchema: {},
-				nullable: true,
-				value: null
-			}]
-		},
-		nodeId,
-		target
-	}];
-}
-function createWait(target, nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputDefinitions: [],
-			inputs: {},
-			kind: "wait",
-			name,
-			prompt: name
-		},
-		nodeId,
-		target
-	}];
-}
-function createApproval(target, nodeId, name) {
-	return [{
-		kind: "graph.node.create",
-		node: {
-			inputDefinitions: [],
-			inputs: {},
-			kind: "approval",
-			name,
-			prompt: name
-		},
-		nodeId,
-		target
-	}];
-}
-function createBuiltinTrigger(target, nodeId, node) {
-	return [{
-		kind: "graph.node.create",
-		node,
-		nodeId,
-		target
-	}];
-}
-function createProviderTrigger(target, 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,
-		target
-	}];
-}
-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(target, identity, name = "AI Decision", questions) {
-	return createManagedTask(target, 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(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({ kind: "flow" }, 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 target = { kind: "flow" };
-var descriptions = {
-	"manual": "A Manual start node.",
-	"error": "A Flow Error node. Select upstream Flows, then publish and enable this Flow to listen for failures in their automatic runs.",
-	"webhook": "A Webhook start node.",
-	"cron": "An hourly scheduled start node.",
-	"poll": "Gmail polling by key; replace CONNECTION_ID with an active Gmail connection.",
-	"integration": "Telegram webhook integration by key; replace CONNECTION_ID with an active Telegram connection.",
-	"decision": "AI Decision evaluates named questions against target and returns a complete answer object per output. Configure target before running.",
-	"openapi": "A fixed JSON API operation. Replace the example document and URL before running.",
-	"connector": "A Connector Task and its node. Replace ACTION_ID, CONNECTION_ID and port definitions using connector_get / connector show.",
-	"code": "A JavaScript module and its node. Use Code for custom computation; use Connector Tasks for existing actions.",
-	"condition": "A condition with true and false execution branches.",
-	"value": "A fixed value node.",
-	"approval": "An Approval with approve and reject decision branches and a built-in notification output.",
-	"wait": "A Wait with a continue action and a built-in notification output.",
-	"agent": "An Agent with code computation enabled. Configure a model available in the deployment.",
-	"llm-chat": "An LLM chat Task and its node; configure a model available in the deployment.",
-	"llm-json": "An LLM JSON Task and its node; configure a model available in the deployment.",
-	"poll-notification": "Gmail events → JavaScript text formatting → Connector notification. Replace connection/action IDs and match the notification input ports."
-};
-var authoringExamples = Object.keys(descriptions).map((name) => ({
-	name,
-	description: descriptions[name]
-}));
-function authoringExample(name) {
-	let operations;
-	switch (name) {
-		case "error":
-			operations = createBuiltinTrigger(target, "error", {
-				kind: "error",
-				name: "Flow Error"
+var authoringExamples = Object.keys(descriptions).map((name) => ({
+	name,
+	description: descriptions[name]
+}));
+function authoringExample(name) {
+	let operations;
+	switch (name) {
+		case "error":
+			operations = createBuiltinTrigger("error", {
+				kind: "error",
+				name: "Flow Error"
 			});
 			break;
 		case "decision":
-			operations = createDecisionTask(target, {
-				nodeId: "decision",
-				taskId: "decision-task"
-			}, "AI Decision", [{
+			operations = createDecisionTask({ nodeId: "decision" }, "AI Decision", [{
 				name: "needs_support",
 				type: "noul",
 				instructions: "Does the customer need support?"
 			}]);
 			break;
 		case "openapi":
-			operations = createManagedTask(target, {
-				nodeId: "api",
-				taskId: "api-task"
-			}, openApiTask(selectOperation({
+			operations = createManagedTask({ nodeId: "api" }, openApiTask(selectOperation({
 				openapi: "3.1.0",
 				paths: { "/items": { get: { responses: { "200": { content: { "application/json": { schema: {
 					type: "array",
@@ -11992,13 +10999,13 @@ function authoringExample(name) {
 			}, "https://api.example.com/openapi.json", "/items", "get")));
 			break;
 		case "manual":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "manual",
 				name: "Start"
 			});
 			break;
 		case "webhook":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "webhook",
 				method: "POST",
 				name: "Webhook",
@@ -12006,7 +11013,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "cron":
-			operations = createBuiltinTrigger(target, "start", {
+			operations = createBuiltinTrigger("start", {
 				kind: "cron",
 				name: "Schedule",
 				cronTimes: [{
@@ -12040,10 +11047,7 @@ function authoringExample(name) {
 			}];
 			break;
 		case "agent":
-			operations = createManagedTask(target, {
-				nodeId: "agent",
-				taskId: "agent-task"
-			}, {
+			operations = createManagedTask({ nodeId: "agent" }, {
 				name: "Agent",
 				inputs: [{
 					handle: "input",
@@ -12067,10 +11071,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "connector":
-			operations = createManagedTask(target, {
-				nodeId: "notify",
-				taskId: "notify-task"
-			}, {
+			operations = createManagedTask({ nodeId: "notify" }, {
 				name: "Notify",
 				executor: {
 					kind: "connector",
@@ -12087,7 +11088,7 @@ function authoringExample(name) {
 			});
 			break;
 		case "code":
-			operations = createCodeTask(target, {
+			operations = createCodeTask({
 				nodeId: "format",
 				moduleId: "format-module"
 			}, "Format", {
@@ -12112,10 +11113,9 @@ function authoringExample(name) {
 			break;
 		case "condition":
 			operations = [
-				...createCondition(target, "condition", "Condition"),
+				...createCondition("condition", "Condition"),
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "condition",
 					handle: "0/0/0/left",
 					value: {
@@ -12125,7 +11125,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "condition",
 					handle: "0/0/0/right",
 					value: {
@@ -12136,20 +11135,17 @@ function authoringExample(name) {
 			];
 			break;
 		case "value":
-			operations = createValue(target, "value", "Value");
+			operations = createValue("value", "Value");
 			break;
 		case "approval":
-			operations = createApproval(target, "approval", "Approve?");
+			operations = createApproval("approval", "Approve?");
 			break;
 		case "wait":
-			operations = createWait(target, "wait", "Continue?");
+			operations = createWait("wait", "Continue?");
 			break;
 		case "llm-chat":
 		case "llm-json":
-			operations = createLlmTask(target, {
-				nodeId: "llm",
-				taskId: "llm-task"
-			}, "LLM", name == "llm-chat" ? "chat" : "json", "Generated response.");
+			operations = createLlmTask({ nodeId: "llm" }, "LLM", name == "llm-chat" ? "chat" : "json", "Generated response.");
 			break;
 		case "poll-notification":
 			operations = [
@@ -12158,7 +11154,6 @@ function authoringExample(name) {
 				...authoringExample("connector").operations,
 				{
 					kind: "graph.edge.connect",
-					target,
 					edge: {
 						source: "mail",
 						target: "format"
@@ -12166,7 +11161,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.edge.connect",
-					target,
 					edge: {
 						source: "format",
 						target: "notify"
@@ -12174,7 +11168,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "format",
 					handle: "events",
 					before: {
@@ -12192,7 +11185,6 @@ function authoringExample(name) {
 				},
 				{
 					kind: "graph.node.input.set",
-					target,
 					nodeId: "notify",
 					handle: "text",
 					before: {
@@ -12224,10 +11216,10 @@ var json = json$3();
 var id = string().min(1);
 var version = literal(1);
 var flowName = id.refine((value) => value == value.trim() && resourceNameIssue(value) == null, "Flow name is invalid.");
-var inputs = record(string(), record(string(), json));
+var inputs = record$1(string(), record$1(string(), json));
 var trigger = strictObject({
 	nodeId: id,
-	outputs: record(string(), json)
+	outputs: record$1(string(), json)
 });
 var schemas = {
 	loadOpenApiDocument: strictObject({
@@ -12262,7 +11254,7 @@ var schemas = {
 	}),
 	updatePresentation: strictObject({
 		expectedRevision: int().positive(),
-		value: record(string(), json),
+		value: record$1(string(), json),
 		version
 	}),
 	checkFlow: strictObject({