@oomol-lab/open-flow 0.1.0-beta.50 → 0.1.0-beta.52

package/dist/common/control-requests.js

@@ -859,7 +859,7 @@ var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
 };
 var COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
 var COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
-var validate = ((schema, value, _ctx) => {
+var validate$1 = ((schema, value, _ctx) => {
 	const validator = schema._zod.bag.validator;
 	if (validator !== void 0) {
 		if (validator(value) !== COMPILE_INVALID) return true;
@@ -4991,7 +4991,7 @@ var ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 		own(this, "spa", value);
 	},
 	validate(data, params) {
-		return validate(this, data, params);
+		return validate$1(this, data, params);
 	},
 	validateAsync(data, params) {
 		return validateAsync$1(this, data, params);
@@ -5457,7 +5457,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 ?? {},
@@ -5781,11 +5781,11 @@ function checkJsonDepth(value, depth = 0) {
 }
 //#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",
@@ -5808,40 +5808,40 @@ var webhookMethods = [
 var text$1 = string();
 var json$2 = json$3();
 var strings = array(text$1);
-var port = object({
+var port = object$1({
 	description: text$1.optional(),
 	jsonSchema: json$2,
 	nullable: boolean(),
 	handle: text$1
 });
 var input = port.extend({ value: json$2.optional() });
-var group = object({
+var group = object$1({
 	collapsed: boolean().optional(),
 	group: text$1
 });
-var nodeSource = object({
+var nodeSource = object$1({
 	kind: literal("node"),
 	nodeId: text$1,
 	output: text$1,
 	field: text$1.optional()
 });
-var flowSource = object({
+var flowSource = object$1({
 	kind: literal("flow"),
 	input: text$1
 });
 var source = union([
 	nodeSource,
 	flowSource,
-	object({
+	object$1({
 		kind: literal("binding"),
 		bindingId: text$1
 	})
 ]);
-var fixedInput = union([object({ kind: literal("unset") }), object({
+var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
 	kind: literal("value"),
 	value: json$2
 })]);
-var mapping = union([fixedInput, object({
+var mapping = union([fixedInput, object$1({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
@@ -5882,40 +5882,58 @@ var capability = union([
 		})).optional()
 	})
 ]);
-var inline = object({
+var inline = object$1({
 	...ports,
 	name: text$1,
 	moduleId: text$1,
 	capabilities: array(capability).optional()
 });
-var agentValue = union([object({
+var agentValue = union([object$1({
 	kind: literal("value"),
 	value: json$2
-}), object({
+}), object$1({
 	kind: literal("input"),
 	input: text$1
 })]);
-var agentInput = union([agentValue, object({ kind: literal("model") })]);
-var managed = object({
+var agentInput = union([agentValue, object$1({ kind: literal("model") })]);
+var managed = object$1({
 	...ports,
 	name: text$1,
 	executor: union([
-		object({
+		object$1({
 			kind: literal("connector"),
 			action: text$1,
 			connectionId: text$1.optional()
 		}),
-		object({
+		object$1({
+			kind: literal("openapi"),
+			sourceUrl: text$1,
+			method: text$1,
+			path: text$1,
+			serverUrl: text$1,
+			document: json$2,
+			auth: array(object$1({
+				id: text$1,
+				type: _enum([
+					"bearer",
+					"basic",
+					"apiKey"
+				]),
+				name: text$1.optional(),
+				in: _enum(["header", "query"]).optional()
+			}))
+		}),
+		object$1({
 			kind: literal("llm"),
 			mode: _enum(["chat", "json"])
 		}),
-		object({
+		object$1({
 			kind: literal("agent"),
 			code: boolean().optional(),
 			model: text$1,
 			prompt: text$1,
 			maxRounds: number(),
-			tools: array(object({
+			tools: array(object$1({
 				id: text$1,
 				name: text$1,
 				description: text$1,
@@ -5924,7 +5942,7 @@ var managed = object({
 				approval: boolean(),
 				inputs: array(input.extend({ source: agentInput }))
 			})),
-			notification: object({
+			notification: object$1({
 				taskId: text$1,
 				messageHandle: text$1,
 				inputs: record(text$1, agentValue)
@@ -5932,20 +5950,20 @@ var managed = object({
 		})
 	])
 });
-var operand = union([object({
+var operand = union([object$1({
 	kind: literal("value"),
 	value: json$2.optional(),
 	jsonSchema: json$2.optional()
-}), object({
+}), object$1({
 	kind: literal("source"),
 	source
 })]);
 var condition = {
 	matchMode: _enum(["first", "all"]),
-	cases: array(object({
+	cases: array(object$1({
 		description: text$1.optional(),
 		output: text$1,
-		groups: array(object({ expressions: array(object({
+		groups: array(object$1({ expressions: array(object$1({
 			left: operand,
 			operator: _enum([
 				"!=",
@@ -5977,7 +5995,7 @@ var wait = {
 	inputDefinitions: array(input),
 	prompt: text$1
 };
-var webhookOptions = object({
+var webhookOptions = object$1({
 	allowedMethods: never().optional(),
 	allowedOrigins: strings.optional(),
 	noResponseBody: never().optional(),
@@ -6000,8 +6018,8 @@ var definition = {
 	outputs: array(port).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
 	provider: text$1
 };
-var endpoint = object({
-	body: object({
+var endpoint = object$1({
+	body: object$1({
 		allowArray: boolean(),
 		allowEmpty: boolean(),
 		formats: array(_enum([
@@ -6021,6 +6039,7 @@ var endpoint = object({
 	])),
 	successStatus: number()
 });
+var sourceFlowIds = array(text$1.min(1)).refine((ids) => new Set(ids).size === ids.length, "Duplicate source Flow ID.");
 var trigger$1 = {
 	name: text$1,
 	description: text$1.optional(),
@@ -6035,30 +6054,30 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
-	object({
+	object$1({
 		...base,
 		inputs: record(text$1, 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("subflow"),
 		subflowId: text$1
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("task"),
 		task: inline,
 		additionalInputs: array(input).optional()
 	}),
-	object({
+	object$1({
 		...base,
 		kind: literal("task"),
 		taskId: text$1,
@@ -6074,48 +6093,53 @@ var node = union([
 		kind: literal("wait"),
 		...wait
 	}).omit({ timeoutMs: true }),
-	object({
+	object$1({
 		...trigger$1,
 		kind: literal("manual")
 	}),
-	object({
+	strictObject({
+		...trigger$1,
+		kind: literal("error"),
+		sourceFlowIds: sourceFlowIds.optional()
+	}),
+	object$1({
 		...trigger$1,
 		kind: literal("webhook"),
 		...webhook
 	}),
-	object({
+	object$1({
 		...trigger$1,
 		kind: literal("cron"),
 		cronTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger$1,
 		kind: literal("poll"),
 		connectionId: text$1.min(1).optional(),
 		config: record(text$1, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("poll")
 		}),
 		pollTimes: triggerScheduleSchema
 	}),
-	object({
+	object$1({
 		...trigger$1,
 		kind: literal("integration"),
 		connectionId: text$1.min(1).optional(),
 		config: record(text$1, fixedInput),
-		definition: object({
+		definition: object$1({
 			...definition,
 			type: literal("integration"),
 			endpoint
 		})
 	})
 ]);
-var target$1 = union([object({ kind: literal("flow") }), object({
+var target$1 = union([object$1({ kind: literal("flow") }), object$1({
 	kind: literal("subflow"),
 	id: text$1
 })]);
-var edge = object({
+var edge = object$1({
 	source: text$1,
 	target: text$1,
 	sourceHandle: text$1.optional()
@@ -6124,32 +6148,36 @@ var at = {
 	nodeId: text$1,
 	target: target$1
 };
-var subflow = object({
+var subflow = object$1({
 	name: text$1,
 	inputs: array(input),
 	outputs: array(port.extend({ sources: array(union([nodeSource, flowSource])) }))
 });
-var graph = object({
+var graph = object$1({
 	nodes: record(text$1, node),
 	edges: array(edge).default([])
 });
-var binding = object({
+var binding = object$1({
 	kind: literal("variable"),
 	target: text$1
 });
-var module = object({
+var module = object$1({
 	name: text$1,
 	imports: strings,
 	source: text$1
 });
-var document = object({
+var document = object$1({
 	bindings: record(text$1, binding),
 	graph,
 	subflows: record(text$1, subflow.extend({ graph })),
 	tasks: record(text$1, managed)
 });
-object({
-	modelVersion: union([literal(2), literal(4)]),
+object$1({
+	modelVersion: union([
+		literal(2),
+		literal(4),
+		literal(5)
+	]),
 	document,
 	modules: record(text$1, module)
 }).extend({
@@ -6157,6 +6185,11 @@ object({
 	version: literal(1)
 });
 var shapes = {
+	"graph.trigger.sources.set": {
+		nodeId: text$1,
+		before: sourceFlowIds.optional(),
+		value: sourceFlowIds.optional()
+	},
 	"binding.create": {
 		bindingId: text$1,
 		binding
@@ -6181,14 +6214,14 @@ var shapes = {
 	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: literal("connectionId"),
 			before: text$1.min(1).optional(),
 			value: text$1.min(1).optional()
 		}),
-		object({
+		object$1({
 			...at,
 			kind: literal("graph.node.field.set"),
 			field: _enum([
@@ -6199,14 +6232,14 @@ var shapes = {
 			before: text$1.optional(),
 			value: text$1.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"),
@@ -6227,8 +6260,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,
@@ -6237,20 +6270,20 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
-		before: object(wait),
-		value: object(wait)
+		target: object$1({ kind: literal("flow") }),
+		before: object$1(wait),
+		value: object$1(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
-		before: object(webhook),
-		value: object(webhook)
+		target: object$1({ kind: literal("flow") }),
+		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,
@@ -6310,6 +6343,11 @@ var shapes = {
 		before: text$1.optional(),
 		value: text$1.optional()
 	},
+	"task.openapi.set": {
+		taskId: text$1,
+		before: managed,
+		value: managed
+	},
 	"task.agent.set": {
 		taskId: text$1,
 		before: managed,
@@ -6326,7 +6364,7 @@ var shapes = {
 		value: text$1
 	}
 };
-var variants = new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
+var variants = new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
 	kind: literal(kind),
 	...shape
 })]));
@@ -6340,7 +6378,7 @@ function parseOperation(candidate, index, parse) {
 	}
 }
 function decodeChangeOperation(candidate, index) {
-	const { kind } = parseOperation(candidate, index, object({ kind: text$1 }).parse);
+	const { kind } = parseOperation(candidate, index, object$1({ kind: text$1 }).parse);
 	const schema = variants.get(kind);
 	if (schema == null) throw new TypeError(`operations[${index}]: Unknown operation ${JSON.stringify(kind)}.`);
 	return parseOperation(candidate, index, schema.parse);
@@ -6361,6 +6399,136 @@ function resourceNameIssue(value) {
 	if (!/^[\p{L}\p{N}](?:[\p{L}\p{N} _-]*[\p{L}\p{N}])?$/u.test(name)) return "specialCharacter";
 }
 //#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
+function deepCompareStrict(a, b) {
+	const typeofa = typeof a;
+	if (typeofa !== typeof b) return false;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b)) return false;
+		const length = a.length;
+		if (length !== b.length) return false;
+		for (let i = 0; i < length; i++) if (!deepCompareStrict(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeofa === "object") {
+		if (!a || !b) return a === b;
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys.length !== bKeys.length) return false;
+		for (const k of aKeys) if (!deepCompareStrict(a[k], b[k])) return false;
+		return true;
+	}
+	return a === b;
+}
+//#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/pointer.js
+function encodePointer(p) {
+	return encodeURI(escapePointer(p));
+}
+function escapePointer(p) {
+	return p.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+//#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/dereference.js
+var schemaArrayKeyword = {
+	prefixItems: true,
+	items: true,
+	allOf: true,
+	anyOf: true,
+	oneOf: true
+};
+var schemaMapKeyword = {
+	$defs: true,
+	definitions: true,
+	properties: true,
+	patternProperties: true,
+	dependentSchemas: true
+};
+var ignoredKeyword = {
+	id: true,
+	$id: true,
+	$ref: true,
+	$schema: true,
+	$anchor: true,
+	$vocabulary: true,
+	$comment: true,
+	default: true,
+	enum: true,
+	const: true,
+	required: true,
+	type: true,
+	maximum: true,
+	minimum: true,
+	exclusiveMaximum: true,
+	exclusiveMinimum: true,
+	multipleOf: true,
+	maxLength: true,
+	minLength: true,
+	pattern: true,
+	format: true,
+	maxItems: true,
+	minItems: true,
+	uniqueItems: true,
+	maxProperties: true,
+	minProperties: true
+};
+var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
+function dereference(schema, lookup = Object.create(null), baseURI = initialBaseURI, basePointer = "") {
+	if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+		const id = schema.$id || schema.id;
+		if (id) {
+			const url = new URL(id, baseURI.href);
+			if (url.hash.length > 1) lookup[url.href] = schema;
+			else {
+				url.hash = "";
+				if (basePointer === "") baseURI = url;
+				else dereference(schema, lookup, baseURI);
+			}
+		}
+	} else if (schema !== true && schema !== false) return lookup;
+	const schemaURI = baseURI.href + (basePointer ? "#" + basePointer : "");
+	if (lookup[schemaURI] !== void 0) throw new Error(`Duplicate schema URI "${schemaURI}".`);
+	lookup[schemaURI] = schema;
+	if (schema === true || schema === false) return lookup;
+	if (schema.__absolute_uri__ === void 0) Object.defineProperty(schema, "__absolute_uri__", {
+		enumerable: false,
+		value: schemaURI
+	});
+	if (schema.$ref && schema.__absolute_ref__ === void 0) {
+		const url = new URL(schema.$ref, baseURI.href);
+		url.hash = url.hash;
+		Object.defineProperty(schema, "__absolute_ref__", {
+			enumerable: false,
+			value: url.href
+		});
+	}
+	if (schema.$recursiveRef && schema.__absolute_recursive_ref__ === void 0) {
+		const url = new URL(schema.$recursiveRef, baseURI.href);
+		url.hash = url.hash;
+		Object.defineProperty(schema, "__absolute_recursive_ref__", {
+			enumerable: false,
+			value: url.href
+		});
+	}
+	if (schema.$anchor) {
+		const url = new URL("#" + schema.$anchor, baseURI.href);
+		lookup[url.href] = schema;
+	}
+	for (let key in schema) {
+		if (ignoredKeyword[key]) continue;
+		const keyBase = `${basePointer}/${encodePointer(key)}`;
+		const subSchema = schema[key];
+		if (Array.isArray(subSchema)) {
+			if (schemaArrayKeyword[key]) {
+				const length = subSchema.length;
+				for (let i = 0; i < length; i++) dereference(subSchema[i], lookup, baseURI, `${keyBase}/${i}`);
+			}
+		} else if (schemaMapKeyword[key]) for (let subKey in subSchema) dereference(subSchema[subKey], lookup, baseURI, `${keyBase}/${encodePointer(subKey)}`);
+		else dereference(subSchema, lookup, baseURI, keyBase);
+	}
+	return lookup;
+}
+//#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/format.js
 var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
 var DAYS = [
@@ -6461,6 +6629,656 @@ function regex(str) {
 	}
 }
 //#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/ucs2-length.js
+function ucs2length(s) {
+	let result = 0;
+	let length = s.length;
+	let index = 0;
+	let charCode;
+	while (index < length) {
+		result++;
+		charCode = s.charCodeAt(index++);
+		if (charCode >= 55296 && charCode <= 56319 && index < length) {
+			charCode = s.charCodeAt(index);
+			if ((charCode & 64512) == 56320) index++;
+		}
+	}
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validate.js
+function validate(instance, schema, draft = "2019-09", lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = Object.create(null)) {
+	if (schema === true) return {
+		valid: true,
+		errors: []
+	};
+	if (schema === false) return {
+		valid: false,
+		errors: [{
+			instanceLocation,
+			keyword: "false",
+			keywordLocation: instanceLocation,
+			error: "False boolean schema."
+		}]
+	};
+	const rawInstanceType = typeof instance;
+	let instanceType;
+	switch (rawInstanceType) {
+		case "boolean":
+		case "number":
+		case "string":
+			instanceType = rawInstanceType;
+			break;
+		case "object":
+			if (instance === null) instanceType = "null";
+			else if (Array.isArray(instance)) instanceType = "array";
+			else instanceType = "object";
+			break;
+		default: throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
+	}
+	const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
+	const errors = [];
+	if ($recursiveAnchor === true && recursiveAnchor === null) recursiveAnchor = schema;
+	if ($recursiveRef === "#") {
+		const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
+		const keywordLocation = `${schemaLocation}/$recursiveRef`;
+		const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
+		if (!result.valid) errors.push({
+			instanceLocation,
+			keyword: "$recursiveRef",
+			keywordLocation,
+			error: "A subschema had errors."
+		}, ...result.errors);
+	}
+	if ($ref !== void 0) {
+		const refSchema = lookup[__absolute_ref__ || $ref];
+		if (refSchema === void 0) {
+			let message = `Unresolved $ref "${$ref}".`;
+			if (__absolute_ref__ && __absolute_ref__ !== $ref) message += `  Absolute URI "${__absolute_ref__}".`;
+			message += `\nKnown schemas:\n- ${Object.keys(lookup).join("\n- ")}`;
+			throw new Error(message);
+		}
+		const keywordLocation = `${schemaLocation}/$ref`;
+		const result = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
+		if (!result.valid) errors.push({
+			instanceLocation,
+			keyword: "$ref",
+			keywordLocation,
+			error: "A subschema had errors."
+		}, ...result.errors);
+		if (draft === "4" || draft === "7") return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	if (Array.isArray($type)) {
+		let length = $type.length;
+		let valid = false;
+		for (let i = 0; i < length; i++) if (instanceType === $type[i] || $type[i] === "integer" && instanceType === "number" && instance % 1 === 0 && instance === instance) {
+			valid = true;
+			break;
+		}
+		if (!valid) errors.push({
+			instanceLocation,
+			keyword: "type",
+			keywordLocation: `${schemaLocation}/type`,
+			error: `Instance type "${instanceType}" is invalid. Expected "${$type.join("\", \"")}".`
+		});
+	} else if ($type === "integer") {
+		if (instanceType !== "number" || instance % 1 || instance !== instance) errors.push({
+			instanceLocation,
+			keyword: "type",
+			keywordLocation: `${schemaLocation}/type`,
+			error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+		});
+	} else if ($type !== void 0 && instanceType !== $type) errors.push({
+		instanceLocation,
+		keyword: "type",
+		keywordLocation: `${schemaLocation}/type`,
+		error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+	});
+	if ($const !== void 0) {
+		if (instanceType === "object" || instanceType === "array") {
+			if (!deepCompareStrict(instance, $const)) errors.push({
+				instanceLocation,
+				keyword: "const",
+				keywordLocation: `${schemaLocation}/const`,
+				error: `Instance does not match ${JSON.stringify($const)}.`
+			});
+		} else if (instance !== $const) errors.push({
+			instanceLocation,
+			keyword: "const",
+			keywordLocation: `${schemaLocation}/const`,
+			error: `Instance does not match ${JSON.stringify($const)}.`
+		});
+	}
+	if ($enum !== void 0) {
+		if (instanceType === "object" || instanceType === "array") {
+			if (!$enum.some((value) => deepCompareStrict(instance, value))) errors.push({
+				instanceLocation,
+				keyword: "enum",
+				keywordLocation: `${schemaLocation}/enum`,
+				error: `Instance does not match any of ${JSON.stringify($enum)}.`
+			});
+		} else if (!$enum.some((value) => instance === value)) errors.push({
+			instanceLocation,
+			keyword: "enum",
+			keywordLocation: `${schemaLocation}/enum`,
+			error: `Instance does not match any of ${JSON.stringify($enum)}.`
+		});
+	}
+	if ($not !== void 0) {
+		const keywordLocation = `${schemaLocation}/not`;
+		if (validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation).valid) errors.push({
+			instanceLocation,
+			keyword: "not",
+			keywordLocation,
+			error: "Instance matched \"not\" schema."
+		});
+	}
+	let subEvaluateds = [];
+	if ($anyOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/anyOf`;
+		const errorsLength = errors.length;
+		let anyValid = false;
+		for (let i = 0; i < $anyOf.length; i++) {
+			const subSchema = $anyOf[i];
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			anyValid = anyValid || result.valid;
+			if (result.valid) subEvaluateds.push(subEvaluated);
+		}
+		if (anyValid) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "anyOf",
+			keywordLocation,
+			error: "Instance does not match any subschemas."
+		});
+	}
+	if ($allOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/allOf`;
+		const errorsLength = errors.length;
+		let allValid = true;
+		for (let i = 0; i < $allOf.length; i++) {
+			const subSchema = $allOf[i];
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			allValid = allValid && result.valid;
+			if (result.valid) subEvaluateds.push(subEvaluated);
+		}
+		if (allValid) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "allOf",
+			keywordLocation,
+			error: `Instance does not match every subschema.`
+		});
+	}
+	if ($oneOf !== void 0) {
+		const keywordLocation = `${schemaLocation}/oneOf`;
+		const errorsLength = errors.length;
+		const matches = $oneOf.filter((subSchema, i) => {
+			const subEvaluated = Object.create(evaluated);
+			const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+			errors.push(...result.errors);
+			if (result.valid) subEvaluateds.push(subEvaluated);
+			return result.valid;
+		}).length;
+		if (matches === 1) errors.length = errorsLength;
+		else errors.splice(errorsLength, 0, {
+			instanceLocation,
+			keyword: "oneOf",
+			keywordLocation,
+			error: `Instance does not match exactly one subschema (${matches} matches).`
+		});
+	}
+	if (instanceType === "object" || instanceType === "array") Object.assign(evaluated, ...subEvaluateds);
+	if ($if !== void 0) {
+		const keywordLocation = `${schemaLocation}/if`;
+		if (validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid) {
+			if ($then !== void 0) {
+				const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
+				if (!thenResult.valid) errors.push({
+					instanceLocation,
+					keyword: "if",
+					keywordLocation,
+					error: `Instance does not match "then" schema.`
+				}, ...thenResult.errors);
+			}
+		} else if ($else !== void 0) {
+			const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
+			if (!elseResult.valid) errors.push({
+				instanceLocation,
+				keyword: "if",
+				keywordLocation,
+				error: `Instance does not match "else" schema.`
+			}, ...elseResult.errors);
+		}
+	}
+	if (instanceType === "object") {
+		if ($required !== void 0) {
+			for (const key of $required) if (!(key in instance)) errors.push({
+				instanceLocation,
+				keyword: "required",
+				keywordLocation: `${schemaLocation}/required`,
+				error: `Instance does not have required property "${key}".`
+			});
+		}
+		const keys = Object.keys(instance);
+		if ($minProperties !== void 0 && keys.length < $minProperties) errors.push({
+			instanceLocation,
+			keyword: "minProperties",
+			keywordLocation: `${schemaLocation}/minProperties`,
+			error: `Instance does not have at least ${$minProperties} properties.`
+		});
+		if ($maxProperties !== void 0 && keys.length > $maxProperties) errors.push({
+			instanceLocation,
+			keyword: "maxProperties",
+			keywordLocation: `${schemaLocation}/maxProperties`,
+			error: `Instance does not have at least ${$maxProperties} properties.`
+		});
+		if ($propertyNames !== void 0) {
+			const keywordLocation = `${schemaLocation}/propertyNames`;
+			for (const key in instance) {
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "propertyNames",
+					keywordLocation,
+					error: `Property name "${key}" does not match schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($dependentRequired !== void 0) {
+			const keywordLocation = `${schemaLocation}/dependantRequired`;
+			for (const key in $dependentRequired) if (key in instance) {
+				const required = $dependentRequired[key];
+				for (const dependantKey of required) if (!(dependantKey in instance)) errors.push({
+					instanceLocation,
+					keyword: "dependentRequired",
+					keywordLocation,
+					error: `Instance has "${key}" but does not have "${dependantKey}".`
+				});
+			}
+		}
+		if ($dependentSchemas !== void 0) for (const key in $dependentSchemas) {
+			const keywordLocation = `${schemaLocation}/dependentSchemas`;
+			if (key in instance) {
+				const result = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "dependentSchemas",
+					keywordLocation,
+					error: `Instance has "${key}" but does not match dependant schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($dependencies !== void 0) {
+			const keywordLocation = `${schemaLocation}/dependencies`;
+			for (const key in $dependencies) if (key in instance) {
+				const propsOrSchema = $dependencies[key];
+				if (Array.isArray(propsOrSchema)) {
+					for (const dependantKey of propsOrSchema) if (!(dependantKey in instance)) errors.push({
+						instanceLocation,
+						keyword: "dependencies",
+						keywordLocation,
+						error: `Instance has "${key}" but does not have "${dependantKey}".`
+					});
+				} else {
+					const result = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
+					if (!result.valid) errors.push({
+						instanceLocation,
+						keyword: "dependencies",
+						keywordLocation,
+						error: `Instance has "${key}" but does not match dependant schema.`
+					}, ...result.errors);
+				}
+			}
+		}
+		const thisEvaluated = Object.create(null);
+		let stop = false;
+		if ($properties !== void 0) {
+			const keywordLocation = `${schemaLocation}/properties`;
+			for (const key in $properties) {
+				if (!(key in instance)) continue;
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
+				if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+				else {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "properties",
+						keywordLocation,
+						error: `Property "${key}" does not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+		}
+		if (!stop && $patternProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/patternProperties`;
+			for (const pattern in $patternProperties) {
+				const regex = new RegExp(pattern, "u");
+				const subSchema = $patternProperties[pattern];
+				for (const key in instance) {
+					if (!regex.test(key)) continue;
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
+					if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+					else {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "patternProperties",
+							keywordLocation,
+							error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
+						}, ...result.errors);
+					}
+				}
+			}
+		}
+		if (!stop && $additionalProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/additionalProperties`;
+			for (const key in instance) {
+				if (thisEvaluated[key]) continue;
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (result.valid) evaluated[key] = true;
+				else {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "additionalProperties",
+						keywordLocation,
+						error: `Property "${key}" does not match additional properties schema.`
+					}, ...result.errors);
+				}
+			}
+		} else if (!stop && $unevaluatedProperties !== void 0) {
+			const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
+			for (const key in instance) if (!evaluated[key]) {
+				const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+				const result = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+				if (result.valid) evaluated[key] = true;
+				else errors.push({
+					instanceLocation,
+					keyword: "unevaluatedProperties",
+					keywordLocation,
+					error: `Property "${key}" does not match unevaluated properties schema.`
+				}, ...result.errors);
+			}
+		}
+	} else if (instanceType === "array") {
+		if ($maxItems !== void 0 && instance.length > $maxItems) errors.push({
+			instanceLocation,
+			keyword: "maxItems",
+			keywordLocation: `${schemaLocation}/maxItems`,
+			error: `Array has too many items (${instance.length} > ${$maxItems}).`
+		});
+		if ($minItems !== void 0 && instance.length < $minItems) errors.push({
+			instanceLocation,
+			keyword: "minItems",
+			keywordLocation: `${schemaLocation}/minItems`,
+			error: `Array has too few items (${instance.length} < ${$minItems}).`
+		});
+		const length = instance.length;
+		let i = 0;
+		let stop = false;
+		if ($prefixItems !== void 0) {
+			const keywordLocation = `${schemaLocation}/prefixItems`;
+			const length2 = Math.min($prefixItems.length, length);
+			for (; i < length2; i++) {
+				const result = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+				evaluated[i] = true;
+				if (!result.valid) {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "prefixItems",
+						keywordLocation,
+						error: `Items did not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+		}
+		if ($items !== void 0) {
+			const keywordLocation = `${schemaLocation}/items`;
+			if (Array.isArray($items)) {
+				const length2 = Math.min($items.length, length);
+				for (; i < length2; i++) {
+					const result = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "items",
+							keywordLocation,
+							error: `Items did not match schema.`
+						}, ...result.errors);
+						if (stop) break;
+					}
+				}
+			} else for (; i < length; i++) {
+				const result = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+				evaluated[i] = true;
+				if (!result.valid) {
+					stop = shortCircuit;
+					errors.push({
+						instanceLocation,
+						keyword: "items",
+						keywordLocation,
+						error: `Items did not match schema.`
+					}, ...result.errors);
+					if (stop) break;
+				}
+			}
+			if (!stop && $additionalItems !== void 0) {
+				const keywordLocation = `${schemaLocation}/additionalItems`;
+				for (; i < length; i++) {
+					const result = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "additionalItems",
+							keywordLocation,
+							error: `Items did not match additional items schema.`
+						}, ...result.errors);
+					}
+				}
+			}
+		}
+		if ($contains !== void 0) {
+			if (length === 0 && $minContains === void 0) errors.push({
+				instanceLocation,
+				keyword: "contains",
+				keywordLocation: `${schemaLocation}/contains`,
+				error: `Array is empty. It must contain at least one item matching the schema.`
+			});
+			else if ($minContains !== void 0 && length < $minContains) errors.push({
+				instanceLocation,
+				keyword: "minContains",
+				keywordLocation: `${schemaLocation}/minContains`,
+				error: `Array has less items (${length}) than minContains (${$minContains}).`
+			});
+			else {
+				const keywordLocation = `${schemaLocation}/contains`;
+				const errorsLength = errors.length;
+				let contained = 0;
+				for (let j = 0; j < length; j++) {
+					const result = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
+					if (result.valid) {
+						evaluated[j] = true;
+						contained++;
+					} else errors.push(...result.errors);
+				}
+				if (contained >= ($minContains || 0)) errors.length = errorsLength;
+				if ($minContains === void 0 && $maxContains === void 0 && contained === 0) errors.splice(errorsLength, 0, {
+					instanceLocation,
+					keyword: "contains",
+					keywordLocation,
+					error: `Array does not contain item matching schema.`
+				});
+				else if ($minContains !== void 0 && contained < $minContains) errors.push({
+					instanceLocation,
+					keyword: "minContains",
+					keywordLocation: `${schemaLocation}/minContains`,
+					error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
+				});
+				else if ($maxContains !== void 0 && contained > $maxContains) errors.push({
+					instanceLocation,
+					keyword: "maxContains",
+					keywordLocation: `${schemaLocation}/maxContains`,
+					error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
+				});
+			}
+		}
+		if (!stop && $unevaluatedItems !== void 0) {
+			const keywordLocation = `${schemaLocation}/unevaluatedItems`;
+			for (; i < length; i++) {
+				if (evaluated[i]) continue;
+				const result = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+				evaluated[i] = true;
+				if (!result.valid) errors.push({
+					instanceLocation,
+					keyword: "unevaluatedItems",
+					keywordLocation,
+					error: `Items did not match unevaluated items schema.`
+				}, ...result.errors);
+			}
+		}
+		if ($uniqueItems) for (let j = 0; j < length; j++) {
+			const a = instance[j];
+			const ao = typeof a === "object" && a !== null;
+			for (let k = 0; k < length; k++) {
+				if (j === k) continue;
+				const b = instance[k];
+				if (a === b || ao && typeof b === "object" && b !== null && deepCompareStrict(a, b)) {
+					errors.push({
+						instanceLocation,
+						keyword: "uniqueItems",
+						keywordLocation: `${schemaLocation}/uniqueItems`,
+						error: `Duplicate items at indexes ${j} and ${k}.`
+					});
+					j = Number.MAX_SAFE_INTEGER;
+					k = Number.MAX_SAFE_INTEGER;
+				}
+			}
+		}
+	} else if (instanceType === "number") {
+		if (draft === "4") {
+			if ($minimum !== void 0 && ($exclusiveMinimum === true && instance <= $minimum || instance < $minimum)) errors.push({
+				instanceLocation,
+				keyword: "minimum",
+				keywordLocation: `${schemaLocation}/minimum`,
+				error: `${instance} is less than ${$exclusiveMinimum ? "or equal to " : ""} ${$minimum}.`
+			});
+			if ($maximum !== void 0 && ($exclusiveMaximum === true && instance >= $maximum || instance > $maximum)) errors.push({
+				instanceLocation,
+				keyword: "maximum",
+				keywordLocation: `${schemaLocation}/maximum`,
+				error: `${instance} is greater than ${$exclusiveMaximum ? "or equal to " : ""} ${$maximum}.`
+			});
+		} else {
+			if ($minimum !== void 0 && instance < $minimum) errors.push({
+				instanceLocation,
+				keyword: "minimum",
+				keywordLocation: `${schemaLocation}/minimum`,
+				error: `${instance} is less than ${$minimum}.`
+			});
+			if ($maximum !== void 0 && instance > $maximum) errors.push({
+				instanceLocation,
+				keyword: "maximum",
+				keywordLocation: `${schemaLocation}/maximum`,
+				error: `${instance} is greater than ${$maximum}.`
+			});
+			if ($exclusiveMinimum !== void 0 && instance <= $exclusiveMinimum) errors.push({
+				instanceLocation,
+				keyword: "exclusiveMinimum",
+				keywordLocation: `${schemaLocation}/exclusiveMinimum`,
+				error: `${instance} is less than ${$exclusiveMinimum}.`
+			});
+			if ($exclusiveMaximum !== void 0 && instance >= $exclusiveMaximum) errors.push({
+				instanceLocation,
+				keyword: "exclusiveMaximum",
+				keywordLocation: `${schemaLocation}/exclusiveMaximum`,
+				error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
+			});
+		}
+		if ($multipleOf !== void 0) {
+			const remainder = instance % $multipleOf;
+			if (Math.abs(0 - remainder) >= 1.1920929e-7 && Math.abs($multipleOf - remainder) >= 1.1920929e-7) errors.push({
+				instanceLocation,
+				keyword: "multipleOf",
+				keywordLocation: `${schemaLocation}/multipleOf`,
+				error: `${instance} is not a multiple of ${$multipleOf}.`
+			});
+		}
+	} else if (instanceType === "string") {
+		const length = $minLength === void 0 && $maxLength === void 0 ? 0 : ucs2length(instance);
+		if ($minLength !== void 0 && length < $minLength) errors.push({
+			instanceLocation,
+			keyword: "minLength",
+			keywordLocation: `${schemaLocation}/minLength`,
+			error: `String is too short (${length} < ${$minLength}).`
+		});
+		if ($maxLength !== void 0 && length > $maxLength) errors.push({
+			instanceLocation,
+			keyword: "maxLength",
+			keywordLocation: `${schemaLocation}/maxLength`,
+			error: `String is too long (${length} > ${$maxLength}).`
+		});
+		if ($pattern !== void 0 && !new RegExp($pattern, "u").test(instance)) errors.push({
+			instanceLocation,
+			keyword: "pattern",
+			keywordLocation: `${schemaLocation}/pattern`,
+			error: `String does not match pattern.`
+		});
+		if ($format !== void 0 && format[$format] && !format[$format](instance)) errors.push({
+			instanceLocation,
+			keyword: "format",
+			keywordLocation: `${schemaLocation}/format`,
+			error: `String does not match format "${$format}".`
+		});
+	}
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validator.js
+var Validator = class {
+	schema;
+	draft;
+	shortCircuit;
+	lookup;
+	constructor(schema, draft = "2019-09", shortCircuit = true) {
+		this.schema = schema;
+		this.draft = draft;
+		this.shortCircuit = shortCircuit;
+		this.lookup = dereference(schema);
+	}
+	validate(instance) {
+		return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
+	}
+	addSchema(schema, id) {
+		if (id) schema = {
+			...schema,
+			$id: id
+		};
+		dereference(schema, this.lookup);
+	}
+};
+//#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
 function createId() {
@@ -9216,6 +10034,416 @@ function createSchemaComparer() {
 	] });
 }
 createSchemaComparer();
+//#endregion
+//#region src/flow/common/schema.ts
+function schemaObject(schema) {
+	return schema != null && typeof schema == "object" && !Array.isArray(schema) ? schema : void 0;
+}
+var validators = /* @__PURE__ */ new WeakMap();
+function matchesSchema(value, schema) {
+	return schemaValidationErrors(value, schema).length == 0;
+}
+function schemaValidationErrors(value, schema) {
+	if (typeof schema == "boolean") return schema ? [] : ["The schema does not allow any value."];
+	const source = schemaObject(schema);
+	if (source == null || source.properties != null && schemaObject(source.properties) == null) return ["Invalid output schema."];
+	try {
+		let validator = validators.get(source);
+		if (validator == null) {
+			const declaration = typeof source.$schema == "string" ? source.$schema : "";
+			const draft = declaration.includes("draft-04") ? "4" : declaration.includes("draft-07") ? "7" : declaration.includes("2020-12") ? "2020-12" : "2019-09";
+			validator = new Validator(structuredClone(source), draft);
+			validators.set(source, validator);
+		}
+		const result = validator.validate(value);
+		return result.valid ? [] : result.errors.map((issue) => `${issue.instanceLocation || "/"}: ${issue.error}`);
+	} catch {
+		return ["Output schema validation failed."];
+	}
+}
+//#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.");
+	if (!requirements.length) return [{
+		label: "None",
+		auth: []
+	}];
+	return requirements.map((entry) => {
+		const names = Object.keys(object(entry));
+		const label = names.join(" + ") || "None";
+		try {
+			if (!names.length) return {
+				label,
+				auth: []
+			};
+			const schemes = object(object(doc.components).securitySchemes);
+			return {
+				label,
+				auth: names.map((id) => {
+					const scheme = resolved(doc, schemes[id]);
+					if (scheme.type == "http" && ["bearer", "basic"].includes(String(scheme.scheme).toLowerCase())) return {
+						id,
+						type: String(scheme.scheme).toLowerCase()
+					};
+					if (scheme.type == "apiKey" && (scheme.in == "header" || scheme.in == "query") && typeof scheme.name == "string") return {
+						id,
+						type: "apiKey",
+						name: scheme.name,
+						in: scheme.in
+					};
+					throw new Error("This security scheme is unsupported. Supply an access token using manual Bearer authentication if applicable.");
+				})
+			};
+		} catch (error) {
+			return {
+				label,
+				error: error.message
+			};
+		}
+	});
+}
+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)]));
+}
+function selectOperation(value, sourceUrl, path, method) {
+	const doc = snapshot(value, path, method);
+	const choices = securityOptions(doc, path, method);
+	const auth = choices.find((choice) => choice.auth != null)?.auth;
+	if (auth == null) throw new Error(choices[0]?.error ?? "Unsupported authentication.");
+	const config = {
+		kind: "openapi",
+		sourceUrl: httpUrl(sourceUrl),
+		method,
+		path,
+		serverUrl: serverAddress(servers(doc, path, method)[0], sourceUrl),
+		document: doc,
+		auth
+	};
+	openApiTask(config);
+	return config;
+}
 `${JSON.stringify("open-flow-engine/v5")}`, new Set([
 	"assert",
 	"assert/strict",
@@ -10393,7 +11621,7 @@ var triggerCreate = strictObject({
 function decodeDraftOperations(value) {
 	checkJsonDepth(value);
 	return array(unknown()).min(1).parse(value).map((candidate, index) => {
-		const { kind } = parseOperation(candidate, index, object({ kind: text }).parse);
+		const { kind } = parseOperation(candidate, index, object$1({ kind: text }).parse);
 		return kind == "graph.trigger.create" ? parseOperation(candidate, index, triggerCreate.parse) : decodeChangeOperation(candidate, index);
 	});
 }
@@ -10449,10 +11677,12 @@ var eventSourceRevisionSchema = strictObject({
 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.",
+	"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.",
@@ -10471,6 +11701,24 @@ var authoringExamples = Object.keys(descriptions).map((name) => ({
 function authoringExample(name) {
 	let operations;
 	switch (name) {
+		case "error":
+			operations = createBuiltinTrigger(target, "error", {
+				kind: "error",
+				name: "Flow Error"
+			});
+			break;
+		case "openapi":
+			operations = createManagedTask(target, {
+				nodeId: "api",
+				taskId: "api-task"
+			}, openApiTask(selectOperation({
+				openapi: "3.1.0",
+				paths: { "/items": { get: { responses: { "200": { content: { "application/json": { schema: {
+					type: "array",
+					items: { type: "string" }
+				} } } } } } } }
+			}, "https://api.example.com/openapi.json", "/items", "get")));
+			break;
 		case "manual":
 			operations = createBuiltinTrigger(target, "start", {
 				kind: "manual",
@@ -10710,6 +11958,10 @@ var trigger = strictObject({
 	outputs: record(string(), json)
 });
 var schemas = {
+	loadOpenApiDocument: strictObject({
+		url: string().min(1).max(8192),
+		version
+	}),
 	createEventSource: createEventSourceSchema,
 	updateEventSource: updateEventSourceSchema,
 	eventSourceRevision: eventSourceRevisionSchema,
@@ -10806,6 +12058,7 @@ function decoder(schema) {
 	return (value) => schema.parse(value);
 }
 var controlRequests = {
+	loadOpenApiDocument: decoder(schemas.loadOpenApiDocument),
 	createEventSource: decoder(schemas.createEventSource),
 	updateEventSource: decoder(schemas.updateEventSource),
 	eventSourceRevision: decoder(schemas.eventSourceRevision),