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

package/dist/browser/flow-change.js

@@ -188,7 +188,7 @@ function slugify(input) {
 	return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
 var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
-function isObject(data) {
+function isObject$1(data) {
 	return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 var allowsEval = /* @__PURE__*/ cached(() => {
@@ -201,18 +201,18 @@ var allowsEval = /* @__PURE__*/ cached(() => {
 		return false;
 	}
 });
-function isPlainObject(o) {
-	if (isObject(o) === false) return false;
+function isPlainObject$1(o) {
+	if (isObject$1(o) === false) return false;
 	const ctor = o.constructor;
 	if (ctor === void 0) return true;
 	if (typeof ctor !== "function") return true;
 	const prot = ctor.prototype;
-	if (isObject(prot) === false) return false;
+	if (isObject$1(prot) === false) return false;
 	if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
 	return true;
 }
 function shallowClone(o) {
-	if (isPlainObject(o)) return { ...o };
+	if (isPlainObject$1(o)) return { ...o };
 	if (Array.isArray(o)) return [...o];
 	if (o instanceof Map) return new Map(o);
 	if (o instanceof Set) return new Set(o);
@@ -267,7 +267,7 @@ var BIGINT_FORMAT_RANGES = {
 	int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
 	uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")]
 };
-function pick(schema, mask) {
+function pick$1(schema, mask) {
 	const currDef = schema._zod.def;
 	const checks = currDef.checks;
 	if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
@@ -300,7 +300,7 @@ function omit(schema, mask) {
 	}));
 }
 function extend(schema, shape) {
-	if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	if (!isPlainObject$1(shape)) throw new Error("Invalid input to extend: expected a plain object");
 	const checks = schema._zod.def.checks;
 	if (checks && checks.length > 0) {
 		const existingShape = sourceShape(schema);
@@ -315,7 +315,7 @@ function extended(schema, shape) {
 	return newShape;
 }
 function safeExtend(schema, shape) {
-	if (!isPlainObject(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	if (!isPlainObject$1(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
 	return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
 }
 function merge(a, b) {
@@ -2085,7 +2085,7 @@ var $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject$2 = isObject;
+	const isObject = isObject$1;
 	const catchall = def.catchall;
 	let value;
 	const memo = globalConfig.memoizer;
@@ -2093,7 +2093,7 @@ var $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2223,7 +2223,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 		return doc.compile();
 	};
 	let fastpass;
-	const isObject$1 = isObject;
+	const isObject = isObject$1;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -2231,7 +2231,7 @@ var $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$1(input)) {
+		if (!isObject(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2304,6 +2304,70 @@ var $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def) => {
 		});
 	};
 });
+function discriminatorMap(def) {
+	const map = /* @__PURE__ */ new Map();
+	for (const option of def.options) {
+		const values = option._zod.propValues?.[def.discriminator];
+		if (!values || values.size === 0) throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
+		for (const value of values) if (map.has(value)) {
+			if (value !== void 0) throw new Error(`Duplicate discriminator value "${String(value)}"`);
+			map.set(value, null);
+		} else map.set(value, option);
+	}
+	return map;
+}
+var $ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
+	def.inclusive = false;
+	$ZodUnion.init(inst, def);
+	const _super = inst._zod.parse;
+	defineLazyInternal(inst, "propValues", (zod) => {
+		const propValues = {};
+		let undefinedCount = 0;
+		for (const option of zod.def.options) {
+			const pv = option._zod.propValues;
+			if (!pv || Object.keys(pv).length === 0) throw new Error(`Invalid discriminated union option at index "${zod.def.options.indexOf(option)}"`);
+			if (pv[zod.def.discriminator]?.has(void 0)) undefinedCount++;
+			for (const [k, v] of Object.entries(pv)) {
+				if (!Object.prototype.hasOwnProperty.call(propValues, k)) assignProp(propValues, k, /* @__PURE__ */ new Set());
+				for (const val of v) propValues[k].add(val);
+			}
+		}
+		if (!zod.def.unionFallback && undefinedCount > 1) propValues[zod.def.discriminator]?.delete(void 0);
+		return propValues;
+	});
+	def.options.forEach((option, i) => {
+		const propShape = rawShape(option._zod.def);
+		if (propShape && !Object.prototype.hasOwnProperty.call(propShape, def.discriminator)) throw new Error(`Invalid discriminated union option at index "${i}"`);
+	});
+	const disc = cached(() => discriminatorMap(def));
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isObject$1(input)) {
+			payload.issues.push({
+				code: "invalid_type",
+				expected: "object",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const value = input?.[def.discriminator];
+		const opt = disc.value.get(value);
+		if (opt && (value !== void 0 || ctx.direction !== "backward")) return opt._zod.run(payload, ctx);
+		if (def.unionFallback || ctx.direction === "backward") return _super(payload, ctx);
+		payload.issues.push({
+			code: "invalid_union",
+			errors: [],
+			note: "No matching discriminator",
+			discriminator: def.discriminator,
+			options: Array.from(disc.value.keys()).filter((value) => disc.value.get(value) !== null),
+			input,
+			path: [def.discriminator],
+			inst
+		});
+		return payload;
+	};
+});
 var $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
 	$ZodType.init(inst, def);
 	inst._zod.parse = (payload, ctx) => {
@@ -2331,7 +2395,7 @@ function mergeValues(a, b) {
 		valid: true,
 		data: a
 	};
-	if (isPlainObject(a) && isPlainObject(b)) {
+	if (isPlainObject$1(a) && isPlainObject$1(b)) {
 		const bKeys = Object.keys(b);
 		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
 		const newObj = {
@@ -2424,7 +2488,7 @@ var $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 	memo?.attach(inst);
 	inst._zod.parse = (payload, ctx) => {
 		const input = payload.value;
-		if (!isPlainObject(input)) {
+		if (!isPlainObject$1(input)) {
 			payload.issues.push({
 				expected: "record",
 				code: "invalid_type",
@@ -5495,7 +5559,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		return merge(this, other);
 	},
 	pick(mask) {
-		return pick(this, mask);
+		return pick$1(this, mask);
 	},
 	omit(mask) {
 		return omit(this, mask);
@@ -5538,6 +5602,18 @@ function union(options, params) {
 		...normalizeParams(params)
 	});
 }
+var ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
+	ZodUnion.init(inst, def);
+	$ZodDiscriminatedUnion.init(inst, def);
+});
+function discriminatedUnion(discriminator, options, params) {
+	return new ZodDiscriminatedUnion({
+		type: "union",
+		options,
+		discriminator,
+		...normalizeParams(params)
+	});
+}
 var ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
 	$ZodIntersection.init(inst, def);
 	ZodType.init(inst, def);
@@ -5815,137 +5891,3009 @@ function json$1(params) {
 	});
 	return jsonSchema;
 }
-function checkJsonDepth(value, depth = 0) {
-	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
-	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
+//#endregion
+//#region src/json-schema-subset/utils.ts
+var nextId = 0;
+function createId() {
+	const id = nextId;
+	nextId += 1;
+	return id;
+}
+function deepFreeze(target) {
+	if (typeof target === "object" && target !== null && !Object.isFrozen(target)) {
+		for (const key of Object.getOwnPropertyNames(target)) deepFreeze(Reflect.get(target, key));
+		Object.freeze(target);
+	}
+	return target;
+}
+function pick(target, keys) {
+	const newTarget = {};
+	for (const key of keys) if (key in target) newTarget[key] = target[key];
+	return newTarget;
+}
+function deepCopy(value) {
+	if (typeof value !== "object" || value === null) return value;
+	else if (Array.isArray(value)) {
+		const array = [];
+		for (const [i, element] of value.entries()) array[i] = deepCopy(element);
+		return array;
+	} else {
+		const newObject = {};
+		for (const key in value) newObject[key] = deepCopy(value[key]);
+		return newObject;
+	}
+}
+function isDeepEquals(value1, value2) {
+	if (value1 === value2) return true;
+	if (value1 === null) return false;
+	if (typeof value1 !== "object") return false;
+	if (typeof value1 !== typeof value2) return false;
+	if (Array.isArray(value1)) {
+		if (!Array.isArray(value2)) return false;
+		if (value1.length !== value2.length) return false;
+		for (const [i, value1Element] of value1.entries()) if (!isDeepEquals(value1Element, value2[i])) return false;
+	} else {
+		if (Array.isArray(value2)) return false;
+		for (const key in value1) {
+			if (!(key in value2)) return false;
+			if (!isDeepEquals(value1[key], value2[key])) return false;
+		}
+		for (const key in value2) if (!(key in value1)) return false;
+	}
+	return true;
 }
 //#endregion
-//#region src/flow/common/triggerScheduleSchema.ts
-var triggerScheduleSchema = array(union([object({
-	type: literal("cron"),
-	expression: string(),
-	timezone: string()
-}), object({
-	type: literal("every"),
-	unit: _enum([
-		"day",
-		"hour",
-		"minute",
-		"month",
-		"week"
-	]),
-	value: number()
-})]));
+//#region src/json-schema-subset/expression/result.ts
+var ExpressionSingleResult = Object.freeze({
+	Equals: 0,
+	Containing: 1,
+	ContainedBy: 2,
+	Rejection: 3,
+	Intersection: 4
+});
+var ExpressionEquals = toExpression(ExpressionSingleResult.Equals);
+var ExpressionContaining = toExpression(ExpressionSingleResult.Containing);
+var ExpressionContainedBy = toExpression(ExpressionSingleResult.ContainedBy);
+var ExpressionRejection = toExpression(ExpressionSingleResult.Rejection);
+var ExpressionIntersection = toExpression(ExpressionSingleResult.Intersection);
+var ExpressionMaskList = deepFreeze([
+	[ExpressionSingleResult.Equals, ExpressionEquals],
+	[ExpressionSingleResult.Containing, ExpressionContaining],
+	[ExpressionSingleResult.ContainedBy, ExpressionContainedBy],
+	[ExpressionSingleResult.Rejection, ExpressionRejection],
+	[ExpressionSingleResult.Intersection, ExpressionIntersection]
+]);
+var ExpressionAny = (() => {
+	let expression = 0;
+	for (const [_, mask] of ExpressionMaskList) expression |= mask;
+	return expression;
+})();
+function hasEquals(expression) {
+	return !!(expression & ExpressionEquals);
+}
+function hasContaining(expression) {
+	return !!(expression & ExpressionContaining);
+}
+function hasContainedBy(expression) {
+	return !!(expression & ExpressionContainedBy);
+}
+function hasRejection(expression) {
+	return !!(expression & ExpressionRejection);
+}
+function hasIntersection(expression) {
+	return !!(expression & ExpressionIntersection);
+}
+function toExpression(expression) {
+	return 1 << expression;
+}
 //#endregion
-//#region src/flow/common/webhookMethod.ts
-var webhookMethods = [
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-];
+//#region src/json-schema-subset/expression/combination.ts
+function makeCombination(calculator) {
+	let expression = 0;
+	let count = 0;
+	const quantum = { push: (newExpression) => {
+		if (count === 0) expression = newExpression;
+		else expression = forEach(expression, newExpression, calculator);
+		count += 1;
+		return expression;
+	} };
+	Object.defineProperties(quantum, {
+		result: { get: () => expression },
+		count: { get: () => count }
+	});
+	return quantum;
+}
+function forEach(e1, e2, calculator) {
+	let expression = 0;
+	for (const [singleResult1, mask1] of ExpressionMaskList) if (mask1 & e1) {
+		for (const [singleResult2, mask2] of ExpressionMaskList) if (mask2 & e2) {
+			expression |= calculator(singleResult1, singleResult2);
+			if (expression === ExpressionAny) return expression;
+		}
+	}
+	return expression;
+}
 //#endregion
-//#region src/flow/common/changeSchema.ts
-var currentFlowModelVersion = 5;
-var text = string();
-var json = json$1();
-var strings = array(text);
-var port = object({
-	description: text.optional(),
-	jsonSchema: json,
-	nullable: boolean(),
-	handle: text
-});
-var input = port.extend({ value: json.optional() });
-var group = object({
-	collapsed: boolean().optional(),
-	group: text
-});
-var nodeSource = object({
-	kind: literal("node"),
-	nodeId: text,
-	output: text,
-	field: text.optional()
-});
-var flowSource = object({
-	kind: literal("flow"),
-	input: text
+//#region src/json-schema-subset/expression/calculator.ts
+var CalculatorOperator = Object.freeze({
+	Save: 0,
+	OneOf: 1,
+	AllOf: 2,
+	AnyOf: 3,
+	Not: 4,
+	Swap: 5
+});
+function calculate(operator, expressions) {
+	switch (operator) {
+		case CalculatorOperator.Save: return expressions[0];
+		case CalculatorOperator.OneOf: return calculateOneOf(expressions);
+		case CalculatorOperator.AllOf:
+		case CalculatorOperator.AnyOf: return calculateCombination(operator, expressions);
+		case CalculatorOperator.Not:
+		case CalculatorOperator.Swap: return calculateUnary(operator, expressions[0]);
+	}
+}
+function swap(expression) {
+	return calculateUnary(CalculatorOperator.Swap, expression);
+}
+/**
+* The oneOf operator is indivisible, so `a + b + c` must be evaluated as one expression.
+* ![](../../doc/images/all_of_expression.png)
+*/
+function calculateOneOf(expressions) {
+	if (expressions.length === 1) return expressions[0];
+	const unionSet = calculateCombination(CalculatorOperator.AnyOf, expressions);
+	const intersectionList = [];
+	for (let i = 0; i < expressions.length; ++i) for (let j = i + 1; j < expressions.length; ++j) {
+		const left = expressions[i];
+		const right = expressions[j];
+		const intersection = calculateCombination(CalculatorOperator.AllOf, [left, right]);
+		intersectionList.push(intersection);
+	}
+	const banZone = calculateCombination(CalculatorOperator.AnyOf, intersectionList);
+	const enableZone = calculateUnary(CalculatorOperator.Not, banZone);
+	return calculateCombination(CalculatorOperator.AllOf, [unionSet, enableZone]);
+}
+function calculateCombination(operator, expressions) {
+	if (expressions.length < 0) throw new Error("invalid expressions: empty array");
+	let combination;
+	switch (operator) {
+		case CalculatorOperator.AllOf:
+			combination = makeCombination(calculateAllOf);
+			break;
+		case CalculatorOperator.AnyOf:
+			combination = makeCombination(calculateAnyOf);
+			break;
+		default: throw new Error(`invalid operator ${operator}`);
+	}
+	for (const expression of expressions) combination.push(expression);
+	return combination.result;
+}
+function calculateUnary(operator, expression) {
+	let calculator;
+	let result = 0;
+	switch (operator) {
+		case CalculatorOperator.Not:
+			calculator = calculateNot;
+			break;
+		case CalculatorOperator.Swap:
+			calculator = calculateSwap;
+			break;
+		default: throw new Error(`invalid operator ${operator}`);
+	}
+	for (const [singleExpression, maskExpression] of ExpressionMaskList) if (maskExpression & expression) result |= calculator(singleExpression);
+	return result;
+}
+function calculateAllOf(e1, e2) {
+	let result = 0;
+	switch (e1) {
+		case ExpressionSingleResult.Equals:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = 0;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionContainedBy;
+			}
+			break;
+		case ExpressionSingleResult.Containing:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionEquals | ExpressionContaining;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionRejection;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionIntersection | ExpressionContainedBy;
+			}
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = 0;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionContainedBy;
+			}
+			break;
+		case ExpressionSingleResult.Rejection:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = 0;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionRejection;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = 0;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionRejection;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionRejection;
+			}
+			break;
+		case ExpressionSingleResult.Intersection: switch (e2) {
+			case ExpressionSingleResult.Equals:
+				result = ExpressionContainedBy;
+				break;
+			case ExpressionSingleResult.Containing:
+				result = ExpressionIntersection | ExpressionContainedBy;
+				break;
+			case ExpressionSingleResult.ContainedBy:
+				result = ExpressionContainedBy;
+				break;
+			case ExpressionSingleResult.Rejection:
+				result = ExpressionRejection;
+				break;
+			case ExpressionSingleResult.Intersection: result = ExpressionContainedBy | ExpressionRejection | ExpressionIntersection;
+		}
+	}
+	return result;
+}
+function calculateAnyOf(e1, e2) {
+	let result = 0;
+	switch (e1) {
+		case ExpressionSingleResult.Equals:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionContaining;
+			}
+			break;
+		case ExpressionSingleResult.Containing:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionContaining;
+			}
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionEquals;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionEquals | ExpressionContainedBy;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionIntersection;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionContaining | ExpressionIntersection;
+			}
+			break;
+		case ExpressionSingleResult.Rejection:
+			switch (e2) {
+				case ExpressionSingleResult.Equals:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.Containing:
+					result = ExpressionContaining;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					result = ExpressionIntersection;
+					break;
+				case ExpressionSingleResult.Rejection:
+					result = ExpressionRejection;
+					break;
+				case ExpressionSingleResult.Intersection: result = ExpressionIntersection;
+			}
+			break;
+		case ExpressionSingleResult.Intersection: switch (e2) {
+			case ExpressionSingleResult.Equals:
+				result = ExpressionContaining;
+				break;
+			case ExpressionSingleResult.Containing:
+				result = ExpressionContaining;
+				break;
+			case ExpressionSingleResult.ContainedBy:
+				result = ExpressionContaining | ExpressionIntersection;
+				break;
+			case ExpressionSingleResult.Rejection:
+				result = ExpressionIntersection;
+				break;
+			case ExpressionSingleResult.Intersection: result = ExpressionContaining | ExpressionIntersection;
+		}
+	}
+	return result;
+}
+function calculateNot(expression) {
+	let result = 0;
+	switch (expression) {
+		case ExpressionSingleResult.Equals:
+			result = ExpressionRejection;
+			break;
+		case ExpressionSingleResult.Containing:
+			result = ExpressionRejection;
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			result = ExpressionIntersection;
+			break;
+		case ExpressionSingleResult.Rejection:
+			result = ExpressionEquals | ExpressionContaining;
+			break;
+		case ExpressionSingleResult.Intersection: result = ExpressionContainedBy | ExpressionIntersection;
+	}
+	return result;
+}
+function calculateSwap(expression) {
+	let result = 0;
+	switch (expression) {
+		case ExpressionSingleResult.Equals:
+			result = ExpressionEquals;
+			break;
+		case ExpressionSingleResult.Containing:
+			result = ExpressionContainedBy;
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			result = ExpressionContaining;
+			break;
+		case ExpressionSingleResult.Rejection:
+			result = ExpressionRejection;
+			break;
+		case ExpressionSingleResult.Intersection: result = ExpressionIntersection;
+	}
+	return result;
+}
+//#endregion
+//#region src/json-schema-subset/expression/types.ts
+var ExpressionKind = Object.freeze({
+	Leaf: 0,
+	Not: 1,
+	AllOf: 2,
+	AnyOf: 3,
+	OneOf: 4
 });
-var source = union([
-	nodeSource,
-	flowSource,
-	object({
-		kind: literal("binding"),
-		bindingId: text
-	})
-]);
-var fixedInput = union([object({ kind: literal("unset") }), object({
-	kind: literal("value"),
-	value: json
-})]);
-var mapping = union([fixedInput, object({
-	kind: literal("sources"),
-	sources: array(source)
-})]);
-var inputs = record(text, mapping);
-var ports = {
-	inputs: array(union([input, group])),
-	outputs: array(union([port, group]))
+//#endregion
+//#region src/json-schema-subset/expression/expression.ts
+var expression = (delegate) => (e1, e2) => {
+	const rootNode = {
+		parent: null,
+		swapped: false,
+		expressions: null,
+		calculation: {
+			operator: CalculatorOperator.Save,
+			results: [0],
+			willSwap: false,
+			count: 0
+		}
+	};
+	const extendQueue = [{
+		parent: {
+			node: rootNode,
+			index: 0
+		},
+		swapped: false,
+		expressions: [e1, e2],
+		calculation: null
+	}];
+	const calculateQueue = [];
+	while (extendQueue.length > 0 || calculateQueue.length > 0) {
+		while (extendQueue.length > 0) extendNode(extendQueue.pop());
+		while (calculateQueue.length > 0) calculateNode(calculateQueue.pop());
+	}
+	function extendNode(node) {
+		let result = ExpressionEquals;
+		const [leftExpression, rightExpression] = node.expressions;
+		if (!delegate.equals(leftExpression, rightExpression)) {
+			const expression1 = delegate.describe(leftExpression);
+			if (expression1.kind !== ExpressionKind.Leaf) {
+				const [calculation, expressions] = expendExpression(expression1, false);
+				node.expressions = null;
+				node.calculation = calculation;
+				for (const [index, childExpression] of expressions.entries()) extendQueue.push({
+					parent: {
+						node,
+						index
+					},
+					swapped: node.swapped,
+					expressions: [childExpression, rightExpression],
+					calculation: null
+				});
+				return;
+			}
+			const expression2 = delegate.describe(rightExpression);
+			if (expression2.kind !== ExpressionKind.Leaf) {
+				const [calculation, expressions] = expendExpression(expression2, true);
+				node.expressions = null;
+				node.calculation = calculation;
+				for (const [index, childExpression] of expressions.entries()) extendQueue.push({
+					parent: {
+						node,
+						index
+					},
+					swapped: !node.swapped,
+					expressions: [childExpression, leftExpression],
+					calculation: null
+				});
+				return;
+			}
+			result = delegate.calculate(leftExpression, rightExpression);
+			delegate.observeCalculation?.(leftExpression, rightExpression, result, node.swapped);
+			if (result === 0) throw new Error("cannot response expression as none");
+		}
+		node.expressions = null;
+		node.calculation = {
+			operator: CalculatorOperator.Save,
+			results: [result],
+			willSwap: false,
+			count: 0
+		};
+		calculateQueue.push(node);
+	}
+	function expendExpression(description, willSwap) {
+		let operator = CalculatorOperator.Save;
+		let expressions;
+		switch (description.kind) {
+			case ExpressionKind.Not:
+				operator = CalculatorOperator.Not;
+				expressions = [description.expression];
+				break;
+			case ExpressionKind.AllOf:
+				operator = CalculatorOperator.AllOf;
+				expressions = [...description.expressions];
+				break;
+			case ExpressionKind.AnyOf:
+				operator = CalculatorOperator.AnyOf;
+				expressions = [...description.expressions];
+				break;
+			case ExpressionKind.OneOf:
+				operator = CalculatorOperator.OneOf;
+				expressions = [...description.expressions];
+				break;
+			default: throw new Error(`invalid kind ${description.kind}`);
+		}
+		return [{
+			operator,
+			willSwap,
+			count: 0,
+			results: Array(expressions.length).fill(-1)
+		}, expressions];
+	}
+	function calculateNode(node) {
+		const calculation = node.calculation;
+		const parent = node.parent;
+		let result = calculate(calculation.operator, calculation.results);
+		if (result === 0) result = ExpressionContainedBy;
+		if (calculation.willSwap) result = swap(result);
+		if (parent) {
+			const parentCalculation = parent.node.calculation;
+			const parentResults = parentCalculation.results;
+			parentResults[parent.index] = result;
+			parentCalculation.count += 1;
+			if (parentCalculation.count >= parentResults.length) calculateQueue.push(parent.node);
+		}
+	}
+	const result = rootNode.calculation.results[0];
+	if (result === 0) throw new Error("cannot find result of root");
+	return result;
 };
-var capability = union([
-	strictObject({
-		kind: literal("connector"),
-		action: text,
-		connectionId: text.optional(),
-		connections: array(strictObject({
-			connectionId: text,
-			alias: text.optional()
-		}))
-	}),
-	strictObject({
-		kind: literal("connector"),
-		mode: literal("shared")
-	}),
-	strictObject({
-		kind: literal("connector"),
-		mode: literal("independent"),
-		actions: array(strictObject({
-			action: text,
-			connectionId: text.optional()
-		}))
-	}),
-	strictObject({
-		kind: literal("connector"),
-		actionHints: array(text).optional(),
-		connectionHints: array(strictObject({
-			action: text,
-			connectionId: text,
-			alias: text.optional()
-		})).optional()
-	})
-]);
-var inline = object({
-	...ports,
-	name: text,
-	moduleId: text,
-	capabilities: array(capability).optional()
-});
-var agentValue = union([object({
-	kind: literal("value"),
-	value: json
-}), object({
-	kind: literal("input"),
-	input: text
-})]);
-var agentInput = union([agentValue, object({ kind: literal("model") })]);
-var managed = object({
-	...ports,
-	name: text,
-	executor: union([
-		object({
-			kind: literal("connector"),
-			action: text,
+//#endregion
+//#region src/json-schema-subset/error.ts
+var SchemaError = class extends Error {
+	constructor(items = []) {
+		super(createSchemaErrorMessage(items));
+		this.name = "SchemaError";
+		this.items = items;
+	}
+};
+var SchemaErrorItemKind = Object.freeze({
+	Compiled: 0,
+	External: 1
+});
+function stringifySchemaError(errorItem) {
+	switch (errorItem.kind) {
+		case SchemaErrorItemKind.Compiled: {
+			const { message, path } = errorItem;
+			return `${message} (at ${path.length > 0 ? path.join(".") : "$root"})`;
+		}
+		case SchemaErrorItemKind.External: return String(errorItem.error);
+	}
+}
+function createSchemaErrorMessage(items) {
+	switch (items.length) {
+		case 0: return "without any items";
+		case 1: return stringifySchemaError(items[0]);
+		default: return `${stringifySchemaError(items[0])} ... omit the rest ${items.length - 1} items`;
+	}
+}
+//#endregion
+//#region src/json-schema-subset/compiler/common.ts
+var jsonSchemaKeys = /* @__PURE__ */ new Set([
+	"type",
+	"enum",
+	"const",
+	"multipleOf",
+	"maximum",
+	"exclusiveMaximum",
+	"minimum",
+	"exclusiveMinimum",
+	"maxLength",
+	"minLength",
+	"pattern",
+	"items",
+	"additionalItems",
+	"maxItems",
+	"minItems",
+	"uniqueItems",
+	"contains",
+	"maxProperties",
+	"minProperties",
+	"required",
+	"properties",
+	"patternProperties",
+	"additionalProperties",
+	"dependencies",
+	"propertyNames",
+	"if",
+	"then",
+	"else",
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"not",
+	"format",
+	"contentMediaType",
+	"contentEncoding",
+	"definitions"
+]);
+function isJSONSchemaKey(key) {
+	return jsonSchemaKeys.has(key);
+}
+function isLogicEmptyObject(object) {
+	for (const key in object) if (isJSONSchemaKey(key)) return false;
+	return true;
+}
+function joinPath(context, ...extraPath) {
+	return {
+		...context,
+		path: [...context.path, ...extraPath]
+	};
+}
+function unwrapJSONSchema7Definition(schema) {
+	if (typeof schema === "boolean") throw new Error("JSONSchema7Definition cannot be boolean");
+	return schema;
+}
+function recordError({ path, errors }, message, ...extraPath) {
+	errors.push(createSchemaError(path, extraPath, message));
+}
+function recordWarn({ path, warns }, message, ...extraPath) {
+	warns.push(createSchemaError(path, extraPath, message));
+}
+function createSchemaError(path, extraPath, message) {
+	return {
+		kind: SchemaErrorItemKind.Compiled,
+		message,
+		path: [...path, ...extraPath]
+	};
+}
+//#endregion
+//#region src/json-schema-subset/compiler/utils.ts
+function cleanEmptyValues(origin) {
+	for (const key in origin) {
+		const value = origin[key];
+		if (value === void 0) delete origin[key];
+		else if (value && typeof value === "object") {
+			if (Array.isArray(value)) {
+				if (value.length === 0) delete origin[key];
+			} else if (isEmptyObject(value)) delete origin[key];
+		}
+	}
+	return origin;
+}
+function isEmptyObject(object) {
+	for (const _ in object) return false;
+	return true;
+}
+//#endregion
+//#region src/json-schema-subset/compiler/wrapper.ts
+var symbolID = Symbol("compiledId");
+var symbolKind = Symbol("compiledKind");
+var symbolPath = Symbol("compiledPath");
+var symbolValidatorLoader = Symbol("validatorLoader");
+var CompiledKind = Object.freeze({
+	Extends: 0,
+	Never: 1,
+	Any: 2,
+	Null: 3,
+	String: 4,
+	Numeric: 5,
+	Boolean: 6,
+	Object: 7,
+	Array: 8,
+	Not: 9,
+	Combination: 10,
+	EnumOrConst: 11
+});
+var ANY = deepFreeze(toCompiledSchema(CompiledKind.Any, createId(), {}, () => () => true));
+var NEVER = deepFreeze(toCompiledSchema(CompiledKind.Never, createId(), {
+	type: "string",
+	maxLength: 0,
+	minLength: 1
+}, () => () => false));
+function isCompiledObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	return symbolID in value;
+}
+function isCompiledSchema(object) {
+	if (object === null || typeof object !== "object") return false;
+	return symbolID in object && symbolKind in object;
+}
+function getKind(schema) {
+	if (isCompiledSchema(schema)) return schema[symbolKind];
+	else return CompiledKind.Extends;
+}
+function getId(schema) {
+	if (isCompiledSchema(schema) || isCompiledObject(schema)) return schema[symbolID];
+	else return schema.id;
+}
+function getPath(schema) {
+	return isCompiledSchema(schema) ? schema[symbolPath] : void 0;
+}
+function wrapCompiledValue(value) {
+	if (value === null || typeof value !== "object") return value;
+	Object.defineProperty(value, symbolID, {
+		value: createId(),
+		configurable: false,
+		writable: false,
+		enumerable: false
+	});
+	return value;
+}
+function wrapCompiledSchema(kind, schema, delegate, path = []) {
+	return toCompiledSchema(kind, createId(), schema, delegate && (() => {
+		return delegate.compile(schema);
+	}), path);
+}
+function toNever(schema) {
+	return toCompiledSchema(CompiledKind.Never, createId(), { ...schema }, schema[symbolValidatorLoader], schema[symbolPath]);
+}
+function toCompiledSchema(kind, id, schema, validatorLoader, path = []) {
+	let validator = null;
+	Object.defineProperties(schema, {
+		[symbolKind]: {
+			value: kind,
+			configurable: false,
+			writable: false,
+			enumerable: false
+		},
+		[symbolID]: {
+			value: id,
+			configurable: false,
+			writable: false,
+			enumerable: false
+		},
+		[symbolPath]: {
+			value: path,
+			configurable: false,
+			writable: false,
+			enumerable: false
+		},
+		[symbolValidatorLoader]: {
+			value: validatorLoader,
+			configurable: false,
+			writable: false,
+			enumerable: false
+		},
+		isValid: {
+			configurable: false,
+			enumerable: false,
+			get: () => {
+				if (validatorLoader) {
+					if (!validator) validator = validatorLoader();
+					return validator;
+				} else return;
+			}
+		}
+	});
+	return schema;
+}
+//#endregion
+//#region src/json-schema-subset/compiler/array.ts
+function compileArraySchema(context, schema) {
+	let items = compileItems(context, schema);
+	let maxItems = getItemsLimit(context, "maxItems", schema);
+	const minItems = getItemsLimit(context, "minItems", schema);
+	const contains = compileContains(context, schema);
+	const uniqueItems = schema.uniqueItems;
+	let additionalItems;
+	if (Array.isArray(items)) additionalItems = compileAdditionalItems(context, schema);
+	else if (schema.additionalItems) recordWarn(context, "it is needless when items is not array", "additionalItems");
+	if (!items || !contains || additionalItems === null) return null;
+	let isNever = false;
+	let updateMaxItems = false;
+	if (Array.isArray(items)) {
+		if (maxItems !== void 0 && maxItems <= items.length) {
+			items = items.splice(maxItems);
+			additionalItems = variableToNever(additionalItems, context.delegate);
+		}
+		const firstNeverItemIndex = items.findIndex((item) => getKind(item) === CompiledKind.Never);
+		if (firstNeverItemIndex !== -1) {
+			items = items.splice(firstNeverItemIndex);
+			additionalItems = variableToNever(additionalItems, context.delegate);
+			if (maxItems === void 0) {
+				maxItems = items.length;
+				updateMaxItems = true;
+			}
+		}
+		if (minItems !== void 0 && items.length < minItems) {
+			recordWarn(context, `length(${items.length}) of items if less than minItems(${minItems})`);
+			isNever = true;
+		}
+		if (items.length === 0 && additionalItems && getKind(additionalItems) === CompiledKind.Never) isNever = true;
+	} else if (getKind(items) === CompiledKind.Never) isNever = true;
+	if (maxItems !== void 0 && minItems !== void 0 && maxItems < minItems) {
+		if (!updateMaxItems) recordWarn(context, `maxItems(${maxItems}) is less than minItems(${minItems})`);
+		isNever = true;
+	}
+	return wrapCompiledSchema(isNever ? CompiledKind.Never : CompiledKind.Array, cleanEmptyValues({
+		type: "array",
+		items,
+		contains,
+		uniqueItems,
+		maxItems,
+		minItems,
+		additionalItems
+	}), context.delegate, context.path);
+}
+function compileItems(context, { items }) {
+	if (!items) return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	if (Array.isArray(items)) {
+		const schemas = [];
+		let hasAnyError = false;
+		for (const [i, item] of items.entries()) {
+			const schema = compileSchema(joinPath(context, "items", i), unwrapJSONSchema7Definition(item));
+			if (!schema) {
+				hasAnyError = true;
+				continue;
+			}
+			schemas.push(schema);
+		}
+		if (hasAnyError) return null;
+		return schemas;
+	} else return compileSchema(joinPath(context, "items"), unwrapJSONSchema7Definition(items));
+}
+function getItemsLimit(context, name, schema) {
+	const propertiesLimit = schema[name];
+	if (propertiesLimit === void 0) return;
+	if (Number.isNaN(propertiesLimit)) {
+		recordWarn(context, "find NaN", name);
+		return;
+	}
+	if (propertiesLimit < 0) {
+		recordWarn(context, `find invalid number ${propertiesLimit}`, name);
+		return;
+	}
+	return propertiesLimit;
+}
+function compileContains(context, { contains }) {
+	if (!contains) return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	return compileSchema(joinPath(context, "contains"), unwrapJSONSchema7Definition(contains));
+}
+function compileAdditionalItems(context, { additionalItems }) {
+	switch (typeof additionalItems) {
+		case "boolean": if (additionalItems) return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+		else return false;
+		case "object": return compileSchema(joinPath(context, "additionalItems"), additionalItems);
+		default: return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	}
+}
+function variableToNever(schema, delegate) {
+	if (schema === void 0) return wrapCompiledSchema(CompiledKind.Never, {
+		type: "string",
+		maxLength: 0,
+		minLength: 1
+	}, delegate);
+	else if (isCompiledSchema(schema)) return getKind(schema) === CompiledKind.Never ? schema : toNever(schema);
+	else return schema;
+}
+//#endregion
+//#region src/json-schema-subset/compiler/combination.ts
+var COMBINATION_KEYS = Object.freeze([
+	"allOf",
+	"anyOf",
+	"oneOf"
+]);
+function compileCombinationSchema(context, key, combinationList, delegate) {
+	if (combinationList.length === 0) {
+		recordError(context, "disable empty list", key);
+		return null;
+	}
+	const compiledCombinationList = [];
+	for (const [i, element] of combinationList.entries()) {
+		const compiledSchema = compileSchema(joinPath(context, key, i), unwrapJSONSchema7Definition(element));
+		if (compiledSchema) compiledCombinationList.push(compiledSchema);
+	}
+	if (compiledCombinationList.length < combinationList.length) return null;
+	let anyCount = 0;
+	let neverCount = 0;
+	for (const compiledSchema of compiledCombinationList) switch (getKind(compiledSchema)) {
+		case CompiledKind.Any:
+			anyCount += 1;
+			break;
+		case CompiledKind.Never: neverCount += 1;
+	}
+	let kind = CompiledKind.Combination;
+	switch (key) {
+		case "allOf":
+			if (neverCount > 0) kind = CompiledKind.Never;
+			else if (anyCount === compiledCombinationList.length) kind = CompiledKind.Any;
+			else if (!areAllTypesTheSame(compiledCombinationList)) kind = CompiledKind.Never;
+			break;
+		case "anyOf":
+			if (anyCount > 0) kind = CompiledKind.Any;
+			else if (neverCount === compiledCombinationList.length) kind = CompiledKind.Never;
+			break;
+		case "oneOf": if (anyCount > 1) kind = CompiledKind.Never;
+		else if (neverCount === compiledCombinationList.length) kind = CompiledKind.Never;
+		else if (anyCount === 1 && neverCount === compiledCombinationList.length - 1) kind = CompiledKind.Any;
+	}
+	return wrapCompiledSchema(kind, { [key]: compiledCombinationList }, delegate, context.path);
+}
+function areAllTypesTheSame(combinationList) {
+	let lastKind = null;
+	for (const schema of combinationList) {
+		const kind = getKind(schema);
+		switch (kind) {
+			case CompiledKind.Any:
+			case CompiledKind.Never: break;
+			default: if (lastKind === null) lastKind = kind;
+			else if (lastKind !== kind) return false;
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/json-schema-subset/checker/validator.ts
+var ValidResult = Object.freeze({
+	Valid: 0,
+	Invalid: 1,
+	Unknown: 2
+});
+function valid(compiledSchema, value) {
+	const isValid = compiledSchema.isValid;
+	if (isValid) {
+		if (isValid(value) === true) return ValidResult.Valid;
+		else return ValidResult.Invalid;
+	} else return ValidResult.Unknown;
+}
+//#endregion
+//#region src/json-schema-subset/compiler/enumAndConst.ts
+function compileEnumAndConst(context, enumList, constValue, schema) {
+	let compiledEnum;
+	let isNever = false;
+	if (enumList) {
+		if (enumList.length === 0) {
+			recordError(context, "disable empty list", "enum");
+			return null;
+		}
+		compiledEnum = [];
+		for (const [i, enumValue] of enumList.entries()) switch (valid(schema, enumValue)) {
+			case ValidResult.Valid:
+				compiledEnum.push(wrapCompiledValue(enumValue));
+				break;
+			case ValidResult.Invalid: recordWarn(context, "cannot pass JSON schema of currently schema object", "enum", i);
+		}
+		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
+	}
+	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (compiledEnum) {
+		if (compiledEnum.length === 0) isNever = true;
+		else if (constValue) {
+			let foundEquals = false;
+			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
+				foundEquals = true;
+				break;
+			}
+			if (!foundEquals) isNever = true;
+		}
+	}
+	const kind = isNever ? CompiledKind.Never : CompiledKind.EnumOrConst;
+	const compiledSchema = {};
+	if (schema.type) compiledSchema.type = schema.type;
+	if (compiledEnum) compiledSchema.enum = compiledEnum;
+	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
+}
+//#endregion
+//#region src/json-schema-subset/compiler/object.ts
+var OBJECT_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"maxProperties",
+	"minProperties",
+	"required",
+	"properties",
+	"patternProperties",
+	"additionalProperties",
+	"dependencies",
+	"propertyNames"
+]);
+function compileObjectSchema(context, schema) {
+	const rejectKeys = Object.keys(schema).filter((k) => !OBJECT_KEYS.has(k) && isJSONSchemaKey(k));
+	if (rejectKeys.length > 0) recordWarn(context, `type="object" will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+	const maxProperties = getPropertiesLimit(context, "maxProperties", schema);
+	const minProperties = getPropertiesLimit(context, "minProperties", schema);
+	const additionalPropertiesSchema = compileAdditionalProperties(context, schema);
+	const patternProperties = compilePatternProperties(context, schema);
+	const propertyNames = compilePropertyNames(context, schema);
+	const dependentTuple = compileDependencies(context, schema);
+	if (!additionalPropertiesSchema || !patternProperties || !propertyNames || !dependentTuple) return null;
+	const properties = compileProperties(context, patternProperties, propertyNames, schema);
+	if (!properties) return null;
+	const required = compileRequired(context, createBanKeyChecker(additionalPropertiesSchema, patternProperties, propertyNames, properties), dependentTuple, schema);
+	return wrapCompiledSchema(checkSchemaIsNever(context, additionalPropertiesSchema, properties, required, maxProperties, minProperties) ? CompiledKind.Never : CompiledKind.Object, cleanEmptyValues({
+		type: "object",
+		required,
+		properties,
+		minProperties,
+		maxProperties,
+		additionalProperties: additionalPropertiesSchema,
+		patternProperties: unwrapPatternProperties(patternProperties),
+		dependencies: mergeDependentTuple(dependentTuple, schema),
+		propertyNames
+	}), context.delegate, context.path);
+}
+function getPropertiesLimit(context, name, schema) {
+	const propertiesLimit = schema[name];
+	if (propertiesLimit === void 0) return;
+	if (Number.isNaN(propertiesLimit)) {
+		recordWarn(context, "find NaN", name);
+		return;
+	}
+	if (propertiesLimit < 0) {
+		recordWarn(context, `find invalid number ${propertiesLimit}`, name);
+		return;
+	}
+	return propertiesLimit;
+}
+function compileAdditionalProperties(context, { additionalProperties }) {
+	if (additionalProperties === false) return wrapCompiledSchema(CompiledKind.Never, {
+		type: "string",
+		maxLength: 0,
+		minLength: 1
+	}, context.delegate, context.path);
+	if (typeof additionalProperties !== "object") return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	return compileSchema(joinPath(context, "additionalProperties"), unwrapJSONSchema7Definition(additionalProperties));
+}
+function compilePatternProperties(context, { patternProperties }) {
+	let foundSubError = false;
+	const target = {};
+	for (const key in patternProperties) {
+		const regExp = wrapRegExp(key);
+		if (regExp instanceof Error) {
+			recordWarn(context, `property name invalid. ${key}`, "patternProperties", key);
+			continue;
+		}
+		const schema = unwrapJSONSchema7Definition(patternProperties[key]);
+		const compiledSchema = compileSchema(joinPath(context, "patternProperties", key), schema);
+		if (!compiledSchema) {
+			foundSubError = true;
+			continue;
+		}
+		target[key] = [compiledSchema, regExp];
+	}
+	if (foundSubError) return null;
+	return target;
+}
+function compilePropertyNames(context, { propertyNames }) {
+	if (!propertyNames) return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	propertyNames = unwrapJSONSchema7Definition(propertyNames);
+	const schema = compileSchema(joinPath(context, "propertyNames"), propertyNames);
+	if (!schema) return null;
+	const kind = getKind(schema);
+	if (kind !== CompiledKind.String && kind !== CompiledKind.Any) return toNever(schema);
+	return schema;
+}
+function compileProperties(context, patternProperties, propertyNamesSchema, { properties }) {
+	let foundSubError = false;
+	if (!properties) return {};
+	const target = {};
+	for (const key in properties) {
+		if (valid(propertyNamesSchema, key) === ValidResult.Invalid) {
+			recordWarn(context, `key ${JSON.stringify(key)} cannot pass JSON schema from propertyNames`, "properties");
+			continue;
+		}
+		const patternSchema = findPatternSchema(patternProperties, key);
+		if (patternSchema && getKind(patternSchema) === CompiledKind.Never) {
+			recordWarn(context, `key ${JSON.stringify(key)} matches a pattern that has a impossible(never) schema`, "properties");
+			continue;
+		}
+		const schema = unwrapJSONSchema7Definition(properties[key]);
+		const compiledSchema = compileSchema(joinPath(context, "properties", key), schema);
+		if (!compiledSchema) {
+			foundSubError = true;
+			continue;
+		}
+		target[key] = compiledSchema;
+	}
+	if (foundSubError) return null;
+	return target;
+}
+function compileDependencies(context, { dependencies }) {
+	if (!dependencies) return [{}, {}];
+	const dependentRequired = {};
+	const dependentSchemas = {};
+	for (const key in dependencies) {
+		const dependency = unwrapJSONSchema7Definition(dependencies[key]);
+		if (Array.isArray(dependency)) {
+			const { keys, duplicated } = checkUniqueKeys(dependency);
+			if (duplicated) recordWarn(context, `found duplicated property names: ${duplicated.join(", ")}`, "dependencies", key);
+			dependentRequired[key] = keys;
+		} else {
+			const compiledSchema = compileSchema(joinPath(context, "dependencies", key), dependency);
+			if (compiledSchema) {
+				const kind = getKind(compiledSchema);
+				if (kind === CompiledKind.Object || kind === CompiledKind.Any) dependentSchemas[key] = compiledSchema;
+				else if (kind === CompiledKind.Extends) dependentSchemas[key] = NEVER;
+				else dependentSchemas[key] = toNever(compiledSchema);
+			}
+		}
+	}
+	return [dependentRequired, dependentSchemas];
+}
+function createBanKeyChecker(additionalPropertiesSchema, patternProperties, propertyNamesSchema, properties) {
+	return (key) => {
+		if (valid(propertyNamesSchema, key) === ValidResult.Invalid) return true;
+		const patternSchema = findPatternSchema(patternProperties, key);
+		if (patternSchema && getKind(patternSchema) === CompiledKind.Never) return true;
+		if (getKind(properties[key] ?? additionalPropertiesSchema) === CompiledKind.Never) return true;
+		return false;
+	};
+}
+function compileRequired(context, isBan, dependentTuple, { required }) {
+	if (!required) return [];
+	const uniqueCheckedResult = checkUniqueKeys(required);
+	if (uniqueCheckedResult.duplicated) recordWarn(context, `found duplicated required keys: ${uniqueCheckedResult.duplicated.join(", ")}`, "required");
+	const requiredKeys = [];
+	const banKeys = [];
+	for (const requiredKey of uniqueCheckedResult.keys) if (collectDependencies(dependentTuple, requiredKey).some((key) => isBan(key))) banKeys.push(requiredKey);
+	else requiredKeys.push(requiredKey);
+	if (banKeys.length > 0) recordWarn(context, `key ${banKeys.map((k) => JSON.stringify(k)).join(", ")} will ban by another condition`, "required");
+	return requiredKeys;
+}
+function checkSchemaIsNever(context, additionalPropertiesSchema, properties, required, maxProperties, minProperties) {
+	if (maxProperties !== void 0 && minProperties !== void 0 && maxProperties < minProperties) {
+		recordWarn(context, `maxProperties(${maxProperties}) is less than minProperties(${minProperties})`);
+		return true;
+	}
+	if (maxProperties !== void 0 && required.length > maxProperties) {
+		recordWarn(context, `length(${required.length}) of required is greater than maxProperties(${maxProperties})`);
+		return true;
+	}
+	if (minProperties !== void 0 && required.length < minProperties) {
+		recordWarn(context, `length(${required.length}) of required is less than minProperties(${minProperties})`);
+		return true;
+	}
+	if (getKind(additionalPropertiesSchema) !== CompiledKind.Never) return false;
+	for (const key in properties) {
+		const compiledSchema = properties[key];
+		if (getKind(compiledSchema) !== CompiledKind.Never) return false;
+	}
+	return true;
+}
+function collectDependencies([dependentRequired, dependentSchemas], seedKey) {
+	const queue = [seedKey];
+	const collection = new Set(queue);
+	while (queue.length > 0) {
+		const key = queue.pop();
+		const schema = dependentSchemas[key];
+		const requiredKeys = dependentRequired[key];
+		if (schema) {
+			if (getKind(schema) === CompiledKind.Object) collectKeys(schema.required);
+		}
+		if (requiredKeys) collectKeys(requiredKeys);
+	}
+	function collectKeys(keys) {
+		if (keys) {
+			for (const key of keys) if (!collection.has(key)) {
+				collection.add(key);
+				queue.push(key);
+			}
+		}
+	}
+	return [...collection];
+}
+function checkUniqueKeys(keys) {
+	const checking = /* @__PURE__ */ new Set();
+	const duplicated = /* @__PURE__ */ new Set();
+	for (const e of keys) if (checking.has(e)) duplicated.add(e);
+	else checking.add(e);
+	if (duplicated.size === 0) return {
+		keys: [...keys],
+		duplicated: null
+	};
+	else return {
+		keys: [...checking],
+		duplicated: [...duplicated]
+	};
+}
+function findPatternSchema(patternProperties, checkedKey) {
+	for (const key in patternProperties) {
+		const [schema, regExp] = patternProperties[key];
+		if (regExp.test(checkedKey)) return schema;
+	}
+	return null;
+}
+function wrapRegExp(pattern) {
+	try {
+		return new RegExp(pattern, "i");
+	} catch (error) {
+		if (error instanceof SyntaxError) return error;
+		else throw error;
+	}
+}
+function unwrapPatternProperties(patternProperties) {
+	const target = {};
+	for (const key in patternProperties) target[key] = patternProperties[key][0];
+	return target;
+}
+function mergeDependentTuple([dependentRequired, dependentSchemas], { dependencies }) {
+	const target = {};
+	for (const key in dependencies) {
+		const required = dependentRequired[key];
+		const schema = dependentSchemas[key];
+		target[key] = required || schema;
+	}
+	return target;
+}
+//#endregion
+//#region src/json-schema-subset/compiler/primitive.ts
+var NUMERIC_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"multipleOf",
+	"maximum",
+	"exclusiveMaximum",
+	"minimum",
+	"exclusiveMinimum"
+]);
+var STRING_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"format",
+	"maxLength",
+	"minLength",
+	"pattern"
+]);
+function compilePrimitiveSchema(context, schema) {
+	const { type } = schema;
+	switch (type) {
+		case "number":
+		case "integer": return compileNumericSchema(context, schema);
+		case "string": return compileStringSchema(context, schema);
+		case "boolean":
+		case "null": {
+			const rejectKeys = Object.keys(schema).filter((k) => isJSONSchemaKey(k) && k !== "type");
+			if (rejectKeys.length > 0) recordWarn(context, `key "type" will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+			return wrapCompiledSchema(type === "null" ? CompiledKind.Null : CompiledKind.Boolean, { type }, context.delegate, context.path);
+		}
+		default:
+			recordError(context, `invalid type ${JSON.stringify(type)}`);
+			return null;
+	}
+}
+function compileNumericSchema(context, schema) {
+	const rejectKeys = Object.keys(schema).filter((k) => !NUMERIC_KEYS.has(k) && isJSONSchemaKey(k));
+	if (rejectKeys.length > 0) recordWarn(context, `type=${JSON.stringify(schema.type)} will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+	const compiledSchema = pick(schema, NUMERIC_KEYS);
+	for (const key of NUMERIC_KEYS) {
+		const value = compiledSchema[key];
+		if (key !== "type" && value !== void 0 && Number.isNaN(value)) {
+			recordWarn(context, "found NaN", key);
+			delete compiledSchema[key];
+		}
+	}
+	const { maximum, exclusiveMaximum, minimum, exclusiveMinimum } = compiledSchema;
+	if (maximum !== void 0 && exclusiveMaximum !== void 0) {
+		if (maximum === exclusiveMaximum) delete compiledSchema.maximum;
+		else if (maximum < exclusiveMaximum) delete compiledSchema.exclusiveMaximum;
+		else if (maximum > exclusiveMaximum) delete compiledSchema.maximum;
+	}
+	if (minimum !== void 0 && exclusiveMinimum !== void 0) {
+		if (minimum === exclusiveMinimum) delete compiledSchema.minimum;
+		else if (minimum < exclusiveMinimum) delete compiledSchema.exclusiveMinimum;
+		else if (minimum > exclusiveMinimum) delete compiledSchema.minimum;
+	}
+	const { multipleOf } = compiledSchema;
+	if (multipleOf === 0) {
+		delete compiledSchema.multipleOf;
+		compiledSchema.type = "number";
+		recordWarn(context, "cannot be 0", "multipleOf");
+	}
+	let kind = CompiledKind.Numeric;
+	if (!isNumericPossibleInvalid(compiledSchema)) kind = CompiledKind.Never;
+	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
+}
+function isNumericPossibleInvalid(compiledSchema) {
+	const { maximum, exclusiveMaximum, minimum, exclusiveMinimum } = compiledSchema;
+	if (maximum !== void 0 && minimum !== void 0) return maximum >= minimum;
+	else if (exclusiveMaximum !== void 0 && minimum !== void 0) return exclusiveMaximum > minimum;
+	else if (maximum !== void 0 && exclusiveMinimum !== void 0) return maximum > exclusiveMinimum;
+	else if (exclusiveMaximum !== void 0 && exclusiveMinimum !== void 0) return exclusiveMaximum > exclusiveMinimum;
+	else return true;
+}
+function compileStringSchema(context, schema) {
+	const rejectKeys = Object.keys(schema).filter((k) => !STRING_KEYS.has(k) && isJSONSchemaKey(k));
+	if (rejectKeys.length > 0) recordWarn(context, `type="string" will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+	const compiledSchema = pick(schema, STRING_KEYS);
+	cleanInvalidLength(context, compiledSchema, "maxLength");
+	cleanInvalidLength(context, compiledSchema, "minLength");
+	const max = compiledSchema.maxLength;
+	const min = compiledSchema.minLength;
+	let kind = CompiledKind.String;
+	if (max !== void 0) {
+		if (max < 0) kind = CompiledKind.Never;
+		else if (max !== void 0 && min !== void 0 && max < min) kind = CompiledKind.Never;
+	}
+	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
+}
+function cleanInvalidLength(context, compiledSchema, key) {
+	const length = compiledSchema[key];
+	if (length !== void 0) {
+		if (Number.isNaN(length)) {
+			recordWarn(context, "found NaN", key);
+			delete compiledSchema[key];
+		}
+	}
+}
+//#endregion
+//#region src/json-schema-subset/compiler/compiler.ts
+var emptyList = Object.freeze([]);
+function compile(schema, extendsContext, payload, delegate) {
+	if (isCompiledSchema(schema)) return {
+		schema,
+		warns: emptyList
+	};
+	if (extendsContext.isExtendsSchema(schema)) return {
+		schema,
+		warns: emptyList
+	};
+	if (delegate) {
+		const isSchemaResult = delegate.isSchema(schema);
+		if (typeof isSchemaResult === "object") {
+			const items = [];
+			for (const error of isSchemaResult) items.push({
+				kind: SchemaErrorItemKind.External,
+				error
+			});
+			if (items.length > 0) return items;
+		} else if (isSchemaResult === false) throw new Error("it is not a JSON Schema 7");
+	}
+	const context = {
+		delegate,
+		payload,
+		extends: extendsContext,
+		path: [],
+		errors: [],
+		warns: []
+	};
+	const compiledSchema = compileSchema(context, schema);
+	if (compiledSchema) assertCondition(context.errors.length === 0, "found errors (it should be empty)");
+	else {
+		assertCondition(context.errors.length > 0, "cannot found any errors");
+		return context.errors;
+	}
+	return {
+		schema: compiledSchema,
+		warns: context.warns
+	};
+}
+function assertCondition(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function compileSchema(context, schema) {
+	if (context.extends.isExtendsSchema(schema)) return schema;
+	if (isCompiledSchema(schema)) return schema;
+	const extendsSchema = context.extends.tryCompiledExtendsSchema(schema, context.payload);
+	if (extendsSchema) return extendsSchema;
+	let targetSchema = schema;
+	let shouldHandleEnumAndConst = false;
+	const { enum: enumList, const: constValue } = schema;
+	if (enumList || constValue) {
+		const { enum: _0, const: _1, ...rest } = schema;
+		targetSchema = rest;
+		shouldHandleEnumAndConst = true;
+	}
+	let compiledSchema = checkAndCompileSchema(context, targetSchema);
+	if (compiledSchema && shouldHandleEnumAndConst) compiledSchema = compileEnumAndConst(context, enumList, constValue, compiledSchema);
+	if (!compiledSchema) return null;
+	return compiledSchema;
+}
+function checkAndCompileSchema(context, schema) {
+	for (const key of COMBINATION_KEYS) {
+		const combinationList = schema[key];
+		if (combinationList) {
+			const rejectKeys = Object.keys(schema).filter((k) => isJSONSchemaKey(k) && k !== key);
+			if (rejectKeys.length > 0) recordWarn(context, `composition key ${JSON.stringify(key)} will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+			const compiledSchema = compileCombinationSchema(context, key, combinationList);
+			if (!compiledSchema) return null;
+			return compiledSchema;
+		}
+	}
+	{
+		const notSchema = unwrapJSONSchema7Definition(schema.not);
+		if (notSchema) {
+			const rejectKeys = Object.keys(schema).filter((k) => isJSONSchemaKey(k) && k !== "not");
+			if (rejectKeys.length > 0) recordWarn(context, `key "not" will exclude other keys: ${rejectKeys.toSorted().join(", ")}`);
+			const subSchema = compileSchema(joinPath(context, "not"), notSchema);
+			if (!subSchema) return null;
+			let kind = CompiledKind.Not;
+			switch (getKind(subSchema)) {
+				case CompiledKind.Never:
+					kind = CompiledKind.Any;
+					break;
+				case CompiledKind.Any: kind = CompiledKind.Never;
+			}
+			return wrapCompiledSchema(kind, { not: subSchema }, context.delegate, context.path);
+		}
+	}
+	if (schema.type) {
+		const { type } = schema;
+		if (Array.isArray(type)) {
+			const { type: _type, ...rest } = schema;
+			return compileCombinationSchema(context, "anyOf", type.map((item) => ({
+				...rest,
+				type: item
+			})));
+		}
+		switch (type) {
+			case "object": return compileObjectSchema(context, schema);
+			case "array": return compileArraySchema(context, schema);
+			default: return compilePrimitiveSchema(context, schema);
+		}
+	}
+	if (isLogicEmptyObject(schema)) return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path);
+	recordError(context, "unrecognized");
+	return null;
+}
+//#endregion
+//#region src/json-schema-subset/checker/tools/mark.ts
+var VariableBundleDescription = class {
+	constructor(_keys) {
+		const keys = Object.freeze(_keys.toSorted());
+		if (keys.length > 32) throw new Error(`cannot define ${keys.length} keys which is greater than 32`);
+		this.keys = keys;
+		this.clazz = class extends VariableBundleImpls {
+			constructor(int32) {
+				super(keys, int32);
+			}
+		};
+		for (const [i, key] of this.keys.entries()) {
+			const mask = 1 << i;
+			Object.defineProperty(this.clazz.prototype, key, {
+				enumerable: true,
+				get: function get() {
+					return !!(this.int32 & mask);
+				},
+				set: function set(value) {
+					if (value) this.int32 |= mask;
+					else this.int32 &= ~mask;
+				}
+			});
+		}
+	}
+	toBundle(variable) {
+		let int32 = 0;
+		if (typeof variable === "number") int32 = variable;
+		else if (variable) {
+			for (const [i, key] of this.keys.entries()) if (variable[key]) int32 |= 1 << i;
+		}
+		return new this.clazz(int32);
+	}
+};
+var VariableBundleImpls = class {
+	constructor(keys, int32) {
+		this.keys = keys;
+		this.int32 = int32;
+	}
+	toInt32() {
+		return this.int32;
+	}
+	toString() {
+		const object = {};
+		for (const key of this.keys) object[key] = this[key];
+		return JSON.stringify(object);
+	}
+};
+//#endregion
+//#region src/json-schema-subset/checker/tools/quantum.ts
+function makeQuantum(keys) {
+	return new QuantumImpls(keys);
+}
+var QuantumImpls = class {
+	constructor(keys) {
+		this.description = new VariableBundleDescription(keys);
+	}
+	get keys() {
+		return this.description.keys;
+	}
+	variable(variable) {
+		let int32;
+		if (variable) int32 = this.description.toBundle(variable).toInt32();
+		return new QuantumVariableImpls(this.description, int32);
+	}
+};
+var QuantumVariableImpls = class {
+	constructor(description, int32) {
+		this.values = /* @__PURE__ */ new Set();
+		this.description = description;
+		if (int32 !== void 0) this.values.add(int32);
+	}
+	[Symbol.iterator]() {
+		const iterator = this.values[Symbol.iterator]();
+		return { next: () => {
+			const result = iterator.next();
+			if (result.done) return result;
+			else return {
+				done: false,
+				value: this.description.toBundle(result.value)
+			};
+		} };
+	}
+	assign(other) {
+		const { values } = other;
+		for (const int32 of values) this.values.add(int32);
+		return this;
+	}
+	push(expression, calculate) {
+		const nextValues = /* @__PURE__ */ new Set();
+		for (const int32 of this.values) for (const [singleExpression, mask] of ExpressionMaskList) if (expression & mask) {
+			const variable = this.description.toBundle(int32);
+			calculate(singleExpression, variable);
+			nextValues.add(variable.toInt32());
+		}
+		this.values = nextValues;
+	}
+	update(invoker) {
+		const nextValues = /* @__PURE__ */ new Set();
+		for (const int32 of this.values) {
+			const variable = this.description.toBundle(int32);
+			invoker(variable);
+			nextValues.add(variable.toInt32());
+		}
+		this.values = nextValues;
+	}
+};
+//#endregion
+//#region src/json-schema-subset/checker/tools/range.ts
+function splitRange$3(range1, range2) {
+	const [min1] = range1;
+	const [min2] = range2;
+	if (min1.num < min2.num) return splitRangeLessBranch(range1, range2);
+	else if (min1.num > min2.num) return splitRangeGreaterBranch(range1, range2);
+	else return splitRangeEqualsBranch(range1, range2);
+}
+function splitRangeLessBranch(range1, range2) {
+	const [min1, max1] = range1;
+	const [min2, max2] = range2;
+	if (max1.num <= min2.num) {
+		const exclusive1 = max1.exclusive;
+		const exclusive2 = min2.exclusive;
+		if (max1.num < min2.num || exclusive1 || exclusive2) return {
+			left: {
+				fromLeft: true,
+				range: range1
+			},
+			right: {
+				fromLeft: false,
+				range: range2
+			}
+		};
+	}
+	if (max1.num <= max2.num) {
+		let hasRight = true;
+		let isLeftRangeOverride = false;
+		if (max1.num === max2.num) {
+			const exclusive1 = max1.exclusive;
+			const exclusive2 = max2.exclusive;
+			hasRight = exclusive1 !== exclusive2;
+			isLeftRangeOverride = !exclusive1 && exclusive2;
+		}
+		if (!isLeftRangeOverride) {
+			let right;
+			if (hasRight) right = {
+				fromLeft: false,
+				range: [reversalExclusive(max1), max2]
+			};
+			return {
+				left: {
+					fromLeft: true,
+					range: [min1, reversalExclusive(min2)]
+				},
+				center: [min2, max1],
+				right
+			};
+		}
+	}
+	return {
+		left: {
+			fromLeft: true,
+			range: [min1, reversalExclusive(min2)]
+		},
+		center: [min2, max2],
+		right: {
+			fromLeft: true,
+			range: [reversalExclusive(max2), max1]
+		}
+	};
+}
+function splitRangeGreaterBranch(range1, range2) {
+	const [min1, max1] = range1;
+	const [min2, max2] = range2;
+	if (min1.num >= max2.num) {
+		const exclusive1 = max2.exclusive;
+		const exclusive2 = min1.exclusive;
+		if (min1.num > max2.num || exclusive1 || exclusive2) return {
+			left: {
+				fromLeft: false,
+				range: range2
+			},
+			right: {
+				fromLeft: true,
+				range: range1
+			}
+		};
+	}
+	if (max2.num <= max1.num) {
+		let hasRight = true;
+		let isRightRangeOverride = false;
+		if (max1.num === max2.num) {
+			const exclusive1 = max2.exclusive;
+			const exclusive2 = max1.exclusive;
+			hasRight = exclusive1 !== exclusive2;
+			isRightRangeOverride = !exclusive1 && exclusive2;
+		}
+		if (!isRightRangeOverride) {
+			let right;
+			if (hasRight) right = {
+				fromLeft: true,
+				range: [reversalExclusive(max2), max1]
+			};
+			return {
+				left: {
+					fromLeft: false,
+					range: [min2, reversalExclusive(min1)]
+				},
+				center: [min1, max2],
+				right
+			};
+		}
+	}
+	return {
+		left: {
+			fromLeft: false,
+			range: [min2, reversalExclusive(min1)]
+		},
+		center: [min1, max1],
+		right: {
+			fromLeft: false,
+			range: [reversalExclusive(max1), max2]
+		}
+	};
+}
+function splitRangeEqualsBranch(range1, range2) {
+	const [min1, max1] = range1;
+	const [min2, max2] = range2;
+	const exclusive1 = min1.exclusive;
+	const exclusive2 = min2.exclusive;
+	let left;
+	let centerBegin = min1;
+	if (!exclusive1 && exclusive2) {
+		centerBegin = min2;
+		left = {
+			fromLeft: true,
+			range: [min1, reversalExclusive(min2)]
+		};
+	} else if (exclusive1 && !exclusive2) left = {
+		fromLeft: false,
+		range: [min2, reversalExclusive(min1)]
+	};
+	if (max1.num <= max2.num) {
+		let hasRight = true;
+		let isLeftRangeOverride = false;
+		if (max1.num === max2.num) {
+			const maxExclusive1 = max1.exclusive;
+			const maxExclusive2 = max2.exclusive;
+			hasRight = maxExclusive1 !== maxExclusive2;
+			isLeftRangeOverride = !maxExclusive1 && maxExclusive2;
+		}
+		if (!isLeftRangeOverride) {
+			let right;
+			if (hasRight) right = {
+				fromLeft: false,
+				range: [reversalExclusive(max1), max2]
+			};
+			return {
+				left,
+				center: [centerBegin, max1],
+				right
+			};
+		}
+	}
+	return {
+		left,
+		center: [centerBegin, max2],
+		right: {
+			fromLeft: true,
+			range: [reversalExclusive(max2), max1]
+		}
+	};
+}
+function reversalExclusive(point) {
+	return {
+		num: point.num,
+		exclusive: !point.exclusive
+	};
+}
+//#endregion
+//#region src/json-schema-subset/checker/range.ts
+var createRangeSplitter = (undefinedMin) => (min1 = undefinedMin, max1 = Number.POSITIVE_INFINITY, min2 = undefinedMin, max2 = Number.POSITIVE_INFINITY) => {
+	const { left, center, right } = splitRange$3([{
+		num: min1,
+		exclusive: false
+	}, {
+		num: max1,
+		exclusive: false
+	}], [{
+		num: min2,
+		exclusive: false
+	}, {
+		num: max2,
+		exclusive: false
+	}]);
+	let leftItem;
+	let rightItem;
+	let intersectionItem;
+	if (left) leftItem = {
+		min: left.range[0].num,
+		max: left.range[1].num,
+		isFrom1: left.fromLeft
+	};
+	if (right) rightItem = {
+		min: right.range[0].num,
+		max: right.range[1].num,
+		isFrom1: right.fromLeft
+	};
+	if (center) intersectionItem = {
+		min: center[0].num,
+		max: center[1].num
+	};
+	return {
+		left: leftItem,
+		right: rightItem,
+		intersection: intersectionItem
+	};
+};
+function toExpressionSingleResult({ left, right, intersection }) {
+	if (!intersection) return ExpressionSingleResult.Rejection;
+	let extra1 = false;
+	let extra2 = false;
+	if (left) {
+		if (left.isFrom1) extra1 = true;
+		else extra2 = true;
+	}
+	if (right) {
+		if (right.isFrom1) extra1 = true;
+		else extra2 = true;
+	}
+	if (extra1 && extra2) return ExpressionSingleResult.Intersection;
+	if (extra1) return ExpressionSingleResult.Containing;
+	if (extra2) return ExpressionSingleResult.ContainedBy;
+	return ExpressionSingleResult.Equals;
+}
+//#endregion
+//#region src/json-schema-subset/checker/array.ts
+var splitRange$2 = createRangeSplitter(0);
+var quantum$1 = makeQuantum([
+	"hasCommon",
+	"hasExtra1",
+	"hasExtra2",
+	"hasRejection",
+	"hasCommonBroken"
+]);
+function calculateArray({ calculate }, schema1, schema2) {
+	const splitResult = splitRange$2(schema1.minItems, schema1.maxItems, schema2.minItems, schema2.maxItems);
+	const splitExpression = toExpressionSingleResult(splitResult);
+	if (splitExpression === ExpressionSingleResult.Rejection) return ExpressionRejection;
+	const [items1, additionalItems1] = normalizeArray(schema1);
+	const [items2, additionalItems2] = normalizeArray(schema2);
+	const itemsLength = Math.max(items1.length, items2.length) + 1;
+	const length = Math.min(itemsLength, splitResult.intersection.max);
+	const quantumVariable = quantum$1.variable({});
+	const minItems = Math.min(schema1.minItems ?? 0, schema2.minItems ?? 0);
+	for (let i = 0; i < length; i++) {
+		const expression = calculate(items1[i] ?? additionalItems1, items2[i] ?? additionalItems2);
+		quantumVariable.push(expression, (singleExpression, variable) => {
+			switch (singleExpression) {
+				case ExpressionSingleResult.Equals:
+					if (!variable.hasRejection) variable.hasCommon = true;
+					break;
+				case ExpressionSingleResult.Containing:
+					if (!variable.hasRejection) variable.hasCommon = true;
+					variable.hasExtra1 = true;
+					break;
+				case ExpressionSingleResult.ContainedBy:
+					if (!variable.hasRejection) variable.hasCommon = true;
+					variable.hasExtra2 = true;
+					break;
+				case ExpressionSingleResult.Intersection:
+					if (!variable.hasRejection) variable.hasCommon = true;
+					variable.hasExtra1 = true;
+					variable.hasExtra2 = true;
+					break;
+				case ExpressionSingleResult.Rejection:
+					if (i < minItems) variable.hasCommonBroken = true;
+					variable.hasRejection = true;
+					variable.hasExtra1 = true;
+					variable.hasExtra2 = true;
+			}
+		});
+	}
+	quantumVariable.update((variable) => {
+		switch (splitExpression) {
+			case ExpressionSingleResult.Containing:
+				variable.hasExtra1 = true;
+				break;
+			case ExpressionSingleResult.ContainedBy:
+				variable.hasExtra2 = true;
+				break;
+			case ExpressionSingleResult.Intersection:
+				variable.hasExtra1 = true;
+				variable.hasExtra2 = true;
+		}
+		if (schema1.uniqueItems && !schema2.uniqueItems && (schema2.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra2 = true;
+		else if (!schema1.uniqueItems && schema2.uniqueItems && (schema1.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra1 = true;
+		if (schema1.maxItems === 0 || schema2.maxItems === 0) {
+			variable.hasCommon = true;
+			if (schema1.maxItems !== 0) variable.hasExtra1 = true;
+			if (schema2.maxItems !== 0) variable.hasExtra2 = true;
+		}
+	});
+	let expression = 0;
+	for (const { hasExtra1, hasExtra2, hasCommon, hasCommonBroken } of quantumVariable) {
+		let finalHasCommon = hasCommon;
+		if (hasCommonBroken) finalHasCommon = false;
+		if (!finalHasCommon) expression |= ExpressionRejection;
+		else if (hasExtra1 && hasExtra2) expression |= ExpressionIntersection;
+		else if (hasExtra1) expression |= ExpressionContaining;
+		else if (hasExtra2) expression |= ExpressionContainedBy;
+		else expression |= ExpressionEquals;
+	}
+	return expression;
+}
+function normalizeArray({ items, additionalItems }) {
+	if (Array.isArray(items)) return [items, additionalItems ?? ANY];
+	else return [[], items ?? ANY];
+}
+//#endregion
+//#region src/json-schema-subset/checker/cache.ts
+function wrapEqualsCheckerWithCache(check) {
+	const map = /* @__PURE__ */ new Map();
+	return (value1, value2) => {
+		const isObject1 = isCompiledObject(value1);
+		if (isObject1 !== isCompiledObject(value2)) return false;
+		if (!isObject1) return value1 === value2;
+		return getWithCache(map, value1, value2, check);
+	};
+}
+function wrapSchemaCalculatorWithCache(check) {
+	const map = /* @__PURE__ */ new Map();
+	return (schema1, schema2) => getWithCache(map, schema1, schema2, check);
+}
+function getWithCache(map, node1, node2, check) {
+	const key = `${getId(node1)}/${getId(node2)}`;
+	let result = map.get(key);
+	if (result === void 0) map.set(key, result = check(node1, node2));
+	return result;
+}
+//#endregion
+//#region src/json-schema-subset/checker/enumAndConst.ts
+function calculateEnumAndEnum(context, schema1, schema2) {
+	const enumList1 = normalizeEnumList(schema1);
+	const enumList2 = normalizeEnumList(schema2);
+	let foundExtra1 = false;
+	let foundExtra2 = false;
+	let foundIntersection = false;
+	for (const enum1 of enumList1) {
+		if (hasEqualsEnum(context, enumList2, enum1)) foundIntersection = true;
+		else foundExtra1 = true;
+		if (foundExtra1 && foundIntersection) break;
+	}
+	for (const enum2 of enumList2) {
+		if (hasEqualsEnum(context, enumList1, enum2)) foundIntersection = true;
+		else foundExtra2 = true;
+		if (foundExtra2 && foundIntersection) break;
+	}
+	if (!foundIntersection) return ExpressionRejection;
+	if (foundExtra1 && foundExtra2) return ExpressionIntersection;
+	if (foundExtra1) return ExpressionContaining;
+	if (foundExtra2) return ExpressionContainedBy;
+	return ExpressionEquals;
+}
+function calculateEnumAndSchema(enumSchema, schema) {
+	let hasValid = false;
+	let hasInvalid = false;
+	for (const enumValue of normalizeEnumList(enumSchema)) {
+		switch (valid(schema, enumValue)) {
+			case ValidResult.Valid:
+				hasValid = true;
+				break;
+			case ValidResult.Invalid:
+				hasInvalid = true;
+				break;
+			case ValidResult.Unknown: return ExpressionAny;
+		}
+		if (hasValid && hasInvalid) break;
+	}
+	if (hasValid && hasInvalid) return ExpressionIntersection;
+	if (hasValid) return ExpressionEquals | ExpressionContainedBy;
+	if (hasInvalid) return ExpressionRejection;
+	if (getKind(schema) === CompiledKind.Never) return ExpressionEquals;
+	return ExpressionContainedBy;
+}
+function normalizeEnumList({ const: constValue, enum: enumList }) {
+	if (constValue !== void 0) return [constValue];
+	if (enumList) return enumList;
+	throw new Error("invalid branch");
+}
+function hasEqualsEnum({ isEquals }, enumList, checkedEnum) {
+	for (const searchedEnum of enumList) if (isEquals(searchedEnum, checkedEnum)) return true;
+	return false;
+}
+//#endregion
+//#region src/json-schema-subset/checker/equals.ts
+function schemaEqualsChecker(extendsContext) {
+	function isSchemaEquals(schema1, schema2) {
+		const isExtends1 = extendsContext.isExtendsSchema(schema1);
+		const isExtends2 = extendsContext.isExtendsSchema(schema2);
+		if (isExtends1 || isExtends2) return extendsContext.equals(schema1, schema2);
+		else return isCompiledSchemaEquals(schema1, schema2);
+	}
+	const equalsMap = /* @__PURE__ */ new Map();
+	function isCompiledSchemaEquals(schema1, schema2) {
+		const id1 = getId(schema1);
+		const id2 = getId(schema2);
+		if (id1 === id2) return true;
+		const key = `${id1}/${id2}`;
+		let isEquals = equalsMap.get(key);
+		if (isEquals === void 0) {
+			isEquals = isObjectLikeEquals(schema1, schema2);
+			equalsMap.set(key, isEquals);
+		}
+		return isEquals;
+	}
+	function isObjectLikeEquals(object1, object2) {
+		if (Array.isArray(object1)) {
+			if (!Array.isArray(object2)) return false;
+			if (object1.length !== object2.length) return false;
+			for (const [i, value1Element] of object1.entries()) if (!isValueEquals(value1Element, object2[i])) return false;
+		} else {
+			if (Array.isArray(object2)) return false;
+			for (const key in object1) {
+				if (!(key in object2)) return false;
+				if (!isValueEquals(Reflect.get(object1, key), Reflect.get(object2, key))) return false;
+			}
+			for (const key in object2) if (!(key in object1)) return false;
+		}
+		return true;
+	}
+	function isValueEquals(value1, value2) {
+		if (value1 === value2) return true;
+		if (value1 === null) return false;
+		if (typeof value1 !== "object") return false;
+		if (typeof value1 !== typeof value2) return false;
+		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
+		return isObjectLikeEquals(value1, value2);
+	}
+	return isSchemaEquals;
+}
+//#endregion
+//#region src/json-schema-subset/checker/numeric/integerNormalizer.ts
+function normalizeInteger(schema) {
+	const floatRange = pickRange(schema);
+	const multipleOf = schema.multipleOf ?? 1;
+	const range = cutRange(floatRange, multipleOf);
+	if (!range) return null;
+	return {
+		multipleOf,
+		range
+	};
+}
+function isPointRange([point1, point2]) {
+	if (point1.num !== point2.num) return false;
+	if (point1.exclusive) return false;
+	if (point2.exclusive) return false;
+	return true;
+}
+function cutRange(range, multipleOf) {
+	if (!range) return;
+	const [originMin, originMax] = range;
+	let min = nextInteger(originMin.num, multipleOf);
+	let max = previousInteger(originMax.num, multipleOf);
+	if (min === originMin.num && originMin.exclusive) min += multipleOf;
+	if (max === originMax.num && originMax.exclusive) max -= multipleOf;
+	if (min > max) return;
+	if (min === max) {
+		if (min === Number.POSITIVE_INFINITY) return;
+		if (min === Number.NEGATIVE_INFINITY) return;
+	}
+	return [{
+		num: min,
+		exclusive: false
+	}, {
+		num: max,
+		exclusive: false
+	}];
+}
+function nextInteger(float, multipleOf) {
+	return Math.ceil(float / multipleOf) * multipleOf;
+}
+function previousInteger(float, multipleOf) {
+	return Math.floor(float / multipleOf) * multipleOf;
+}
+//#endregion
+//#region src/json-schema-subset/checker/numeric/float.ts
+function calculateFloat(schema1, schema2) {
+	const { left, right, center } = splitRange$3(pickRange(schema1), pickRange(schema2));
+	if (!center) return ExpressionRejection;
+	let extraLeft = false;
+	let extraRight = false;
+	if (left) {
+		if (left.fromLeft) extraLeft = true;
+		else extraRight = true;
+	}
+	if (right) {
+		if (right.fromLeft) extraLeft = true;
+		else extraRight = true;
+	}
+	if (extraLeft && extraRight) return ExpressionIntersection;
+	if (extraLeft) return ExpressionContaining;
+	if (extraRight) return ExpressionContainedBy;
+	return ExpressionEquals;
+}
+function calculateFloatAndInteger(schema1, schema2) {
+	const floatRange = pickRange(schema1);
+	const integer = normalizeInteger(schema2);
+	if (!integer) return ExpressionContaining;
+	const result = splitRange$3(floatRange, integer.range);
+	const intCenter = cutRange(result.center, integer.multipleOf);
+	const leftIntRange = unwrapAndCutRange(result.left, integer.multipleOf);
+	const rightIntRange = unwrapAndCutRange(result.right, integer.multipleOf);
+	if (!result.center) return ExpressionRejection;
+	let extraFloat = false;
+	let extraInteger = false;
+	if (result.left?.fromLeft) extraFloat = true;
+	if (result.right?.fromLeft) extraFloat = true;
+	if (!intCenter || !isPointRange(result.center)) extraFloat = true;
+	if (leftIntRange) extraInteger = true;
+	if (rightIntRange) extraInteger = true;
+	if (extraFloat && extraInteger) return ExpressionIntersection;
+	if (extraFloat) return ExpressionContaining;
+	if (extraInteger) return ExpressionContainedBy;
+	return ExpressionEquals;
+}
+function pickRange(schema) {
+	let point1;
+	let point2;
+	if (schema.exclusiveMinimum !== void 0) point1 = {
+		num: schema.exclusiveMinimum,
+		exclusive: true
+	};
+	else if (schema.minimum !== void 0) point1 = {
+		num: schema.minimum,
+		exclusive: false
+	};
+	else point1 = {
+		num: Number.NEGATIVE_INFINITY,
+		exclusive: true
+	};
+	if (schema.exclusiveMaximum !== void 0) point2 = {
+		num: schema.exclusiveMaximum,
+		exclusive: true
+	};
+	else if (schema.maximum !== void 0) point2 = {
+		num: schema.maximum,
+		exclusive: false
+	};
+	else point2 = {
+		num: Number.POSITIVE_INFINITY,
+		exclusive: true
+	};
+	return [point1, point2];
+}
+function unwrapAndCutRange(side, multipleOf) {
+	if (!side) return;
+	if (side.fromLeft) return;
+	return cutRange(side.range, multipleOf);
+}
+//#endregion
+//#region src/json-schema-subset/checker/numeric/integer.ts
+function calculateInteger(schema1, schema2) {
+	const integer1 = normalizeInteger(schema1);
+	const integer2 = normalizeInteger(schema2);
+	if (!integer1 && !integer2) return ExpressionEquals;
+	if (!integer1) return ExpressionContainedBy;
+	if (!integer2) return ExpressionContaining;
+	const { range: range1, multipleOf: multipleOf1 } = integer1;
+	const { range: range2, multipleOf: multipleOf2 } = integer2;
+	const result = splitRange$3(range1, range2);
+	let centerRange;
+	let lcm = 0;
+	if (result.center) {
+		lcm = getLCM(multipleOf1, multipleOf2);
+		centerRange = cutRange(result.center, lcm);
+	}
+	if (!centerRange) return ExpressionRejection;
+	let extraLeft = false;
+	let extraRight = false;
+	const { left, right } = result;
+	if (left && cutRange(left.range, left.fromLeft ? multipleOf1 : multipleOf2)) {
+		if (left.fromLeft) extraLeft = true;
+		else extraRight = true;
+	}
+	if (right && cutRange(right.range, right.fromLeft ? multipleOf1 : multipleOf2)) {
+		if (right.fromLeft) extraLeft = true;
+		else extraRight = true;
+	}
+	extraLeft = extraLeft || hasExtraIntegersOnCenter(integer1, centerRange, lcm);
+	extraRight = extraRight || hasExtraIntegersOnCenter(integer2, centerRange, lcm);
+	if (extraLeft && extraRight) return ExpressionIntersection;
+	if (extraLeft) return ExpressionContaining;
+	if (extraRight) return ExpressionContainedBy;
+	return ExpressionEquals;
+}
+function hasExtraIntegersOnCenter({ range, multipleOf }, lcmCenterRange, lcm) {
+	const result = splitRange$3(range, lcmCenterRange);
+	if (cutRange(result.left?.range, multipleOf)) return true;
+	if (cutRange(result.right?.range, multipleOf)) return true;
+	const center = cutRange(result.center, multipleOf);
+	if (!center) return false;
+	const lcmCenterLength = rangeLength(lcmCenterRange);
+	if (rangeLength(center) > lcmCenterLength) return true;
+	if (lcmCenterLength === 1) return false;
+	if (multipleOf < lcm) return true;
+	return false;
+}
+/** Returns the least common multiple. */
+function getLCM(a, b) {
+	return a * b / getGCD(a, b);
+}
+/** @returns The greatest common divisor. */
+function getGCD(a, b) {
+	if (a === 0) return b;
+	return getGCD(b % a, a);
+}
+function rangeLength(range) {
+	if (!range) return 0;
+	const [point1, point2] = range;
+	return point2.num - point1.num + 1;
+}
+//#endregion
+//#region src/json-schema-subset/checker/numeric/checker.ts
+function calculateNumeric(schema1, schema2) {
+	if (isUndefinedNumber(schema1) || isUndefinedNumber(schema2)) return ExpressionAny;
+	const isFloat1 = isFloat(schema1);
+	const isFloat2 = isFloat(schema2);
+	if (isFloat1 && isFloat2) return calculateFloat(schema1, schema2);
+	else if (isFloat1) return calculateFloatAndInteger(schema1, schema2);
+	else if (isFloat2) return swap(calculateFloatAndInteger(schema2, schema1));
+	else return calculateInteger(schema1, schema2);
+}
+function isUndefinedNumber(schema) {
+	const { multipleOf } = schema;
+	if (multipleOf === void 0) return false;
+	if (!Number.isInteger(multipleOf)) return true;
+	if (multipleOf < 0) return true;
+	return false;
+}
+function isFloat(schema) {
+	const { multipleOf } = schema;
+	if (multipleOf !== void 0 && Number.isInteger(multipleOf)) return false;
+	if (schema.type === "integer") return false;
+	return true;
+}
+//#endregion
+//#region src/json-schema-subset/checker/object.ts
+var splitRange$1 = createRangeSplitter(0);
+var quantum = makeQuantum([
+	"hasCommonInRequired",
+	"hasCommonOutRequired",
+	"hasExtra1",
+	"hasExtra2",
+	"hasRejection"
+]);
+function calculateObject(context, schema1, schema2) {
+	if (isPropertiesCountCannotMatch(schema1, schema2)) return ExpressionRejection;
+	const splitRequiredResult = splitRequired(schema1, schema2);
+	if (!splitRequiredResult) return ExpressionRejection;
+	const getProperty1 = createPropertySchemaGetter(schema1);
+	const getProperty2 = createPropertySchemaGetter(schema2);
+	const calculateKey = (key) => {
+		const propertySchema1 = getProperty1(key);
+		const propertySchema2 = getProperty2(key);
+		if (areNotBothNever(propertySchema1, propertySchema2)) return context.calculate(propertySchema1, propertySchema2);
+		else return 0;
+	};
+	const { commonRequired, extraRequired1, extraRequired2 } = splitRequiredResult;
+	const quantumVariable = quantum.variable({});
+	for (const requiredKey of [...commonRequired].toSorted()) quantumVariable.push(calculateKey(requiredKey), calculateCommonRequiredExpression);
+	for (const requiredKey of [...extraRequired1].toSorted()) quantumVariable.push(calculateKey(requiredKey), calculateExtraRequiredExpression1);
+	for (const requiredKey of [...extraRequired2].toSorted()) quantumVariable.push(calculateKey(requiredKey), calculateExtraRequiredExpression2);
+	const { hasOptional1, hasOptional2 } = splitRequiredResult;
+	if (hasOptional1 || hasOptional2) {
+		const calculator = calculateOptionalExpression(hasOptional1, hasOptional2);
+		for (const optionalKey of [...getOptionalKeys(schema1, schema2)].toSorted()) {
+			const expression = calculateKey(optionalKey);
+			if (expression !== 0) quantumVariable.push(expression, calculator);
+		}
+		const additionalProperties1 = schema1.additionalProperties ?? ANY;
+		const additionalProperties2 = schema2.additionalProperties ?? ANY;
+		if (areNotBothNever(additionalProperties1, additionalProperties2)) {
+			const expression = context.calculate(additionalProperties1, additionalProperties2);
+			quantumVariable.push(expression, calculator);
+		}
+	}
+	quantumVariable.update((variable) => {
+		if (!variable.hasRejection) {
+			if (extraRequired1.size > 0) variable.hasExtra2 = true;
+			if (extraRequired2.size > 0) variable.hasExtra1 = true;
+		}
+	});
+	const { requiredKeysCount } = splitRequiredResult;
+	let expression = 0;
+	for (const { hasExtra1, hasExtra2, hasCommonInRequired, hasCommonOutRequired, hasRejection } of quantumVariable) if (!hasCommonInRequired && requiredKeysCount > 0) expression |= ExpressionRejection;
+	else if (!hasCommonOutRequired && requiredKeysCount === 0) expression |= ExpressionRejection;
+	else if (hasRejection) expression |= ExpressionRejection;
+	else if (hasExtra1 && hasExtra2) expression |= ExpressionIntersection;
+	else if (hasExtra1) expression |= ExpressionContaining;
+	else if (hasExtra2) expression |= ExpressionContainedBy;
+	else expression |= ExpressionEquals;
+	return expression;
+}
+function isPropertiesCountCannotMatch(schema1, schema2) {
+	return toExpressionSingleResult(splitRange$1(schema1.minProperties, schema1.maxProperties, schema2.minProperties, schema2.maxProperties)) === ExpressionSingleResult.Rejection;
+}
+function splitRequired(schema1, schema2) {
+	const extraRequired1 = new Set(schema1.required);
+	const extraRequired2 = new Set(schema2.required);
+	const commonRequired = /* @__PURE__ */ new Set();
+	const wholeRequired = /* @__PURE__ */ new Set();
+	const requiredCount1 = extraRequired1.size;
+	const requiredCount2 = extraRequired2.size;
+	for (const key of extraRequired1) {
+		if (extraRequired2.has(key)) commonRequired.add(key);
+		wholeRequired.add(key);
+	}
+	for (const key of extraRequired2) {
+		if (extraRequired1.has(key)) commonRequired.add(key);
+		wholeRequired.add(key);
+	}
+	const requiredKeysCount = wholeRequired.size;
+	for (const key of commonRequired) {
+		extraRequired1.delete(key);
+		extraRequired2.delete(key);
+	}
+	const maxProperties1 = schema1.maxProperties ?? Number.MAX_SAFE_INTEGER;
+	const maxProperties2 = schema2.maxProperties ?? Number.MAX_SAFE_INTEGER;
+	if (requiredKeysCount > maxProperties1 || requiredKeysCount > maxProperties2) return null;
+	return {
+		requiredKeysCount,
+		extraRequired1,
+		extraRequired2,
+		commonRequired,
+		hasOptional1: maxProperties1 > requiredCount1,
+		hasOptional2: maxProperties2 > requiredCount2
+	};
+}
+function getOptionalKeys(schema1, schema2) {
+	const optionalKeys = new Set(schema1.required);
+	const properties1 = schema1.properties;
+	const properties2 = schema2.properties;
+	const required1 = schema1.required;
+	const required2 = schema2.required;
+	if (properties1) for (const key in properties1) optionalKeys.add(key);
+	if (properties2) for (const key in properties2) optionalKeys.add(key);
+	if (required1) for (const key of required1) optionalKeys.delete(key);
+	if (required2) for (const key of required2) optionalKeys.delete(key);
+	return optionalKeys;
+}
+var calculateCommonRequiredExpression = (singleExpression, variable) => {
+	switch (singleExpression) {
+		case ExpressionSingleResult.Equals:
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Containing:
+			variable.hasExtra1 = true;
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			variable.hasExtra2 = true;
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Intersection:
+			variable.hasExtra1 = true;
+			variable.hasExtra2 = true;
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Rejection: variable.hasRejection = true;
+	}
+};
+var calculateExtraRequiredExpression1 = (singleExpression, variable) => {
+	switch (singleExpression) {
+		case ExpressionSingleResult.Equals:
+		case ExpressionSingleResult.ContainedBy:
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Intersection:
+		case ExpressionSingleResult.Containing:
+			variable.hasExtra1 = true;
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Rejection: variable.hasRejection = true;
+	}
+};
+var calculateExtraRequiredExpression2 = (singleExpression, variable) => {
+	switch (singleExpression) {
+		case ExpressionSingleResult.Equals:
+		case ExpressionSingleResult.Containing:
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Intersection:
+		case ExpressionSingleResult.ContainedBy:
+			variable.hasExtra2 = true;
+			variable.hasCommonInRequired = true;
+			break;
+		case ExpressionSingleResult.Rejection: variable.hasRejection = true;
+	}
+};
+var calculateOptionalExpression = (hasOptional1, hasOptional2) => (singleExpression, variable) => {
+	if (variable.hasRejection) return;
+	let foundExtraPossibility1 = false;
+	let foundExtraPossibility2 = false;
+	let foundCommonPossibility = false;
+	switch (singleExpression) {
+		case ExpressionSingleResult.Equals:
+			foundCommonPossibility = true;
+			break;
+		case ExpressionSingleResult.Containing:
+			foundExtraPossibility1 = true;
+			foundCommonPossibility = true;
+			break;
+		case ExpressionSingleResult.ContainedBy:
+			foundExtraPossibility2 = true;
+			foundCommonPossibility = true;
+			break;
+		case ExpressionSingleResult.Intersection:
+			foundExtraPossibility1 = true;
+			foundExtraPossibility2 = true;
+			foundCommonPossibility = true;
+			break;
+		case ExpressionSingleResult.Rejection:
+			foundExtraPossibility1 = true;
+			foundExtraPossibility2 = true;
+	}
+	if (hasOptional1 && foundExtraPossibility1) variable.hasExtra1 = true;
+	if (hasOptional2 && foundExtraPossibility2) variable.hasExtra2 = true;
+	if (hasOptional1 && hasOptional2 && foundCommonPossibility) variable.hasCommonOutRequired = true;
+};
+function createPropertySchemaGetter(schema) {
+	const properties = schema.properties;
+	const propertyNames = schema.propertyNames;
+	const additionalProperties = schema.additionalProperties;
+	const patternProperties = [];
+	if (schema.patternProperties) for (const pattern in schema.patternProperties) {
+		const valueSchema = schema.patternProperties[pattern];
+		const regExp = new RegExp(pattern, "i");
+		patternProperties.push({
+			pattern: regExp,
+			schema: valueSchema
+		});
+	}
+	return (key) => {
+		if (propertyNames && valid(propertyNames, key) === ValidResult.Invalid) return NEVER;
+		for (const { pattern, schema: patternSchema } of patternProperties) if (pattern.test(key)) return patternSchema;
+		const propertySchema = (properties && properties[key]) ?? additionalProperties;
+		if (!propertySchema) return ANY;
+		return propertySchema;
+	};
+}
+function areNotBothNever(schema1, schema2) {
+	const kind1 = getKind(schema1);
+	const kind2 = getKind(schema2);
+	return kind1 !== CompiledKind.Never || kind2 !== CompiledKind.Never;
+}
+//#endregion
+//#region src/json-schema-subset/checker/string.ts
+var splitRange = createRangeSplitter(0);
+function calculateString(schema1, schema2) {
+	if (schema2.format && !schema1.format) return ExpressionContaining;
+	if (schema1.format && schema2.format && schema1.format !== schema2.format) return ExpressionAny;
+	const expression = toExpressionSingleResult(splitRange(schema1.minLength, schema1.maxLength, schema2.minLength, schema2.maxLength));
+	const hasPattern1 = !!schema1.pattern;
+	const hasPattern2 = !!schema2.pattern;
+	switch (expression) {
+		case ExpressionSingleResult.Rejection: return ExpressionRejection;
+		case ExpressionSingleResult.Containing: return hasPattern1 ? ExpressionAny : ExpressionContaining;
+		case ExpressionSingleResult.ContainedBy: return hasPattern2 ? ExpressionAny : ExpressionContainedBy;
+		case ExpressionSingleResult.Equals:
+			if (hasPattern1 && hasPattern2) return schema1.pattern === schema2.pattern ? ExpressionEquals : ExpressionAny;
+			if (hasPattern1) return ExpressionEquals | ExpressionContainedBy;
+			if (hasPattern2) return ExpressionEquals | ExpressionContaining;
+			return ExpressionEquals;
+		case ExpressionSingleResult.Intersection:
+			if (hasPattern1 && hasPattern2) return ExpressionAny;
+			if (hasPattern1) return ExpressionIntersection | ExpressionRejection | ExpressionContainedBy;
+			if (hasPattern2) return ExpressionIntersection | ExpressionRejection | ExpressionContaining;
+			return ExpressionIntersection;
+	}
+}
+//#endregion
+//#region src/json-schema-subset/checker/checker.ts
+function checkWithResult(extendsContext, schema1, schema2) {
+	const context = {};
+	const errorPaths = [];
+	const calculate = wrapSchemaCalculatorWithCache(calculator(extendsContext, context));
+	const describe = describer();
+	const equals = schemaEqualsChecker(extendsContext);
+	context.isEquals = wrapEqualsCheckerWithCache(isDeepEquals);
+	context.calculate = expression({
+		describe,
+		equals,
+		calculate,
+		observeCalculation: (left, right, result, swapped) => {
+			if (!isDecisiveMismatch(swapped ? swap(result) : result)) return;
+			const errorPath = swapped ? findMismatchPath(right, left) : findMismatchPath(left, right);
+			if (errorPath) errorPaths.push(errorPath);
+		}
+	});
+	Object.freeze(context);
+	const comparisonExpression = context.calculate(schema1, schema2);
+	return {
+		errorPath: errorPaths[0],
+		expression: comparisonExpression
+	};
+}
+var describer = () => (schema) => {
+	let description;
+	switch (getKind(schema)) {
+		case CompiledKind.Not:
+			description = {
+				kind: ExpressionKind.Not,
+				expression: schema.not
+			};
+			break;
+		case CompiledKind.Combination:
+			if ("allOf" in schema) description = {
+				kind: ExpressionKind.AllOf,
+				expressions: rejectInSchemaList(schema.allOf, CompiledKind.Any)
+			};
+			else if ("anyOf" in schema) description = {
+				kind: ExpressionKind.AnyOf,
+				expressions: rejectInSchemaList(schema.anyOf, CompiledKind.Never)
+			};
+			else if ("oneOf" in schema) description = {
+				kind: ExpressionKind.OneOf,
+				expressions: rejectInSchemaList(schema.oneOf, CompiledKind.Never)
+			};
+			else throw new Error(`invalid combination JSON Schema: ${JSON.stringify(schema)}`);
+			break;
+		default: description = { kind: ExpressionKind.Leaf };
+	}
+	return description;
+};
+var calculator = (extendsContext, context) => (schema1, schema2) => {
+	const kind1 = getKind(schema1);
+	const kind2 = getKind(schema2);
+	if (kind1 === CompiledKind.Extends || kind2 === CompiledKind.Extends) return extendsContext.calculate(schema1, schema2);
+	switch (kind1) {
+		case CompiledKind.Any: return kind2 === CompiledKind.Any ? ExpressionEquals : ExpressionContaining;
+		case CompiledKind.Never: return kind2 === CompiledKind.Never ? ExpressionEquals : ExpressionContainedBy;
+	}
+	switch (kind2) {
+		case CompiledKind.Any: return ExpressionContainedBy;
+		case CompiledKind.Never: return ExpressionContaining;
+	}
+	if (kind1 === CompiledKind.EnumOrConst && kind2 === CompiledKind.EnumOrConst) return calculateEnumAndEnum(context, schema1, schema2);
+	if (kind1 === CompiledKind.EnumOrConst) return calculateEnumAndSchema(schema1, schema2);
+	if (kind2 === CompiledKind.EnumOrConst) return swap(calculateEnumAndSchema(schema2, schema1));
+	if (kind1 !== kind2) return ExpressionRejection;
+	switch (kind1) {
+		case CompiledKind.Null: return ExpressionEquals;
+		case CompiledKind.Numeric: return calculateNumeric(schema1, schema2);
+		case CompiledKind.String: return calculateString(schema1, schema2);
+		case CompiledKind.Boolean: return ExpressionEquals;
+		case CompiledKind.Object: return calculateObject(context, schema1, schema2);
+		case CompiledKind.Array: return calculateArray(context, schema1, schema2);
+		default: throw new Error(`invalid kind ${kind1}`);
+	}
+};
+function rejectInSchemaList(schemaList, kind) {
+	return schemaList.filter((e) => getKind(e) !== kind);
+}
+function isDecisiveMismatch(result) {
+	return !hasEquals(result) && !hasContainedBy(result) && (hasContaining(result) || hasIntersection(result) || hasRejection(result));
+}
+function findMismatchPath(source, target) {
+	const targetPath = getPath(target);
+	if (!targetPath) return void 0;
+	const sourceKind = getKind(source);
+	const targetKind = getKind(target);
+	if (sourceKind !== targetKind) return [...targetPath, "type"];
+	const sourceSchema = source;
+	const targetSchema = target;
+	switch (targetKind) {
+		case CompiledKind.String:
+			if ((sourceSchema.minLength ?? 0) < (targetSchema.minLength ?? 0)) return [...targetPath, "minLength"];
+			if ((sourceSchema.maxLength ?? Number.POSITIVE_INFINITY) > (targetSchema.maxLength ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxLength"];
+			if (sourceSchema.pattern !== targetSchema.pattern && targetSchema.pattern) return [...targetPath, "pattern"];
+			if (sourceSchema.format !== targetSchema.format && targetSchema.format) return [...targetPath, "format"];
+			break;
+		case CompiledKind.Numeric:
+			if ((sourceSchema.minimum ?? sourceSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) < (targetSchema.minimum ?? targetSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY)) return [...targetPath, targetSchema.exclusiveMinimum == null ? "minimum" : "exclusiveMinimum"];
+			if ((sourceSchema.maximum ?? sourceSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY) > (targetSchema.maximum ?? targetSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY)) return [...targetPath, targetSchema.exclusiveMaximum == null ? "maximum" : "exclusiveMaximum"];
+			if (sourceSchema.multipleOf !== targetSchema.multipleOf && targetSchema.multipleOf != null) return [...targetPath, "multipleOf"];
+			break;
+		case CompiledKind.Array:
+			if ((sourceSchema.minItems ?? 0) < (targetSchema.minItems ?? 0)) return [...targetPath, "minItems"];
+			if ((sourceSchema.maxItems ?? Number.POSITIVE_INFINITY) > (targetSchema.maxItems ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxItems"];
+			if (!sourceSchema.uniqueItems && targetSchema.uniqueItems) return [...targetPath, "uniqueItems"];
+			break;
+		case CompiledKind.Object: {
+			const sourceRequired = new Set(sourceSchema.required ?? []);
+			if ((targetSchema.required ?? []).some((key) => !sourceRequired.has(key))) return [...targetPath, "required"];
+			if ((sourceSchema.minProperties ?? 0) < (targetSchema.minProperties ?? 0)) return [...targetPath, "minProperties"];
+			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
+			break;
+		}
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+	}
+	return targetPath;
+}
+//#endregion
+//#region src/json-schema-subset/extends/extendsContext.ts
+var ExtendsContext = class ExtendsContext {
+	constructor(extendsSchemaClasses = []) {
+		this.extendsSchemaClasses = Object.freeze([...extendsSchemaClasses]);
+	}
+	tryCompiledExtendsSchema(target, payload) {
+		for (const extendsSchemaClass of this.extendsSchemaClasses) if (extendsSchemaClass.isMatch(target)) return new extendsSchemaClass(createId(), target, payload);
+		return null;
+	}
+	isExtendsSchema(target) {
+		for (const extendsSchemaClass of this.extendsSchemaClasses) if (target instanceof extendsSchemaClass) return true;
+		return false;
+	}
+	calculate(schema1, schema2) {
+		const shouldSwap = !(schema1 instanceof this.findMatchedClass(schema1, schema2));
+		let expressionResult = 0;
+		let result;
+		if (shouldSwap) result = schema2.compare(schema1);
+		else result = schema1.compare(schema2);
+		for (let expression of result) {
+			if (shouldSwap) expression = ExtendsContext.swap(expression);
+			expressionResult |= toExpression(expression);
+		}
+		return expressionResult;
+	}
+	equals(schema1, schema2) {
+		if (!(schema1 instanceof this.findMatchedClass(schema1, schema2))) return schema2.equals(schema1);
+		else return schema1.equals(schema2);
+	}
+	findMatchedClass(schema1, schema2) {
+		for (const schemaClass of this.extendsSchemaClasses) {
+			if (schema1 instanceof schemaClass) return schemaClass;
+			if (schema2 instanceof schemaClass) return schemaClass;
+		}
+		throw new Error("Invalid schema");
+	}
+	static swap(expression) {
+		switch (expression) {
+			case ExpressionSingleResult.Containing: return ExpressionSingleResult.ContainedBy;
+			case ExpressionSingleResult.ContainedBy: return ExpressionSingleResult.Containing;
+			default: return expression;
+		}
+	}
+};
+//#endregion
+//#region src/json-schema-subset/preprocessing.ts
+function preprocessSchema(schema, compile, printWarnLog = false) {
+	const schemaResult = compile(schema);
+	if (Array.isArray(schemaResult)) {
+		const errorItems = [];
+		collectWithPathPrefix(errorItems, schemaResult, "$");
+		throw new SchemaError(errorItems);
+	}
+	const { schema: compiledSchema, warns } = schemaResult;
+	if (printWarnLog && warns.length > 0) {
+		console.warn(`found ${warns.length} warns after compile schema`);
+		for (const warn of warns) console.warn(stringifySchemaError(warn));
+	}
+	return compiledSchema;
+}
+function preprocessSchemasPair(schema1, schema2, compile, printWarnLog = false) {
+	const schemaResult1 = compile(schema1);
+	const schemaResult2 = compile(schema2);
+	if (Array.isArray(schemaResult1) || Array.isArray(schemaResult2)) {
+		const errorItems = [];
+		if (Array.isArray(schemaResult1)) collectWithPathPrefix(errorItems, schemaResult1, "$1");
+		if (Array.isArray(schemaResult2)) collectWithPathPrefix(errorItems, schemaResult2, "$2");
+		throw new SchemaError(errorItems);
+	}
+	const { schema: compiledSchema1, warns: superWarns } = schemaResult1;
+	const { schema: compiledSchema2, warns: subWarns } = schemaResult2;
+	if (printWarnLog) {
+		if (superWarns.length > 0) console.warn(`found ${superWarns.length} warns after compile superSchema`);
+		for (const warn of superWarns) console.warn(stringifySchemaError(warn));
+		if (subWarns.length > 0) console.warn(`found ${subWarns.length} warns after compile subSchema`);
+		for (const warn of subWarns) console.warn(stringifySchemaError(warn));
+	}
+	return [compiledSchema1, compiledSchema2];
+}
+function collectWithPathPrefix(errorItems, compiledItems, prefix) {
+	for (const compiledItem of compiledItems) {
+		const replacedItem = {
+			...compiledItem,
+			path: [prefix, ...compiledItem.path]
+		};
+		errorItems.push(replacedItem);
+	}
+}
+//#endregion
+//#region src/json-schema-subset/global.ts
+var SubsetCompareResult = Object.freeze({
+	True: 0,
+	False: 1,
+	Unknown: 2
+});
+function makeSubsetCompare({ extendsSchemaClasses, delegate } = {}) {
+	const extendsContext = new ExtendsContext(extendsSchemaClasses);
+	return Object.freeze({
+		compile: (schema, payload, printWarnLog) => {
+			const compiler = (candidate) => compile(candidate, extendsContext, payload, delegate);
+			return preprocessSchema(schema, compiler, printWarnLog);
+		},
+		isSubset: (superSchema, subSchema, printWarnLog = false) => {
+			const compiler = (candidate) => compile(candidate, extendsContext, void 0, delegate);
+			const [schema1, schema2] = preprocessSchemasPair(superSchema, subSchema, compiler, printWarnLog);
+			const { errorPath, expression } = checkWithResult(extendsContext, schema1, schema2);
+			const foundTrueExpression = hasEquals(expression) || hasContainedBy(expression);
+			const foundFalseExpression = hasContaining(expression) || hasIntersection(expression) || hasRejection(expression);
+			if (foundTrueExpression && !foundFalseExpression) return { result: SubsetCompareResult.True };
+			if (!foundTrueExpression && foundFalseExpression) return {
+				errorPath,
+				result: SubsetCompareResult.False
+			};
+			return { result: SubsetCompareResult.Unknown };
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@wopjs+cast@0.1.16/node_modules/@wopjs/cast/dist/index.mjs
+var isString = (x) => typeof x === "string";
+var isArray = Array.isArray;
+var isObject = (x) => x !== null && typeof x === "object";
+var isPlainObject = (x) => isObject(x) && !isArray(x);
+var toPlainObject = (x) => isPlainObject(x) ? x : void 0;
+//#endregion
+//#region src/manifest/common/schemaComparer.ts
+function isStringLikeSchema(value) {
+	return toPlainObject(value)?.type === "string";
+}
+function assertSchemaCompareContext(value) {
+	const context = toPlainObject(value);
+	const error = toPlainObject(context?.error);
+	if (context == null || error == null || context.packageId != null && !isString(context.packageId) || error.message != null && !isString(error.message)) throw new TypeError("Invalid schema comparison context.");
+}
+function parseSchemaCompareContext(value) {
+	if (value == null) return { error: {} };
+	assertSchemaCompareContext(value);
+	return value;
+}
+var SpecialSchema = class SpecialSchema {
+	static setError(fromSchema, toSchema, message) {
+		if (fromSchema instanceof SpecialSchema) fromSchema.context.error.message = message;
+		else if (toSchema instanceof SpecialSchema) toSchema.context.error.message = message;
+	}
+	constructor(id, value, context) {
+		this.id = id;
+		this.value = value;
+		this.context = parseSchemaCompareContext(context);
+	}
+	compare(other) {
+		if (isCompiledSchema(other) && getKind(other) === CompiledKind.Any) return [ExpressionSingleResult.ContainedBy];
+		return this.compareImpl(other);
+	}
+};
+var SingleSelectSchema = class SingleSelectSchema extends SpecialSchema {
+	static isMatch(value) {
+		const enumValues = toPlainObject(value)?.enum;
+		return Array.isArray(enumValues) && enumValues.every((v) => isString(v));
+	}
+	constructor(id, value, context) {
+		if (!SingleSelectSchema.isMatch(value)) throw new TypeError("Invalid single-select schema.");
+		super(id, value, context);
+	}
+	compareImpl(other) {
+		if (isStringLikeSchema(other)) return [ExpressionSingleResult.ContainedBy];
+		if (other instanceof SingleSelectSchema) {
+			const f = new Set(this.value.enum);
+			let result = ExpressionSingleResult.Equals;
+			for (const v of other.value.enum) {
+				if (!f.has(v)) result = ExpressionSingleResult.ContainedBy;
+				f.delete(v);
+			}
+			if (f.size === 0) return [result];
+			if (f.size === this.value.enum.length) return [ExpressionSingleResult.Rejection];
+			return [ExpressionSingleResult.Intersection];
+		}
+		return [ExpressionSingleResult.Rejection];
+	}
+	equals(other) {
+		if (other instanceof SingleSelectSchema) {
+			const f = new Set(this.value.enum);
+			for (const v of other.value.enum) {
+				if (!f.has(v)) return false;
+				f.delete(v);
+			}
+			return f.size === 0;
+		}
+		return false;
+	}
+};
+var BinarySchema = class BinarySchema extends SpecialSchema {
+	static isMatch(value) {
+		return toPlainObject(value)?.contentMediaType === "oomol/bin";
+	}
+	constructor(id, value, context) {
+		if (!BinarySchema.isMatch(value)) throw new TypeError("Invalid binary schema.");
+		super(id, value, context);
+	}
+	compareImpl(other) {
+		if (other instanceof BinarySchema) return [ExpressionSingleResult.Equals];
+		else {
+			SpecialSchema.setError(this, other, "edgeError.binDiffType");
+			return [ExpressionSingleResult.Rejection];
+		}
+	}
+	equals(other) {
+		return other instanceof BinarySchema;
+	}
+};
+var ArtifactSchema = class ArtifactSchema extends SpecialSchema {
+	static isMatch(value) {
+		return toPlainObject(value)?.contentMediaType === "oomol/artifact";
+	}
+	constructor(id, value, context) {
+		if (!ArtifactSchema.isMatch(value)) throw new TypeError("Invalid Artifact schema.");
+		super(id, value, context);
+	}
+	compareImpl(other) {
+		if (other instanceof ArtifactSchema) return [ExpressionSingleResult.Equals];
+		SpecialSchema.setError(this, other, "edgeError.artifactDiffType");
+		return [ExpressionSingleResult.Rejection];
+	}
+	equals(other) {
+		return other instanceof ArtifactSchema;
+	}
+};
+function createSchemaComparer() {
+	return makeSubsetCompare({ extendsSchemaClasses: [
+		SingleSelectSchema,
+		BinarySchema,
+		ArtifactSchema
+	] });
+}
+createSchemaComparer();
+//#endregion
+//#region src/decision/common/decision.ts
+var decisionLimits = {
+	choice: 255,
+	score: 10
+};
+/** Ordered prefixes are shared by authoring, schemas, validation, and execution. */
+function limitDecisionQuestion(question) {
+	if (question.type === "noul" || question.criteria.length <= decisionLimits[question.type]) return question;
+	if (question.type === "choice") return {
+		...question,
+		criteria: question.criteria.slice(0, decisionLimits.choice)
+	};
+	return {
+		...question,
+		criteria: question.criteria.slice(0, decisionLimits.score)
+	};
+}
+function limitDecisionQuestions(questions) {
+	const limited = questions.map(limitDecisionQuestion);
+	return limited.every((question, i) => question === questions[i]) ? questions : limited;
+}
+/** Loading an oversized task also updates its previously generated output schemas. */
+function limitDecisionTask(task) {
+	if (task.executor.kind !== "decision") return task;
+	const original = task.executor.questions;
+	const questions = limitDecisionQuestions(original);
+	if (questions === original) return task;
+	const outputs = task.outputs.map((port) => {
+		if (!("handle" in port)) return port;
+		const index = original.findIndex((question) => question.name === port.handle);
+		if (index < 0 || original[index] === questions[index] || !dequal(port.jsonSchema, answerSchema(original[index]))) return port;
+		return {
+			...port,
+			jsonSchema: decisionAnswerSchema(questions[index])
+		};
+	});
+	return {
+		...task,
+		executor: {
+			...task.executor,
+			questions
+		},
+		outputs
+	};
+}
+var probability = {
+	type: "number",
+	minimum: 0,
+	maximum: 1
+};
+function decisionAnswerSchema(question) {
+	return answerSchema(limitDecisionQuestion(question));
+}
+function answerSchema(question) {
+	const properties = { type: { const: question.type } };
+	if (question.type === "noul") properties.noul = probability;
+	else {
+		const keys = question.type === "choice" ? question.criteria.map((item) => item.name) : question.criteria.map((_, index) => String(index));
+		properties.confidence = probability;
+		properties.probabilities = {
+			type: "object",
+			properties: Object.fromEntries(keys.map((key) => [key, probability])),
+			required: keys,
+			additionalProperties: false
+		};
+		if (question.type === "choice") properties.choice = {
+			type: "string",
+			...keys.length ? { enum: keys } : {}
+		};
+		else {
+			properties.score = {
+				type: "number",
+				minimum: 0,
+				maximum: Math.max(0, keys.length - 1)
+			};
+			properties.legend = {
+				type: "object",
+				properties: Object.fromEntries(keys.map((key) => [key, { type: "string" }])),
+				required: keys,
+				additionalProperties: false
+			};
+		}
+	}
+	return {
+		type: "object",
+		properties,
+		required: Object.keys(properties)
+	};
+}
+function checkJsonDepth(value, depth = 0) {
+	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
+	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
+}
+//#endregion
+//#region src/flow/common/triggerScheduleSchema.ts
+var triggerScheduleSchema = array(union([object({
+	type: literal("cron"),
+	expression: string(),
+	timezone: string()
+}), object({
+	type: literal("every"),
+	unit: _enum([
+		"day",
+		"hour",
+		"minute",
+		"month",
+		"week"
+	]),
+	value: number()
+})]));
+//#endregion
+//#region src/flow/common/webhookMethod.ts
+var webhookMethods = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+//#endregion
+//#region src/flow/common/changeSchema.ts
+var currentFlowModelVersion = 5;
+var text = string();
+var json = json$1();
+var strings = array(text);
+var port = object({
+	description: text.optional(),
+	jsonSchema: json,
+	nullable: boolean(),
+	handle: text
+});
+var input = port.extend({ value: json.optional() });
+var group = object({
+	collapsed: boolean().optional(),
+	group: text
+});
+var nodeSource = object({
+	kind: literal("node"),
+	nodeId: text,
+	output: text,
+	field: text.optional()
+});
+var flowSource = object({
+	kind: literal("flow"),
+	input: text
+});
+var source = union([
+	nodeSource,
+	flowSource,
+	object({
+		kind: literal("binding"),
+		bindingId: text
+	})
+]);
+var fixedInput = union([object({ kind: literal("unset") }), object({
+	kind: literal("value"),
+	value: json
+})]);
+var mapping = union([fixedInput, object({
+	kind: literal("sources"),
+	sources: array(source)
+})]);
+var inputs = record(text, mapping);
+var ports = {
+	inputs: array(union([input, group])),
+	outputs: array(union([port, group]))
+};
+var capability = union([
+	strictObject({
+		kind: literal("connector"),
+		action: text,
+		connectionId: text.optional(),
+		connections: array(strictObject({
+			connectionId: text,
+			alias: text.optional()
+		}))
+	}),
+	strictObject({
+		kind: literal("connector"),
+		mode: literal("shared")
+	}),
+	strictObject({
+		kind: literal("connector"),
+		mode: literal("independent"),
+		actions: array(strictObject({
+			action: text,
+			connectionId: text.optional()
+		}))
+	}),
+	strictObject({
+		kind: literal("connector"),
+		actionHints: array(text).optional(),
+		connectionHints: array(strictObject({
+			action: text,
+			connectionId: text,
+			alias: text.optional()
+		})).optional()
+	})
+]);
+var inline = object({
+	...ports,
+	name: text,
+	moduleId: text,
+	capabilities: array(capability).optional()
+});
+var agentValue = union([object({
+	kind: literal("value"),
+	value: json
+}), object({
+	kind: literal("input"),
+	input: text
+})]);
+var agentInput = union([agentValue, object({ kind: literal("model") })]);
+var decisionQuestion = discriminatedUnion("type", [
+	strictObject({
+		name: text,
+		instructions: text,
+		type: literal("noul"),
+		criteria: strictObject({
+			true: text.optional(),
+			false: text.optional()
+		}).optional()
+	}),
+	strictObject({
+		name: text,
+		instructions: text,
+		type: literal("choice"),
+		criteria: array(strictObject({
+			name: text,
+			description: text
+		}))
+	}),
+	strictObject({
+		name: text,
+		instructions: text,
+		type: literal("score"),
+		criteria: strings
+	})
+]);
+var managed = object({
+	...ports,
+	name: text,
+	executor: union([
+		object({
+			kind: literal("connector"),
+			action: text,
 			connectionId: text.optional()
 		}),
 		object({
@@ -5966,6 +8914,10 @@ var managed = object({
 				in: _enum(["header", "query"]).optional()
 			}))
 		}),
+		strictObject({
+			kind: literal("decision"),
+			questions: array(decisionQuestion)
+		}),
 		object({
 			kind: literal("llm"),
 			mode: _enum(["chat", "json"])
@@ -5992,7 +8944,7 @@ var managed = object({
 			}).optional()
 		})
 	])
-});
+}).transform(limitDecisionTask);
 var operand = union([object({
 	kind: literal("value"),
 	value: json.optional(),
@@ -6386,6 +9338,11 @@ var shapes = {
 		before: text.optional(),
 		value: text.optional()
 	},
+	"task.decision.set": {
+		taskId: text,
+		before: managed,
+		value: managed
+	},
 	"task.openapi.set": {
 		taskId: text,
 		before: managed,
@@ -7147,6 +10104,16 @@ function applyFlowChanges(content, operations) {
 			document.tasks = tasks;
 			break;
 		}
+		case "task.decision.set": {
+			const task = document.tasks[operation.taskId];
+			if (task?.executor.kind != "decision" || operation.value.executor.kind != "decision") invalid("The AI Decision Task does not exist.");
+			if (!dequal(task, operation.before)) invalid("The AI Decision Task changed before this operation was applied.");
+			document.tasks = {
+				...document.tasks,
+				[operation.taskId]: operation.value
+			};
+			break;
+		}
 		case "task.openapi.set": {
 			const task = document.tasks[operation.taskId];
 			if (task?.executor.kind != "openapi" || operation.value.executor.kind != "openapi") invalid("The OpenAPI Task does not exist.");