@oomol-lab/open-flow 0.1.0-beta.61 → 0.1.0-beta.63

package/dist/common/control-api.js

@@ -1,36 +1,3 @@
-//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
-var has = Object.prototype.hasOwnProperty;
-function dequal(foo, bar) {
-	var ctor, len;
-	if (foo === bar) return true;
-	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-		if (ctor === Date) return foo.getTime() === bar.getTime();
-		if (ctor === RegExp) return foo.toString() === bar.toString();
-		if (ctor === Array) {
-			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
-			return len === -1;
-		}
-		if (!ctor || typeof foo === "object") {
-			len = 0;
-			for (ctor in foo) {
-				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
-			}
-			return Object.keys(bar).length === len;
-		}
-	}
-	return foo !== foo && bar !== bar;
-}
-//#endregion
-//#region src/openapi/common/authBindings.ts
-/** Never allow credentials to enter a Revision as literal node inputs. */
-function assertOpenApiAuthBindings(document) {
-	for (const node of Object.values(document.graph.nodes)) {
-		if (node.kind != "task" || !("executor" in node.task) || node.task.executor.kind != "openapi") continue;
-		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("OpenAPI authentication accepts deployment variables and upstream outputs only.");
-	}
-}
-//#endregion
 //#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -5371,7 +5338,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 		return required(ZodNonOptional, this, args[0]);
 	}
 });
-function object$1(shape, params) {
+function object(shape, params) {
 	return new ZodObject({
 		type: "object",
 		shape: shape ?? {},
@@ -5431,7 +5398,7 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record$3(keyType, valueType, params) {
+function record$2(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string$1(),
@@ -5679,7 +5646,7 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
-function json$4(params) {
+function json$3(params) {
 	const jsonSchema = lazy(() => {
 		return union([
 			string$1(params),
@@ -5687,7 +5654,7 @@ function json$4(params) {
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record$3(string$1(), jsonSchema)
+			record$2(string$1(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
@@ -5699,27 +5666,6 @@ function preprocess(fn, schema) {
 		out: schema
 	});
 }
-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$1({
-	type: literal("cron"),
-	expression: string$1(),
-	timezone: string$1()
-}), object$1({
-	type: literal("every"),
-	unit: _enum([
-		"day",
-		"hour",
-		"minute",
-		"month",
-		"week"
-	]),
-	value: number()
-})]));
 //#endregion
 //#region src/flow/common/webhookMethod.ts
 var webhookMethods = [
@@ -5732,702 +5678,148 @@ var webhookMethods = [
 function webhookSupportsBody(method) {
 	return method !== "GET";
 }
-var text = string$1();
-var json$3 = json$4();
-var strings$1 = array(text);
-var port$1 = object$1({
-	description: text.optional(),
-	jsonSchema: json$3,
-	nullable: boolean(),
-	handle: text
-});
-var input = port$1.extend({ value: json$3.optional() });
-var group = object$1({
-	collapsed: boolean().optional(),
-	group: text
-});
-var source = union([object$1({
-	kind: literal("node"),
-	nodeId: text,
-	output: text,
-	field: text.optional()
-}), object$1({
-	kind: literal("binding"),
-	bindingId: text
-})]);
-var fixedInput = union([object$1({ kind: literal("unset") }), object$1({
-	kind: literal("value"),
-	value: json$3
-})]);
-var mapping = union([fixedInput, object$1({
-	kind: literal("sources"),
-	sources: array(source)
-})]);
-var inputs = record$3(text, mapping);
-var ports$1 = {
-	inputs: array(union([input, group])),
-	outputs: array(union([port$1, 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()
-	})
+//#endregion
+//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
+			return len === -1;
+		}
+		if (!ctor || typeof foo === "object") {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+	return foo !== foo && bar !== bar;
+}
+//#endregion
+//#region src/openapi/common/authBindings.ts
+/** Never allow credentials to enter a Revision as literal node inputs. */
+function assertOpenApiAuthBindings(document) {
+	for (const node of Object.values(document.graph.nodes)) {
+		if (node.kind != "task" || !("executor" in node.task) || node.task.executor.kind != "openapi") continue;
+		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("OpenAPI authentication accepts deployment variables and upstream outputs only.");
+	}
+}
+//#endregion
+//#region src/flow/common/condition.ts
+var unaryOperator = (operator) => operator.startsWith("is");
+var operandHandle = (caseIndex, groupIndex, expressionIndex, side) => `${caseIndex}/${groupIndex}/${expressionIndex}/${side}`;
+/** Derived addresses let operand bindings use the ordinary input analysis and editor. Never persisted as node inputs. */
+function conditionOperands(node) {
+	return node.cases.flatMap((item, c) => item.groups.flatMap((group, g) => group.expressions.flatMap((expression, e) => [{
+		handle: operandHandle(c, g, e, "left"),
+		operand: expression.left,
+		expression,
+		side: "left"
+	}, ...!unaryOperator(expression.operator) ? [{
+		handle: operandHandle(c, g, e, "right"),
+		operand: expression.right ?? { kind: "value" },
+		expression,
+		side: "right"
+	}] : []])));
+}
+function conditionInputPorts(node) {
+	return Object.fromEntries(conditionOperands(node).map(({ handle, operand }) => [handle, {
+		jsonSchema: operand.kind === "value" ? operand.jsonSchema ?? {} : {},
+		nullable: operand.kind === "value" ? operand.value === null : true
+	}]));
+}
+//#endregion
+//#region src/flow/common/change.ts
+var schemaKeywords = /* @__PURE__ */ new Set([
+	"const",
+	"enum",
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"maximum",
+	"maxItems",
+	"maxLength",
+	"maxProperties",
+	"minimum",
+	"minItems",
+	"minLength",
+	"minProperties",
+	"multipleOf",
+	"pattern",
+	"required",
+	"type"
 ]);
-var inline = object$1({
-	...ports$1,
-	name: text,
-	moduleId: text,
-	capabilities: array(capability).optional()
-});
-var agentValue = union([object$1({
-	kind: literal("value"),
-	value: json$3
-}), object$1({
-	kind: literal("input"),
-	input: text
-})]);
-var agentInput = union([agentValue, object$1({ 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$1
-	})
-]);
-var managedFields = object$1({
-	...ports$1,
-	name: text,
-	executor: union([
-		object$1({
-			kind: literal("connector"),
-			action: text,
-			connectionId: text.optional()
-		}),
-		object$1({
-			kind: literal("openapi"),
-			sourceUrl: text,
-			method: text,
-			path: text,
-			serverUrl: text,
-			document: json$3,
-			auth: array(object$1({
-				id: text,
-				type: _enum([
-					"bearer",
-					"basic",
-					"apiKey"
-				]),
-				name: text.optional(),
-				in: _enum(["header", "query"]).optional()
-			}))
-		}),
-		strictObject({
-			kind: literal("decision"),
-			questions: array(decisionQuestion)
-		}),
-		object$1({
-			kind: literal("llm"),
-			mode: _enum(["chat", "json"])
-		}),
-		object$1({
-			kind: literal("agent"),
-			code: boolean().optional(),
-			model: text,
-			prompt: text,
-			maxRounds: number(),
-			tools: array(object$1({
-				id: text,
-				name: text,
-				description: text,
-				action: text,
-				connectionId: text.optional(),
-				approval: boolean(),
-				inputs: array(input.extend({ source: agentInput }))
-			})),
-			notification: object$1({
-				action: text,
-				connectionId: text.optional(),
-				inputDefinitions: array(input),
-				messageHandle: text,
-				inputs: record$3(text, agentValue)
-			}).optional()
-		})
-	])
-});
-var managed = managedFields.transform(limitDecisionTask);
-var operand$1 = union([object$1({
-	kind: literal("value"),
-	value: json$3.optional(),
-	jsonSchema: json$3.optional()
-}), object$1({
-	kind: literal("source"),
-	source
-})]);
-var condition = {
-	matchMode: _enum(["first", "all"]),
-	cases: array(object$1({
-		description: text.optional(),
-		output: text,
-		groups: array(object$1({ expressions: array(object$1({
-			left: operand$1,
-			operator: _enum([
-				"!=",
-				"<",
-				"<=",
-				"==",
-				">",
-				">=",
-				"contains",
-				"endsWith",
-				"hasKey",
-				"hasValue",
-				"isEmpty",
-				"isFalse",
-				"isNotEmpty",
-				"isNotNull",
-				"isNull",
-				"isTrue",
-				"notContains",
-				"notHasKey",
-				"notHasValue",
-				"startsWith"
-			]),
-			right: operand$1.optional()
-		})) }))
-	}))
-};
-var wait = {
-	inputDefinitions: array(input),
-	prompt: text
-};
-var webhookOptions = object$1({
-	allowedMethods: never().optional(),
-	allowedOrigins: strings$1.optional(),
-	noResponseBody: never().optional(),
-	responseData: text.optional(),
-	responseHeaders: record$3(text, text).optional(),
-	responseStatusCode: number().int().min(200).max(599).optional()
-});
-var webhook = {
-	bodyFields: array(input),
-	method: _enum(webhookMethods),
-	options: webhookOptions.optional()
-};
-var definition = {
-	configInputs: ports$1.inputs,
-	definitionVersion: literal(2),
-	description: text,
-	displayName: text,
-	key: text,
-	name: text,
-	outputs: array(port$1).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
-	provider: text
-};
-var endpoint = object$1({
-	body: object$1({
-		allowArray: boolean(),
-		allowEmpty: boolean(),
-		formats: array(_enum([
-			"form",
-			"json",
-			"multipart",
-			"text"
-		]))
-	}),
-	methods: array(_enum([
-		"DELETE",
-		"GET",
-		"HEAD",
-		"PATCH",
-		"POST",
-		"PUT"
-	])),
-	successStatus: number()
-});
-var sourceFlowIds = array(text.min(1)).refine((ids) => new Set(ids).size === ids.length, "Duplicate source Flow ID.");
-var trigger = {
-	name: text,
-	description: text.optional(),
-	icon: text.optional()
-};
-var base = {
-	maxExecutions: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-	inputs,
-	name: text.optional(),
-	description: text.optional(),
-	icon: text.optional(),
-	timeoutMs: number().optional()
-};
-var node = union([
-	object$1({
-		...base,
-		inputs: record$3(text, never()),
-		kind: literal("condition"),
-		...condition
-	}),
-	object$1({
-		...base,
-		inputs: unknown().transform(() => ({})).default({}),
-		kind: literal("value"),
-		values: array(input)
-	}),
-	object$1({
-		...base,
-		kind: literal("task"),
-		task: union([inline, managed]),
-		additionalInputs: array(input).optional()
-	}),
-	strictObject({
-		...base,
-		kind: literal("approval"),
-		...wait
-	}).omit({ timeoutMs: true }),
-	strictObject({
-		...base,
-		kind: literal("wait"),
-		...wait
-	}).omit({ timeoutMs: true }),
-	object$1({
-		...trigger,
-		kind: literal("manual")
-	}),
-	strictObject({
-		...trigger,
-		kind: literal("error"),
-		sourceFlowIds: sourceFlowIds.optional()
-	}),
-	object$1({
-		...trigger,
-		kind: literal("webhook"),
-		...webhook
-	}),
-	object$1({
-		...trigger,
-		kind: literal("cron"),
-		cronTimes: triggerScheduleSchema
-	}),
-	object$1({
-		...trigger,
-		kind: literal("poll"),
-		connectionId: text.min(1).optional(),
-		config: record$3(text, fixedInput),
-		definition: object$1({
-			...definition,
-			type: literal("poll")
-		}),
-		pollTimes: triggerScheduleSchema
-	}),
-	object$1({
-		...trigger,
-		kind: literal("integration"),
-		connectionId: text.min(1).optional(),
-		config: record$3(text, fixedInput),
-		definition: object$1({
-			...definition,
-			type: literal("integration"),
-			endpoint
-		})
-	})
-]);
-/** Configuration schemas shared by the node authoring boundary. */
-var authoringDefinitionSchemas = {
-	input,
-	port: port$1,
-	ports: ports$1,
-	condition: strictObject(condition),
-	wait: strictObject(wait),
-	webhook: strictObject(webhook),
-	schedule: triggerScheduleSchema,
-	capabilities: array(capability),
-	connector: managedFields.shape.executor.options[0].omit({ kind: true }).strict(),
-	openapi: managedFields.shape.executor.options[1].omit({ kind: true }).strict(),
-	decision: managedFields.shape.executor.options[2].omit({ kind: true }).strict(),
-	llm: managedFields.shape.executor.options[3].omit({ kind: true }).strict(),
-	agent: managedFields.shape.executor.options[4].omit({
-		kind: true,
-		notification: true
-	}).strict()
-};
-var edge = object$1({
-	source: text,
-	target: text,
-	sourceHandle: text.optional()
-});
-var at = {
-	nodeId: text,
-	target: never().optional()
-};
-var graph = object$1({
-	nodes: record$3(text, node),
-	edges: array(edge).default([])
-});
-var binding = object$1({
-	kind: literal("variable"),
-	target: text
-});
-var module = object$1({
-	name: text,
-	imports: strings$1,
-	source: text
-});
-var document = preprocess(rejectRetiredDefinitions, object$1({
-	bindings: record$3(text, binding),
-	graph
-}));
-var revision = object$1({
-	modelVersion: union([
-		literal(2),
-		literal(4),
-		literal(5),
-		literal(6)
-	]),
-	document,
-	modules: record$3(text, module)
-});
-revision.extend({
-	kind: literal("open-flow-flow-revision"),
-	version: literal(1)
-});
-function rejectRetiredDefinitions(value) {
-	const candidate = record$2(value);
-	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
-	if (Object.values(record$2(record$2(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record$2(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
-	const subflows = candidate.subflows;
-	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
-	if (Object.values(record$2(record$2(candidate.graph).nodes)).some((candidateNode) => record$2(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
-	return value;
-}
-function record$2(value) {
-	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
-}
-function decodeRevisionContent(value) {
-	checkJsonDepth(value);
-	const content = revision.parse(value);
-	checkModelVersion(content);
-	assertOpenApiAuthBindings(content.document);
-	return content;
-}
-var shapes = {
-	"graph.trigger.sources.set": {
-		nodeId: text,
-		before: sourceFlowIds.optional(),
-		value: sourceFlowIds.optional()
-	},
-	"binding.create": {
-		bindingId: text,
-		binding
-	},
-	"binding.delete": { bindingId: text },
-	"binding.target.set": {
-		bindingId: text,
-		before: text,
-		value: text
-	},
-	"graph.edge.connect": {
-		edge,
-		target: never().optional()
-	},
-	"graph.edge.disconnect": {
-		edge,
-		target: never().optional()
-	},
-	"graph.node.create": {
-		...at,
-		node
-	},
-	"graph.node.replace": {
-		...at,
-		before: node,
-		node
-	},
-	"graph.node.delete": at,
-	"graph.node.field.set": union([
-		object$1({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("connectionId"),
-			before: text.min(1).optional(),
-			value: text.min(1).optional()
-		}),
-		object$1({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: _enum([
-				"description",
-				"icon",
-				"name"
-			]),
-			before: text.optional(),
-			value: text.optional()
-		}),
-		object$1({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("maxExecutions"),
-			before: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
-			value: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
-		}),
-		object$1({
-			...at,
-			kind: literal("graph.node.field.set"),
-			field: literal("timeoutMs"),
-			before: number().optional(),
-			value: number().optional()
-		})
-	]),
-	"graph.node.input.set": {
-		...at,
-		handle: text,
-		before: mapping.optional(),
-		value: mapping.optional()
-	},
-	"graph.node.additional-inputs.set": {
-		...at,
-		before: array(input).optional(),
-		value: array(input).optional()
-	},
-	"graph.node.condition.set": {
-		...at,
-		before: object$1(condition),
-		value: object$1(condition)
-	},
-	"graph.node.values.set": {
-		...at,
-		before: array(input),
-		value: array(input)
-	},
-	"graph.node.resolution.set": {
-		...at,
-		before: object$1(wait),
-		value: object$1(wait)
-	},
-	"graph.node.webhook.set": {
-		...at,
-		before: object$1(webhook),
-		value: object$1(webhook)
-	},
-	"graph.node.task.ports.set": {
-		...at,
-		before: object$1(ports$1),
-		value: object$1(ports$1)
-	},
-	"graph.node.task.name.set": {
-		...at,
-		before: text,
-		value: text
-	},
-	"graph.node.task.capabilities.set": {
-		...at,
-		before: array(capability).optional(),
-		value: array(capability).optional()
-	},
-	"graph.trigger.config.set": {
-		nodeId: text,
-		name: text,
-		before: fixedInput.optional(),
-		value: fixedInput.optional()
-	},
-	"graph.trigger.schedule.set": {
-		nodeId: text,
-		before: triggerScheduleSchema,
-		value: triggerScheduleSchema
-	},
-	"module.create": {
-		moduleId: text,
-		module
-	},
-	"module.delete": { moduleId: text },
-	"module.rename": {
-		moduleId: text,
-		before: text,
-		name: text
-	},
-	"module.source.replace": {
-		moduleId: text,
-		beforeImports: strings$1,
-		beforeSource: text,
-		imports: strings$1,
-		source: text
-	},
-	"graph.node.task.set": {
-		...at,
-		before: union([inline, managed]),
-		value: union([inline, managed])
-	}
-};
-array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object$1({
-	kind: literal(kind),
-	...shape
-})])).values()])).min(1);
-function checkModelVersion(content) {
-	if (content.modelVersion < 6 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task)) throw new TypeError("Node-owned managed Tasks require Flow model version 6.");
-	if (content.modelVersion < 5 && Object.values(content.document.graph.nodes).some((itemNode) => itemNode.kind == "error")) throw new TypeError("Error workflows require Flow model version 5.");
-}
-//#endregion
-//#region src/flow/common/condition.ts
-var unaryOperator = (operator) => operator.startsWith("is");
-var operandHandle = (caseIndex, groupIndex, expressionIndex, side) => `${caseIndex}/${groupIndex}/${expressionIndex}/${side}`;
-/** Derived addresses let operand bindings use the ordinary input analysis and editor. Never persisted as node inputs. */
-function conditionOperands(node) {
-	return node.cases.flatMap((item, c) => item.groups.flatMap((group, g) => group.expressions.flatMap((expression, e) => [{
-		handle: operandHandle(c, g, e, "left"),
-		operand: expression.left,
-		expression,
-		side: "left"
-	}, ...!unaryOperator(expression.operator) ? [{
-		handle: operandHandle(c, g, e, "right"),
-		operand: expression.right ?? { kind: "value" },
-		expression,
-		side: "right"
-	}] : []])));
-}
-function nodeInputMappings(node) {
-	if (node.kind != "condition") return "inputs" in node ? node.inputs : {};
-	return Object.fromEntries(conditionOperands(node).flatMap(({ handle, operand }) => operand.kind == "source" ? [[handle, {
-		kind: "sources",
-		sources: [operand.source]
-	}]] : operand.value === void 0 ? [] : [[handle, {
-		kind: "value",
-		value: operand.value
-	}]]));
-}
-function conditionInputPorts(node) {
-	return Object.fromEntries(conditionOperands(node).map(({ handle, operand }) => [handle, {
-		jsonSchema: operand.kind === "value" ? operand.jsonSchema ?? {} : {},
-		nullable: operand.kind === "value" ? operand.value === null : true
-	}]));
-}
-//#endregion
-//#region src/flow/common/change.ts
-var schemaKeywords = /* @__PURE__ */ new Set([
-	"const",
-	"enum",
-	"exclusiveMaximum",
-	"exclusiveMinimum",
-	"maximum",
-	"maxItems",
-	"maxLength",
-	"maxProperties",
-	"minimum",
-	"minItems",
-	"minLength",
-	"minProperties",
-	"multipleOf",
-	"pattern",
-	"required",
-	"type"
-]);
-function isSchemaKeyword(value) {
-	return schemaKeywords.has(value);
-}
-function portsByHandle(ports) {
-	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
-}
-//#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/json-schema-subset/expression/result.ts
-var ExpressionSingleResult = Object.freeze({
-	Equals: 0,
-	Containing: 1,
-	ContainedBy: 2,
-	Rejection: 3,
-	Intersection: 4
+function isSchemaKeyword(value) {
+	return schemaKeywords.has(value);
+}
+function portsByHandle(ports) {
+	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
+}
+//#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/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);
@@ -7319,10 +6711,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		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 (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -7335,7 +6727,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -7730,7 +7122,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -8320,7 +7712,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === 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);
@@ -8476,1096 +7868,1353 @@ function calculateInteger(schema1, schema2) {
 		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);
+	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;
+	};
 }
-/** @returns The greatest common divisor. */
-function getGCD(a, b) {
-	if (a === 0) return b;
-	return getGCD(b % a, a);
+function areNotBothNever(schema1, schema2) {
+	const kind1 = getKind(schema1);
+	const kind2 = getKind(schema2);
+	return kind1 !== CompiledKind.Never || kind2 !== CompiledKind.Never;
 }
-function rangeLength(range) {
-	if (!range) return 0;
-	const [point1, point2] = range;
-	return point2.num - point1.num + 1;
+//#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/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);
+//#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$1({
+		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
+	};
 }
-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;
+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 isFloat(schema) {
-	const { multipleOf } = schema;
-	if (multipleOf !== void 0 && Number.isInteger(multipleOf)) return false;
-	if (schema.type === "integer") return false;
-	return true;
+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 === void 0 ? "enum" : "const"];
+	}
+	return targetPath;
 }
 //#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);
+//#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);
 		}
-		const additionalProperties1 = schema1.additionalProperties ?? ANY;
-		const additionalProperties2 = schema2.additionalProperties ?? ANY;
-		if (areNotBothNever(additionalProperties1, additionalProperties2)) {
-			const expression = context.calculate(additionalProperties1, additionalProperties2);
-			quantumVariable.push(expression, calculator);
+		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");
 	}
-	quantumVariable.update((variable) => {
-		if (!variable.hasRejection) {
-			if (extraRequired1.size > 0) variable.hasExtra2 = true;
-			if (extraRequired2.size > 0) variable.hasExtra1 = true;
+	static swap(expression) {
+		switch (expression) {
+			case ExpressionSingleResult.Containing: return ExpressionSingleResult.ContainedBy;
+			case ExpressionSingleResult.ContainedBy: return ExpressionSingleResult.Containing;
+			default: return expression;
 		}
-	});
-	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;
+	}
+};
+//#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 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);
+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);
 	}
-	for (const key of extraRequired2) {
-		if (extraRequired1.has(key)) commonRequired.add(key);
-		wholeRequired.add(key);
+	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));
 	}
-	const requiredKeysCount = wholeRequired.size;
-	for (const key of commonRequired) {
-		extraRequired1.delete(key);
-		extraRequired2.delete(key);
+	return [compiledSchema1, compiledSchema2];
+}
+function collectWithPathPrefix(errorItems, compiledItems, prefix) {
+	for (const compiledItem of compiledItems) {
+		const replacedItem = {
+			...compiledItem,
+			path: [prefix, ...compiledItem.path]
+		};
+		errorItems.push(replacedItem);
 	}
-	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;
+//#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 };
+		}
+	});
 }
-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;
+//#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/flow/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;
 	}
-};
-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;
+	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 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 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];
 	}
-};
-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;
+	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;
 	}
-	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
-		});
+var BinarySchema = class BinarySchema extends SpecialSchema {
+	static isMatch(value) {
+		return toPlainObject(value)?.contentMediaType === "oomol/bin";
 	}
-	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;
+	constructor(id, value, context) {
+		if (!BinarySchema.isMatch(value)) throw new TypeError("Invalid binary schema.");
+		super(id, value, context);
 	}
-}
-//#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$1({
-		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);
+	compareImpl(other) {
+		if (other instanceof BinarySchema) return [ExpressionSingleResult.Equals];
+		else {
+			SpecialSchema.setError(this, other, "edgeError.binDiffType");
+			return [ExpressionSingleResult.Rejection];
 		}
-	});
-	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;
+	equals(other) {
+		return other instanceof BinarySchema;
+	}
 };
-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;
+var ArtifactSchema = class ArtifactSchema extends SpecialSchema {
+	static isMatch(value) {
+		return toPlainObject(value)?.contentMediaType === "oomol/artifact";
 	}
-	switch (kind2) {
-		case CompiledKind.Any: return ExpressionContainedBy;
-		case CompiledKind.Never: return ExpressionContaining;
+	constructor(id, value, context) {
+		if (!ArtifactSchema.isMatch(value)) throw new TypeError("Invalid Artifact schema.");
+		super(id, value, context);
 	}
-	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}`);
+	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 rejectInSchemaList(schemaList, kind) {
-	return schemaList.filter((e) => getKind(e) !== kind);
+function createSchemaComparer() {
+	return makeSubsetCompare({ extendsSchemaClasses: [
+		SingleSelectSchema,
+		BinarySchema,
+		ArtifactSchema
+	] });
 }
-function isDecisiveMismatch(result) {
-	return !hasEquals(result) && !hasContainedBy(result) && (hasContaining(result) || hasIntersection(result) || hasRejection(result));
+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 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;
+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
+			};
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
 	}
-	return targetPath;
+	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/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;
-		}
-	}
+//#region src/flow/common/triggerScheduleSchema.ts
+var triggerScheduleSchema = array(union([object({
+	type: literal("cron"),
+	expression: string$1(),
+	timezone: string$1()
+}), object({
+	type: literal("every"),
+	unit: _enum([
+		"day",
+		"hour",
+		"minute",
+		"month",
+		"week"
+	]),
+	value: number()
+})]));
+var text = string$1();
+var json$2 = json$3();
+var strings$1 = array(text);
+var port$1 = object({
+	description: text.optional(),
+	jsonSchema: json$2,
+	nullable: boolean(),
+	handle: text
+});
+var input = port$1.extend({ value: json$2.optional() });
+var group = object({
+	collapsed: boolean().optional(),
+	group: text
+});
+var source = union([object({
+	kind: literal("node"),
+	nodeId: text,
+	output: text,
+	field: text.optional()
+}), object({
+	kind: literal("binding"),
+	bindingId: text
+})]);
+var fixedInput = union([object({ kind: literal("unset") }), object({
+	kind: literal("value"),
+	value: json$2
+})]);
+var mapping = union([fixedInput, object({
+	kind: literal("sources"),
+	sources: array(source)
+})]);
+var inputs = record$2(text, mapping);
+var ports$1 = {
+	inputs: array(union([input, group])),
+	outputs: array(union([port$1, 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$1,
+	name: text,
+	moduleId: text,
+	capabilities: array(capability).optional()
+});
+var agentValue = union([object({
+	kind: literal("value"),
+	value: json$2
+}), 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$1
+	})
+]);
+var managedFields = object({
+	...ports$1,
+	name: text,
+	executor: union([
+		object({
+			kind: literal("connector"),
+			action: text,
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
+		}),
+		object({
+			kind: literal("openapi"),
+			sourceUrl: text,
+			method: text,
+			path: text,
+			serverUrl: text,
+			document: json$2,
+			auth: array(object({
+				id: text,
+				type: _enum([
+					"bearer",
+					"basic",
+					"apiKey"
+				]),
+				name: text.optional(),
+				in: _enum(["header", "query"]).optional()
+			}))
+		}),
+		strictObject({
+			kind: literal("decision"),
+			questions: array(decisionQuestion)
+		}),
+		object({
+			kind: literal("llm"),
+			mode: _enum(["chat", "json"])
+		}),
+		object({
+			kind: literal("agent"),
+			code: boolean().optional(),
+			model: text,
+			prompt: text,
+			maxRounds: number(),
+			tools: array(object({
+				id: text,
+				name: text,
+				description: text,
+				action: text,
+				connectionId: text.optional(),
+				approval: boolean(),
+				inputs: array(input.extend({ source: agentInput }))
+			})),
+			notification: object({
+				action: text,
+				connectionId: text.optional(),
+				inputDefinitions: array(input),
+				messageHandle: text,
+				inputs: record$2(text, agentValue)
+			}).optional()
+		})
+	])
+});
+var managed = managedFields.transform(limitDecisionTask);
+var operand$1 = union([object({
+	kind: literal("value"),
+	value: json$2.optional(),
+	jsonSchema: json$2.optional()
+}), object({
+	kind: literal("source"),
+	source
+})]);
+var condition = {
+	matchMode: _enum(["first", "all"]),
+	cases: array(object({
+		description: text.optional(),
+		output: text,
+		groups: array(object({ expressions: array(object({
+			left: operand$1,
+			operator: _enum([
+				"!=",
+				"<",
+				"<=",
+				"==",
+				">",
+				">=",
+				"contains",
+				"endsWith",
+				"hasKey",
+				"hasValue",
+				"isEmpty",
+				"isFalse",
+				"isNotEmpty",
+				"isNotNull",
+				"isNull",
+				"isTrue",
+				"notContains",
+				"notHasKey",
+				"notHasValue",
+				"startsWith"
+			]),
+			right: operand$1.optional()
+		})) }))
+	}))
 };
-//#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
+var wait = {
+	inputDefinitions: array(input),
+	prompt: text
+};
+var webhookOptions = object({
+	allowedMethods: never().optional(),
+	allowedOrigins: strings$1.optional(),
+	noResponseBody: never().optional(),
+	responseData: text.optional(),
+	responseHeaders: record$2(text, text).optional(),
+	responseStatusCode: number().int().min(200).max(599).optional()
 });
-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/flow/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 webhook = {
+	bodyFields: array(input),
+	method: _enum(webhookMethods),
+	options: webhookOptions.optional()
 };
-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 definition = {
+	configInputs: ports$1.inputs,
+	definitionVersion: literal(2),
+	description: text,
+	displayName: text,
+	key: text,
+	name: text,
+	outputs: array(port$1).refine((definitions) => new Set(definitions.map((output) => output.handle)).size === definitions.length, "Duplicate Trigger output handle."),
+	provider: text
 };
-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 endpoint = object({
+	body: object({
+		allowArray: boolean(),
+		allowEmpty: boolean(),
+		formats: array(_enum([
+			"form",
+			"json",
+			"multipart",
+			"text"
+		]))
+	}),
+	methods: array(_enum([
+		"DELETE",
+		"GET",
+		"HEAD",
+		"PATCH",
+		"POST",
+		"PUT"
+	])),
+	successStatus: number()
+});
+var sourceFlowIds = array(text.min(1)).refine((ids) => new Set(ids).size === ids.length, "Duplicate source Flow ID.");
+var trigger = {
+	name: text,
+	description: text.optional(),
+	icon: text.optional()
 };
-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;
-	}
+var base = {
+	maxExecutions: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+	inputs,
+	name: text.optional(),
+	description: text.optional(),
+	icon: text.optional(),
+	timeoutMs: number().optional()
 };
-function createSchemaComparer() {
-	return makeSubsetCompare({ extendsSchemaClasses: [
-		SingleSelectSchema,
-		BinarySchema,
-		ArtifactSchema
-	] });
-}
-createSchemaComparer();
-//#endregion
-//#region src/decision/common/decision.ts
-var decisionLimits = {
-	choice: 255,
-	score: 10
+var node = union([
+	object({
+		...base,
+		inputs: record$2(text, never()),
+		kind: literal("condition"),
+		...condition
+	}),
+	object({
+		...base,
+		inputs: unknown().transform(() => ({})).default({}),
+		kind: literal("value"),
+		values: array(input)
+	}),
+	object({
+		...base,
+		kind: literal("task"),
+		task: union([inline, managed]),
+		additionalInputs: array(input).optional()
+	}),
+	strictObject({
+		...base,
+		kind: literal("approval"),
+		...wait
+	}).omit({ timeoutMs: true }),
+	strictObject({
+		...base,
+		kind: literal("wait"),
+		...wait
+	}).omit({ timeoutMs: true }),
+	object({
+		...trigger,
+		kind: literal("manual")
+	}),
+	strictObject({
+		...trigger,
+		kind: literal("error"),
+		sourceFlowIds: sourceFlowIds.optional()
+	}),
+	object({
+		...trigger,
+		kind: literal("webhook"),
+		...webhook
+	}),
+	object({
+		...trigger,
+		kind: literal("cron"),
+		cronTimes: triggerScheduleSchema
+	}),
+	object({
+		...trigger,
+		kind: literal("poll"),
+		connectionId: text.min(1).optional(),
+		config: record$2(text, fixedInput),
+		definition: object({
+			...definition,
+			type: literal("poll")
+		}),
+		pollTimes: triggerScheduleSchema
+	}),
+	object({
+		...trigger,
+		kind: literal("integration"),
+		connectionId: text.min(1).optional(),
+		config: record$2(text, fixedInput),
+		definition: object({
+			...definition,
+			type: literal("integration"),
+			endpoint
+		})
+	})
+]);
+/** Configuration schemas shared by the node authoring boundary. */
+var authoringDefinitionSchemas = {
+	input,
+	port: port$1,
+	ports: ports$1,
+	condition: strictObject(condition),
+	wait: strictObject(wait),
+	webhook: strictObject(webhook),
+	schedule: triggerScheduleSchema,
+	capabilities: array(capability),
+	connector: managedFields.shape.executor.options[0].omit({ kind: true }).strict(),
+	openapi: managedFields.shape.executor.options[1].omit({ kind: true }).strict(),
+	decision: managedFields.shape.executor.options[2].omit({ kind: true }).strict(),
+	llm: managedFields.shape.executor.options[3].omit({ kind: true }).strict(),
+	agent: managedFields.shape.executor.options[4].omit({
+		kind: true,
+		notification: true
+	}).strict()
 };
-/** 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
+var edge = object({
+	source: text,
+	target: text,
+	sourceHandle: text.optional()
+});
+var at = {
+	nodeId: text,
+	target: never().optional()
 };
-function decisionAnswerSchema(question) {
-	return answerSchema(limitDecisionQuestion(question));
+var graph = object({
+	nodes: record$2(text, node),
+	edges: array(edge).default([])
+});
+var binding$1 = object({
+	kind: literal("variable"),
+	target: text
+});
+var module = object({
+	name: text,
+	imports: strings$1,
+	source: text
+});
+var document = preprocess(rejectRetiredDefinitions, object({
+	bindings: record$2(text, binding$1),
+	graph
+}));
+var revision = object({
+	modelVersion: union([
+		literal(2),
+		literal(4),
+		literal(5),
+		literal(6)
+	]),
+	document,
+	modules: record$2(text, module)
+});
+revision.extend({
+	kind: literal("open-flow-flow-revision"),
+	version: literal(1)
+});
+function rejectRetiredDefinitions(value) {
+	const candidate = record$1(value);
+	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
+	if (Object.values(record$1(record$1(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record$1(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
+	const subflows = candidate.subflows;
+	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
+	if (Object.values(record$1(record$1(candidate.graph).nodes)).some((candidateNode) => record$1(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	return value;
 }
-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 record$1(value) {
+	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
 }
-//#endregion
-//#region src/trigger/common/contract.ts
-var errorOutputs = [
-	{
-		handle: "workflow",
-		nullable: false,
-		jsonSchema: {
-			type: "object",
-			additionalProperties: false,
-			required: [
-				"flowId",
-				"name",
-				"revisionId",
-				"publicationId"
-			],
-			properties: {
-				flowId: { type: "string" },
-				name: { type: "string" },
-				revisionId: { type: "string" },
-				publicationId: { type: ["string", "null"] }
-			}
-		}
+function decodeRevisionContent(value) {
+	checkJsonDepth(value);
+	const content = revision.parse(value);
+	checkModelVersion(content);
+	assertOpenApiAuthBindings(content.document);
+	return content;
+}
+var shapes = {
+	"graph.trigger.sources.set": {
+		nodeId: text,
+		before: sourceFlowIds.optional(),
+		value: sourceFlowIds.optional()
 	},
-	{
-		handle: "execution",
-		nullable: false,
-		jsonSchema: {
-			type: "object",
-			additionalProperties: false,
-			required: [
-				"runId",
-				"status",
-				"startedAt",
-				"finishedAt"
-			],
-			properties: {
-				runId: { type: "string" },
-				status: { enum: ["failed", "indeterminate"] },
-				startedAt: { type: ["string", "null"] },
-				finishedAt: { type: "string" }
-			}
-		}
+	"binding.create": {
+		bindingId: text,
+		binding: binding$1
 	},
-	{
-		handle: "error",
-		nullable: false,
-		jsonSchema: {
-			type: "object",
-			additionalProperties: false,
-			required: ["code", "message"],
-			properties: {
-				code: { type: "string" },
-				message: { type: "string" },
-				nodeId: { type: "string" },
-				jobId: { type: "string" },
-				path: {
-					type: "array",
-					items: { type: "string" }
-				}
-			}
-		}
-	}
-];
-var webhookOutputs = [
-	{
-		handle: "headers",
-		jsonSchema: {
-			type: "object",
-			additionalProperties: { type: "string" }
-		},
-		nullable: false
+	"binding.delete": { bindingId: text },
+	"binding.target.set": {
+		bindingId: text,
+		before: text,
+		value: text
 	},
-	{
-		handle: "query",
-		jsonSchema: {
-			type: "object",
-			additionalProperties: {
-				type: ["string", "array"],
-				items: { type: "string" }
-			}
-		},
-		nullable: false
+	"graph.edge.connect": {
+		edge,
+		target: never().optional()
 	},
-	{
-		handle: "body",
-		jsonSchema: {
-			type: "object",
-			additionalProperties: true
-		},
-		nullable: false
+	"graph.edge.disconnect": {
+		edge,
+		target: never().optional()
 	},
-	{
-		handle: "webhookUrl",
-		jsonSchema: { type: "string" },
-		nullable: false
-	}
-];
-var cronOutputs = [{
-	handle: "scheduledAt",
-	jsonSchema: {
-		type: "string",
-		format: "date-time"
+	"graph.node.create": {
+		...at,
+		node
 	},
-	nullable: false
-}];
-function triggerOutputDefinitions(trigger) {
-	switch (trigger.kind) {
-		case "error": return errorOutputs;
-		case "manual": return [];
-		case "cron": return cronOutputs;
-		case "poll":
-		case "integration": return trigger.definition.outputs;
-		case "webhook": return webhookOutputs.filter((port) => port.handle !== "body" || webhookSupportsBody(trigger.method)).map((port) => port.handle === "body" ? Object.assign({}, port, { jsonSchema: {
-			type: "object",
-			additionalProperties: false,
-			properties: Object.fromEntries(trigger.bodyFields.map((field) => [field.handle, field.jsonSchema])),
-			required: trigger.bodyFields.filter((field) => !field.nullable && !Object.hasOwn(field, "value")).map((field) => field.handle)
-		} }) : port);
-	}
-}
-function triggerOutputPorts(trigger) {
-	return Object.fromEntries(triggerOutputDefinitions(trigger).map(({ handle, ...port }) => [handle, port]));
-}
-//#endregion
-//#region src/flow/common/graph.ts
-function nodeInputPorts(node) {
-	switch (node.kind) {
-		case "condition": return conditionInputPorts(node);
-		case "value": return {};
-		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
-		case "approval":
-		case "wait": return portsByHandle(node.inputDefinitions);
-		case "cron":
-		case "integration":
-		case "poll":
-		case "error":
-		case "manual":
-		case "webhook": return {};
-	}
-}
-function resolutionActions(node) {
-	return node.kind == "wait" ? ["continue"] : ["approve", "reject"];
-}
-var objectPort = (properties) => ({
-	nullable: false,
-	jsonSchema: {
-		type: "object",
-		properties,
-		required: Object.keys(properties),
-		additionalProperties: false
-	}
-});
-function resolutionOutputPorts(node) {
-	const actions = resolutionActions(node);
-	const inputs = {
-		type: "object",
-		properties: Object.fromEntries(node.inputDefinitions.map((port) => [port.handle, {}])),
-		required: node.inputDefinitions.map((port) => port.handle),
-		additionalProperties: false
-	};
-	return {
-		pending: objectPort({
-			inputs,
-			prompt: { type: "string" },
-			...Object.fromEntries(actions.map((action) => [`${action}Url`, { type: "string" }])),
-			expiresAt: { type: "string" }
+	"graph.node.replace": {
+		...at,
+		before: node,
+		node
+	},
+	"graph.node.delete": at,
+	"graph.node.field.set": union([
+		object({
+			...at,
+			kind: literal("graph.node.field.set"),
+			field: literal("connectionId"),
+			before: text.min(1).optional(),
+			value: text.min(1).optional()
 		}),
-		...Object.fromEntries(actions.map((action) => [action, objectPort({
-			inputs,
-			action: { const: action },
-			resolvedAt: { type: "string" },
-			comment: { type: ["string", "null"] }
-		})]))
-	};
-}
-function nodeOutputPorts(node) {
-	switch (node.kind) {
-		case "condition": return {};
-		case "value": return portsByHandle(node.values);
-		case "task": return portsByHandle(node.task.outputs);
-		case "approval":
-		case "wait": return resolutionOutputPorts(node);
-		case "cron":
-		case "integration":
-		case "poll":
-		case "error":
-		case "manual":
-		case "webhook": return triggerOutputPorts(node);
+		object({
+			...at,
+			kind: literal("graph.node.field.set"),
+			field: _enum([
+				"description",
+				"icon",
+				"name"
+			]),
+			before: text.optional(),
+			value: text.optional()
+		}),
+		object({
+			...at,
+			kind: literal("graph.node.field.set"),
+			field: literal("maxExecutions"),
+			before: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+			value: number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
+		}),
+		object({
+			...at,
+			kind: literal("graph.node.field.set"),
+			field: literal("timeoutMs"),
+			before: number().optional(),
+			value: number().optional()
+		})
+	]),
+	"graph.node.input.set": {
+		...at,
+		handle: text,
+		before: mapping.optional(),
+		value: mapping.optional()
+	},
+	"graph.node.additional-inputs.set": {
+		...at,
+		before: array(input).optional(),
+		value: array(input).optional()
+	},
+	"graph.node.condition.set": {
+		...at,
+		before: object(condition),
+		value: object(condition)
+	},
+	"graph.node.values.set": {
+		...at,
+		before: array(input),
+		value: array(input)
+	},
+	"graph.node.resolution.set": {
+		...at,
+		before: object(wait),
+		value: object(wait)
+	},
+	"graph.node.webhook.set": {
+		...at,
+		before: object(webhook),
+		value: object(webhook)
+	},
+	"graph.node.task.ports.set": {
+		...at,
+		before: object(ports$1),
+		value: object(ports$1)
+	},
+	"graph.node.task.name.set": {
+		...at,
+		before: text,
+		value: text
+	},
+	"graph.node.task.capabilities.set": {
+		...at,
+		before: array(capability).optional(),
+		value: array(capability).optional()
+	},
+	"graph.trigger.config.set": {
+		nodeId: text,
+		name: text,
+		before: fixedInput.optional(),
+		value: fixedInput.optional()
+	},
+	"graph.trigger.schedule.set": {
+		nodeId: text,
+		before: triggerScheduleSchema,
+		value: triggerScheduleSchema
+	},
+	"module.create": {
+		moduleId: text,
+		module
+	},
+	"module.delete": { moduleId: text },
+	"module.rename": {
+		moduleId: text,
+		before: text,
+		name: text
+	},
+	"module.source.replace": {
+		moduleId: text,
+		beforeImports: strings$1,
+		beforeSource: text,
+		imports: strings$1,
+		source: text
+	},
+	"graph.node.task.set": {
+		...at,
+		before: union([inline, managed]),
+		value: union([inline, managed])
 	}
-}
-//#endregion
-//#region src/control/common/authoringCondition.ts
-/** Preserve empty groups in invalid drafts; do not turn them into unconditional branches. */
-function conditionConfigurationView(node, source) {
-	const operand = (value) => value.kind == "source" ? source(value.source) : {
-		kind: "value",
-		...value.value === void 0 ? {} : { value: value.value },
-		...value.jsonSchema === void 0 ? {} : { schema: value.jsonSchema }
-	};
-	const expression = (value) => ({
-		left: operand(value.left),
-		operator: value.operator,
-		...value.right === void 0 ? {} : { right: operand(value.right) }
-	});
-	return {
-		match: node.matchMode,
-		branches: node.cases.map((branch) => {
-			const groups = branch.groups.map((group) => group.expressions.length == 1 ? expression(group.expressions[0]) : { all: group.expressions.map(expression) });
-			return {
-				name: branch.output,
-				...branch.description === void 0 ? {} : { description: branch.description },
-				when: groups.length == 1 ? groups[0] : { any: groups }
-			};
-		})
-	};
-}
-//#endregion
-//#region src/control/common/authoringFields.ts
-/** Business field contracts, independent of storage handles and presentation groups. */
-function fieldsView(ports) {
-	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, {
-		schema: port.jsonSchema,
-		nullable: port.nullable,
-		...port.description == null ? {} : { description: port.description },
-		...Object.hasOwn(port, "value") ? { default: port.value } : {}
-	}]] : []));
+};
+array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, shape instanceof ZodType ? shape : object({
+	kind: literal(kind),
+	...shape
+})])).values()])).min(1);
+function checkModelVersion(content) {
+	if (content.modelVersion < 6 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task)) throw new TypeError("Node-owned managed Tasks require Flow model version 6.");
+	if (content.modelVersion < 5 && Object.values(content.document.graph.nodes).some((itemNode) => itemNode.kind == "error")) throw new TypeError("Error workflows require Flow model version 5.");
 }
 //#endregion
 //#region src/control/common/authoringLlm.ts
 var authoringLlmConfiguration = strictObject({
 	mode: _enum(["chat", "json"]),
-	resultSchema: json$4(),
-	model: json$4().optional().describe("Default model settings: {model, temperature?, top_p?, max_tokens?}. A bound model input takes precedence."),
-	template: json$4().optional().describe("Default message templates: [{role: \"system\" | \"user\" | \"assistant\", content: \"Text with {{namedInput}}\"}]."),
-	messages: json$4().optional().describe("Default conversation history, prepended without template interpolation; an array of {role, content} or null.")
-});
-var defaults = {
-	model: "model",
-	template: "template",
-	messages: "messages"
-};
-/** Read defaults only. Node bindings remain independently visible and editable. */
-function llmConfigurationView(task) {
-	if (task.executor.kind != "llm") throw new TypeError("Expected an LLM task.");
-	const config = {
-		mode: task.executor.mode,
-		resultSchema: task.outputs.find((port) => "handle" in port)?.jsonSchema ?? {}
-	};
-	for (const [name, handle] of Object.entries(defaults)) {
-		const port = task.inputs.find((candidate) => "handle" in candidate && candidate.handle == handle);
-		if (port != null && Object.hasOwn(port, "value")) config[name] = port.value;
-	}
-	return config;
-}
-//#endregion
-//#region src/openapi/common/openapi.ts
-var methods = [
-	"get",
-	"put",
-	"post",
-	"delete",
-	"options",
-	"head",
-	"patch",
-	"trace"
-];
-function object(value) {
-	if (value == null || typeof value != "object" || Array.isArray(value)) throw new Error("Expected an OpenAPI object.");
-	return value;
-}
-function parseOpenApi(value) {
-	const doc = object(value);
-	if (typeof doc.openapi != "string" || !/^3\.[01]\.\d+$/.test(doc.openapi)) throw new Error("Only OpenAPI 3.0 and 3.1 JSON documents are supported.");
-	object(doc.paths);
-	return doc;
-}
-function pointer(doc, ref) {
-	if (!ref.startsWith("#/")) throw new Error("External OpenAPI references are not supported.");
-	let value = doc;
-	for (const key of decodeURIComponent(ref.slice(2)).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))) {
-		const source = object(value);
-		if (!Object.hasOwn(source, key)) throw new Error("An OpenAPI reference is missing.");
-		value = source[key];
-	}
-	return value;
-}
-function resolved(doc, value) {
-	let result = object(value);
-	const seen = /* @__PURE__ */ new Set();
-	while (typeof result.$ref == "string") {
-		if (seen.has(result.$ref)) throw new Error("Circular non-schema reference is unsupported.");
-		seen.add(result.$ref);
-		const { $ref, ...siblings } = result;
-		result = {
-			...object(pointer(doc, $ref)),
-			...siblings
-		};
-	}
-	return result;
-}
-function operation(doc, path, method) {
-	const item = resolved(doc, object(doc.paths)[path]);
-	if (!methods.includes(method) || item[method] == null) throw new Error("The selected operation is no longer available.");
-	return {
-		item,
-		op: object(item[method])
-	};
-}
-function securityOptions(value, path, method) {
-	const doc = parseOpenApi(value);
-	const { op } = operation(doc, path, method);
-	const requirements = op.security ?? doc.security ?? [];
-	if (!Array.isArray(requirements)) throw new Error("Invalid security requirements.");
-	if (!requirements.length) return [{
-		label: "None",
-		auth: []
-	}];
-	return requirements.map((entry) => {
-		const names = Object.keys(object(entry));
-		const label = names.join(" + ") || "None";
-		try {
-			if (!names.length) return {
-				label,
-				auth: []
-			};
-			const schemes = object(object(doc.components).securitySchemes);
-			return {
-				label,
-				auth: names.map((id) => {
-					const scheme = resolved(doc, schemes[id]);
-					if (scheme.type == "http" && ["bearer", "basic"].includes(String(scheme.scheme).toLowerCase())) return {
-						id,
-						type: String(scheme.scheme).toLowerCase()
-					};
-					if (scheme.type == "apiKey" && (scheme.in == "header" || scheme.in == "query") && typeof scheme.name == "string") return {
-						id,
-						type: "apiKey",
-						name: scheme.name,
-						in: scheme.in
-					};
-					throw new Error("This security scheme is unsupported. Supply an access token using manual Bearer authentication if applicable.");
-				})
-			};
-		} catch (error) {
-			return {
-				label,
-				error: error.message
-			};
-		}
-	});
-}
+	resultSchema: json$3(),
+	model: json$3().optional().describe("Default model settings: {model, temperature?, top_p?, max_tokens?}. A bound model input takes precedence."),
+	template: json$3().optional().describe("Default message templates: [{role: \"system\" | \"user\" | \"assistant\", content: \"Text with {{namedInput}}\"}]."),
+	messages: json$3().optional().describe("Default conversation history, prepended without template interpolation; an array of {role, content} or null.")
+});
 //#endregion
 //#region src/control/common/authoringOpenApi.ts
 var authenticationSchema = union([
@@ -9577,45 +9226,18 @@ var authenticationSchema = union([
 		in: _enum(["header", "query"])
 	})
 ]);
-strictObject({
+var authoringOpenApiSchema = strictObject({
 	sourceUrl: string$1().min(1),
 	path: string$1().min(1),
 	method: string$1().min(1),
 	serverUrl: string$1().optional(),
 	authentication: authenticationSchema.optional().describe("Omit to use the operation default. Bind credentials through the advertised node inputs.")
 });
-function openApiAuthenticationChoices(config) {
-	try {
-		return securityOptions(config.document, config.path, config.method).map(({ label, auth, error }) => Object.assign({ label }, auth == null ? { error } : { authentication: { schemes: auth.map((item) => item.id) } }));
-	} catch (error) {
-		return [{
-			label: "Saved operation",
-			error: error.message
-		}];
-	}
-}
-function authenticationView(config) {
-	const schemes = config.auth.map((item) => item.id);
-	if (!openApiAuthenticationChoices(config).some((option) => "authentication" in option && dequal(option.authentication?.schemes, schemes)) && config.auth.length == 1) {
-		const { id: _id, ...manual } = config.auth[0];
-		return manual;
-	}
-	return { schemes };
-}
-function openApiConfigView(config) {
-	return {
-		sourceUrl: config.sourceUrl,
-		path: config.path,
-		method: config.method,
-		serverUrl: config.serverUrl,
-		authentication: authenticationView(config)
-	};
-}
 //#endregion
 //#region src/control/common/authoringSchema.ts
 var id$1 = string$1().min(1);
-var json$2 = json$4();
-var patch = record$3(id$1, json$2);
+var json$1 = json$3();
+var patch = record$2(id$1, json$1);
 var type = _enum([
 	"manual",
 	"webhook",
@@ -9650,7 +9272,7 @@ var authoringSourceSchema = union([
 	variable$1,
 	strictObject({
 		kind: literal("value"),
-		value: json$2
+		value: json$1
 	}),
 	strictObject({ kind: literal("unset") }),
 	strictObject({ kind: literal("default") }),
@@ -9662,8 +9284,8 @@ var authoringSourceSchema = union([
 var operand = union([
 	strictObject({
 		kind: literal("value"),
-		value: json$2.optional(),
-		schema: json$2.optional()
+		value: json$1.optional(),
+		schema: json$1.optional()
 	}),
 	output,
 	variable$1
@@ -9671,25 +9293,25 @@ var operand = union([
 var agentTool = authoringDefinitionSchemas.agent.shape.tools.element.omit({
 	id: true,
 	inputs: true
-}).extend({ inputs: record$3(id$1, authoringDefinitionSchemas.agent.shape.tools.element.shape.inputs.element.shape.source).optional().describe("Action input sources by name. The tool resolves types from the Action. New inputs default to model-provided; existing sources are preserved when omitted.") }).strict();
+}).extend({ inputs: record$2(id$1, authoringDefinitionSchemas.agent.shape.tools.element.shape.inputs.element.shape.source).optional().describe("Action input sources by name. The tool resolves types from the Action. New inputs default to model-provided; existing sources are preserved when omitted.") }).strict();
 var notification = strictObject({
 	...authoringDefinitionSchemas.connector.shape,
 	messageHandle: id$1,
-	inputs: record$3(id$1, union([strictObject({
+	inputs: record$2(id$1, union([strictObject({
 		kind: literal("value"),
-		value: json$2
+		value: json$1
 	}), strictObject({
 		kind: literal("input"),
 		input: id$1
 	})]))
 });
 var field = strictObject({
-	schema: json$2.optional(),
+	schema: json$1.optional(),
 	nullable: boolean().optional(),
 	description: string$1().optional()
 });
-var inputFields = record$3(id$1, field.extend({ default: json$2.optional() })).describe("Optional business input constraints by name. A binding to a new Code, Agent, LLM, Wait or Approval input automatically declares an input accepting any JSON. Existing constraints are preserved. Omitted schema accepts any JSON; omitted nullable is true. Use default for inherited values; input.set supplies data.");
-var outputFields = record$3(id$1, field).describe("Code return fields by name. Omitted schema accepts any JSON; omitted nullable is true.");
+var inputFields = record$2(id$1, field.extend({ default: json$1.optional() })).describe("Optional business input constraints by name. A binding to a new Code, Agent, LLM, Wait or Approval input automatically declares an input accepting any JSON. Existing constraints are preserved. Omitted schema accepts any JSON; omitted nullable is true. Use default for inherited values; input.set supplies data.");
+var outputFields = record$2(id$1, field).describe("Code return fields by name. Omitted schema accepts any JSON; omitted nullable is true.");
 var expression = strictObject({
 	left: operand,
 	operator: authoringDefinitionSchemas.condition.shape.cases.element.shape.groups.element.shape.expressions.element.shape.operator,
@@ -9701,36 +9323,53 @@ var when = union([
 	all,
 	strictObject({ any: array(union([expression, all])) })
 ]);
-strictObject({}), strictObject({ sourceFlowIds: array(id$1).optional() }), authoringDefinitionSchemas.webhook.omit({ bodyFields: true }).extend({ body: inputFields }).strict(), strictObject({ schedule: authoringDefinitionSchemas.schedule }), strictObject({
-	key: id$1,
-	connectionId: id$1.optional(),
-	schedule: authoringDefinitionSchemas.schedule
-}), strictObject({
-	key: id$1,
-	connectionId: id$1.optional()
-}), strictObject({
-	inputs: inputFields,
-	outputs: outputFields,
-	capabilities: authoringDefinitionSchemas.capabilities.optional()
-}), authoringDefinitionSchemas.connector.strict(), authoringDefinitionSchemas.agent.omit({
-	prompt: true,
-	tools: true
-}).extend({
-	inputs: inputFields,
-	resultSchema: json$2.describe("JSON schema of the final result. Defaults to text. The tool manages the output definition; references can omit port."),
-	tools: array(agentTool),
-	notification: notification.optional()
-}).strict(), authoringLlmConfiguration.extend({ inputs: inputFields }), authoringDefinitionSchemas.decision, strictObject({
-	match: _enum(["first", "all"]),
-	branches: array(strictObject({
-		name: id$1,
-		description: string$1().optional(),
-		when
-	}))
-}), strictObject({
-	values: patch,
-	outputs: outputFields
-}), strictObject({ inputs: inputFields }), strictObject({ inputs: inputFields });
+var authoringConfigurations = {
+	manual: strictObject({}),
+	error: strictObject({ sourceFlowIds: array(id$1).optional() }),
+	webhook: authoringDefinitionSchemas.webhook.omit({ bodyFields: true }).extend({ body: inputFields }).strict(),
+	cron: strictObject({ schedule: authoringDefinitionSchemas.schedule }),
+	poll: strictObject({
+		key: id$1,
+		connectionId: id$1.optional(),
+		schedule: authoringDefinitionSchemas.schedule
+	}),
+	integration: strictObject({
+		key: id$1,
+		connectionId: id$1.optional()
+	}),
+	code: strictObject({
+		inputs: inputFields,
+		outputs: outputFields,
+		capabilities: authoringDefinitionSchemas.capabilities.optional()
+	}),
+	connector: authoringDefinitionSchemas.connector.omit({ outputMode: true }).strict(),
+	openapi: authoringOpenApiSchema,
+	agent: authoringDefinitionSchemas.agent.omit({
+		prompt: true,
+		tools: true
+	}).extend({
+		inputs: inputFields,
+		resultSchema: json$1.describe("JSON schema of the final result. Defaults to text. The tool manages the output definition; references can omit port."),
+		tools: array(agentTool),
+		notification: notification.optional()
+	}).strict(),
+	llm: authoringLlmConfiguration.extend({ inputs: inputFields }),
+	decision: authoringDefinitionSchemas.decision,
+	condition: strictObject({
+		match: _enum(["first", "all"]),
+		branches: array(strictObject({
+			name: id$1,
+			description: string$1().optional(),
+			when
+		}))
+	}),
+	value: strictObject({
+		values: patch,
+		outputs: outputFields
+	}),
+	wait: strictObject({ inputs: inputFields }),
+	approval: strictObject({ inputs: inputFields })
+};
 var updates = strictObject({
 	name: id$1.optional(),
 	description: string$1().optional(),
@@ -9746,7 +9385,7 @@ var authoringEditSchema = discriminatedUnion("op", [
 		type,
 		name: id$1,
 		config: patch.optional(),
-		inputs: record$3(id$1, authoringSourceSchema).optional().describe("Input data sources, applied after creation, as input.set operations. Execution edges are separate."),
+		inputs: record$2(id$1, authoringSourceSchema).optional().describe("Input data sources, applied after creation, as input.set operations. Execution edges are separate."),
 		code: string$1().optional(),
 		prompt: string$1().optional()
 	}),
@@ -9816,7 +9455,7 @@ strictObject({
 	type: type.optional(),
 	action: id$1.optional()
 }).refine((v) => v.type == null || v.action == null, "Choose type or action.");
-var authoringDiagnosticSchema = object$1({
+var authoringDiagnosticSchema = object({
 	code: id$1,
 	message: string$1(),
 	nodes: array(id$1),
@@ -9824,24 +9463,24 @@ var authoringDiagnosticSchema = object$1({
 	line: number().optional(),
 	column: number().optional()
 });
-var authoringCheckResponse = object$1({
+var authoringCheckResponse = object({
 	flowId: id$1,
 	revisionId: id$1,
 	valid: boolean(),
 	diagnostics: array(authoringDiagnosticSchema),
 	version: literal(1)
 });
-var authoringEditResponse = object$1({
+var authoringEditResponse = object({
 	flowId: id$1,
 	saved: literal(true),
 	revision: id$1,
-	nodes: record$3(id$1, id$1),
-	changes: array(object$1({
+	nodes: record$2(id$1, id$1),
+	changes: array(object({
 		index: int(),
 		op: id$1,
 		node: id$1.optional()
 	})),
-	validation: object$1({
+	validation: object({
 		status: _enum([
 			"valid",
 			"invalid",
@@ -9851,21 +9490,21 @@ var authoringEditResponse = object$1({
 	}),
 	version: literal(1)
 });
-var authoringReadResponse = object$1({
+var authoringReadResponse = object({
 	flowId: id$1,
 	revision: id$1,
-	data: object$1({
-		nodes: array(record$3(string$1(), json$2)).optional(),
-		edges: array(json$2).optional(),
-		text: record$3(string$1(), json$2).optional()
+	data: object({
+		nodes: array(record$2(string$1(), json$1)).optional(),
+		edges: array(json$1).optional(),
+		text: record$2(string$1(), json$1).optional()
 	}),
 	version: literal(1)
 });
-var authoringSearchResponse = object$1({
+var authoringSearchResponse = object({
 	flowId: id$1,
 	revision: id$1,
-	data: object$1({
-		matches: array(object$1({
+	data: object({
+		matches: array(object({
 			node: id$1,
 			field: id$1,
 			line: int().optional(),
@@ -9877,168 +9516,36 @@ var authoringSearchResponse = object$1({
 	version: literal(1)
 });
 //#endregion
-//#region src/control/common/authoringTools.ts
-function outwardAgentTools(tools) {
-	return tools.map(({ id: _id, inputs, ...tool }) => ({
-		...tool,
-		inputs: Object.fromEntries(inputs.map((input) => [input.handle, input.source]))
-	}));
+//#region src/control/common/authoringFields.ts
+/** Business field contracts, independent of storage handles and presentation groups. */
+function fieldsView(ports) {
+	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, {
+		schema: port.jsonSchema,
+		nullable: port.nullable,
+		...port.description == null ? {} : { description: port.description },
+		...Object.hasOwn(port, "value") ? { default: port.value } : {}
+	}]] : []));
 }
 //#endregion
-//#region src/control/common/authoring.ts
-var record$1 = (value) => value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
-var json$1 = (value) => JSON.parse(JSON.stringify(value));
-var AuthoringError = class extends Error {
-	constructor(code, message, details = {}) {
-		super(message);
-		this.code = code;
-		this.details = details;
-		this.name = "AuthoringError";
-	}
-};
-function fail(code, message, details = {}) {
-	throw new AuthoringError(code, message, details);
-}
-function nodeAt(content, ref) {
-	return (Object.hasOwn(content.document.graph.nodes, ref) ? content.document.graph.nodes[ref] : void 0) ?? fail("node.not-found", `Node ${JSON.stringify(ref)} does not exist.`, { node: ref });
-}
-function taskAt(node) {
-	return node.kind == "task" ? node.task : void 0;
-}
-var llmReservedInputs = [
-	"model",
-	"template",
-	"messages"
-];
-function inputDefinitions(node) {
-	if (node.kind == "condition") return {};
-	if (node.kind == "poll" || node.kind == "integration") return Object.fromEntries(node.definition.configInputs.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
-	return nodeInputPorts(node);
-}
-function inputMappings(node) {
-	return node.kind == "condition" ? {} : node.kind == "poll" || node.kind == "integration" ? node.config : nodeInputMappings(node);
-}
-function typeOf(node) {
-	const task = taskAt(node);
-	return node.kind != "task" ? node.kind : task != null && "executor" in task ? task.executor.kind : "code";
-}
-function outwardSource(content, value) {
-	if (Array.isArray(value)) return value.map((v) => outwardSource(content, v));
-	if (value == null || typeof value != "object") return value;
-	const v = record$1(value);
-	if (v.kind == "node" && typeof v.nodeId == "string" && typeof v.output == "string") return {
-		kind: "output",
-		node: v.nodeId,
-		port: v.output,
-		...v.field == null ? {} : { field: v.field }
-	};
-	if (v.kind == "binding" && typeof v.bindingId == "string") return {
-		kind: "variable",
-		name: content.document.bindings[v.bindingId]?.target ?? "[missing variable]"
-	};
-	if (v.kind == "value") return value;
-	return Object.fromEntries(Object.entries(v).map(([k, item]) => [k, outwardSource(content, item)]));
-}
-function authoringEdges(edges) {
-	return edges.map((edge) => edge.sourceHandle == null ? {
-		source: edge.source,
-		target: edge.target
-	} : {
-		source: edge.source,
-		target: edge.target,
-		branch: edge.sourceHandle
-	});
-}
-function authoringNode(content, ref) {
-	const node = nodeAt(content, ref), type = typeOf(node), task = taskAt(node);
-	let config = {};
-	const texts = {};
-	if (task != null && "executor" in task) {
-		const { kind: _, ...executor } = task.executor;
-		config = { ...executor };
-		if (task.executor.kind == "agent") {
-			const { prompt, tools, notification, ...rest } = task.executor;
-			const { kind: _agentKind, ...settings } = rest;
-			config = {
-				...settings,
-				inputs: fieldsView([...task.inputs, ...node.kind == "task" ? node.additionalInputs ?? [] : []]),
-				resultSchema: task.outputs.find((port) => "handle" in port)?.jsonSchema ?? { type: "string" },
-				tools: outwardAgentTools(tools)
-			};
-			texts.prompt = prompt;
-			if (notification != null) {
-				const { inputDefinitions: _definitions, ...noticeSettings } = notification;
-				config.notification = noticeSettings;
-			}
-		} else if (task.executor.kind == "llm") config = {
-			...llmConfigurationView(task),
-			inputs: fieldsView([...task.inputs, ...node.kind == "task" ? node.additionalInputs ?? [] : []].filter((port) => !("handle" in port) || !llmReservedInputs.includes(port.handle)))
-		};
-		else if (task.executor.kind == "openapi") config = { ...openApiConfigView(task.executor) };
-	} else if (node.kind == "task" && "moduleId" in node.task) {
-		config = {
-			inputs: fieldsView([...node.task.inputs, ...node.additionalInputs ?? []]),
-			outputs: fieldsView(node.task.outputs),
-			...node.task.capabilities == null ? {} : { capabilities: node.task.capabilities }
+//#region src/control/common/authoringTriggers.ts
+/** Shared business configuration for authoring and published entry inspection. */
+function triggerConfiguration(node) {
+	switch (node.kind) {
+		case "manual": return {};
+		case "webhook": return {
+			body: fieldsView(node.bodyFields),
+			method: node.method,
+			...node.options == null ? {} : { options: node.options }
 		};
-		texts.code = content.modules[node.task.moduleId]?.source ?? "";
-	} else switch (node.kind) {
-		case "condition":
-			config = { ...conditionConfigurationView(node, (value) => outwardSource(content, value)) };
-			break;
-		case "value":
-			config = {
-				values: Object.fromEntries(node.values.filter((port) => Object.hasOwn(port, "value")).map((port) => [port.handle, port.value])),
-				outputs: fieldsView(node.values.map(({ value: _value, ...port }) => port))
-			};
-			break;
-		case "wait":
-		case "approval":
-			config = { inputs: fieldsView(node.inputDefinitions) };
-			texts.prompt = node.prompt;
-			break;
-		case "webhook":
-			config = {
-				body: fieldsView(node.bodyFields),
-				method: node.method,
-				...node.options == null ? {} : { options: node.options }
-			};
-			break;
-		case "cron":
-			config = { schedule: node.cronTimes };
-			break;
-		case "error":
-			config = node.sourceFlowIds == null ? {} : { sourceFlowIds: node.sourceFlowIds };
-			break;
+		case "cron": return { schedule: node.cronTimes };
+		case "error": return node.sourceFlowIds == null ? {} : { sourceFlowIds: node.sourceFlowIds };
 		case "poll":
-		case "integration": config = {
+		case "integration": return {
 			key: node.definition.key,
 			...node.connectionId == null ? {} : { connectionId: node.connectionId },
 			...node.kind == "poll" ? { schedule: node.pollTimes } : {}
 		};
 	}
-	const edges = authoringEdges(content.document.graph.edges);
-	return {
-		ref,
-		type,
-		name: node.name ?? ref,
-		readOnly: false,
-		...node.description == null ? {} : { description: node.description },
-		...node.icon == null ? {} : { icon: node.icon },
-		..."timeoutMs" in node && node.timeoutMs != null ? { timeoutMs: node.timeoutMs } : {},
-		..."maxExecutions" in node && node.maxExecutions != null ? { maxExecutions: node.maxExecutions } : {},
-		config: json$1(config),
-		texts: Object.fromEntries(Object.entries(texts).map(([field, text]) => [field, {
-			lines: text.split("\n").length,
-			characters: text.length
-		}])),
-		inputs: outwardSource(content, inputMappings(node)),
-		inputPorts: fieldsView(Object.entries(inputDefinitions(node)).map(([handle, port]) => Object.assign({}, port, { handle }))),
-		outputPorts: fieldsView(Object.entries(nodeOutputPorts(node)).map(([handle, port]) => Object.assign({}, port, { handle }))),
-		...task != null && "executor" in task && task.executor.kind == "openapi" ? { authenticationChoices: openApiAuthenticationChoices(task.executor) } : {},
-		incoming: edges.filter((e) => e.target == ref),
-		outgoing: edges.filter((e) => e.source == ref)
-	};
 }
 //#endregion
 //#region src/control/common/errors.ts
@@ -10074,7 +9581,6 @@ var controlErrorCode = {
 	publicationConflict: "publication.conflict",
 	publicationNotFound: "publication.not-found",
 	publicationUnsupported: "publication.unsupported",
-	resourceNotFound: "resource.not-found",
 	publishOperationNotFound: "publication.operation-not-found",
 	routeNotFound: "route.not-found",
 	runConflict: "run.conflict",
@@ -10123,7 +9629,6 @@ var controlErrorMetadata = {
 	[controlErrorCode.publicationConflict]: { status: 409 },
 	[controlErrorCode.publicationNotFound]: { status: 404 },
 	[controlErrorCode.publicationUnsupported]: { status: 409 },
-	[controlErrorCode.resourceNotFound]: { status: 404 },
 	[controlErrorCode.publishOperationNotFound]: { status: 404 },
 	[controlErrorCode.routeNotFound]: { status: 404 },
 	[controlErrorCode.runConflict]: { status: 409 },
@@ -10175,28 +9680,164 @@ function exact(value, keys) {
 		invalidResponse([missing.length > 0 ? `Missing fields: ${missing.join(", ")}.` : "", unexpected.length > 0 ? `Unexpected fields: ${unexpected.join(", ")}.` : ""].filter(Boolean).join(" "));
 	}
 }
-function integer(value) {
-	return Number.isSafeInteger(value) ? value : invalidResponse("Expected a safe integer.");
-}
-function jsonValue(value) {
-	if (value === null || typeof value == "boolean" || typeof value == "string") return value;
-	if (typeof value == "number" && Number.isFinite(value)) return value;
-	if (Array.isArray(value)) return value.map(jsonValue);
+function integer(value) {
+	return Number.isSafeInteger(value) ? value : invalidResponse("Expected a safe integer.");
+}
+function jsonValue(value) {
+	if (value === null || typeof value == "boolean" || typeof value == "string") return value;
+	if (typeof value == "number" && Number.isFinite(value)) return value;
+	if (Array.isArray(value)) return value.map(jsonValue);
+	const source = record(value);
+	return Object.fromEntries(Object.entries(source).map(([key, item]) => [key, jsonValue(item)]));
+}
+function optionalString(value) {
+	if (value == null) return;
+	return string(value);
+}
+//#endregion
+//#region src/control/common/publicationDecoders.ts
+function publication(value) {
+	const source = record(value);
+	const liveEnd = source.liveEnd == null ? void 0 : record(source.liveEnd);
+	if (liveEnd != null && typeof liveEnd.enabled != "boolean") return invalidResponse();
+	const operation = source.operation;
+	const sourcePublicationId = source.sourcePublicationId;
+	if (source.version != 1) return invalidResponse();
+	if (operation != "publish" && operation != "rollback") return invalidResponse();
+	if (sourcePublicationId != null && typeof sourcePublicationId != "string") return invalidResponse();
+	return {
+		...liveEnd == null ? {} : { liveEnd: {
+			enabled: liveEnd.enabled,
+			endedAt: string(liveEnd.endedAt)
+		} },
+		actorId: string(source.actorId),
+		closureDigest: string(source.closureDigest),
+		createdAt: string(source.createdAt),
+		engineContract: string(source.engineContract),
+		flowId: string(source.flowId),
+		modelVersion: integer(source.modelVersion),
+		operation,
+		publicationId: string(source.publicationId),
+		sharedAccessDigest: string(source.sharedAccessDigest),
+		revisionDigest: string(source.revisionDigest),
+		revisionId: string(source.revisionId),
+		...sourcePublicationId == null ? {} : { sourcePublicationId },
+		version: 1
+	};
+}
+function publishOperation(value) {
+	const source = record(value);
+	const status = source.status;
+	const common = {
+		createdAt: string(source.createdAt),
+		flowId: string(source.flowId),
+		operationId: string(source.operationId),
+		revisionId: string(source.revisionId),
+		updatedAt: string(source.updatedAt),
+		version: 1
+	};
+	if (source.version != 1) return invalidResponse();
+	switch (status) {
+		case "pending":
+			exact(source, [
+				"createdAt",
+				"flowId",
+				"operationId",
+				"revisionId",
+				"status",
+				"updatedAt",
+				"version"
+			]);
+			return {
+				...common,
+				status
+			};
+		case "succeeded":
+			exact(source, [
+				"createdAt",
+				"flowId",
+				"operationId",
+				"publicationId",
+				"revisionId",
+				"status",
+				"updatedAt",
+				"version"
+			]);
+			return {
+				...common,
+				publicationId: string(source.publicationId),
+				status
+			};
+		case "failed": {
+			exact(source, [
+				"createdAt",
+				"flowId",
+				"issue",
+				"operationId",
+				"revisionId",
+				"status",
+				"updatedAt",
+				"version"
+			]);
+			const issue = record(source.issue);
+			const nodeId = issue.nodeId;
+			exact(issue, [
+				"code",
+				"message",
+				...nodeId == null ? [] : ["nodeId"]
+			]);
+			return {
+				...common,
+				issue: {
+					code: string(issue.code),
+					message: string(issue.message),
+					...nodeId == null ? {} : { nodeId: string(nodeId) }
+				},
+				status
+			};
+		}
+		default: return invalidResponse();
+	}
+}
+function live(value) {
 	const source = record(value);
-	return Object.fromEntries(Object.entries(source).map(([key, item]) => [key, jsonValue(item)]));
+	const status = source.status;
+	const candidate = source.publication;
+	if (source.version != 1 || typeof source.hasUnpublishedChanges != "boolean") return invalidResponse();
+	if (status != "not-published" && status != "runnable" && status != "suspended") return invalidResponse();
+	if (status == "not-published" && candidate !== null) return invalidResponse();
+	if (status != "not-published" && candidate === null) return invalidResponse();
+	return {
+		flowId: string(source.flowId),
+		hasUnpublishedChanges: source.hasUnpublishedChanges,
+		publication: candidate === null ? null : publication(candidate),
+		revision: integer(source.revision),
+		status,
+		version: 1
+	};
 }
-function optionalString(value) {
-	if (value == null) return;
-	return string(value);
+function publicationPage(value) {
+	const source = record(value);
+	const nextCursor = source.nextCursor;
+	const total = source.total;
+	if (source.version != 1 || !Array.isArray(source.publications)) return invalidResponse();
+	if (nextCursor != null && typeof nextCursor != "string") return invalidResponse();
+	if (total != null && !Number.isSafeInteger(total)) return invalidResponse();
+	return {
+		...nextCursor == null ? {} : { nextCursor },
+		publications: source.publications.map(publication),
+		...total == null ? {} : { total },
+		version: 1
+	};
 }
 //#endregion
 //#region src/trigger/common/configSchema.ts
 var configInputsSchema = array(union([strictObject({
 	handle: string$1().min(1),
 	description: string$1().optional(),
-	jsonSchema: json$4(),
+	jsonSchema: json$3(),
 	nullable: boolean(),
-	value: json$4().optional()
+	value: json$3().optional()
 }), strictObject({
 	group: string$1(),
 	collapsed: boolean().optional()
@@ -10372,69 +10013,122 @@ function pollTriggerTestResult(value) {
 	};
 }
 //#endregion
-//#region src/control/common/publicationResources.ts
-function publicationResources(content) {
-	return Object.entries(content.document.graph.nodes).flatMap(([resourceId, node]) => {
-		if (node.kind != "webhook" && node.kind != "cron" && node.kind != "poll" && node.kind != "integration" && node.kind != "error") return [];
-		const view = authoringNode(content, resourceId);
+//#region src/control/common/liveDetails.ts
+var metadata = {
+	nodeId: string$1().min(1),
+	name: string$1(),
+	description: string$1().optional()
+};
+var binding = unknown().transform(triggerBinding);
+var provider = {
+	provider: string$1().min(1),
+	inputs: record$2(string$1(), discriminatedUnion("kind", [strictObject({
+		kind: literal("value"),
+		value: json$3()
+	}), strictObject({ kind: literal("unset") })]))
+};
+var entrySchema = discriminatedUnion("type", [
+	strictObject({
+		...metadata,
+		type: literal("manual"),
+		config: authoringConfigurations.manual
+	}),
+	strictObject({
+		...metadata,
+		type: literal("webhook"),
+		config: authoringConfigurations.webhook,
+		binding
+	}),
+	strictObject({
+		...metadata,
+		type: literal("cron"),
+		config: authoringConfigurations.cron,
+		binding
+	}),
+	strictObject({
+		...metadata,
+		type: literal("error"),
+		config: authoringConfigurations.error,
+		binding
+	}),
+	strictObject({
+		...metadata,
+		...provider,
+		type: literal("poll"),
+		config: authoringConfigurations.poll,
+		binding
+	}),
+	strictObject({
+		...metadata,
+		...provider,
+		type: literal("integration"),
+		config: authoringConfigurations.integration,
+		binding
+	})
+]);
+/** Project only the selected published definition and its current bindings. */
+function liveEntries(content, current, bindings) {
+	const byNode = new Map(bindings.filter((item) => item.flowId == current.flowId && item.currentPublicationId == current.publicationId && item.currentRevisionId == current.revisionId).map((item) => [item.triggerNodeId, item]));
+	return decodeEntries(Object.entries(content.document.graph.nodes).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([nodeId, node]) => {
+		if (node.kind != "manual" && node.kind != "webhook" && node.kind != "cron" && node.kind != "error" && node.kind != "poll" && node.kind != "integration") return [];
+		const config = triggerConfiguration(node);
 		return [{
-			resourceId,
-			kind: "trigger",
+			nodeId,
+			name: node.name,
 			type: node.kind,
-			name: view.name,
-			...view.description == null ? {} : { description: view.description },
-			config: view.config,
-			inputs: view.inputs
+			...node.description == null ? {} : { description: node.description },
+			config: node.kind == "webhook" && !webhookSupportsBody(node.method) ? {
+				...config,
+				body: {}
+			} : config,
+			...node.kind == "manual" ? {} : { binding: byNode.get(nodeId) },
+			...node.kind == "poll" || node.kind == "integration" ? {
+				provider: node.definition.provider,
+				inputs: node.config
+			} : {}
 		}];
-	});
-}
-function context(source) {
-	if (source.version != 1 || source.status != "live" && source.status != "historical") return invalidResponse();
-	if (source.status == "live" ? typeof source.enabled != "boolean" : source.enabled !== void 0) return invalidResponse();
-	return {
-		flowId: string(source.flowId),
-		publicationId: string(source.publicationId),
-		revisionId: string(source.revisionId),
-		status: source.status,
-		...source.enabled == null ? {} : { enabled: source.enabled },
-		version: 1
-	};
-}
-function resource(value, scope) {
-	const source = record(value);
-	const type = source.type;
-	if (source.kind != "trigger" || type != "webhook" && type != "cron" && type != "poll" && type != "integration" && type != "error") return invalidResponse();
-	if (source.description != null && typeof source.description != "string") return invalidResponse();
-	const resourceId = string(source.resourceId);
-	const runtime = source.runtime == null ? void 0 : triggerBinding(source.runtime);
-	if (runtime != null && (scope.status != "live" || runtime.flowId != scope.flowId || runtime.currentPublicationId != scope.publicationId || runtime.currentRevisionId != scope.revisionId || runtime.triggerNodeId != resourceId || runtime.kind != type)) return invalidResponse();
-	return {
-		resourceId,
-		kind: "trigger",
-		type,
-		name: string(source.name),
-		...source.description == null ? {} : { description: source.description },
-		config: jsonValue(source.config),
-		inputs: jsonValue(source.inputs),
-		...runtime == null ? {} : { runtime }
-	};
+	}), current);
 }
-function decodePublicationResources(value) {
+function decodeLiveDetails(value) {
 	const source = record(value);
-	const scope = context(source);
-	if (!Array.isArray(source.resources)) return invalidResponse();
+	const flowId = string(source.flowId);
+	if (source.version != 1 || !Array.isArray(source.entries)) return invalidResponse();
+	if (source.publication === null) {
+		if (source.status != "not-published" || source.entries.length != 0 || Object.hasOwn(source, "enabled")) return invalidResponse();
+		return {
+			flowId,
+			publication: null,
+			status: "not-published",
+			entries: [],
+			version: 1
+		};
+	}
+	const current = publication(source.publication);
+	const status = source.status;
+	if (current.flowId != flowId || typeof source.enabled != "boolean") return invalidResponse();
+	if (status != "runnable" && status != "suspended") return invalidResponse();
+	if (!source.enabled && source.status == "runnable") return invalidResponse();
 	return {
-		...scope,
-		resources: source.resources.map((item) => resource(item, scope))
+		flowId,
+		publication: current,
+		status,
+		enabled: source.enabled,
+		entries: decodeEntries(source.entries, current),
+		version: 1
 	};
 }
-function decodePublicationResource(value) {
-	const source = record(value);
-	const scope = context(source);
-	return {
-		...scope,
-		resource: resource(source.resource, scope)
-	};
+/** Both producers and consumers enforce the same published-entry invariants. */
+function decodeEntries(values, current) {
+	const parsed = array(entrySchema).safeParse(values);
+	if (!parsed.success) return invalidResponse();
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of parsed.data) {
+		if (ids.has(entry.nodeId)) return invalidResponse();
+		ids.add(entry.nodeId);
+		if (entry.type != "manual" && (entry.binding.flowId != current.flowId || entry.binding.triggerNodeId != entry.nodeId || entry.binding.kind != entry.type || entry.binding.currentPublicationId != current.publicationId || entry.binding.currentRevisionId != current.revisionId)) return invalidResponse();
+		if (entry.type == "webhook" && (!entry.binding.endpointUrl || !webhookSupportsBody(entry.config.method) && Object.keys(entry.config.body).length > 0)) return invalidResponse();
+	}
+	return parsed.data;
 }
 //#endregion
 //#region src/control/common/providerIconSprite.ts
@@ -10471,6 +10165,24 @@ function providerIconAppearance(metadata, position) {
 	};
 }
 //#endregion
+//#region src/flow/common/workflowFile.ts
+var envelope = strictObject({
+	kind: literal("open-flow-workflow"),
+	version: literal(1),
+	name: string$1().optional(),
+	content: unknown(),
+	presentation: record$2(string$1(), json$3()).optional()
+});
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+function decodeWorkflowFile(value) {
+	checkJsonDepth(value, -1);
+	const file = envelope.parse(value);
+	return {
+		...file,
+		content: decodeRevisionContent(file.content)
+	};
+}
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder$1 = new TextEncoder();
 function canonicalText(value) {
@@ -10825,41 +10537,231 @@ function connectorActionMetadata(value) {
 		serviceName: string(source.serviceName)
 	};
 }
-function connectorAction(value) {
-	const { defaultConnection, ...metadata } = record(value);
-	const action = connectorActionMetadata(metadata);
-	if (defaultConnection == null) return action;
-	const preferred = connection(defaultConnection);
-	if (preferred.serviceId != action.serviceId || preferred.status != "active") return invalidResponse();
-	return {
-		...action,
-		defaultConnection: preferred
-	};
+function connectorAction(value) {
+	const { defaultConnection, ...metadata } = record(value);
+	const action = connectorActionMetadata(metadata);
+	if (defaultConnection == null) return action;
+	const preferred = connection(defaultConnection);
+	if (preferred.serviceId != action.serviceId || preferred.status != "active") return invalidResponse();
+	return {
+		...action,
+		defaultConnection: preferred
+	};
+}
+function connectorProvider(value) {
+	const source = record(value);
+	const homepageUrl = source.homepageUrl;
+	const icon = source.icon;
+	if (source.noSetup !== void 0 && typeof source.noSetup != "boolean") return invalidResponse();
+	exact(source, [
+		...Object.hasOwn(source, "noSetup") ? ["noSetup"] : [],
+		"serviceId",
+		"serviceName",
+		...homepageUrl == null ? [] : ["homepageUrl"],
+		...icon == null ? [] : ["icon"],
+		..."iconSprite" in source ? ["iconSprite"] : [],
+		..."iconSpritePosition" in source ? ["iconSpritePosition"] : []
+	]);
+	if (homepageUrl != null && typeof homepageUrl != "string" || icon != null && typeof icon != "string") return invalidResponse();
+	return {
+		...homepageUrl == null ? {} : { homepageUrl },
+		...icon == null ? {} : { icon },
+		...providerIconAppearance(source.iconSprite, source.iconSpritePosition),
+		serviceId: string(source.serviceId),
+		serviceName: string(source.serviceName),
+		...source.noSetup === void 0 ? {} : { noSetup: source.noSetup }
+	};
+}
+//#endregion
+//#region src/trigger/common/contract.ts
+var errorOutputs = [
+	{
+		handle: "workflow",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"flowId",
+				"name",
+				"revisionId",
+				"publicationId"
+			],
+			properties: {
+				flowId: { type: "string" },
+				name: { type: "string" },
+				revisionId: { type: "string" },
+				publicationId: { type: ["string", "null"] }
+			}
+		}
+	},
+	{
+		handle: "execution",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"runId",
+				"status",
+				"startedAt",
+				"finishedAt"
+			],
+			properties: {
+				runId: { type: "string" },
+				status: { enum: ["failed", "indeterminate"] },
+				startedAt: { type: ["string", "null"] },
+				finishedAt: { type: "string" }
+			}
+		}
+	},
+	{
+		handle: "error",
+		nullable: false,
+		jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: ["code", "message"],
+			properties: {
+				code: { type: "string" },
+				message: { type: "string" },
+				nodeId: { type: "string" },
+				jobId: { type: "string" },
+				path: {
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}
+	}
+];
+var webhookOutputs = [
+	{
+		handle: "headers",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		},
+		nullable: false
+	},
+	{
+		handle: "query",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: {
+				type: ["string", "array"],
+				items: { type: "string" }
+			}
+		},
+		nullable: false
+	},
+	{
+		handle: "body",
+		jsonSchema: {
+			type: "object",
+			additionalProperties: true
+		},
+		nullable: false
+	},
+	{
+		handle: "webhookUrl",
+		jsonSchema: { type: "string" },
+		nullable: false
+	}
+];
+var cronOutputs = [{
+	handle: "scheduledAt",
+	jsonSchema: {
+		type: "string",
+		format: "date-time"
+	},
+	nullable: false
+}];
+function triggerOutputDefinitions(trigger) {
+	switch (trigger.kind) {
+		case "error": return errorOutputs;
+		case "manual": return [];
+		case "cron": return cronOutputs;
+		case "poll":
+		case "integration": return trigger.definition.outputs;
+		case "webhook": return webhookOutputs.filter((port) => port.handle !== "body" || webhookSupportsBody(trigger.method)).map((port) => port.handle === "body" ? Object.assign({}, port, { jsonSchema: {
+			type: "object",
+			additionalProperties: false,
+			properties: Object.fromEntries(trigger.bodyFields.map((field) => [field.handle, field.jsonSchema])),
+			required: trigger.bodyFields.filter((field) => !field.nullable && !Object.hasOwn(field, "value")).map((field) => field.handle)
+		} }) : port);
+	}
+}
+function triggerOutputPorts(trigger) {
+	return Object.fromEntries(triggerOutputDefinitions(trigger).map(({ handle, ...port }) => [handle, port]));
 }
-function connectorProvider(value) {
-	const source = record(value);
-	const homepageUrl = source.homepageUrl;
-	const icon = source.icon;
-	if (source.noSetup !== void 0 && typeof source.noSetup != "boolean") return invalidResponse();
-	exact(source, [
-		...Object.hasOwn(source, "noSetup") ? ["noSetup"] : [],
-		"serviceId",
-		"serviceName",
-		...homepageUrl == null ? [] : ["homepageUrl"],
-		...icon == null ? [] : ["icon"],
-		..."iconSprite" in source ? ["iconSprite"] : [],
-		..."iconSpritePosition" in source ? ["iconSpritePosition"] : []
-	]);
-	if (homepageUrl != null && typeof homepageUrl != "string" || icon != null && typeof icon != "string") return invalidResponse();
+//#endregion
+//#region src/flow/common/graph.ts
+function nodeInputPorts(node) {
+	switch (node.kind) {
+		case "condition": return conditionInputPorts(node);
+		case "value": return {};
+		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
+		case "approval":
+		case "wait": return portsByHandle(node.inputDefinitions);
+		case "cron":
+		case "integration":
+		case "poll":
+		case "error":
+		case "manual":
+		case "webhook": return {};
+	}
+}
+function resolutionActions(node) {
+	return node.kind == "wait" ? ["continue"] : ["approve", "reject"];
+}
+var objectPort = (properties) => ({
+	nullable: false,
+	jsonSchema: {
+		type: "object",
+		properties,
+		required: Object.keys(properties),
+		additionalProperties: false
+	}
+});
+function resolutionOutputPorts(node) {
+	const actions = resolutionActions(node);
+	const inputs = {
+		type: "object",
+		properties: Object.fromEntries(node.inputDefinitions.map((port) => [port.handle, {}])),
+		required: node.inputDefinitions.map((port) => port.handle),
+		additionalProperties: false
+	};
 	return {
-		...homepageUrl == null ? {} : { homepageUrl },
-		...icon == null ? {} : { icon },
-		...providerIconAppearance(source.iconSprite, source.iconSpritePosition),
-		serviceId: string(source.serviceId),
-		serviceName: string(source.serviceName),
-		...source.noSetup === void 0 ? {} : { noSetup: source.noSetup }
+		pending: objectPort({
+			inputs,
+			prompt: { type: "string" },
+			...Object.fromEntries(actions.map((action) => [`${action}Url`, { type: "string" }])),
+			expiresAt: { type: "string" }
+		}),
+		...Object.fromEntries(actions.map((action) => [action, objectPort({
+			inputs,
+			action: { const: action },
+			resolvedAt: { type: "string" },
+			comment: { type: ["string", "null"] }
+		})]))
 	};
 }
+function nodeOutputPorts(node) {
+	switch (node.kind) {
+		case "condition": return {};
+		case "value": return portsByHandle(node.values);
+		case "task": return portsByHandle(node.task.outputs);
+		case "approval":
+		case "wait": return resolutionOutputPorts(node);
+		case "cron":
+		case "integration":
+		case "poll":
+		case "error":
+		case "manual":
+		case "webhook": return triggerOutputPorts(node);
+	}
+}
 //#endregion
 //#region src/control/common/flowInspection.ts
 async function inspectFlowDraft(flow, readDraft) {
@@ -11171,7 +11073,7 @@ var resultQuerySchema = strictObject({
 });
 //#endregion
 //#region src/control/common/results.ts
-var json = json$4();
+var json = json$3();
 var entry = strictObject({
 	pointer: string$1(),
 	type: _enum([
@@ -11603,142 +11505,6 @@ function variableReferences(input) {
 	};
 }
 //#endregion
-//#region src/control/common/publicationDecoders.ts
-function publication(value) {
-	const source = record(value);
-	const liveEnd = source.liveEnd == null ? void 0 : record(source.liveEnd);
-	if (liveEnd != null && typeof liveEnd.enabled != "boolean") return invalidResponse();
-	const operation = source.operation;
-	const sourcePublicationId = source.sourcePublicationId;
-	if (source.version != 1) return invalidResponse();
-	if (operation != "publish" && operation != "rollback") return invalidResponse();
-	if (sourcePublicationId != null && typeof sourcePublicationId != "string") return invalidResponse();
-	return {
-		...liveEnd == null ? {} : { liveEnd: {
-			enabled: liveEnd.enabled,
-			endedAt: string(liveEnd.endedAt)
-		} },
-		actorId: string(source.actorId),
-		closureDigest: string(source.closureDigest),
-		createdAt: string(source.createdAt),
-		engineContract: string(source.engineContract),
-		flowId: string(source.flowId),
-		modelVersion: integer(source.modelVersion),
-		operation,
-		publicationId: string(source.publicationId),
-		sharedAccessDigest: string(source.sharedAccessDigest),
-		revisionDigest: string(source.revisionDigest),
-		revisionId: string(source.revisionId),
-		...sourcePublicationId == null ? {} : { sourcePublicationId },
-		version: 1
-	};
-}
-function publishOperation(value) {
-	const source = record(value);
-	const status = source.status;
-	const common = {
-		createdAt: string(source.createdAt),
-		flowId: string(source.flowId),
-		operationId: string(source.operationId),
-		revisionId: string(source.revisionId),
-		updatedAt: string(source.updatedAt),
-		version: 1
-	};
-	if (source.version != 1) return invalidResponse();
-	switch (status) {
-		case "pending":
-			exact(source, [
-				"createdAt",
-				"flowId",
-				"operationId",
-				"revisionId",
-				"status",
-				"updatedAt",
-				"version"
-			]);
-			return {
-				...common,
-				status
-			};
-		case "succeeded":
-			exact(source, [
-				"createdAt",
-				"flowId",
-				"operationId",
-				"publicationId",
-				"revisionId",
-				"status",
-				"updatedAt",
-				"version"
-			]);
-			return {
-				...common,
-				publicationId: string(source.publicationId),
-				status
-			};
-		case "failed": {
-			exact(source, [
-				"createdAt",
-				"flowId",
-				"issue",
-				"operationId",
-				"revisionId",
-				"status",
-				"updatedAt",
-				"version"
-			]);
-			const issue = record(source.issue);
-			const nodeId = issue.nodeId;
-			exact(issue, [
-				"code",
-				"message",
-				...nodeId == null ? [] : ["nodeId"]
-			]);
-			return {
-				...common,
-				issue: {
-					code: string(issue.code),
-					message: string(issue.message),
-					...nodeId == null ? {} : { nodeId: string(nodeId) }
-				},
-				status
-			};
-		}
-		default: return invalidResponse();
-	}
-}
-function live(value) {
-	const source = record(value);
-	const status = source.status;
-	const candidate = source.publication;
-	if (source.version != 1 || typeof source.hasUnpublishedChanges != "boolean") return invalidResponse();
-	if (status != "not-published" && status != "runnable" && status != "suspended") return invalidResponse();
-	if (status == "not-published" && candidate !== null) return invalidResponse();
-	if (status != "not-published" && candidate === null) return invalidResponse();
-	return {
-		flowId: string(source.flowId),
-		hasUnpublishedChanges: source.hasUnpublishedChanges,
-		publication: candidate === null ? null : publication(candidate),
-		revision: integer(source.revision),
-		status,
-		version: 1
-	};
-}
-function publicationPage(value) {
-	const source = record(value);
-	const nextCursor = source.nextCursor;
-	const total = source.total;
-	if (source.version != 1 || !Array.isArray(source.publications)) return invalidResponse();
-	if (nextCursor != null && typeof nextCursor != "string") return invalidResponse();
-	if (total != null && !Number.isSafeInteger(total)) return invalidResponse();
-	return {
-		...nextCursor == null ? {} : { nextCursor },
-		publications: source.publications.map(publication),
-		...total == null ? {} : { total },
-		version: 1
-	};
-}
-//#endregion
 //#region src/control/common/revisionDecoders.ts
 function revisionMetadata(value) {
 	const source = record(value);
@@ -12327,6 +12093,26 @@ var ControlClient = class {
 		exact(source, ["version"]);
 		if (source.version != 1) return invalidResponse();
 	}
+	async exportFlow(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export`);
+		try {
+			return decodeWorkflowFile(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async importFlow(file, options = {}) {
+		return flow(await this.request("/v1/flows/import", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				version: 1
+			})
+		}));
+	}
 	async createFlow(name, idempotencyKey = `flow-${randomId()}`, teamId) {
 		return flow(await this.request("/v1/flows", {
 			body: JSON.stringify({
@@ -12680,21 +12466,14 @@ var ControlClient = class {
 			method: "POST"
 		}));
 	}
+	async getLiveDetails(flowId, signal) {
+		const details = decodeLiveDetails(await this.request(`/v1/flows/${segment(flowId)}/live/details`, { signal }));
+		if (details.flowId != flowId) return invalidResponse();
+		return details;
+	}
 	async getLive(flowId, signal) {
 		return live(await this.request(`/v1/flows/${segment(flowId)}/live`, { signal }));
 	}
-	async listPublicationResources(flowId, publicationId) {
-		const query = publicationId == null ? "" : `?publicationId=${encodeURIComponent(publicationId)}`;
-		const result = decodePublicationResources(await this.request(`/v1/flows/${segment(flowId)}/resources${query}`));
-		if (result.flowId != flowId || publicationId != null && result.publicationId != publicationId) return invalidResponse();
-		return result;
-	}
-	async getPublicationResource(flowId, resourceId, publicationId) {
-		const query = publicationId == null ? "" : `?publicationId=${encodeURIComponent(publicationId)}`;
-		const result = decodePublicationResource(await this.request(`/v1/flows/${segment(flowId)}/resources/${segment(resourceId)}${query}`));
-		if (result.flowId != flowId || result.resource.resourceId != resourceId || publicationId != null && result.publicationId != publicationId) return invalidResponse();
-		return result;
-	}
 	async listPublications(flowId, options = {}, signal) {
 		const parameters = new URLSearchParams();
 		if (options.cursor != null) parameters.set("cursor", options.cursor);
@@ -12858,4 +12637,4 @@ var ControlClient = class {
 	}
 };
 //#endregion
-export { ApiError, ControlClient, actionSummary, controlErrorCode, controlErrorMetadata, connectorAccess as decodeConnectorAccess, connectorAccessSnapshot as decodeConnectorAccessSnapshot, decodeEventSource, decodeEventSources, decodeResultList, decodeResultRead, decodeRunEvent, decodeTriggerCatalog, flowInspection, inspectFlowDraft, isRunTerminalEvent, nodeDetails, parseProviderAccessSource, parseResultQuery, providerAccessBindingId, providerIconAppearance, publicationResources, readResult, searchTriggerKeys };
+export { ApiError, ControlClient, actionSummary, controlErrorCode, controlErrorMetadata, connectorAccess as decodeConnectorAccess, connectorAccessSnapshot as decodeConnectorAccessSnapshot, decodeEventSource, decodeEventSources, decodeResultList, decodeResultRead, decodeRunEvent, decodeTriggerCatalog, flowInspection, inspectFlowDraft, isRunTerminalEvent, liveEntries, nodeDetails, parseProviderAccessSource, parseResultQuery, providerAccessBindingId, providerIconAppearance, readResult, searchTriggerKeys };