@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.75

package/dist/common/flow-semantics.js

@@ -4128,446 +4128,84 @@ function decisionTaskIssues(task) {
 	}] : []];
 }
 //#endregion
-//#region src/openapi/common/openapi.ts
-var methods = [
-	"get",
-	"put",
-	"post",
-	"delete",
-	"options",
-	"head",
-	"patch",
-	"trace"
-];
-function object$1(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;
+//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
 }
-function parseOpenApi(value) {
-	const doc = object$1(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$1(doc.paths);
-	return doc;
+function joinValues(array, separator = "|") {
+	return array.map((val) => stringifyPrimitive(val)).join(separator);
 }
-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$1(value);
-		if (!Object.hasOwn(source, key)) throw new Error("An OpenAPI reference is missing.");
-		value = source[key];
-	}
+function jsonStringifyReplacer(_, value) {
+	if (typeof value === "bigint") return value.toString();
 	return value;
 }
-function resolved(doc, value) {
-	let result = object$1(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$1(pointer(doc, $ref)),
-			...siblings
-		};
+var Cached = class {
+	constructor(getter) {
+		this._getter = getter;
+		this._value = void 0;
 	}
-	return result;
+	get value() {
+		const getter = this._getter;
+		if (getter !== void 0) {
+			this._value = getter();
+			this._getter = void 0;
+		}
+		return this._value;
+	}
+};
+function cached(getter) {
+	return new Cached(getter);
 }
-function operation(doc, path, method) {
-	const item = resolved(doc, object$1(doc.paths)[path]);
-	if (!methods.includes(method) || item[method] == null) throw new Error("The selected operation is no longer available.");
-	return {
-		item,
-		op: object$1(item[method])
-	};
+function nullish(input) {
+	return input === null || input === void 0;
 }
-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$1);
+function cleanRegex(source) {
+	const start = source.startsWith("^") ? 1 : 0;
+	const end = source.endsWith("$") ? source.length - 1 : source.length;
+	return source.slice(start, end);
 }
-function snapshot(documentValue, path, method) {
-	const doc = parseOpenApi(documentValue);
-	const { item, op } = operation(doc, path, method);
-	const security = op.security ?? doc.security ?? [];
-	const result = {
-		openapi: doc.openapi,
-		paths: { [path]: {
-			[method]: op,
-			...item.parameters == null ? {} : { parameters: item.parameters }
-		} },
-		servers: servers(doc, path, method),
-		security
-	};
-	const visited = /* @__PURE__ */ new Set();
-	function copy(ref) {
-		if (visited.has(ref)) return;
-		visited.add(ref);
-		const value = pointer(doc, ref);
-		const keys = decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
-		if (keys.some((key) => [
-			"__proto__",
-			"constructor",
-			"prototype"
-		].includes(key))) throw new Error("Unsupported reference key.");
-		let target = result;
-		for (const key of keys.slice(0, -1)) {
-			if (!Object.hasOwn(target, key)) target[key] = {};
-			target = object$1(target[key]);
-		}
-		target[keys.at(-1)] = structuredClone(value);
-		visit(value);
-	}
-	function visit(value) {
-		if (value == null || typeof value != "object") return;
-		if (Array.isArray(value)) {
-			value.forEach(visit);
-			return;
-		}
-		if (typeof object$1(value).$ref == "string") copy(object$1(value).$ref);
-		for (const [key, child] of Object.entries(value)) if (![
-			"example",
-			"examples",
-			"default"
-		].includes(key)) visit(child);
-	}
-	visit(result);
-	for (const entry of security) for (const name of Object.keys(object$1(entry))) copy(`#/components/securitySchemes/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`);
-	return structuredClone(result);
+function floatSafeRemainder(val, step) {
+	const ratio = val / step;
+	const roundedRatio = Math.round(ratio);
+	const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
+	if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
+	return ratio - roundedRatio;
 }
-function schema$1(doc, schemaValue) {
-	const defs = {};
-	const ids = /* @__PURE__ */ new Map();
-	function convert(value) {
-		if (typeof value == "boolean") return value;
-		const source = object$1(value);
-		if (source.format == "binary" || source.$dynamicRef != null || source.$id != null) throw new Error("Binary and dynamically scoped schemas are unsupported.");
-		const result = {};
-		for (const [key, child] of Object.entries(source)) {
-			if ([
-				"nullable",
-				"example",
-				"xml",
-				"discriminator",
-				"__proto__"
-			].includes(key)) continue;
-			if (key == "$ref") {
-				if (typeof child != "string") throw new Error("Invalid schema reference.");
-				let id = ids.get(child);
-				if (id == null) {
-					id = `s${ids.size}`;
-					ids.set(child, id);
-					defs[id] = convert(pointer(doc, child));
-				}
-				result.$ref = `#/$defs/${id}`;
-			} else if ([
-				"properties",
-				"patternProperties",
-				"$defs",
-				"definitions",
-				"dependentSchemas"
-			].includes(key)) result[key] = Object.fromEntries(Object.entries(object$1(child)).map(([name, childSchema]) => [name, convert(childSchema)]));
-			else if ([
-				"allOf",
-				"anyOf",
-				"oneOf",
-				"prefixItems"
-			].includes(key)) {
-				if (!Array.isArray(child)) throw new Error("Invalid schema composition.");
-				result[key] = child.map(convert);
-			} else if ([
-				"items",
-				"additionalProperties",
-				"not",
-				"if",
-				"then",
-				"else",
-				"contains",
-				"propertyNames",
-				"unevaluatedProperties"
-			].includes(key)) result[key] = convert(child);
-			else result[key] = child;
-		}
-		if (source.nullable === true) return { anyOf: [result, { type: "null" }] };
-		for (const key of ["minimum", "maximum"]) {
-			const exclusive = key == "minimum" ? "exclusiveMinimum" : "exclusiveMaximum";
-			if (typeof result[exclusive] == "boolean") {
-				if (result[exclusive] && typeof result[key] == "number") {
-					result[exclusive] = result[key];
-					delete result[key];
-				} else delete result[exclusive];
+var EVALUATING = /* @__PURE__*/ Symbol("evaluating");
+function defineLazy(object, key, getter) {
+	let value = void 0;
+	Object.defineProperty(object, key, {
+		get() {
+			if (value === EVALUATING) return;
+			if (value === void 0) {
+				value = EVALUATING;
+				value = getter();
 			}
-		}
-		return result;
-	}
-	let converted = convert(schemaValue);
-	if (typeof converted == "object" && converted != null && typeof object$1(converted).$ref == "string") {
-		const id = String(object$1(converted).$ref).slice(8);
-		const { $ref: _ref, ...siblings } = object$1(converted);
-		converted = {
-			...object$1(defs[id]),
-			...siblings
-		};
-	}
-	if (typeof converted == "boolean") return converted;
-	return {
-		$schema: "https://json-schema.org/draft/2020-12/schema",
-		...object$1(converted),
-		...Object.keys(defs).length ? { $defs: defs } : {}
-	};
+			return value;
+		},
+		set(v) {
+			Object.defineProperty(object, key, { value: v });
+		},
+		configurable: true
+	});
 }
-function parameters(config) {
-	const doc = parseOpenApi(config.document);
-	const { item, op } = operation(doc, config.path, config.method);
-	const entries = /* @__PURE__ */ new Map();
-	for (const value of [...item.parameters ?? [], ...op.parameters ?? []]) {
-		const p = resolved(doc, value);
-		if (![
-			"path",
-			"query",
-			"header"
-		].includes(String(p.in)) || typeof p.name != "string" || p.content != null) throw new Error("Only schema-based path, query and header parameters are supported.");
-		if (p.allowReserved === true) throw new Error("allowReserved parameters are unsupported.");
-		if ((p.style ?? (p.in == "query" ? "form" : "simple")) != (p.in == "query" ? "form" : "simple")) throw new Error("Only form query and simple path/header serialization are supported.");
-		entries.set(`${p.in}.${p.in == "header" ? p.name.toLowerCase() : p.name}`, p);
-	}
-	return [...entries.values()];
+function assignProp(target, prop, value) {
+	Object.defineProperty(target, prop, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
 }
-function jsonContent(doc, value) {
-	const content = resolved(doc, value);
-	const media = object$1(content.content);
-	const mediaType = media["application/json"] != null ? "application/json" : Object.keys(media).find((key) => /^application\/.+\+json$/.test(key));
-	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$1(json).schema ?? {}),
-		required: content.required === true,
-		mediaType
-	};
-}
-function authHandles(auth) {
-	return auth.flatMap((scheme) => scheme.type == "basic" ? [`auth.${scheme.id}.username`, `auth.${scheme.id}.password`] : [`auth.${scheme.id}.token`]);
-}
-function openApiTask(config, name = "OpenAPI") {
-	if (!config.path) return {
-		name,
-		executor: config,
-		inputs: [],
-		outputs: []
-	};
-	const doc = parseOpenApi(config.document);
-	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 defaultValue = typeof jsonSchema == "boolean" ? void 0 : object$1(jsonSchema).default;
-		return {
-			handle: `${p.in}.${p.name}`,
-			jsonSchema,
-			nullable: p.required !== true && p.in != "path" || matchesSchema(null, jsonSchema),
-			...typeof p.description == "string" ? { description: p.description } : {},
-			...defaultValue === void 0 ? {} : { value: defaultValue }
-		};
-	});
-	if (op.requestBody != null) {
-		if (config.method == "get" || config.method == "head") throw new Error("GET and HEAD request bodies are unsupported.");
-		const body = jsonContent(doc, op.requestBody);
-		inputs.push({
-			handle: "body",
-			jsonSchema: body.schema,
-			nullable: !body.required || matchesSchema(null, body.schema)
-		});
-	}
-	const occupied = new Set(params.map((p) => `${p.in}.${p.in == "header" ? String(p.name).toLowerCase() : p.name}`));
-	for (const auth of config.auth) {
-		const location = auth.type == "apiKey" ? `${auth.in}.${auth.in == "header" ? auth.name?.toLowerCase() : auth.name}` : "header.authorization";
-		if (occupied.has(location)) throw new Error("Authentication conflicts with a parameter or another security scheme.");
-		if (auth.type == "apiKey" && (!auth.name || !["header", "query"].includes(auth.in ?? ""))) throw new Error("API Key requires a name and location.");
-		occupied.add(location);
-	}
-	inputs.push(...authHandles(config.auth).map((handle) => ({
-		handle,
-		jsonSchema: { type: "string" },
-		nullable: false
-	})));
-	const responses = object$1(op.responses);
-	const schemas = [];
-	for (const [status, response] of Object.entries(responses)) if (/^2\d\d$|^2XX$/.test(status) || status == "default") {
-		const r = resolved(doc, response);
-		if (r.content == null) schemas.push({ type: "null" });
-		else {
-			jsonContent(doc, r);
-			for (const [mediaType, media] of Object.entries(object$1(r.content))) if (/^application\/(json|.+\+json)$/.test(mediaType)) schemas.push(schema$1(doc, object$1(media).schema ?? {}));
-		}
-	}
-	if (!schemas.length) throw new Error("A successful JSON response definition is required.");
-	return {
-		name,
-		executor: config,
-		inputs,
-		outputs: [
-			{
-				handle: "body",
-				jsonSchema: schemas.length == 1 ? schemas[0] : {
-					$schema: "https://json-schema.org/draft/2020-12/schema",
-					anyOf: schemas.map((s, index) => inlineSchema(s, index))
-				},
-				nullable: config.method == "head" || schemas.some((item) => matchesSchema(null, item))
-			},
-			{
-				handle: "statusCode",
-				jsonSchema: { type: "integer" },
-				nullable: false
-			},
-			{
-				handle: "headers",
-				jsonSchema: {
-					type: "object",
-					additionalProperties: { type: "string" }
-				},
-				nullable: false
-			}
-		]
-	};
-}
-function inlineSchema(value, index) {
-	if (Array.isArray(value)) return value.map((item) => inlineSchema(item, index));
-	if (value == null || typeof value != "object") return value;
-	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key == "$ref" && typeof child == "string" && child.startsWith("#/") ? `#/anyOf/${index}/${child.slice(2)}` : inlineSchema(child, index)]));
-}
-/** The canvas validator and property panel share the same configuration contract. */
-function openApiFieldIssues(task) {
-	if (task.executor.kind != "openapi") return [];
-	const config = task.executor;
-	let field = "sourceUrl";
-	try {
-		if (!config.sourceUrl.trim()) return [{
-			field,
-			message: "Enter an OpenAPI JSON document URL."
-		}];
-		httpUrl(config.sourceUrl);
-		field = "operation";
-		if (!config.path) return [{
-			field,
-			message: "Select an OpenAPI operation."
-		}];
-		field = "serverUrl";
-		httpUrl(config.serverUrl);
-		if (new URL(config.serverUrl).search) throw new Error("Server URLs must not contain a query string.");
-		field = "operation";
-		if (!dequal(config.document, snapshot(config.document, config.path, config.method))) return [{
-			field,
-			message: "Save only the selected operation and its dependencies."
-		}];
-		const expected = openApiTask(config, task.name);
-		if (!dequal(expected.inputs, task.inputs) || !dequal(expected.outputs, task.outputs)) return [{
-			field,
-			message: "OpenAPI ports must match the saved operation."
-		}];
-		return [];
-	} catch (error) {
-		return [{
-			field,
-			message: error.message
-		}];
-	}
-}
-function openApiIssues(task) {
-	return openApiFieldIssues(task).map((issue) => issue.message);
-}
-//#endregion
-//#region src/flow/common/inputValue.ts
-/** An explicit clear suppresses the default; absent mappings still inherit it. */
-function inputValue(mapping, fallback) {
-	if (mapping?.kind === "unset") return void 0;
-	return mapping?.kind === "value" ? mapping.value : fallback;
-}
-//#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
-function getEnumValues(entries) {
-	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
-}
-function joinValues(array, separator = "|") {
-	return array.map((val) => stringifyPrimitive(val)).join(separator);
-}
-function jsonStringifyReplacer(_, value) {
-	if (typeof value === "bigint") return value.toString();
-	return value;
-}
-var Cached = class {
-	constructor(getter) {
-		this._getter = getter;
-		this._value = void 0;
-	}
-	get value() {
-		const getter = this._getter;
-		if (getter !== void 0) {
-			this._value = getter();
-			this._getter = void 0;
-		}
-		return this._value;
-	}
-};
-function cached(getter) {
-	return new Cached(getter);
-}
-function nullish(input) {
-	return input === null || input === void 0;
-}
-function cleanRegex(source) {
-	const start = source.startsWith("^") ? 1 : 0;
-	const end = source.endsWith("$") ? source.length - 1 : source.length;
-	return source.slice(start, end);
-}
-function floatSafeRemainder(val, step) {
-	const ratio = val / step;
-	const roundedRatio = Math.round(ratio);
-	const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
-	if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
-	return ratio - roundedRatio;
-}
-var EVALUATING = /* @__PURE__*/ Symbol("evaluating");
-function defineLazy(object, key, getter) {
-	let value = void 0;
-	Object.defineProperty(object, key, {
-		get() {
-			if (value === EVALUATING) return;
-			if (value === void 0) {
-				value = EVALUATING;
-				value = getter();
-			}
-			return value;
-		},
-		set(v) {
-			Object.defineProperty(object, key, { value: v });
-		},
-		configurable: true
-	});
-}
-function assignProp(target, prop, value) {
-	Object.defineProperty(target, prop, {
-		value,
-		writable: true,
-		enumerable: true,
-		configurable: true
-	});
-}
-/**
-* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
-*
-* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
-*/
-function rawShape(def) {
-	const desc = Object.getOwnPropertyDescriptor(def, "shape");
-	return desc?.get ? desc.get.raw : desc?.value;
+/**
+* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
+*
+* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
+*/
+function rawShape(def) {
+	const desc = Object.getOwnPropertyDescriptor(def, "shape");
+	return desc?.get ? desc.get.raw : desc?.value;
 }
 function sourceShape(schema) {
 	return rawShape(schema._zod.def) ?? schema._zod.def.shape;
@@ -9830,7 +9468,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		return required(ZodNonOptional, this, args[0]);
 	}
 });
-function object(shape, params) {
+function object$1(shape, params) {
 	return new ZodObject({
 		type: "object",
 		shape: shape ?? {},
@@ -10058,110 +9696,724 @@ function prefault(innerType, defaultValue) {
 		}
 	});
 }
-var ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def) => {
-	$ZodNonOptional.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
-	inst.unwrap = () => inst._zod.def.innerType;
-});
-function nonoptional(innerType, params) {
-	return new ZodNonOptional({
-		type: "nonoptional",
-		innerType,
-		...normalizeParams(params)
-	});
+var ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def) => {
+	$ZodNonOptional.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+	return new ZodNonOptional({
+		type: "nonoptional",
+		innerType,
+		...normalizeParams(params)
+	});
+}
+var ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def) => {
+	$ZodCatch.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+	inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+	return new ZodCatch({
+		type: "catch",
+		innerType,
+		catchValue: typeof catchValue === "function" ? catchValue : constantCatch(catchValue)
+	});
+}
+var ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def) => {
+	$ZodPipe.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
+	inst.in = def.in;
+	inst.out = def.out;
+});
+function pipe(in_, out) {
+	return new ZodPipe({
+		type: "pipe",
+		in: in_,
+		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);
+	inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+	return new ZodReadonly({
+		type: "readonly",
+		innerType
+	});
+}
+var ZodLazy = /*@__PURE__*/ $constructor("ZodLazy", (inst, def) => {
+	$ZodLazy.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => lazyProcessor(inst, ctx, json, params);
+	inst.unwrap = () => inst._zod.def.getter();
+});
+function lazy(getter) {
+	return new ZodLazy({
+		type: "lazy",
+		getter
+	});
+}
+var ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
+	$ZodCustom.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
+});
+function refine(fn, _params = {}) {
+	return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn, params) {
+	return /* @__PURE__ */ _superRefine(fn, params);
+}
+function json$1(params) {
+	const jsonSchema = lazy(() => {
+		return union([
+			string(params),
+			number(),
+			boolean(),
+			_null(),
+			array(jsonSchema),
+			record$1(string(), jsonSchema)
+		]);
+	});
+	return jsonSchema;
+}
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/iso.js
+function datetime(params) {
+	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
+}
+//#endregion
+//#region src/http/common/headers.ts
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+function httpHeaderNameIssue(name, names) {
+	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
+	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
+}
+//#endregion
+//#region src/http/common/httpRequest.ts
+var parameterSchema = strictObject({
+	mode: _enum(["fields", "object"]).default("fields"),
+	names: array(string()).default([])
+});
+var httpRequestConfigSchema = strictObject({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"HEAD",
+		"OPTIONS"
+	]).default("GET"),
+	query: parameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	headers: parameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	bodyFormat: _enum([
+		"none",
+		"json",
+		"text",
+		"form"
+	]).default("none"),
+	authentication: union([
+		strictObject({ type: literal("none") }),
+		strictObject({ type: _enum(["bearer", "basic"]) }),
+		strictObject({
+			type: literal("apiKey"),
+			name: string(),
+			in: _enum(["header", "query"])
+		})
+	]).default({ type: "none" }),
+	responseFormat: _enum([
+		"auto",
+		"json",
+		"text"
+	]).default("auto"),
+	statusPolicy: _enum(["success", "all"]).default("success")
+});
+var httpRequestExecutorSchema = httpRequestConfigSchema.extend({ kind: literal("http-request") });
+var scalarSchema = { type: [
+	"string",
+	"number",
+	"boolean"
+] };
+var queryValueSchema = { anyOf: [scalarSchema, {
+	type: "array",
+	items: scalarSchema
+}] };
+var httpHeaderSchema = {
+	type: "object",
+	additionalProperties: { type: "string" }
+};
+var httpQuerySchema = {
+	type: "object",
+	additionalProperties: queryValueSchema
+};
+function httpAuthHandles(config) {
+	return config.authentication.type == "none" ? [] : config.authentication.type == "basic" ? ["auth.username", "auth.password"] : ["auth.token"];
+}
+function retain(ports, old) {
+	const remaining = new Map(ports.map((port) => [port.handle, port]));
+	return [...old.flatMap((item) => {
+		if ("group" in item) return [item];
+		const next = remaining.get(item.handle);
+		if (next == null) return [];
+		remaining.delete(item.handle);
+		return [dequal(item.jsonSchema, next.jsonSchema) && item.nullable == next.nullable ? item : next];
+	}), ...remaining.values()];
+}
+function httpRequestTask(config = httpRequestConfigSchema.parse({}), name = "HTTP Request", previous) {
+	const inputs = [{
+		handle: "url",
+		jsonSchema: { type: "string" },
+		nullable: false
+	}];
+	for (const group of ["query", "headers"]) if (config[group].mode == "object") inputs.push({
+		handle: group,
+		jsonSchema: group == "query" ? httpQuerySchema : httpHeaderSchema,
+		nullable: true
+	});
+	else for (const parameterName of config[group].names.filter((value) => value.trim())) inputs.push({
+		handle: `${group == "query" ? "query" : "header"}.${parameterName}`,
+		jsonSchema: group == "query" ? queryValueSchema : { type: "string" },
+		nullable: true
+	});
+	if (config.bodyFormat != "none") inputs.push({
+		handle: "body",
+		jsonSchema: config.bodyFormat == "json" ? {} : config.bodyFormat == "text" ? { type: "string" } : httpQuerySchema,
+		nullable: config.bodyFormat == "json"
+	});
+	inputs.push(...httpAuthHandles(config).map((handle) => ({
+		handle,
+		jsonSchema: { type: "string" },
+		nullable: false
+	})));
+	const outputs = [
+		{
+			handle: "body",
+			jsonSchema: config.responseFormat == "text" ? { type: "string" } : {},
+			nullable: true
+		},
+		{
+			handle: "statusCode",
+			jsonSchema: { type: "integer" },
+			nullable: false
+		},
+		{
+			handle: "headers",
+			jsonSchema: httpHeaderSchema,
+			nullable: false
+		}
+	];
+	return {
+		name,
+		executor: {
+			...config,
+			kind: "http-request"
+		},
+		inputs: retain(inputs, previous?.inputs ?? []),
+		outputs: retain(outputs, previous?.outputs ?? [])
+	};
+}
+function httpRequestIssues(config) {
+	const issues = [];
+	if (["GET", "HEAD"].includes(config.method) && config.bodyFormat != "none") issues.push({
+		field: "bodyFormat",
+		code: "bodyUnsupported",
+		message: "GET and HEAD do not support a request body."
+	});
+	for (const group of ["query", "headers"]) {
+		if (config[group].mode != "fields") continue;
+		const seen = /* @__PURE__ */ new Set();
+		for (const [index, name] of config[group].names.entries()) {
+			const key = group == "headers" ? name.toLowerCase() : name;
+			if (!name.trim() || seen.has(key)) issues.push({
+				field: group,
+				index,
+				code: "parameterNamesInvalid",
+				message: "Parameter names must be nonempty and unique."
+			});
+			seen.add(key);
+			if (group == "headers" && httpHeaderNameIssue(name, []) === "invalid") issues.push({
+				field: group,
+				index,
+				code: "headerNameInvalid",
+				message: "Invalid HTTP header name."
+			});
+		}
+	}
+	const auth = config.authentication;
+	if (auth.type != "none") {
+		const group = auth.type == "apiKey" && auth.in == "query" ? "query" : "headers";
+		const name = auth.type == "apiKey" ? auth.name : "authorization";
+		if (!name.trim()) issues.push({
+			field: "authentication",
+			code: "keyNameRequired",
+			message: "API Key requires a name."
+		});
+		if (group == "headers" && name.trim() && httpHeaderNameIssue(name, []) === "invalid") issues.push({
+			field: "authentication",
+			code: "headerNameInvalid",
+			message: "Invalid authentication header name."
+		});
+		if (config[group].mode == "fields" && config[group].names.some((item) => group == "headers" ? item.toLowerCase() == name.toLowerCase() : item == name)) issues.push({
+			field: "authentication",
+			code: "authConflict",
+			message: "Authentication conflicts with a request parameter."
+		});
+	}
+	return issues;
+}
+function httpRequestUrl(value) {
+	if (typeof value != "string" || !value.trim()) throw new Error("A URL is required.");
+	const url = new URL(value);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("An HTTP(S) URL without credentials is required.");
+	return url;
+}
+//#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 snapshot(documentValue, path, method) {
+	const doc = parseOpenApi(documentValue);
+	const { item, op } = operation(doc, path, method);
+	const security = op.security ?? doc.security ?? [];
+	const result = {
+		openapi: doc.openapi,
+		paths: { [path]: {
+			[method]: op,
+			...item.parameters == null ? {} : { parameters: item.parameters }
+		} },
+		servers: servers(doc, path, method),
+		security
+	};
+	const visited = /* @__PURE__ */ new Set();
+	function copy(ref) {
+		if (visited.has(ref)) return;
+		visited.add(ref);
+		const value = pointer(doc, ref);
+		const keys = decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+		if (keys.some((key) => [
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key))) throw new Error("Unsupported reference key.");
+		let target = result;
+		for (const key of keys.slice(0, -1)) {
+			if (!Object.hasOwn(target, key)) target[key] = {};
+			target = object(target[key]);
+		}
+		target[keys.at(-1)] = structuredClone(value);
+		visit(value);
+	}
+	function visit(value) {
+		if (value == null || typeof value != "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		if (typeof object(value).$ref == "string") copy(object(value).$ref);
+		for (const [key, child] of Object.entries(value)) if (![
+			"example",
+			"examples",
+			"default"
+		].includes(key)) visit(child);
+	}
+	visit(result);
+	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) {
+	const defs = {};
+	const ids = /* @__PURE__ */ new Map();
+	function convert(value) {
+		if (typeof value == "boolean") return value;
+		const source = object(value);
+		if (source.format == "binary" || source.$dynamicRef != null || source.$id != null) throw new Error("Binary and dynamically scoped schemas are unsupported.");
+		const result = {};
+		for (const [key, child] of Object.entries(source)) {
+			if ([
+				"nullable",
+				"example",
+				"xml",
+				"discriminator",
+				"__proto__"
+			].includes(key)) continue;
+			if (key == "$ref") {
+				if (typeof child != "string") throw new Error("Invalid schema reference.");
+				let id = ids.get(child);
+				if (id == null) {
+					id = `s${ids.size}`;
+					ids.set(child, id);
+					defs[id] = convert(pointer(doc, child));
+				}
+				result.$ref = `#/$defs/${id}`;
+			} else if ([
+				"properties",
+				"patternProperties",
+				"$defs",
+				"definitions",
+				"dependentSchemas"
+			].includes(key)) result[key] = Object.fromEntries(Object.entries(object(child)).map(([name, childSchema]) => [name, convert(childSchema)]));
+			else if ([
+				"allOf",
+				"anyOf",
+				"oneOf",
+				"prefixItems"
+			].includes(key)) {
+				if (!Array.isArray(child)) throw new Error("Invalid schema composition.");
+				result[key] = child.map(convert);
+			} else if ([
+				"items",
+				"additionalProperties",
+				"not",
+				"if",
+				"then",
+				"else",
+				"contains",
+				"propertyNames",
+				"unevaluatedProperties"
+			].includes(key)) result[key] = convert(child);
+			else result[key] = child;
+		}
+		if (source.nullable === true) return { anyOf: [result, { type: "null" }] };
+		for (const key of ["minimum", "maximum"]) {
+			const exclusive = key == "minimum" ? "exclusiveMinimum" : "exclusiveMaximum";
+			if (typeof result[exclusive] == "boolean") {
+				if (result[exclusive] && typeof result[key] == "number") {
+					result[exclusive] = result[key];
+					delete result[key];
+				} else delete result[exclusive];
+			}
+		}
+		return result;
+	}
+	let converted = convert(schemaValue);
+	if (typeof converted == "object" && converted != null && typeof object(converted).$ref == "string") {
+		const id = String(object(converted).$ref).slice(8);
+		const { $ref: _ref, ...siblings } = object(converted);
+		converted = {
+			...object(defs[id]),
+			...siblings
+		};
+	}
+	if (typeof converted == "boolean") return converted;
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		...object(converted),
+		...Object.keys(defs).length ? { $defs: defs } : {}
+	};
+}
+function parameters(config) {
+	const doc = parseOpenApi(config.document);
+	const { item, op } = operation(doc, config.path, config.method);
+	const entries = /* @__PURE__ */ new Map();
+	for (const value of [...item.parameters ?? [], ...op.parameters ?? []]) {
+		const p = resolved(doc, value);
+		if (![
+			"path",
+			"query",
+			"header"
+		].includes(String(p.in)) || typeof p.name != "string" || p.content != null) throw new Error("Only schema-based path, query and header parameters are supported.");
+		if (p.allowReserved === true) throw new Error("allowReserved parameters are unsupported.");
+		if ((p.style ?? (p.in == "query" ? "form" : "simple")) != (p.in == "query" ? "form" : "simple")) throw new Error("Only form query and simple path/header serialization are supported.");
+		entries.set(`${p.in}.${p.in == "header" ? p.name.toLowerCase() : p.name}`, p);
+	}
+	return [...entries.values()];
+}
+function jsonContent(doc, value) {
+	const content = resolved(doc, value);
+	const media = object(content.content);
+	const mediaType = media["application/json"] != null ? "application/json" : Object.keys(media).find((key) => /^application\/.+\+json$/.test(key));
+	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 ?? {}),
+		required: content.required === true,
+		mediaType
+	};
+}
+function authHandles(auth) {
+	return auth.flatMap((scheme) => scheme.type == "basic" ? [`auth.${scheme.id}.username`, `auth.${scheme.id}.password`] : [`auth.${scheme.id}.token`]);
+}
+function openApiTask(config, name = "OpenAPI") {
+	if (!config.path) return {
+		name,
+		executor: config,
+		inputs: [],
+		outputs: []
+	};
+	const doc = parseOpenApi(config.document);
+	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 defaultValue = typeof jsonSchema == "boolean" ? void 0 : object(jsonSchema).default;
+		return {
+			handle: `${p.in}.${p.name}`,
+			jsonSchema,
+			nullable: p.required !== true && p.in != "path" || matchesSchema(null, jsonSchema),
+			...typeof p.description == "string" ? { description: p.description } : {},
+			...defaultValue === void 0 ? {} : { value: defaultValue }
+		};
+	});
+	if (op.requestBody != null) {
+		if (config.method == "get" || config.method == "head") throw new Error("GET and HEAD request bodies are unsupported.");
+		const body = jsonContent(doc, op.requestBody);
+		inputs.push({
+			handle: "body",
+			jsonSchema: body.schema,
+			nullable: !body.required || matchesSchema(null, body.schema)
+		});
+	}
+	const occupied = new Set(params.map((p) => `${p.in}.${p.in == "header" ? String(p.name).toLowerCase() : p.name}`));
+	for (const auth of config.auth) {
+		const location = auth.type == "apiKey" ? `${auth.in}.${auth.in == "header" ? auth.name?.toLowerCase() : auth.name}` : "header.authorization";
+		if (occupied.has(location)) throw new Error("Authentication conflicts with a parameter or another security scheme.");
+		if (auth.type == "apiKey" && (!auth.name || !["header", "query"].includes(auth.in ?? ""))) throw new Error("API Key requires a name and location.");
+		occupied.add(location);
+	}
+	inputs.push(...authHandles(config.auth).map((handle) => ({
+		handle,
+		jsonSchema: { type: "string" },
+		nullable: false
+	})));
+	const responses = object(op.responses);
+	const schemas = [];
+	for (const [status, response] of Object.entries(responses)) if (/^2\d\d$|^2XX$/.test(status) || status == "default") {
+		const r = resolved(doc, response);
+		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 ?? {}));
+		}
+	}
+	if (!schemas.length) throw new Error("A successful JSON response definition is required.");
+	return {
+		name,
+		executor: config,
+		inputs,
+		outputs: [
+			{
+				handle: "body",
+				jsonSchema: schemas.length == 1 ? schemas[0] : {
+					$schema: "https://json-schema.org/draft/2020-12/schema",
+					anyOf: schemas.map((s, index) => inlineSchema(s, index))
+				},
+				nullable: config.method == "head" || schemas.some((item) => matchesSchema(null, item))
+			},
+			{
+				handle: "statusCode",
+				jsonSchema: { type: "integer" },
+				nullable: false
+			},
+			{
+				handle: "headers",
+				jsonSchema: {
+					type: "object",
+					additionalProperties: { type: "string" }
+				},
+				nullable: false
+			}
+		]
+	};
+}
+function inlineSchema(value, index) {
+	if (Array.isArray(value)) return value.map((item) => inlineSchema(item, index));
+	if (value == null || typeof value != "object") return value;
+	return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, key == "$ref" && typeof child == "string" && child.startsWith("#/") ? `#/anyOf/${index}/${child.slice(2)}` : inlineSchema(child, index)]));
 }
-var ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def) => {
-	$ZodCatch.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
-	inst.unwrap = () => inst._zod.def.innerType;
-	inst.removeCatch = inst.unwrap;
-});
-function _catch(innerType, catchValue) {
-	return new ZodCatch({
-		type: "catch",
-		innerType,
-		catchValue: typeof catchValue === "function" ? catchValue : constantCatch(catchValue)
-	});
+/** The canvas validator and property panel share the same configuration contract. */
+function openApiFieldIssues(task) {
+	if (task.executor.kind != "openapi") return [];
+	const config = task.executor;
+	let field = "sourceUrl";
+	try {
+		if (!config.sourceUrl.trim()) return [{
+			field,
+			message: "Enter an OpenAPI JSON document URL."
+		}];
+		httpUrl(config.sourceUrl);
+		field = "operation";
+		if (!config.path) return [{
+			field,
+			message: "Select an OpenAPI operation."
+		}];
+		field = "serverUrl";
+		httpUrl(config.serverUrl);
+		if (new URL(config.serverUrl).search) throw new Error("Server URLs must not contain a query string.");
+		field = "operation";
+		if (!dequal(config.document, snapshot(config.document, config.path, config.method))) return [{
+			field,
+			message: "Save only the selected operation and its dependencies."
+		}];
+		const expected = openApiTask(config, task.name);
+		if (!dequal(expected.inputs, task.inputs) || !dequal(expected.outputs, task.outputs)) return [{
+			field,
+			message: "OpenAPI ports must match the saved operation."
+		}];
+		return [];
+	} catch (error) {
+		return [{
+			field,
+			message: error.message
+		}];
+	}
 }
-var ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def) => {
-	$ZodPipe.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
-	inst.in = def.in;
-	inst.out = def.out;
-});
-function pipe(in_, out) {
-	return new ZodPipe({
-		type: "pipe",
-		in: in_,
-		out
-	});
+function openApiIssues(task) {
+	return openApiFieldIssues(task).map((issue) => issue.message);
 }
-var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
-	ZodPipe.init(inst, def);
-	$ZodPreprocess.init(inst, def);
+//#endregion
+//#region src/workflow/common/workflow.ts
+var portSchema = object$1({
+	handle: string().min(1),
+	jsonSchema: json$1(),
+	nullable: boolean(),
+	description: string().optional()
 });
-var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
-	$ZodReadonly.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
-	inst.unwrap = () => inst._zod.def.innerType;
+strictObject({
+	inputs: array(portSchema).nullable(),
+	outputs: array(portSchema).nullable()
 });
-function readonly(innerType) {
-	return new ZodReadonly({
-		type: "readonly",
-		innerType
-	});
-}
-var ZodLazy = /*@__PURE__*/ $constructor("ZodLazy", (inst, def) => {
-	$ZodLazy.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => lazyProcessor(inst, ctx, json, params);
-	inst.unwrap = () => inst._zod.def.getter();
+object$1({
+	version: literal(1),
+	flowId: string().min(1),
+	name: string(),
+	revisionId: string().min(1),
+	publicationId: string().min(1),
+	inputs: array(portSchema),
+	outputs: array(portSchema).nullable()
 });
-function lazy(getter) {
-	return new ZodLazy({
-		type: "lazy",
-		getter
-	});
-}
-var ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
-	$ZodCustom.init(inst, def);
-	ZodType.init(inst, def);
-	inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
+object$1({
+	version: literal(1),
+	direction: _enum(["incoming", "outgoing"]),
+	total: int().nonnegative(),
+	nextOffset: int().nonnegative().optional(),
+	references: array(object$1({
+		flowId: string(),
+		name: string().nullable(),
+		available: boolean(),
+		draft: boolean(),
+		live: object$1({
+			publicationId: string(),
+			enabled: boolean()
+		}).nullable()
+	}))
 });
-function refine(fn, _params = {}) {
-	return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
-}
-function superRefine(fn, params) {
-	return /* @__PURE__ */ _superRefine(fn, params);
-}
-function json$1(params) {
-	const jsonSchema = lazy(() => {
-		return union([
-			string(params),
-			number(),
-			boolean(),
-			_null(),
-			array(jsonSchema),
-			record$1(string(), jsonSchema)
-		]);
-	});
-	return jsonSchema;
-}
-function preprocess(fn, schema) {
-	return new ZodPreprocess({
-		type: "pipe",
-		in: transform(fn),
-		out: schema
-	});
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/iso.js
-function datetime(params) {
-	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
+//#region src/flow/common/inputValue.ts
+/** An explicit clear suppresses the default; absent mappings still inherit it. */
+function inputValue(mapping, fallback) {
+	if (mapping?.kind === "unset") return void 0;
+	return mapping?.kind === "value" ? mapping.value : fallback;
 }
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
@@ -10173,6 +10425,7 @@ var retryNodeTypes = [
 	"code",
 	"connector",
 	"openapi",
+	"http-request",
 	"llm",
 	"decision"
 ];
@@ -10191,11 +10444,11 @@ function supportsNodeRetry(node) {
 }
 //#endregion
 //#region src/flow/common/triggerScheduleSchema.ts
-var triggerScheduleSchema = array(union([object({
+var triggerScheduleSchema = array(union([object$1({
 	type: literal("cron"),
 	expression: string(),
 	timezone: string()
-}), object({
+}), object$1({
 	type: literal("every"),
 	unit: _enum([
 		"day",
@@ -10289,11 +10542,6 @@ function workflowOutputsPort(outputs) {
 		nullable: false
 	};
 }
-/** Header names are case-insensitive; never silently combine duplicate business fields. */
-function webhookHeaderNameIssue(name, names) {
-	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
-	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
-}
 /** Fixed inputs belong to the node, not author-supplied definitions. */
 var webhookResponseInputs = [
 	{
@@ -10324,7 +10572,7 @@ function webhookHeaderValues(source) {
 	const headers = {};
 	const names = [];
 	for (const [name, value] of Object.entries(source)) {
-		if (webhookHeaderNameIssue(name, names) != null) return;
+		if (httpHeaderNameIssue(name, names) != null) return;
 		if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) return;
 		const text = String(value);
 		if ([...text].some((character) => character.charCodeAt(0) > 255 || /[\0\r\n]/.test(character))) return;
@@ -10341,7 +10589,7 @@ var text = string();
 var actionConnection = text.describe("Account selection: omit while unconfigured; use an account ID to select it; use \"\" to explicitly defer configuration. Deferred Actions fail if called; deferred Agent tools are excluded from the callable tool set. Not supported by Triggers.");
 var json = json$1();
 var strings = array(text);
-var port = object({
+var port = object$1({
 	description: text.optional(),
 	jsonSchema: json,
 	nullable: boolean(),
@@ -10349,25 +10597,25 @@ var port = object({
 });
 var workflowInputDefs = array(port.strict());
 var input = port.extend({ value: json.optional() });
-var group = object({
+var group = object$1({
 	collapsed: boolean().optional(),
 	group: text
 });
-var source = union([object({
+var source = union([object$1({
 	kind: literal("node"),
 	nodeId: text,
 	output: text,
 	system: literal(true).optional(),
 	field: text.optional()
-}), object({
+}), object$1({
 	kind: literal("binding"),
 	bindingId: text
 })]);
-var fixedInput = union([object({ kind: literal("unset") }), object({
+var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
 	kind: literal("value"),
 	value: json
 })]);
-var mapping = union([fixedInput, object({
+var mapping = union([fixedInput, object$1({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
@@ -10376,7 +10624,7 @@ var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
 };
-var capability = union([
+var connectorCapabilitySchema = union([
 	strictObject({
 		kind: literal("connector"),
 		action: text,
@@ -10408,20 +10656,43 @@ var capability = union([
 		})).optional()
 	})
 ]);
-var inline = object({
+var workflowCapabilitySchema = strictObject({
+	kind: literal("workflow"),
+	name: text,
+	flowId: text,
+	revisionId: text,
+	inputs: array(port),
+	outputs: array(port).nullable()
+});
+var capability = union([connectorCapabilitySchema, workflowCapabilitySchema]);
+var inline = object$1({
 	...ports,
 	name: text,
 	moduleId: text,
 	capabilities: array(capability).optional()
 });
-var agentValue = union([object({
+var agentValue = union([object$1({
 	kind: literal("value"),
 	value: json
-}), object({
+}), object$1({
 	kind: literal("input"),
 	input: text
 })]);
-var agentInput$1 = union([agentValue, object({ kind: literal("model") })]);
+var agentInput$1 = union([agentValue, object$1({ kind: literal("model") })]);
+var agentToolFields = {
+	id: text,
+	name: text,
+	description: text,
+	approval: boolean(),
+	inputs: array(input.extend({ source: agentInput$1 }))
+};
+var connectorAgentToolSchema = object$1({
+	...agentToolFields,
+	kind: literal("connector").optional(),
+	action: text,
+	connectionId: actionConnection.optional()
+});
+var workflowAgentToolSchema = workflowCapabilitySchema.extend(agentToolFields);
 var decisionQuestion = discriminatedUnion("type", [
 	strictObject({
 		name: text,
@@ -10448,24 +10719,24 @@ var decisionQuestion = discriminatedUnion("type", [
 		criteria: strings
 	})
 ]);
-var managedFields = object({
+var managedFields = object$1({
 	...ports,
 	name: text,
 	executor: union([
-		object({
+		object$1({
 			kind: literal("connector"),
 			action: text,
 			connectionId: actionConnection.optional(),
 			outputMode: literal("value").optional()
 		}),
-		object({
+		object$1({
 			kind: literal("openapi"),
 			sourceUrl: text,
 			method: text,
 			path: text,
 			serverUrl: text,
 			document: json,
-			auth: array(object({
+			auth: array(object$1({
 				id: text,
 				type: _enum([
 					"bearer",
@@ -10480,26 +10751,18 @@ var managedFields = object({
 			kind: literal("decision"),
 			questions: array(decisionQuestion)
 		}),
-		object({
+		object$1({
 			kind: literal("llm"),
 			mode: _enum(["chat", "json"])
 		}),
-		object({
+		object$1({
 			kind: literal("agent"),
 			code: boolean().optional(),
 			model: text,
 			prompt: text,
 			maxRounds: number(),
-			tools: array(object({
-				id: text,
-				name: text,
-				description: text,
-				action: text,
-				connectionId: actionConnection.optional(),
-				approval: boolean(),
-				inputs: array(input.extend({ source: agentInput$1 }))
-			})),
-			notification: object({
+			tools: array(union([workflowAgentToolSchema, connectorAgentToolSchema])),
+			notification: object$1({
 				action: text,
 				connectionId: actionConnection.optional(),
 				inputDefinitions: array(input),
@@ -10511,24 +10774,25 @@ var managedFields = object({
 			kind: literal("workflow"),
 			flowId: text,
 			revisionId: text
-		})
+		}),
+		httpRequestExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
-var operand = union([object({
+var operand = union([object$1({
 	kind: literal("value"),
 	value: json.optional(),
 	jsonSchema: json.optional()
-}), object({
+}), object$1({
 	kind: literal("source"),
 	source
 })]);
 var condition = {
 	matchMode: _enum(["first", "all"]),
-	cases: array(object({
+	cases: array(object$1({
 		description: text.optional(),
 		output: text,
-		groups: array(object({ expressions: array(object({
+		groups: array(object$1({ expressions: array(object$1({
 			left: operand,
 			operator: _enum([
 				"!=",
@@ -10560,7 +10824,7 @@ var wait = {
 	inputDefinitions: array(input),
 	prompt: text
 };
-var webhookOptions = object({
+var webhookOptions = object$1({
 	allowedMethods: never().optional(),
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
@@ -10598,8 +10862,8 @@ var definition = {
 	outputs: array(port).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
 	provider: text
 };
-var endpoint = object({
-	body: object({
+var endpoint = object$1({
+	body: object$1({
 		allowArray: boolean(),
 		allowEmpty: boolean(),
 		formats: array(_enum([
@@ -10648,19 +10912,19 @@ var node = union([
 		outputDefs: array(port.strict()),
 		outputMappings: inputs
 	}).omit({ inputs: true }),
-	object({
+	object$1({
 		...base,
 		inputs: record$1(text, never()),
 		kind: literal("condition"),
 		...condition
 	}),
-	object({
+	object$1({
 		...base,
 		inputs: unknown().transform(() => ({})).default({}),
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("task"),
 		task: union([inline, managed]),
@@ -10677,7 +10941,7 @@ var node = union([
 		...wait,
 		autoContinue: waitAutoContinueDraftSchema.optional()
 	}).omit({ timeoutMs: true }),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("manual")
 	}),
@@ -10691,44 +10955,60 @@ var node = union([
 		kind: literal("error"),
 		sourceFlowIds: sourceFlowIds.optional()
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("webhook"),
 		...webhook
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("cron"),
 		cronTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("poll"),
 		connectionId: text.min(1).optional(),
 		config: record$1(text, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("poll")
 		}),
 		pollTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger,
 		kind: literal("integration"),
 		connectionId: text.min(1).optional(),
 		config: record$1(text, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("integration"),
 			endpoint
 		})
 	})
 ]);
-strictObject(condition), strictObject(wait), strictObject(webhook), managedFields.shape.executor.options[0].omit({ kind: true }).strict(), managedFields.shape.executor.options[1].omit({ kind: true }).strict(), managedFields.shape.executor.options[2].omit({ kind: true }).strict(), managedFields.shape.executor.options[3].omit({ kind: true }).strict(), managedFields.shape.executor.options[4].omit({
-	kind: true,
-	notification: true
-}).strict();
-var edge = object({
+/** Configuration schemas shared by the node authoring boundary. */
+var authoringDefinitionSchemas = {
+	input,
+	port,
+	ports,
+	condition: strictObject(condition),
+	wait: strictObject(wait),
+	waitAutoContinue: waitAutoContinueSchema,
+	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,
 	target: text,
 	sourceHandle: text.optional()
@@ -10737,24 +11017,24 @@ var at = {
 	nodeId: text,
 	target: never().optional()
 };
-var graph = object({
+var graph = object$1({
 	nodes: record$1(text, node),
 	edges: array(edge).default([])
 });
-var binding = object({
+var binding = object$1({
 	kind: literal("variable"),
 	target: text
 });
-var module = object({
+var module = object$1({
 	name: text,
 	imports: strings,
 	source: text
 });
-var document = preprocess(normalizeDocument, object({
+var document = preprocess(normalizeDocument, object$1({
 	bindings: record$1(text, binding),
 	graph
 }));
-object({
+object$1({
 	modelVersion: union([
 		literal(2),
 		literal(4),
@@ -10763,7 +11043,8 @@ object({
 		literal(7),
 		literal(8),
 		literal(9),
-		literal(10)
+		literal(10),
+		literal(11)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -10824,21 +11105,21 @@ var shapes = {
 	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("retry"),
 			before: retryConfigurationSchema.optional(),
 			value: retryConfigurationSchema.optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("connectionId"),
 			before: text.min(1).optional(),
 			value: text.min(1).optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: _enum([
@@ -10850,14 +11131,14 @@ var shapes = {
 			before: text.optional(),
 			value: text.optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("maxExecutions"),
 			before: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
 			value: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("timeoutMs"),
@@ -10878,8 +11159,8 @@ var shapes = {
 	},
 	"graph.node.condition.set": {
 		...at,
-		before: object(condition),
-		value: object(condition)
+		before: object$1(condition),
+		value: object$1(condition)
 	},
 	"graph.node.values.set": {
 		...at,
@@ -10899,13 +11180,13 @@ var shapes = {
 	},
 	"graph.node.webhook.set": {
 		...at,
-		before: object(webhook),
-		value: object(webhook)
+		before: object$1(webhook),
+		value: object$1(webhook)
 	},
 	"graph.node.task.ports.set": {
 		...at,
-		before: object(ports),
-		value: object(ports)
+		before: object$1(ports),
+		value: object$1(ports)
 	},
 	"graph.node.task.name.set": {
 		...at,
@@ -10951,7 +11232,7 @@ var shapes = {
 		value: union([inline, managed])
 	}
 };
-array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
+array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
 	kind: literal(kind),
 	...shape
 })])).values()])).min(1);
@@ -11125,6 +11406,24 @@ function validVariableName(value) {
 function portsByHandle(ports) {
 	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
 }
+var workflowToolNamePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+function workflowToolNameIssue(name, otherNames = []) {
+	if (!workflowToolNamePattern.test(name)) return "invalid";
+	for (const other of otherNames) if (other == name) return "duplicate";
+}
+function decodeTaskCapabilities(value) {
+	if (!Array.isArray(value)) throw new TypeError("Task capabilities must be an array.");
+	const parsed = authoringDefinitionSchemas.capabilities.parse(value);
+	const connectors = decodeConnectorCapabilities(parsed.filter((item) => item.kind == "connector"));
+	const names = /* @__PURE__ */ new Set();
+	for (const item of parsed) {
+		if (item.kind != "workflow") continue;
+		if (workflowToolNameIssue(item.name, names)) throw new TypeError("Workflow tool names must be unique provider-compatible names.");
+		names.add(item.name);
+	}
+	let connectorIndex = 0;
+	return parsed.map((item) => item.kind == "connector" ? connectors[connectorIndex++] : item);
+}
 function decodeConnectorCapabilities(value) {
 	if (!Array.isArray(value)) throw new TypeError("Connector capabilities must be an array.");
 	if (value.length == 0) return [];
@@ -11289,7 +11588,7 @@ function connectionUsage(document) {
 			for (const capability of node.task.capabilities ?? []) if ("mode" in capability && capability.mode == "independent") for (const action of capability.actions) add("code", action.action, action.connectionId);
 		}
 		if (task?.executor.kind == "agent") {
-			for (const tool of task.executor.tools) add("agent", tool.action, tool.connectionId);
+			for (const tool of task.executor.tools) if (tool.kind != "workflow") add("agent", tool.action, tool.connectionId);
 			const notification = task.executor.notification;
 			if (notification != null) add("notification", notification.action, notification.connectionId);
 		}
@@ -11344,6 +11643,7 @@ function clearNodeConnections(graph, connectionId) {
 				return [id, node];
 			}
 			const capabilities = node.task.capabilities?.map((capability) => {
+				if (capability.kind == "workflow") return capability;
 				if (!("mode" in capability)) {
 					if ("action" in capability) {
 						const { connectionId: selected, ...rest } = capability;
@@ -11589,9 +11889,11 @@ function normalizeTriggerOutputs(trigger, outputs) {
 }
 //#endregion
 //#region src/execution/common/engineContract.ts
-var currentEngineContract = "open-flow-engine/v7";
-var nodejsEngineContract = "open-flow-engine/v7/nodejs-compat-v1";
+var currentEngineContract = "open-flow-engine/v8";
+var nodejsEngineContract = "open-flow-engine/v8/nodejs-compat-v1";
 var currentContract = {
+	workflowTools: true,
+	httpRequests: true,
 	waitAutoContinue: true,
 	webhookResponses: true,
 	platformExports: /* @__PURE__ */ new Set(["engineContract", "identity"]),
@@ -11633,10 +11935,18 @@ export function identity(value) { return value }
 `
 };
 function findEngineContract(contract) {
-	if (contract == "open-flow-engine/v7") return currentContract;
-	if (contract == "open-flow-engine/v7/nodejs-compat-v1") return nodejsContract;
+	if (contract == "open-flow-engine/v8") return currentContract;
+	if (contract == "open-flow-engine/v8/nodejs-compat-v1") return nodejsContract;
+	if (contract == "open-flow-engine/v7" || contract == "open-flow-engine/v7/nodejs-compat-v1") return {
+		...contract.endsWith("/nodejs-compat-v1") ? nodejsContract : currentContract,
+		workflowTools: false,
+		httpRequests: false,
+		platformSource: `export const engineContract = ${JSON.stringify(contract)}\nexport function identity(value) { return value }\n`
+	};
 	if (contract == "open-flow-engine/v6" || contract == "open-flow-engine/v6/nodejs-compat-v1") return {
 		...contract == "open-flow-engine/v6" ? currentContract : nodejsContract,
+		workflowTools: false,
+		httpRequests: false,
 		waitAutoContinue: false,
 		webhookResponses: false,
 		platformSource: `export const engineContract = ${JSON.stringify(contract)}
@@ -11839,7 +12149,7 @@ function agentConfigIssues(task) {
 		ids.add(tool.id);
 		names.add(tool.name);
 		if (tool.description.trim().length == 0) issues.push(`Tool ${tool.name} requires a description.`);
-		if (!/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(tool.action)) issues.push(`Tool ${tool.name} has an invalid Action or Connection.`);
+		if (tool.kind != "workflow" && !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_.-]+$/.test(tool.action)) issues.push(`Tool ${tool.name} has an invalid Action or Connection.`);
 		const fields = /* @__PURE__ */ new Set();
 		for (const port of tool.inputs) {
 			if (port.handle.length == 0 || fields.has(port.handle)) issues.push(`Tool ${tool.name} has an empty or duplicate input.`);
@@ -12324,7 +12634,7 @@ function webhookResponseDiagnostics(graph, triggerId, path = `/document/graph/no
 	if (headersSource == null) for (const [headers, location] of [[options.responseHeaders, `${path}/options/responseHeaders`], [headerOutputs, headersPath]]) {
 		const names = [];
 		for (const name of Object.keys(headers ?? {})) {
-			if (webhookHeaderNameIssue(name, names) != null) diagnostics.push(graphDiagnostic("trigger.webhook-response-header-name", "Use valid, unique HTTP header names.", location));
+			if (httpHeaderNameIssue(name, names) != null) diagnostics.push(graphDiagnostic("trigger.webhook-response-header-name", "Use valid, unique HTTP header names.", location));
 			names.push(name);
 		}
 	}
@@ -24530,7 +24840,7 @@ function flowResourceReferences(content) {
 		});
 	}
 	return {
-		calledFlowIds: [...new Set(Object.values(content.document.graph.nodes).flatMap((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "workflow" && node.task.executor.flowId ? [node.task.executor.flowId] : []))].toSorted(),
+		calledFlowIds: [...new Set(Object.values(content.document.graph.nodes).flatMap((node) => nodeWorkflowReferences(node).map(({ target }) => target.flowId).filter(Boolean)))].toSorted(),
 		variableNames: [...new Set(Object.values(variableBindings(content, flowDependencies(content).bindings)))].toSorted(),
 		connections: [...connections].toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, value]) => value),
 		errorSourceFlowIds: [...new Set(Object.values(content.document.graph.nodes).flatMap((node) => node.kind == "error" ? node.sourceFlowIds ?? [] : []))].toSorted()
@@ -24599,7 +24909,7 @@ async function validateFlow(revision, engine) {
 			});
 		}
 		try {
-			decodeConnectorCapabilities(node.task.capabilities === void 0 ? [] : node.task.capabilities);
+			decodeTaskCapabilities(node.task.capabilities === void 0 ? [] : node.task.capabilities);
 		} catch {
 			checked.diagnostics.push({
 				code: "task.capability-incomplete",
@@ -24628,12 +24938,47 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
-		if (task.executor.kind == "openapi") {
-			const handles = authHandles(task.executor.auth);
+		if (task.executor.kind == "http-request") {
+			for (const issue of httpRequestIssues(task.executor)) checked.diagnostics.push({
+				code: "http-request.config-invalid",
+				column: 0,
+				line: 1,
+				message: issue.message,
+				path: `/document/graph/nodes/${nodeId}/task/executor/${issue.field}`
+			});
+			if (node.inputs.url?.kind == "value") try {
+				httpRequestUrl(node.inputs.url.value);
+			} catch {
+				checked.diagnostics.push({
+					code: "http-request.url-invalid",
+					column: 0,
+					line: 1,
+					message: "Enter an HTTP(S) URL without embedded credentials.",
+					path: `/document/graph/nodes/${nodeId}/inputs/url`
+				});
+			}
+			if (task.executor.bodyFormat != "none" && (node.inputs.body == null || node.inputs.body.kind == "unset")) checked.diagnostics.push({
+				code: "http-request.body-required",
+				column: 0,
+				line: 1,
+				message: "Set or bind the request body; JSON null is an explicit value.",
+				path: `/document/graph/nodes/${nodeId}/inputs/body`
+			});
+			const expected = httpRequestTask(task.executor);
+			if (!dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) || !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))) checked.diagnostics.push({
+				code: "http-request.ports-invalid",
+				column: 0,
+				line: 1,
+				message: "HTTP Request ports must match its configuration.",
+				path: `/document/graph/nodes/${nodeId}/task`
+			});
+		}
+		if (task.executor.kind == "openapi" || task.executor.kind == "http-request") {
+			const handles = task.executor.kind == "openapi" ? authHandles(task.executor.auth) : httpAuthHandles(task.executor);
 			for (const handle of handles) {
 				const mapping = node.inputs[handle];
 				if (mapping?.kind != "sources" || mapping.sources.length == 0) checked.diagnostics.push({
-					code: "openapi.auth-source",
+					code: `${task.executor.kind}.auth-source`,
 					column: 0,
 					line: 1,
 					message: "Authentication requires a deployment variable or upstream output.",
@@ -24719,9 +25064,16 @@ function runRevision(revision, triggerId) {
 		}
 	};
 }
+var httpPortContracts = (ports) => ports.filter((port) => "handle" in port).map(({ handle, jsonSchema, nullable }) => ({
+	handle,
+	jsonSchema,
+	nullable
+})).toSorted((a, b) => a.handle.localeCompare(b.handle));
 async function prepareFlow(revision, engineContract, triggerId) {
 	const engine = findEngineContract(engineContract);
 	if (engine == null) return { kind: "engine-unsupported" };
+	if (!engine.httpRequests && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "http-request")) return { kind: "engine-unsupported" };
+	if (!engine.workflowTools && Object.values(revision.document.graph.nodes).some((node) => nodeWorkflowReferences(node).some((ref) => ref.tool != null))) return { kind: "engine-unsupported" };
 	if (triggerId != null) {
 		const trigger = revision.document.graph.nodes[triggerId];
 		if (trigger == null || !isTriggerNode(trigger)) return {
@@ -24780,7 +25132,7 @@ function agentActions(flow) {
 		const task = node.task;
 		if (task.executor.kind != "agent") return [];
 		const notice = task.executor.notification;
-		return [...task.executor.tools, ...notice != null ? [notice] : []].filter((tool) => tool.connectionId !== "").map((tool) => ({
+		return [...task.executor.tools.filter((tool) => tool.kind != "workflow"), ...notice != null ? [notice] : []].filter((tool) => tool.connectionId !== "").map((tool) => ({
 			kind: "connector",
 			action: tool.action,
 			connections: tool.connectionId == null ? [] : [{ connectionId: tool.connectionId }]
@@ -24788,7 +25140,7 @@ function agentActions(flow) {
 	});
 }
 function codeActions(flow) {
-	return Object.values(flow.graph.nodes).flatMap((node) => node.kind == "task" && "moduleId" in node.task ? node.task.capabilities ?? [] : []);
+	return Object.values(flow.graph.nodes).flatMap((node) => node.kind == "task" && "moduleId" in node.task ? (node.task.capabilities ?? []).filter((item) => item.kind == "connector") : []);
 }
 //#endregion
 export { agentActions, agentInput, agentToolInput, agentToolSchema, availableOutputs, codeActions, connectionUsage, createRuntimeProgram, encodeFlowClosure, flowClosure, flowDependencies, flowResourceReferences, graphOrder, matchesSchema, matchesTriggerOutputs, nodeInputPorts, normalizeRunTrigger, normalizeTriggerOutputs, prepareFlow, removeConnectionUsage, renderPrompt, schemaValidationErrors, triggerOutputDefinitions, triggerOutputPorts, validRunTrigger, validateFlow, validateFlowInputs, validateModules, variableBindings, variableInputCompatible };