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

package/dist/common/control-api.js

@@ -1,173 +1,3 @@
-//#region src/control/common/providerIconSprite.ts
-/** Optional artwork must never make an otherwise usable catalog unavailable. */
-function providerIconAppearance(metadata, position) {
-	if (!metadata || typeof metadata != "object" || !position || typeof position != "object") return {};
-	const m = metadata;
-	const p = position;
-	if (typeof m.version != "string" || ![
-		m.pixelRatio,
-		m.iconSize,
-		m.width,
-		m.height
-	].every((v) => Number.isInteger(v) && v > 0) || ![
-		m.bleed,
-		p.x,
-		p.y
-	].every((v) => Number.isInteger(v) && v >= 0) || p.x + m.iconSize > m.width || p.y + m.iconSize > m.height) return {};
-	try {
-		for (const url of [m.lightUrl, m.darkUrl]) if (typeof url != "string" || ![
-			"https:",
-			"http:",
-			"data:"
-		].includes(new URL(url).protocol)) return {};
-	} catch {
-		return {};
-	}
-	return {
-		iconSprite: m,
-		iconSpritePosition: {
-			x: p.x,
-			y: p.y
-		}
-	};
-}
-//#endregion
-//#region src/control/common/errors.ts
-var controlErrorCode = {
-	authenticationRequired: "authentication.required",
-	authorizationDenied: "authorization.denied",
-	bindingUnresolved: "binding.unresolved",
-	connectorActionNotFound: "connector.action-not-found",
-	connectorAccessConflict: "connector.access-conflict",
-	connectorAccessInvalid: "connector.access-invalid",
-	connectorAccessRequired: "connector.access-required",
-	connectorAccessUnsupported: "connector.access-unsupported",
-	connectorUnconfigured: "connector.unconfigured",
-	connectorUnavailable: "connector.unavailable",
-	connectorConsoleUnconfigured: "connector.console-unconfigured",
-	engineUnavailable: "engine.unavailable",
-	engineUnsupported: "engine.unsupported",
-	eventSourceInvalid: "event-source.invalid",
-	eventSourceIdentityUnavailable: "event-source.identity-unavailable",
-	eventSourceNotFound: "event-source.not-found",
-	eventSourceConflict: "event-source.conflict",
-	flowInvalid: "flow.invalid",
-	flowRepairRequired: "flow.repair-required",
-	flowUpgradeRequired: "flow.upgrade-required",
-	flowNotFound: "flow.not-found",
-	flowBusy: "flow.busy",
-	flowConflict: "flow.conflict",
-	flowPresentationConflict: "flow.presentation-conflict",
-	flowRevisionConflict: "flow.revision-conflict",
-	liveConflict: "live.conflict",
-	liveNotFound: "live.not-found",
-	pageInvalidCursor: "page.invalid-cursor",
-	publicationConflict: "publication.conflict",
-	publicationNotFound: "publication.not-found",
-	publicationUnsupported: "publication.unsupported",
-	publishOperationNotFound: "publication.operation-not-found",
-	routeNotFound: "route.not-found",
-	runConflict: "run.conflict",
-	runEventsExpired: "run.events-expired",
-	runInvalid: "run.invalid",
-	runNotFound: "run.not-found",
-	runNotTerminal: "run.not-terminal",
-	runOverloaded: "run.overloaded",
-	runWaitNotFound: "run.wait-not-found",
-	triggerKeyInvalid: "trigger-key.invalid",
-	triggerKeyNotFound: "trigger-key.not-found",
-	triggerNotFound: "trigger.not-found",
-	variableInvalid: "variable.invalid",
-	variableLimitReached: "variable.limit-reached",
-	variableNotFound: "variable.not-found"
-};
-var controlErrorMetadata = {
-	[controlErrorCode.eventSourceInvalid]: { status: 400 },
-	[controlErrorCode.eventSourceIdentityUnavailable]: { status: 409 },
-	[controlErrorCode.eventSourceNotFound]: { status: 404 },
-	[controlErrorCode.eventSourceConflict]: { status: 409 },
-	[controlErrorCode.authenticationRequired]: { status: 401 },
-	[controlErrorCode.authorizationDenied]: { status: 403 },
-	[controlErrorCode.bindingUnresolved]: { status: 409 },
-	[controlErrorCode.connectorActionNotFound]: { status: 404 },
-	[controlErrorCode.connectorAccessConflict]: { status: 412 },
-	[controlErrorCode.connectorAccessInvalid]: { status: 409 },
-	[controlErrorCode.connectorAccessRequired]: { status: 409 },
-	[controlErrorCode.connectorAccessUnsupported]: { status: 409 },
-	[controlErrorCode.connectorUnconfigured]: { status: 503 },
-	[controlErrorCode.connectorUnavailable]: { status: 503 },
-	[controlErrorCode.connectorConsoleUnconfigured]: { status: 503 },
-	[controlErrorCode.engineUnavailable]: { status: 503 },
-	[controlErrorCode.engineUnsupported]: { status: 409 },
-	[controlErrorCode.flowInvalid]: { status: 400 },
-	[controlErrorCode.flowRepairRequired]: { status: 409 },
-	[controlErrorCode.flowUpgradeRequired]: { status: 409 },
-	[controlErrorCode.flowNotFound]: { status: 404 },
-	[controlErrorCode.flowBusy]: { status: 409 },
-	[controlErrorCode.flowConflict]: { status: 409 },
-	[controlErrorCode.flowPresentationConflict]: { status: 412 },
-	[controlErrorCode.flowRevisionConflict]: { status: 412 },
-	[controlErrorCode.liveConflict]: { status: 412 },
-	[controlErrorCode.liveNotFound]: { status: 404 },
-	[controlErrorCode.pageInvalidCursor]: { status: 400 },
-	[controlErrorCode.publicationConflict]: { status: 409 },
-	[controlErrorCode.publicationNotFound]: { status: 404 },
-	[controlErrorCode.publicationUnsupported]: { status: 409 },
-	[controlErrorCode.publishOperationNotFound]: { status: 404 },
-	[controlErrorCode.routeNotFound]: { status: 404 },
-	[controlErrorCode.runConflict]: { status: 409 },
-	[controlErrorCode.runEventsExpired]: { status: 410 },
-	[controlErrorCode.runInvalid]: { status: 400 },
-	[controlErrorCode.runNotFound]: { status: 404 },
-	[controlErrorCode.runNotTerminal]: { status: 409 },
-	[controlErrorCode.runOverloaded]: { status: 429 },
-	[controlErrorCode.runWaitNotFound]: { status: 404 },
-	[controlErrorCode.triggerKeyInvalid]: { status: 409 },
-	[controlErrorCode.triggerKeyNotFound]: { status: 404 },
-	[controlErrorCode.triggerNotFound]: { status: 404 },
-	[controlErrorCode.variableInvalid]: { status: 400 },
-	[controlErrorCode.variableLimitReached]: { status: 409 },
-	[controlErrorCode.variableNotFound]: { status: 404 }
-};
-var ApiError = class extends Error {
-	constructor(status, code, message) {
-		super(message);
-		this.code = code;
-		this.name = "ApiError";
-		this.status = status;
-	}
-};
-//#endregion
-//#region src/control/common/decoding.ts
-function invalidResponse() {
-	throw new ApiError(502, "response.invalid", "The Control API returned an invalid response.");
-}
-function record$1(value) {
-	if (value == null || typeof value != "object" || Array.isArray(value)) return invalidResponse();
-	return value;
-}
-function string$1(value) {
-	return typeof value == "string" && value.length > 0 ? value : invalidResponse();
-}
-function exact(value, keys) {
-	const actual = Object.keys(value);
-	if (actual.length != keys.length || actual.some((key) => !keys.includes(key))) invalidResponse();
-}
-function integer$1(value) {
-	return Number.isSafeInteger(value) ? value : invalidResponse();
-}
-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$1(value);
-	return Object.fromEntries(Object.entries(source).map(([key, item]) => [key, jsonValue(item)]));
-}
-function optionalString(value) {
-	if (value == null) return;
-	return string$1(value);
-}
-//#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");
@@ -1200,7 +1030,7 @@ function datetime(args) {
 	return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
 var anyString = /^[\s\S]{0,}$/;
-var integer = /^-?\d+$/;
+var integer$1 = /^-?\d+$/;
 var number$1 = /^-?\d+(?:\.\d+)?$/;
 var boolean$1 = /^(?:true|false)$/i;
 var _null$2 = /^null$/i;
@@ -2950,6 +2780,9 @@ function handlePipeResult(left, next, ctx) {
 		issues: left.issues
 	}, ctx);
 }
+var $ZodPreprocess = /*@__PURE__*/ $constructor("$ZodPreprocess", (inst, def) => {
+	$ZodPipe.init(inst, def);
+});
 var $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
 	$ZodType.init(inst, def);
 	defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
@@ -4684,7 +4517,7 @@ function stringifyKeyNames(bySchema, json, visited) {
 	else if (typeof rest.const === "number") rest.const = String(rest.const);
 	if (!numericType) return rest;
 	rest.type = "string";
-	if (!values) rest.pattern = (types.includes("number") ? number$1 : integer).source;
+	if (!values) rest.pattern = (types.includes("number") ? number$1 : integer$1).source;
 	return rest;
 }
 /** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */
@@ -5217,7 +5050,7 @@ var ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
 		return this.check(/* @__PURE__ */ _isoDuration(ZodISODuration, params));
 	}
 });
-function string(params) {
+function string$1(params) {
 	return /* @__PURE__ */ _string(ZodString, params);
 }
 var ZodStringFormat = /*@__PURE__*/ $constructor("ZodStringFormat", (inst, def) => {
@@ -5565,10 +5398,10 @@ var ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function record$2(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
-		keyType: string(),
+		keyType: string$1(),
 		valueType: keyType,
 		...normalizeParams(valueType)
 	});
@@ -5774,6 +5607,10 @@ function pipe(in_, out) {
 		out
 	});
 }
+var ZodPreprocess = /*@__PURE__*/ $constructor("ZodPreprocess", (inst, def) => {
+	ZodPipe.init(inst, def);
+	$ZodPreprocess.init(inst, def);
+});
 var ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
 	$ZodReadonly.init(inst, def);
 	ZodType.init(inst, def);
@@ -5809,27 +5646,25 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
-function json$2(params) {
+function json$3(params) {
 	const jsonSchema = lazy(() => {
 		return union([
-			string(params),
+			string$1(params),
 			number(),
 			boolean(),
 			_null(),
 			array(jsonSchema),
-			record(string(), jsonSchema)
+			record$2(string$1(), jsonSchema)
 		]);
 	});
 	return jsonSchema;
 }
-//#endregion
-//#region src/openapi/common/authBindings.ts
-/** Never allow credentials to enter a Revision as literal node inputs. */
-function assertOpenApiAuthBindings(document) {
-	for (const graph of [document.graph, ...Object.values(document.subflows).map((subflow) => subflow.graph)]) for (const node of Object.values(graph.nodes)) {
-		if (node.kind != "task" || node.taskId == null || document.tasks[node.taskId]?.executor.kind != "openapi") continue;
-		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && (mapping.kind == "value" || mapping.kind == "sources" && mapping.sources.some((source) => source.kind == "flow"))) throw new TypeError("OpenAPI authentication accepts deployment variables and upstream outputs only.");
-	}
+function preprocess(fn, schema) {
+	return new ZodPreprocess({
+		type: "pipe",
+		in: transform(fn),
+		out: schema
+	});
 }
 //#endregion
 //#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
@@ -5856,6 +5691,65 @@ function dequal(foo, bar) {
 	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"
+]);
+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() {
@@ -6275,7 +6169,7 @@ var ExpressionKind = Object.freeze({
 });
 //#endregion
 //#region src/json-schema-subset/expression/expression.ts
-var expression = (delegate) => (e1, e2) => {
+var expression$1 = (delegate) => (e1, e2) => {
 	const rootNode = {
 		parent: null,
 		swapped: false,
@@ -8263,7 +8157,7 @@ function checkWithResult(extendsContext, schema1, schema2) {
 	const describe = describer();
 	const equals = schemaEqualsChecker(extendsContext);
 	context.isEquals = wrapEqualsCheckerWithCache(isDeepEquals);
-	context.calculate = expression({
+	context.calculate = expression$1({
 		describe,
 		equals,
 		calculate,
@@ -8502,7 +8396,7 @@ var isObject = (x) => x !== null && typeof x === "object";
 var isPlainObject = (x) => isObject(x) && !isArray(x);
 var toPlainObject = (x) => isPlainObject(x) ? x : void 0;
 //#endregion
-//#region src/manifest/common/schemaComparer.ts
+//#region src/flow/common/schemaComparer.ts
 function isStringLikeSchema(value) {
 	return toPlainObject(value)?.type === "string";
 }
@@ -8709,8 +8603,8 @@ function checkJsonDepth(value, depth = 0) {
 //#region src/flow/common/triggerScheduleSchema.ts
 var triggerScheduleSchema = array(union([object({
 	type: literal("cron"),
-	expression: string(),
-	timezone: string()
+	expression: string$1(),
+	timezone: string$1()
 }), object({
 	type: literal("every"),
 	unit: _enum([
@@ -8734,47 +8628,38 @@ var webhookMethods = [
 function webhookSupportsBody(method) {
 	return method !== "GET";
 }
-var text = string();
-var json$1 = json$2();
-var strings = array(text);
+var text = string$1();
+var json$2 = json$3();
+var strings$1 = array(text);
 var port$1 = object({
 	description: text.optional(),
-	jsonSchema: json$1,
+	jsonSchema: json$2,
 	nullable: boolean(),
 	handle: text
 });
-var input = port$1.extend({ value: json$1.optional() });
+var input = port$1.extend({ value: json$2.optional() });
 var group = object({
 	collapsed: boolean().optional(),
 	group: text
 });
-var nodeSource = object({
+var source = union([object({
 	kind: literal("node"),
 	nodeId: text,
 	output: text,
 	field: text.optional()
-});
-var flowSource = object({
-	kind: literal("flow"),
-	input: text
-});
-var source = union([
-	nodeSource,
-	flowSource,
-	object({
-		kind: literal("binding"),
-		bindingId: text
-	})
-]);
+}), object({
+	kind: literal("binding"),
+	bindingId: text
+})]);
 var fixedInput = union([object({ kind: literal("unset") }), object({
 	kind: literal("value"),
-	value: json$1
+	value: json$2
 })]);
 var mapping = union([fixedInput, object({
 	kind: literal("sources"),
 	sources: array(source)
 })]);
-var inputs = record(text, mapping);
+var inputs = record$2(text, mapping);
 var ports$1 = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port$1, group]))
@@ -8819,7 +8704,7 @@ var inline = object({
 });
 var agentValue = union([object({
 	kind: literal("value"),
-	value: json$1
+	value: json$2
 }), object({
 	kind: literal("input"),
 	input: text
@@ -8848,10 +8733,10 @@ var decisionQuestion = discriminatedUnion("type", [
 		name: text,
 		instructions: text,
 		type: literal("score"),
-		criteria: strings
+		criteria: strings$1
 	})
 ]);
-var managed = object({
+var managedFields = object({
 	...ports$1,
 	name: text,
 	executor: union([
@@ -8866,7 +8751,7 @@ var managed = object({
 			method: text,
 			path: text,
 			serverUrl: text,
-			document: json$1,
+			document: json$2,
 			auth: array(object({
 				id: text,
 				type: _enum([
@@ -8902,17 +8787,20 @@ var managed = object({
 				inputs: array(input.extend({ source: agentInput }))
 			})),
 			notification: object({
-				taskId: text,
+				action: text,
+				connectionId: text.optional(),
+				inputDefinitions: array(input),
 				messageHandle: text,
-				inputs: record(text, agentValue)
+				inputs: record$2(text, agentValue)
 			}).optional()
 		})
 	])
-}).transform(limitDecisionTask);
-var operand = union([object({
+});
+var managed = managedFields.transform(limitDecisionTask);
+var operand$1 = union([object({
 	kind: literal("value"),
-	value: json$1.optional(),
-	jsonSchema: json$1.optional()
+	value: json$2.optional(),
+	jsonSchema: json$2.optional()
 }), object({
 	kind: literal("source"),
 	source
@@ -8923,7 +8811,7 @@ var condition = {
 		description: text.optional(),
 		output: text,
 		groups: array(object({ expressions: array(object({
-			left: operand,
+			left: operand$1,
 			operator: _enum([
 				"!=",
 				"<",
@@ -8946,7 +8834,7 @@ var condition = {
 				"notHasValue",
 				"startsWith"
 			]),
-			right: operand.optional()
+			right: operand$1.optional()
 		})) }))
 	}))
 };
@@ -8956,10 +8844,10 @@ var wait = {
 };
 var webhookOptions = object({
 	allowedMethods: never().optional(),
-	allowedOrigins: strings.optional(),
+	allowedOrigins: strings$1.optional(),
 	noResponseBody: never().optional(),
 	responseData: text.optional(),
-	responseHeaders: record(text, text).optional(),
+	responseHeaders: record$2(text, text).optional(),
 	responseStatusCode: number().int().min(200).max(599).optional()
 });
 var webhook = {
@@ -9015,7 +8903,7 @@ var base = {
 var node = union([
 	object({
 		...base,
-		inputs: record(text, never()),
+		inputs: record$2(text, never()),
 		kind: literal("condition"),
 		...condition
 	}),
@@ -9025,21 +8913,10 @@ var node = union([
 		kind: literal("value"),
 		values: array(input)
 	}),
-	object({
-		...base,
-		kind: literal("subflow"),
-		subflowId: text
-	}),
-	object({
-		...base,
-		kind: literal("task"),
-		task: inline,
-		additionalInputs: array(input).optional()
-	}),
 	object({
 		...base,
 		kind: literal("task"),
-		taskId: text,
+		task: union([inline, managed]),
 		additionalInputs: array(input).optional()
 	}),
 	strictObject({
@@ -9075,7 +8952,7 @@ var node = union([
 		...trigger,
 		kind: literal("poll"),
 		connectionId: text.min(1).optional(),
-		config: record(text, fixedInput),
+		config: record$2(text, fixedInput),
 		definition: object({
 			...definition,
 			type: literal("poll")
@@ -9086,7 +8963,7 @@ var node = union([
 		...trigger,
 		kind: literal("integration"),
 		connectionId: text.min(1).optional(),
-		config: record(text, fixedInput),
+		config: record$2(text, fixedInput),
 		definition: object({
 			...definition,
 			type: literal("integration"),
@@ -9094,10 +8971,25 @@ var node = union([
 		})
 	})
 ]);
-var target = union([object({ kind: literal("flow") }), object({
-	kind: literal("subflow"),
-	id: text
-})]);
+/** 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({
 	source: text,
 	target: text,
@@ -9105,15 +8997,10 @@ var edge = object({
 });
 var at = {
 	nodeId: text,
-	target
+	target: never().optional()
 };
-var subflow = object({
-	name: text,
-	inputs: array(input),
-	outputs: array(port$1.extend({ sources: array(union([nodeSource, flowSource])) }))
-});
 var graph = object({
-	nodes: record(text, node),
+	nodes: record$2(text, node),
 	edges: array(edge).default([])
 });
 var binding = object({
@@ -9122,32 +9009,43 @@ var binding = object({
 });
 var module = object({
 	name: text,
-	imports: strings,
+	imports: strings$1,
 	source: text
 });
-var document = object({
-	bindings: record(text, binding),
-	graph,
-	subflows: record(text, subflow.extend({ graph })),
-	tasks: record(text, managed)
-});
+var document = preprocess(rejectRetiredDefinitions, object({
+	bindings: record$2(text, binding),
+	graph
+}));
 var revision = object({
 	modelVersion: union([
 		literal(2),
 		literal(4),
-		literal(5)
+		literal(5),
+		literal(6)
 	]),
 	document,
-	modules: record(text, module)
+	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 record$1(value) {
+	return value != null && typeof value == "object" && !Array.isArray(value) ? value : {};
+}
 function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
-	checkErrorModelVersion(content);
+	checkModelVersion(content);
 	assertOpenApiAuthBindings(content.document);
 	return content;
 }
@@ -9168,17 +9066,22 @@ var shapes = {
 		value: text
 	},
 	"graph.edge.connect": {
-		target,
-		edge
+		edge,
+		target: never().optional()
 	},
 	"graph.edge.disconnect": {
-		target,
-		edge
+		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({
@@ -9237,13 +9140,11 @@ var shapes = {
 	},
 	"graph.node.resolution.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
 		before: object(wait),
 		value: object(wait)
 	},
 	"graph.node.webhook.set": {
 		...at,
-		target: object({ kind: literal("flow") }),
 		before: object(webhook),
 		value: object(webhook)
 	},
@@ -9285,113 +9186,497 @@ var shapes = {
 	},
 	"module.source.replace": {
 		moduleId: text,
-		beforeImports: strings,
+		beforeImports: strings$1,
 		beforeSource: text,
-		imports: strings,
+		imports: strings$1,
 		source: text
 	},
-	"subflow.create": {
-		subflowId: text,
-		subflow: subflow.extend({ graph })
-	},
-	"subflow.definition.set": {
-		subflowId: text,
-		before: subflow,
-		definition: subflow
-	},
-	"subflow.delete": { subflowId: text },
-	"task.create": {
-		taskId: text,
-		task: managed
-	},
-	"task.delete": { taskId: text },
-	"task.connector.connection.set": {
-		taskId: text,
-		before: text.optional(),
-		value: text.optional()
-	},
-	"task.decision.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.openapi.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.agent.set": {
-		taskId: text,
-		before: managed,
-		value: managed
-	},
-	"task.llm.mode.set": {
-		taskId: text,
-		before: _enum(["chat", "json"]),
-		value: _enum(["chat", "json"])
-	},
-	"task.name.set": {
-		taskId: text,
-		before: text,
-		value: 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({
 	kind: literal(kind),
 	...shape
 })])).values()])).min(1);
-function checkErrorModelVersion(content) {
-	if (content.modelVersion < 5 && [content.document.graph, ...Object.values(content.document.subflows).map((item) => item.graph)].some((item) => Object.values(item.nodes).some((itemNode) => itemNode.kind == "error"))) throw new TypeError("Error workflows require Flow model version 5.");
+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 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
-	}]));
-}
+//#region src/control/common/authoringLlm.ts
+var authoringLlmConfiguration = strictObject({
+	mode: _enum(["chat", "json"]),
+	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/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"
+//#region src/control/common/authoringOpenApi.ts
+var authenticationSchema = union([
+	strictObject({ schemes: array(string$1().min(1)).describe("One complete security alternative advertised by this operation; [] selects no authentication.") }),
+	strictObject({ type: _enum(["bearer", "basic"]) }),
+	strictObject({
+		type: literal("apiKey"),
+		name: string$1().min(1),
+		in: _enum(["header", "query"])
+	})
 ]);
-function isSchemaKeyword(value) {
-	return schemaKeywords.has(value);
+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.")
+});
+//#endregion
+//#region src/control/common/authoringSchema.ts
+var id$1 = string$1().min(1);
+var json$1 = json$3();
+var patch = record$2(id$1, json$1);
+var type = _enum([
+	"manual",
+	"webhook",
+	"cron",
+	"error",
+	"poll",
+	"integration",
+	"code",
+	"connector",
+	"agent",
+	"llm",
+	"decision",
+	"openapi",
+	"condition",
+	"value",
+	"wait",
+	"approval"
+]);
+var referenceSchema = id$1.describe("An existing node reference returned by read/search, or $alias for a preceding node.add in this edit batch. For node.add.as \"step\", reference \"$step\", never bare \"step\". Aliases are local to one batch.");
+var output = strictObject({
+	kind: literal("output"),
+	node: referenceSchema,
+	port: id$1.optional().describe("Omit for a node with one output. For multiple outputs, choose a name from node details."),
+	field: string$1().optional()
+});
+var variable$1 = strictObject({
+	kind: literal("variable"),
+	name: id$1
+});
+var authoringSourceSchema = union([
+	output,
+	variable$1,
+	strictObject({
+		kind: literal("value"),
+		value: json$1
+	}),
+	strictObject({ kind: literal("unset") }),
+	strictObject({ kind: literal("default") }),
+	strictObject({
+		kind: literal("sources"),
+		sources: array(union([output, variable$1])).min(1)
+	})
+]);
+var operand = union([
+	strictObject({
+		kind: literal("value"),
+		value: json$1.optional(),
+		schema: json$1.optional()
+	}),
+	output,
+	variable$1
+]);
+var agentTool = authoringDefinitionSchemas.agent.shape.tools.element.omit({
+	id: true,
+	inputs: true
+}).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$2(id$1, union([strictObject({
+		kind: literal("value"),
+		value: json$1
+	}), strictObject({
+		kind: literal("input"),
+		input: id$1
+	})]))
+});
+var field = strictObject({
+	schema: json$1.optional(),
+	nullable: boolean().optional(),
+	description: string$1().optional()
+});
+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,
+	right: operand.optional()
+});
+var all = strictObject({ all: array(expression) });
+var when = union([
+	expression,
+	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$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(), 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 updates = strictObject({
+	name: id$1.optional(),
+	description: string$1().optional(),
+	icon: string$1().optional(),
+	maxExecutions: int().positive().optional(),
+	timeoutMs: number().nonnegative().optional(),
+	config: patch.optional().describe("Recursively merge configuration; omitted fields remain unchanged and arrays replace as a whole. This includes schema objects: {} does not clear an existing schema. Use clear paths to remove fields, e.g. [\"config\",\"inputs\",\"amount\",\"schema\",\"type\"].")
+});
+var authoringEditSchema = discriminatedUnion("op", [
+	strictObject({
+		op: literal("node.add"),
+		as: id$1.regex(/^[A-Za-z][\w-]*$/).describe("Unique batch-local alias without the $ prefix. Later edits must reference this new node as $alias; the bare alias is not its node ID."),
+		type,
+		name: id$1,
+		config: patch.optional(),
+		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()
+	}),
+	strictObject({
+		op: literal("node.update"),
+		node: referenceSchema,
+		set: updates.optional(),
+		clear: array(array(id$1).min(1)).optional()
+	}),
+	strictObject({
+		op: literal("node.remove"),
+		node: referenceSchema
+	}),
+	strictObject({
+		op: literal("input.set"),
+		node: referenceSchema,
+		input: id$1,
+		source: authoringSourceSchema
+	}),
+	strictObject({
+		op: _enum(["edge.connect", "edge.disconnect"]),
+		source: referenceSchema,
+		target: referenceSchema,
+		branch: id$1.optional()
+	}),
+	strictObject({
+		op: literal("text.edit"),
+		node: referenceSchema,
+		field: _enum(["code", "prompt"]),
+		oldText: id$1,
+		newText: string$1()
+	}),
+	strictObject({
+		op: literal("text.set"),
+		node: referenceSchema,
+		field: _enum(["code", "prompt"]),
+		text: string$1()
+	})
+]);
+strictObject({
+	baseRevision: id$1,
+	requestId: id$1.max(256),
+	edits: array(authoringEditSchema).min(1).max(1e3)
+});
+strictObject({
+	revision: id$1.optional().describe("Fixed revision from a previous read; omit to read the current draft."),
+	nodes: array(id$1).min(1).max(100).optional().describe("Node references to read in one batch. Mutually exclusive with text. Long texts return metadata."),
+	text: strictObject({
+		node: id$1,
+		field: _enum(["code", "prompt"]),
+		start: int().positive().default(1),
+		lines: int().min(1).max(200).default(80)
+	}).optional().describe("Read code or prompt by line (1-based). Mutually exclusive with nodes. Follow nextStart at the same revision until truncated is false.")
+}).refine((v) => v.nodes == null || v.text == null, "Choose nodes or text.").meta({
+	not: { required: ["nodes", "text"] },
+	description: "Omit nodes and text for an outline; provide nodes for details, or text for an excerpt."
+});
+strictObject({ revisionId: id$1 });
+strictObject({
+	revision: id$1.optional(),
+	query: id$1.max(1e3),
+	type: type.optional(),
+	offset: int().nonnegative().default(0),
+	limit: int().min(1).max(100).default(20)
+});
+strictObject({
+	type: type.optional(),
+	action: id$1.optional()
+}).refine((v) => v.type == null || v.action == null, "Choose type or action.");
+var authoringDiagnosticSchema = object({
+	code: id$1,
+	message: string$1(),
+	nodes: array(id$1),
+	field: string$1().optional(),
+	line: number().optional(),
+	column: number().optional()
+});
+var authoringCheckResponse = object({
+	flowId: id$1,
+	revisionId: id$1,
+	valid: boolean(),
+	diagnostics: array(authoringDiagnosticSchema),
+	version: literal(1)
+});
+var authoringEditResponse = object({
+	flowId: id$1,
+	saved: literal(true),
+	revision: id$1,
+	nodes: record$2(id$1, id$1),
+	changes: array(object({
+		index: int(),
+		op: id$1,
+		node: id$1.optional()
+	})),
+	validation: object({
+		status: _enum([
+			"valid",
+			"invalid",
+			"unavailable"
+		]),
+		diagnostics: array(authoringDiagnosticSchema).optional()
+	}),
+	version: literal(1)
+});
+var authoringReadResponse = object({
+	flowId: id$1,
+	revision: id$1,
+	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({
+	flowId: id$1,
+	revision: id$1,
+	data: object({
+		matches: array(object({
+			node: id$1,
+			field: id$1,
+			line: int().optional(),
+			excerpt: string$1()
+		})),
+		total: int(),
+		nextOffset: int().optional()
+	}),
+	version: literal(1)
+});
+//#endregion
+//#region src/control/common/providerIconSprite.ts
+/** Optional artwork must never make an otherwise usable catalog unavailable. */
+function providerIconAppearance(metadata, position) {
+	if (!metadata || typeof metadata != "object" || !position || typeof position != "object") return {};
+	const m = metadata;
+	const p = position;
+	if (typeof m.version != "string" || ![
+		m.pixelRatio,
+		m.iconSize,
+		m.width,
+		m.height
+	].every((v) => Number.isInteger(v) && v > 0) || ![
+		m.bleed,
+		p.x,
+		p.y
+	].every((v) => Number.isInteger(v) && v >= 0) || p.x + m.iconSize > m.width || p.y + m.iconSize > m.height) return {};
+	try {
+		for (const url of [m.lightUrl, m.darkUrl]) if (typeof url != "string" || ![
+			"https:",
+			"http:",
+			"data:"
+		].includes(new URL(url).protocol)) return {};
+	} catch {
+		return {};
+	}
+	return {
+		iconSprite: m,
+		iconSpritePosition: {
+			x: p.x,
+			y: p.y
+		}
+	};
 }
-function portsByHandle(ports) {
-	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
+//#endregion
+//#region src/control/common/errors.ts
+var controlErrorCode = {
+	authenticationRequired: "authentication.required",
+	authorizationDenied: "authorization.denied",
+	bindingUnresolved: "binding.unresolved",
+	connectorActionNotFound: "connector.action-not-found",
+	connectorAccessConflict: "connector.access-conflict",
+	connectorAccessInvalid: "connector.access-invalid",
+	connectorAccessRequired: "connector.access-required",
+	connectorAccessUnsupported: "connector.access-unsupported",
+	connectorUnconfigured: "connector.unconfigured",
+	connectorUnavailable: "connector.unavailable",
+	connectorConsoleUnconfigured: "connector.console-unconfigured",
+	engineUnavailable: "engine.unavailable",
+	engineUnsupported: "engine.unsupported",
+	eventSourceInvalid: "event-source.invalid",
+	eventSourceIdentityUnavailable: "event-source.identity-unavailable",
+	eventSourceNotFound: "event-source.not-found",
+	eventSourceConflict: "event-source.conflict",
+	flowInvalid: "flow.invalid",
+	flowRepairRequired: "flow.repair-required",
+	flowUpgradeRequired: "flow.upgrade-required",
+	flowNotFound: "flow.not-found",
+	flowBusy: "flow.busy",
+	flowConflict: "flow.conflict",
+	flowPresentationConflict: "flow.presentation-conflict",
+	flowRevisionConflict: "flow.revision-conflict",
+	liveConflict: "live.conflict",
+	liveNotFound: "live.not-found",
+	pageInvalidCursor: "page.invalid-cursor",
+	publicationConflict: "publication.conflict",
+	publicationNotFound: "publication.not-found",
+	publicationUnsupported: "publication.unsupported",
+	publishOperationNotFound: "publication.operation-not-found",
+	routeNotFound: "route.not-found",
+	runConflict: "run.conflict",
+	runEventsExpired: "run.events-expired",
+	runInvalid: "run.invalid",
+	runNotFound: "run.not-found",
+	runNotTerminal: "run.not-terminal",
+	runOverloaded: "run.overloaded",
+	runWaitNotFound: "run.wait-not-found",
+	triggerKeyInvalid: "trigger-key.invalid",
+	triggerKeyNotFound: "trigger-key.not-found",
+	triggerNotFound: "trigger.not-found",
+	variableInvalid: "variable.invalid",
+	variableLimitReached: "variable.limit-reached",
+	variableNotFound: "variable.not-found"
+};
+var controlErrorMetadata = {
+	[controlErrorCode.eventSourceInvalid]: { status: 400 },
+	[controlErrorCode.eventSourceIdentityUnavailable]: { status: 409 },
+	[controlErrorCode.eventSourceNotFound]: { status: 404 },
+	[controlErrorCode.eventSourceConflict]: { status: 409 },
+	[controlErrorCode.authenticationRequired]: { status: 401 },
+	[controlErrorCode.authorizationDenied]: { status: 403 },
+	[controlErrorCode.bindingUnresolved]: { status: 409 },
+	[controlErrorCode.connectorActionNotFound]: { status: 404 },
+	[controlErrorCode.connectorAccessConflict]: { status: 412 },
+	[controlErrorCode.connectorAccessInvalid]: { status: 409 },
+	[controlErrorCode.connectorAccessRequired]: { status: 409 },
+	[controlErrorCode.connectorAccessUnsupported]: { status: 409 },
+	[controlErrorCode.connectorUnconfigured]: { status: 503 },
+	[controlErrorCode.connectorUnavailable]: { status: 503 },
+	[controlErrorCode.connectorConsoleUnconfigured]: { status: 503 },
+	[controlErrorCode.engineUnavailable]: { status: 503 },
+	[controlErrorCode.engineUnsupported]: { status: 409 },
+	[controlErrorCode.flowInvalid]: { status: 400 },
+	[controlErrorCode.flowRepairRequired]: { status: 409 },
+	[controlErrorCode.flowUpgradeRequired]: { status: 409 },
+	[controlErrorCode.flowNotFound]: { status: 404 },
+	[controlErrorCode.flowBusy]: { status: 409 },
+	[controlErrorCode.flowConflict]: { status: 409 },
+	[controlErrorCode.flowPresentationConflict]: { status: 412 },
+	[controlErrorCode.flowRevisionConflict]: { status: 412 },
+	[controlErrorCode.liveConflict]: { status: 412 },
+	[controlErrorCode.liveNotFound]: { status: 404 },
+	[controlErrorCode.pageInvalidCursor]: { status: 400 },
+	[controlErrorCode.publicationConflict]: { status: 409 },
+	[controlErrorCode.publicationNotFound]: { status: 404 },
+	[controlErrorCode.publicationUnsupported]: { status: 409 },
+	[controlErrorCode.publishOperationNotFound]: { status: 404 },
+	[controlErrorCode.routeNotFound]: { status: 404 },
+	[controlErrorCode.runConflict]: { status: 409 },
+	[controlErrorCode.runEventsExpired]: { status: 410 },
+	[controlErrorCode.runInvalid]: { status: 400 },
+	[controlErrorCode.runNotFound]: { status: 404 },
+	[controlErrorCode.runNotTerminal]: { status: 409 },
+	[controlErrorCode.runOverloaded]: { status: 429 },
+	[controlErrorCode.runWaitNotFound]: { status: 404 },
+	[controlErrorCode.triggerKeyInvalid]: { status: 409 },
+	[controlErrorCode.triggerKeyNotFound]: { status: 404 },
+	[controlErrorCode.triggerNotFound]: { status: 404 },
+	[controlErrorCode.variableInvalid]: { status: 400 },
+	[controlErrorCode.variableLimitReached]: { status: 409 },
+	[controlErrorCode.variableNotFound]: { status: 404 }
+};
+var ApiError = class extends Error {
+	constructor(status, code, message, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "ApiError";
+		this.status = status;
+	}
+};
+//#endregion
+//#region src/control/common/decoding.ts
+var InvalidResponseError = class extends ApiError {
+	constructor(detail) {
+		super(502, "response.invalid", `The Control API returned an invalid response.${detail == null ? "" : ` ${detail}`}`);
+		this.detail = detail;
+	}
+};
+function invalidResponse(detail) {
+	throw new InvalidResponseError(detail);
+}
+function record(value) {
+	if (value == null || typeof value != "object" || Array.isArray(value)) return invalidResponse("Expected an object.");
+	return value;
+}
+function string(value) {
+	return typeof value == "string" && value.length > 0 ? value : invalidResponse("Expected a non-empty string.");
+}
+function exact(value, keys) {
+	const actual = Object.keys(value);
+	if (actual.length != keys.length || actual.some((key) => !keys.includes(key))) {
+		const missing = keys.filter((key) => !Object.hasOwn(value, key));
+		const unexpected = actual.filter((key) => !keys.includes(key));
+		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);
+	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/flow/common/encoding.ts
@@ -9414,7 +9699,7 @@ async function digestBytes(bytes) {
 //#region src/control/common/providerAccess.ts
 var sourceSchema = discriminatedUnion("kind", [strictObject({ kind: literal("admin-delegation") }), strictObject({
 	kind: literal("policy"),
-	ruleId: string().min(1).nullable()
+	ruleId: string$1().min(1).nullable()
 })]);
 function parseProviderAccessSource(value) {
 	return sourceSchema.parse(value);
@@ -9432,7 +9717,7 @@ async function providerAccessBindingId(teamId, identity) {
 //#endregion
 //#region src/control/common/connectorDecoders.ts
 function accessPermissions(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"actionIds",
 		"allActions",
@@ -9441,10 +9726,19 @@ function accessPermissions(value) {
 		"configured",
 		"proxy"
 	]);
-	if (!Array.isArray(source.triggerIds) || typeof source.allTriggers != "boolean" || !Array.isArray(source.actionIds) || typeof source.allActions != "boolean" || typeof source.configured != "boolean" || typeof source.proxy != "boolean") return invalidResponse();
-	const actionIds = source.actionIds.map(string$1);
-	const triggerIds = source.triggerIds.map(string$1);
-	if (new Set(actionIds).size != actionIds.length || source.allActions && actionIds.length != 0 || new Set(triggerIds).size != triggerIds.length || source.allTriggers && triggerIds.length != 0 || source.proxy && (!source.allActions || !source.allTriggers || source.configured)) return invalidResponse();
+	if (!Array.isArray(source.actionIds)) return invalidResponse("permissions.actionIds: expected an array.");
+	if (!Array.isArray(source.triggerIds)) return invalidResponse("permissions.triggerIds: expected an array.");
+	if (typeof source.allActions != "boolean") return invalidResponse("permissions.allActions: expected a boolean.");
+	if (typeof source.allTriggers != "boolean") return invalidResponse("permissions.allTriggers: expected a boolean.");
+	if (typeof source.configured != "boolean") return invalidResponse("permissions.configured: expected a boolean.");
+	if (typeof source.proxy != "boolean") return invalidResponse("permissions.proxy: expected a boolean.");
+	const actionIds = source.actionIds.map(string);
+	const triggerIds = source.triggerIds.map(string);
+	if (new Set(actionIds).size != actionIds.length) return invalidResponse("permissions.actionIds: duplicate IDs.");
+	if (source.allActions && actionIds.length != 0) return invalidResponse("permissions.actionIds: must be empty when allActions is true.");
+	if (new Set(triggerIds).size != triggerIds.length) return invalidResponse("permissions.triggerIds: duplicate IDs.");
+	if (source.allTriggers && triggerIds.length != 0) return invalidResponse("permissions.triggerIds: must be empty when allTriggers is true.");
+	if (source.proxy && (!source.allActions || !source.allTriggers || source.configured)) return invalidResponse("permissions.proxy: requires allActions=true, allTriggers=true and configured=false.");
 	return {
 		actionIds,
 		triggerIds,
@@ -9455,7 +9749,7 @@ function accessPermissions(value) {
 	};
 }
 function accessBinding(value, candidate) {
-	const source = record$1(value);
+	const source = record(value);
 	const policyRevision = source.policyRevision;
 	const status = source.status;
 	const isDefault = source.isDefault;
@@ -9474,35 +9768,35 @@ function accessBinding(value, candidate) {
 		"providerId",
 		...candidate ? [] : ["status"]
 	]);
-	if (policyRevision != null && typeof policyRevision != "string") return invalidResponse();
-	if (candidate && isDefault !== void 0 && typeof isDefault != "boolean") return invalidResponse();
-	if (permissionGroupName !== void 0 && permissionGroupName !== null && typeof permissionGroupName != "string") return invalidResponse();
+	if (policyRevision != null && typeof policyRevision != "string") return invalidResponse("policyRevision: expected a string.");
+	if (candidate && isDefault !== void 0 && typeof isDefault != "boolean") return invalidResponse("isDefault: expected a boolean.");
+	if (permissionGroupName !== void 0 && permissionGroupName !== null && typeof permissionGroupName != "string") return invalidResponse("permissionGroupName: expected a string or null.");
 	if (!candidate && status != "active" && status != "forbidden" && status != "invalid" && status != "missing") return invalidResponse();
 	let bindingSource;
 	try {
 		bindingSource = parseProviderAccessSource(source.source);
 	} catch {
-		return invalidResponse();
+		return invalidResponse("source: expected { kind: 'admin-delegation' } or { kind: 'policy', ruleId: string | null }.");
 	}
 	return {
-		accessBindingId: string$1(source.accessBindingId),
-		connectionId: string$1(source.connectionId),
+		accessBindingId: string(source.accessBindingId),
+		connectionId: string(source.connectionId),
 		source: bindingSource,
-		connectionDisplayName: string$1(legacy ? source.displayName : source.connectionDisplayName),
+		connectionDisplayName: string(legacy ? source.displayName : source.connectionDisplayName),
 		...candidate && typeof isDefault == "boolean" ? { isDefault } : {},
 		...permissions == null ? {} : { permissions },
 		...permissionGroupName === void 0 ? {} : { permissionGroupName },
 		...policyRevision == null ? {} : { policyRevision },
-		providerId: string$1(source.providerId),
+		providerId: string(source.providerId),
 		...candidate ? {} : { status }
 	};
 }
 function accessMode(value) {
-	if (value != "implicit" && value != "selectable") return invalidResponse();
+	if (value != "implicit" && value != "selectable") return invalidResponse("mode: expected implicit or selectable.");
 	return value;
 }
 function connectorAccess(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"accessRevision",
 		"bindings",
@@ -9512,12 +9806,12 @@ function connectorAccess(value) {
 		..."discardedBindingCount" in source ? ["discardedBindingCount"] : [],
 		"version"
 	]);
-	const accessRevision = integer$1(source.accessRevision);
+	const accessRevision = integer(source.accessRevision);
 	if (source.version != 1 || accessRevision < 0 || !Array.isArray(source.bindings)) return invalidResponse();
 	if ("providerIds" in source && !Array.isArray(source.providerIds)) return invalidResponse();
-	const providerIds = source.providerIds == null ? void 0 : source.providerIds.map((id) => string$1(id));
+	const providerIds = source.providerIds == null ? void 0 : source.providerIds.map((id) => string(id));
 	if (providerIds != null && new Set(providerIds).size != providerIds.length) return invalidResponse();
-	let discardedBindingCount = source.discardedBindingCount == null ? 0 : integer$1(source.discardedBindingCount);
+	let discardedBindingCount = source.discardedBindingCount == null ? 0 : integer(source.discardedBindingCount);
 	if (discardedBindingCount < 0) return invalidResponse();
 	const bindings = [];
 	for (const entry of source.bindings) try {
@@ -9542,14 +9836,14 @@ function connectorAccess(value) {
 		...providerIds == null ? {} : { providerIds },
 		bindings,
 		mode: accessMode(source.mode),
-		sharedAccessDigest: string$1(source.sharedAccessDigest),
+		sharedAccessDigest: string(source.sharedAccessDigest),
 		version: 1
 	};
 }
 function accessGrants(value) {
 	if (!Array.isArray(value)) return invalidResponse();
 	const bindings = value.map((candidate) => {
-		const entry = record$1(candidate);
+		const entry = record(candidate);
 		exact(entry, [
 			"accessBindingId",
 			"connectionId",
@@ -9566,11 +9860,11 @@ function accessGrants(value) {
 		}
 		if (entry.permissionGroupName != null && typeof entry.permissionGroupName != "string") return invalidResponse();
 		return {
-			accessBindingId: string$1(entry.accessBindingId),
-			connectionId: string$1(entry.connectionId),
-			providerId: string$1(entry.providerId),
+			accessBindingId: string(entry.accessBindingId),
+			connectionId: string(entry.connectionId),
+			providerId: string(entry.providerId),
 			source: identity,
-			connectionDisplayName: string$1(entry.connectionDisplayName),
+			connectionDisplayName: string(entry.connectionDisplayName),
 			..."permissionGroupName" in entry ? { permissionGroupName: entry.permissionGroupName } : {}
 		};
 	});
@@ -9578,7 +9872,7 @@ function accessGrants(value) {
 	return bindings;
 }
 function connectorAccessSnapshot(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"mode",
 		"sharedAccessDigest",
@@ -9593,24 +9887,26 @@ function connectorAccessSnapshot(value) {
 	if (mode == "implicit" && (sharedBindings.length > 0 || selectedBindings.length > 0)) return invalidResponse();
 	return {
 		mode,
-		sharedAccessDigest: string$1(source.sharedAccessDigest),
+		sharedAccessDigest: string(source.sharedAccessDigest),
 		sharedBindings,
 		selectedBindings,
 		version: 2
 	};
 }
 function connectorAccessCandidates(value, providerId) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"candidates",
 		"mode",
 		"providerId",
 		"version"
 	]);
-	if (source.version != 1 || string$1(source.providerId) != providerId || !Array.isArray(source.candidates)) return invalidResponse();
+	if (source.version != 1) return invalidResponse("version: expected 1.");
+	if (string(source.providerId) != providerId) return invalidResponse("providerId: does not match the requested provider.");
+	if (!Array.isArray(source.candidates)) return invalidResponse("candidates: expected an array.");
 	const candidates = source.candidates.map((candidate) => accessBinding(candidate, true));
-	if (candidates.some((candidate) => candidate.providerId != providerId)) return invalidResponse();
-	if (new Set(candidates.map((candidate) => candidate.accessBindingId)).size != candidates.length) return invalidResponse();
+	if (candidates.some((candidate) => candidate.providerId != providerId)) return invalidResponse("candidates[].providerId: does not match the requested provider.");
+	if (new Set(candidates.map((candidate) => candidate.accessBindingId)).size != candidates.length) return invalidResponse("candidates[].accessBindingId: duplicate IDs.");
 	return {
 		candidates,
 		mode: accessMode(source.mode),
@@ -9619,34 +9915,35 @@ function connectorAccessCandidates(value, providerId) {
 	};
 }
 function connectorAccessCandidatesBatch(value, providerIds) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, ["results", "version"]);
-	if (source.version != 1 || !Array.isArray(source.results)) return invalidResponse();
+	if (source.version != 1) return invalidResponse("version: expected 1.");
+	if (!Array.isArray(source.results)) return invalidResponse("results: expected an array.");
 	const remaining = new Set(providerIds);
 	const results = source.results.map((entry) => {
-		const item = record$1(entry);
-		const providerId = string$1(item.providerId);
-		if (!remaining.delete(providerId)) return invalidResponse();
+		const item = record(entry);
+		const providerId = string(item.providerId);
+		if (!remaining.delete(providerId)) return invalidResponse("results[].providerId: duplicate or unrequested provider.");
 		if (!Object.hasOwn(item, "error")) return connectorAccessCandidates(item, providerId);
 		exact(item, ["providerId", "error"]);
-		const error = record$1(item.error);
+		const error = record(item.error);
 		exact(error, ["code", "message"]);
 		return {
 			providerId,
 			error: {
-				code: string$1(error.code),
-				message: string$1(error.message)
+				code: string(error.code),
+				message: string(error.message)
 			}
 		};
 	});
-	if (remaining.size != 0) return invalidResponse();
+	if (remaining.size != 0) return invalidResponse("results: missing requested providers.");
 	return {
 		results,
 		version: 1
 	};
 }
 function connection(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		...Object.hasOwn(source, "providerAccountId") ? ["providerAccountId"] : [],
 		...Object.hasOwn(source, "alias") ? ["alias"] : [],
@@ -9662,18 +9959,18 @@ function connection(value) {
 	if (status != "active" && status != "disconnected" && status != "error" && status != "reauth_required") return invalidResponse();
 	if (typeof source.isDefault != "boolean") return invalidResponse();
 	return {
-		...source.providerAccountId === void 0 ? {} : { providerAccountId: string$1(source.providerAccountId) },
-		...source.alias === void 0 ? {} : { alias: string$1(source.alias) },
+		...source.providerAccountId === void 0 ? {} : { providerAccountId: string(source.providerAccountId) },
+		...source.alias === void 0 ? {} : { alias: string(source.alias) },
 		...source.builtInAccount === void 0 ? {} : { builtInAccount: source.builtInAccount },
-		connectionId: string$1(source.connectionId),
-		displayName: string$1(source.displayName),
+		connectionId: string(source.connectionId),
+		displayName: string(source.displayName),
 		isDefault: source.isDefault,
-		serviceId: string$1(source.serviceId),
+		serviceId: string(source.serviceId),
 		status
 	};
 }
 function port(value, input = false) {
-	const source = record$1(value);
+	const source = record(value);
 	const description = source.description;
 	const hasValue = input && Object.hasOwn(source, "value");
 	exact(source, [
@@ -9695,10 +9992,10 @@ function inputPort(value) {
 	return port(value, true);
 }
 function ports(value, decode) {
-	return Object.fromEntries(Object.entries(record$1(value)).map(([handle, candidate]) => [handle, decode(candidate)]));
+	return Object.fromEntries(Object.entries(record(value)).map(([handle, candidate]) => [handle, decode(candidate)]));
 }
 function connectorActionMetadata(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const homepageUrl = source.homepageUrl;
 	const icon = source.icon;
 	exact(source, [
@@ -9722,22 +10019,22 @@ function connectorActionMetadata(value) {
 	return {
 		...source.inputSchema === void 0 ? {} : { inputSchema: jsonValue(source.inputSchema) },
 		...source.outputSchema === void 0 ? {} : { outputSchema: jsonValue(source.outputSchema) },
-		actionId: string$1(source.actionId),
-		...source.operationType == null ? {} : { operationType: string$1(source.operationType) },
+		actionId: string(source.actionId),
+		...source.operationType == null ? {} : { operationType: string(source.operationType) },
 		authenticated: typeof source.authenticated == "boolean" ? source.authenticated : invalidResponse(),
 		description: typeof source.description == "string" ? source.description : invalidResponse(),
 		...homepageUrl == null ? {} : { homepageUrl },
 		...icon == null ? {} : { icon },
 		...providerIconAppearance(source.iconSprite, source.iconSpritePosition),
 		inputs: ports(source.inputs, inputPort),
-		name: string$1(source.name),
+		name: string(source.name),
 		outputs: ports(source.outputs, port),
-		serviceId: string$1(source.serviceId),
-		serviceName: string$1(source.serviceName)
+		serviceId: string(source.serviceId),
+		serviceName: string(source.serviceName)
 	};
 }
 function connectorAction(value) {
-	const { defaultConnection, ...metadata } = record$1(value);
+	const { defaultConnection, ...metadata } = record(value);
 	const action = connectorActionMetadata(metadata);
 	if (defaultConnection == null) return action;
 	const preferred = connection(defaultConnection);
@@ -9748,7 +10045,7 @@ function connectorAction(value) {
 	};
 }
 function connectorProvider(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const homepageUrl = source.homepageUrl;
 	const icon = source.icon;
 	if (source.noSetup !== void 0 && typeof source.noSetup != "boolean") return invalidResponse();
@@ -9766,8 +10063,8 @@ function connectorProvider(value) {
 		...homepageUrl == null ? {} : { homepageUrl },
 		...icon == null ? {} : { icon },
 		...providerIconAppearance(source.iconSprite, source.iconSpritePosition),
-		serviceId: string$1(source.serviceId),
-		serviceName: string$1(source.serviceName),
+		serviceId: string(source.serviceId),
+		serviceName: string(source.serviceName),
 		...source.noSetup === void 0 ? {} : { noSetup: source.noSetup }
 	};
 }
@@ -9896,12 +10193,11 @@ function triggerOutputPorts(trigger) {
 }
 //#endregion
 //#region src/flow/common/graph.ts
-function nodeInputPorts(document, node) {
+function nodeInputPorts(node) {
 	switch (node.kind) {
 		case "condition": return conditionInputPorts(node);
 		case "value": return {};
-		case "subflow": return portsByHandle(document.subflows[node.subflowId]?.inputs ?? []);
-		case "task": return portsByHandle([...node.task != null ? node.task.inputs : document.tasks[node.taskId]?.inputs ?? [], ...node.additionalInputs ?? []]);
+		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
 		case "approval":
 		case "wait": return portsByHandle(node.inputDefinitions);
 		case "cron":
@@ -9947,12 +10243,11 @@ function resolutionOutputPorts(node) {
 		})]))
 	};
 }
-function nodeOutputPorts(document, node) {
+function nodeOutputPorts(node) {
 	switch (node.kind) {
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
-		case "subflow": return portsByHandle(document.subflows[node.subflowId]?.outputs ?? []);
-		case "task": return portsByHandle(node.task != null ? node.task.outputs : document.tasks[node.taskId]?.outputs ?? []);
+		case "task": return portsByHandle(node.task.outputs);
 		case "approval":
 		case "wait": return resolutionOutputPorts(node);
 		case "cron":
@@ -10003,15 +10298,6 @@ function flowInspection(inspected, live, full = false) {
 		draft: {
 			revisionId: draft.revisionId,
 			graph: inspectGraph(document, document.graph),
-			subflows: Object.fromEntries(Object.entries(document.subflows).map(([id, subflow]) => [id, {
-				name: subflow.name,
-				inputs: inspectPorts(subflow.inputs),
-				outputs: subflow.outputs.map((port) => ({
-					handle: port.handle,
-					sources: port.sources
-				})),
-				graph: inspectGraph(document, subflow.graph)
-			}])),
 			bindings: document.bindings,
 			modules: Object.fromEntries(Object.entries(modules).map(([id, module]) => [id, {
 				name: module.name,
@@ -10041,18 +10327,17 @@ function inspectGraph(document, graph) {
 		edges: graph.edges
 	};
 }
-function inspectNode(document, node) {
-	const inputs = nodeInputPorts(document, node);
+function inspectNode(_document, node) {
+	const inputs = nodeInputPorts(node);
 	const defaults = Object.fromEntries(Object.entries(inputs).flatMap(([handle, port]) => Object.hasOwn(port, "value") && !("inputs" in node && Object.hasOwn(node.inputs, handle)) ? [[handle, port.value]] : []));
 	const ports = {
 		inputHandles: Object.keys(inputs),
-		outputHandles: Object.keys(nodeOutputPorts(document, node)),
+		outputHandles: Object.keys(nodeOutputPorts(node)),
 		...Object.keys(defaults).length == 0 ? {} : { inputDefaults: defaults }
 	};
 	switch (node.kind) {
 		case "task": {
-			const { task: inline, additionalInputs: _additional, ...instance } = node;
-			const task = inline ?? document.tasks[node.taskId];
+			const { task, additionalInputs: _additional, ...instance } = node;
 			return {
 				...instance,
 				...ports,
@@ -10112,8 +10397,7 @@ function inspectNode(document, node) {
 		};
 		case "error":
 		case "manual":
-		case "cron":
-		case "subflow": return {
+		case "cron": return {
 			...node,
 			...ports
 		};
@@ -10144,7 +10428,7 @@ function nodeDetails(content, nodeId, node) {
 		node,
 		nodeId
 	};
-	if (node.task != null) {
+	if ("moduleId" in node.task) {
 		const module = content.modules[node.task.moduleId];
 		return {
 			node,
@@ -10152,7 +10436,7 @@ function nodeDetails(content, nodeId, node) {
 			...module == null ? {} : { module }
 		};
 	}
-	const task = content.document.tasks[node.taskId];
+	const task = node.task;
 	return {
 		node,
 		nodeId,
@@ -10161,9 +10445,9 @@ function nodeDetails(content, nodeId, node) {
 }
 //#endregion
 //#region src/control/common/eventSources.ts
-var id = string().min(1).max(256);
-var eventType = string().regex(/^[a-z][a-z0-9_.]{0,127}$/);
-var name = string().trim().min(1).max(128);
+var id = string$1().min(1).max(256);
+var eventType = string$1().regex(/^[a-z][a-z0-9_.]{0,127}$/);
+var name = string$1().trim().min(1).max(128);
 var eventSourceSchema = strictObject({
 	version: literal(1),
 	sourceId: id,
@@ -10178,13 +10462,13 @@ var eventSourceSchema = strictObject({
 	manageSubscriptions: boolean(),
 	verificationTokenConfigured: boolean(),
 	encryptKeyConfigured: boolean(),
-	endpointUrl: string().nullable(),
-	verifiedAt: string().nullable(),
-	lastReceivedAt: string().nullable(),
-	updatedAt: string(),
+	endpointUrl: string$1().nullable(),
+	verifiedAt: string$1().nullable(),
+	lastReceivedAt: string$1().nullable(),
+	updatedAt: string$1(),
 	consumers: array(strictObject({
 		flowId: id,
-		flowName: string(),
+		flowName: string$1(),
 		triggerNodeId: id
 	}))
 });
@@ -10213,32 +10497,32 @@ function isUiLanguage(value) {
 //#endregion
 //#region src/trigger/common/configSchema.ts
 var configInputsSchema = array(union([strictObject({
-	handle: string().min(1),
-	description: string().optional(),
-	jsonSchema: json$2(),
+	handle: string$1().min(1),
+	description: string$1().optional(),
+	jsonSchema: json$3(),
 	nullable: boolean(),
-	value: json$2().optional()
+	value: json$3().optional()
 }), strictObject({
-	group: string(),
+	group: string$1(),
 	collapsed: boolean().optional()
 })]));
 //#endregion
 //#region src/control/common/triggerDecoders.ts
 function triggerKeySummary(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const type = source.type;
 	if (type != "integration" && type != "poll") return invalidResponse();
 	return {
 		description: typeof source.description == "string" ? source.description : invalidResponse(),
-		displayName: string$1(source.displayName),
-		key: string$1(source.key),
-		name: string$1(source.name),
-		provider: string$1(source.provider),
+		displayName: string(source.displayName),
+		key: string(source.key),
+		name: string(source.name),
+		provider: string(source.provider),
 		type
 	};
 }
 function triggerKey(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const summary = triggerKeySummary(source);
 	const base = {
 		configInputs: configInputsSchema.parse(source.configInputs),
@@ -10248,12 +10532,12 @@ function triggerKey(value) {
 		key: summary.key,
 		name: summary.name,
 		outputs: (Array.isArray(source.outputs) ? source.outputs : invalidResponse()).map((entry) => {
-			const port = record$1(entry);
+			const port = record(entry);
 			return Object.assign({
-				handle: string$1(port.handle),
+				handle: string(port.handle),
 				jsonSchema: jsonValue(port.jsonSchema),
 				nullable: typeof port.nullable === "boolean" ? port.nullable : invalidResponse()
-			}, port.description == null ? {} : { description: string$1(port.description) });
+			}, port.description == null ? {} : { description: string(port.description) });
 		}),
 		provider: summary.provider
 	};
@@ -10261,12 +10545,12 @@ function triggerKey(value) {
 		...base,
 		type: "poll"
 	};
-	const endpoint = record$1(source.endpoint);
-	const body = record$1(endpoint.body);
+	const endpoint = record(source.endpoint);
+	const body = record(endpoint.body);
 	if (!Array.isArray(endpoint.methods) || !Array.isArray(body.formats) || typeof body.allowArray != "boolean" || typeof body.allowEmpty != "boolean") return invalidResponse();
-	const methods = endpoint.methods.map(string$1);
-	const formats = body.formats.map(string$1);
-	const successStatus = integer$1(endpoint.successStatus);
+	const methods = endpoint.methods.map(string);
+	const formats = body.formats.map(string);
+	const successStatus = integer(endpoint.successStatus);
 	if (methods.some((method) => ![
 		"DELETE",
 		"GET",
@@ -10318,38 +10602,38 @@ var triggerActivityKinds = /* @__PURE__ */ new Set([
 	"operator.resumed"
 ]);
 function triggerBinding(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const health = source.health;
-	const listener = source.listener == null ? void 0 : record$1(source.listener);
+	const listener = source.listener == null ? void 0 : record(source.listener);
 	if (listener != null && listener.health != "healthy" && listener.health != "failed" && listener.health != "needs_reauth") return invalidResponse();
 	const kind = source.kind;
 	const operatorState = source.operatorState;
-	const runtimeVersion = integer$1(source.runtimeVersion);
+	const runtimeVersion = integer(source.runtimeVersion);
 	if (source.version != 1 || typeof health != "string" || !triggerHealth.has(health)) return invalidResponse();
 	if (typeof kind != "string" || !triggerKinds.has(kind)) return invalidResponse();
 	if (operatorState != "active" && operatorState != "paused") return invalidResponse();
 	if (runtimeVersion <= 0) return invalidResponse();
 	return {
-		...source.currentPublicationId == null ? {} : { currentPublicationId: string$1(source.currentPublicationId) },
-		...source.currentRevisionId == null ? {} : { currentRevisionId: string$1(source.currentRevisionId) },
-		...source.endpointUrl == null ? {} : { endpointUrl: string$1(source.endpointUrl) },
+		...source.currentPublicationId == null ? {} : { currentPublicationId: string(source.currentPublicationId) },
+		...source.currentRevisionId == null ? {} : { currentRevisionId: string(source.currentRevisionId) },
+		...source.endpointUrl == null ? {} : { endpointUrl: string(source.endpointUrl) },
 		...listener == null ? {} : { listener: {
 			health: listener.health,
-			...listener.lastErrorCode == null ? {} : { lastErrorCode: string$1(listener.lastErrorCode) }
+			...listener.lastErrorCode == null ? {} : { lastErrorCode: string(listener.lastErrorCode) }
 		} },
-		flowId: string$1(source.flowId),
+		flowId: string(source.flowId),
 		health,
 		kind,
-		...source.lastErrorCode == null ? {} : { lastErrorCode: string$1(source.lastErrorCode) },
+		...source.lastErrorCode == null ? {} : { lastErrorCode: string(source.lastErrorCode) },
 		operatorState,
 		runtimeVersion,
-		triggerNodeId: string$1(source.triggerNodeId),
-		updatedAt: string$1(source.updatedAt),
+		triggerNodeId: string(source.triggerNodeId),
+		updatedAt: string(source.updatedAt),
 		version: 1
 	};
 }
 function triggerBindingDetail(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (source.version != 1) return invalidResponse();
 	return {
 		binding: triggerBinding(source.binding),
@@ -10357,22 +10641,22 @@ function triggerBindingDetail(value) {
 	};
 }
 function triggerActivity(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const kind = source.kind;
 	if (typeof kind != "string" || !triggerActivityKinds.has(kind)) return invalidResponse();
 	const errorCode = optionalString(source.errorCode);
 	const errorMessage = optionalString(source.errorMessage);
 	if (errorMessage != null && errorMessage.length > 512) return invalidResponse();
 	return {
-		activityId: string$1(source.activityId),
-		createdAt: string$1(source.createdAt),
+		activityId: string(source.activityId),
+		createdAt: string(source.createdAt),
 		...errorCode == null ? {} : { errorCode },
 		...errorMessage == null ? {} : { errorMessage },
 		kind
 	};
 }
 function triggerActivityPage(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const nextCursor = optionalString(source.nextCursor);
 	if (source.version != 1 || !Array.isArray(source.activities)) return invalidResponse();
 	return {
@@ -10382,12 +10666,12 @@ function triggerActivityPage(value) {
 	};
 }
 function pollTriggerTestResult(value) {
-	const source = record$1(value);
-	const filtered = integer$1(source.filtered);
+	const source = record(value);
+	const filtered = integer(source.filtered);
 	if (source.version != 1 || !Array.isArray(source.events) || typeof source.hasMore != "boolean" || filtered < 0) return invalidResponse();
 	return {
 		events: source.events.map((event) => {
-			const object = record$1(event);
+			const object = record(event);
 			return Object.fromEntries(Object.entries(object).map(([key, item]) => [key, jsonValue(item)]));
 		}),
 		filtered,
@@ -10398,7 +10682,7 @@ function pollTriggerTestResult(value) {
 //#endregion
 //#region src/control/common/triggerCatalog.ts
 function decodeTriggerCatalog(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"version",
 		"locale",
@@ -10407,12 +10691,12 @@ function decodeTriggerCatalog(value) {
 	]);
 	if (source.version != 3 || !isUiLanguage(source.locale) || !Array.isArray(source.definitions)) return invalidResponse();
 	const definitions = source.definitions.map(triggerKey);
-	const entries = record$1(source.display);
+	const entries = record(source.display);
 	const keys = new Set(definitions.map((definition) => definition.key));
 	if (keys.size != definitions.length || Object.keys(entries).length != keys.size) return invalidResponse();
 	const display = Object.fromEntries(definitions.map((definition) => {
 		const { key } = definition;
-		const copy = record$1(entries[key]);
+		const copy = record(entries[key]);
 		exact(copy, [
 			"configInputs",
 			"configInputLabels",
@@ -10423,8 +10707,8 @@ function decodeTriggerCatalog(value) {
 		return [key, {
 			configInputs: descriptions(copy.configInputs, definition.configInputs.flatMap((field) => "handle" in field ? [field.handle] : [])),
 			configInputLabels: labels(copy.configInputLabels, definition.configInputs.flatMap((field) => "handle" in field ? [field.handle] : [])),
-			displayName: string$1(copy.displayName),
-			description: string$1(copy.description),
+			displayName: string(copy.displayName),
+			description: string(copy.description),
 			outputs: descriptions(copy.outputs, definition.outputs.map((field) => field.handle))
 		}];
 	}));
@@ -10436,15 +10720,15 @@ function decodeTriggerCatalog(value) {
 	};
 }
 function descriptions(value, handles) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, handles);
-	return Object.fromEntries(Object.entries(source).map(([handle, description]) => [handle, string$1(description)]));
+	return Object.fromEntries(Object.entries(source).map(([handle, description]) => [handle, string(description)]));
 }
 function labels(value, handles) {
-	const source = record$1(value);
+	const source = record(value);
 	if (Object.keys(source).some((handle) => !handles.includes(handle))) return invalidResponse();
 	return Object.fromEntries(Object.entries(source).map(([handle, label]) => {
-		const text = string$1(label);
+		const text = string(label);
 		return text.trim().length == 0 ? invalidResponse() : [handle, text];
 	}));
 }
@@ -10463,16 +10747,16 @@ function searchTriggerKeys(keys, query) {
 //#endregion
 //#region src/control/common/resultQuery.ts
 var resultQuerySchema = strictObject({
-	pointer: string().max(4096).default(""),
+	pointer: string$1().max(4096).default(""),
 	offset: number().int().nonnegative().default(0),
 	limit: number().int().min(1).max(100).default(20),
 	maxBytes: number().int().min(1).max(1048576).default(15e3)
 });
 //#endregion
 //#region src/control/common/results.ts
-var json = json$2();
+var json = json$3();
 var entry = strictObject({
-	pointer: string(),
+	pointer: string$1(),
 	type: _enum([
 		"object",
 		"array",
@@ -10491,26 +10775,26 @@ var page = entry.extend({
 	entries: array(entry).optional()
 });
 var result = strictObject({
-	resultId: string().min(1),
-	callId: string().min(1),
-	toolId: string().min(1),
+	resultId: string$1().min(1),
+	callId: string$1().min(1),
+	toolId: string$1().min(1),
 	source: discriminatedUnion("kind", [strictObject({
 		kind: literal("connector"),
-		action: string().min(1)
+		action: string$1().min(1)
 	}), strictObject({ kind: literal("code") })]),
 	bytes: number().int().nonnegative(),
-	digest: string().regex(/^[a-f0-9]{64}$/),
-	createdAt: string().datetime()
+	digest: string$1().regex(/^[a-f0-9]{64}$/),
+	createdAt: string$1().datetime()
 });
 var listSchema = strictObject({
 	version: literal(1),
-	runId: string(),
+	runId: string$1(),
 	results: array(result),
-	nextAfter: string().optional()
+	nextAfter: string$1().optional()
 });
 var readSchema = strictObject({
 	version: literal(1),
-	runId: string(),
+	runId: string$1(),
 	result,
 	page
 });
@@ -10637,8 +10921,8 @@ function schemaPath(value) {
 	return value.map((part) => typeof part == "string" || Number.isSafeInteger(part) ? part : invalidResponse());
 }
 function schemaMismatch(value) {
-	const source = record$1(value);
-	const kind = string$1(source.kind);
+	const source = record(value);
+	const kind = string(source.kind);
 	if (kind == "artifact" || kind == "binary" || kind == "nullable") return { kind };
 	if (kind == "schema") return {
 		kind,
@@ -10654,30 +10938,30 @@ function schemaMismatch(value) {
 	};
 }
 function diagnostic(value) {
-	const source = record$1(value);
-	const values = source.values == null ? void 0 : record$1(source.values);
+	const source = record(value);
+	const values = source.values == null ? void 0 : record(source.values);
 	return {
-		code: string$1(source.code),
-		column: integer$1(source.column),
-		...source.fields === void 0 ? {} : { fields: Array.isArray(source.fields) ? source.fields.map(string$1) : invalidResponse() },
-		line: integer$1(source.line),
-		message: string$1(source.message),
+		code: string(source.code),
+		column: integer(source.column),
+		...source.fields === void 0 ? {} : { fields: Array.isArray(source.fields) ? source.fields.map(string) : invalidResponse() },
+		line: integer(source.line),
+		message: string(source.message),
 		mismatch: source.mismatch == null ? void 0 : schemaMismatch(source.mismatch),
 		path: typeof source.path == "string" ? source.path : invalidResponse(),
 		...values == null ? {} : { values: Object.fromEntries(Object.entries(values).map(([key, candidate]) => [key, typeof candidate == "string" || typeof candidate == "number" ? candidate : invalidResponse()])) }
 	};
 }
 function flowCheck(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (source.version != 1 || typeof source.valid != "boolean" || !Array.isArray(source.diagnostics)) return invalidResponse();
 	return {
-		closureDigest: string$1(source.closureDigest),
+		closureDigest: string(source.closureDigest),
 		diagnostics: source.diagnostics.map(diagnostic),
-		engineContract: string$1(source.engineContract),
-		flowId: string$1(source.flowId),
-		modelVersion: integer$1(source.modelVersion),
-		revisionDigest: string$1(source.revisionDigest),
-		revisionId: string$1(source.revisionId),
+		engineContract: string(source.engineContract),
+		flowId: string(source.flowId),
+		modelVersion: integer(source.modelVersion),
+		revisionDigest: string(source.revisionDigest),
+		revisionId: string(source.revisionId),
 		valid: source.valid,
 		version: 1
 	};
@@ -10693,7 +10977,7 @@ function connectorProvidersQuery(flowId, locale) {
 	return {
 		path: `/v1/connector/providers${parameters ? `?${parameters}` : ""}`,
 		decode: (value) => {
-			const source = record$1(value);
+			const source = record(value);
 			exact(source, ["providers", "version"]);
 			if (source.version != 1 || !Array.isArray(source.providers)) return invalidResponse();
 			return source.providers.map(connectorProvider);
@@ -10708,7 +10992,7 @@ function connectorActionQuery(actionId, flowId, locale) {
 	return {
 		path: `/v1/connector/actions/${encodeURIComponent(actionId)}${parameters ? `?${parameters}` : ""}`,
 		decode: (value) => {
-			const source = record$1(value);
+			const source = record(value);
 			exact(source, ["action", "version"]);
 			if (source.version != 1) return invalidResponse();
 			return connectorAction(source.action);
@@ -10719,7 +11003,7 @@ function allConnectorConnectionsQuery(flowId) {
 	return {
 		path: `/v1/connector/connections${scope(flowId)}`,
 		decode: (value) => {
-			const source = record$1(value);
+			const source = record(value);
 			exact(source, ["connections", "version"]);
 			if (source.version != 1 || !Array.isArray(source.connections)) return invalidResponse();
 			return source.connections.map(connection);
@@ -10730,44 +11014,82 @@ function connectorConnectionsQuery(serviceId, flowId) {
 	return {
 		path: `/v1/connector/connections/${encodeURIComponent(serviceId)}${scope(flowId)}`,
 		decode: (value) => {
-			const source = record$1(value);
+			const source = record(value);
 			exact(source, [
 				"connections",
 				"serviceId",
 				"version"
 			]);
-			if (source.version != 1 || string$1(source.serviceId) != serviceId || !Array.isArray(source.connections)) return invalidResponse();
+			if (source.version != 1 || string(source.serviceId) != serviceId || !Array.isArray(source.connections)) return invalidResponse();
 			return source.connections.map(connection);
 		}
 	};
 }
 //#endregion
 //#region src/control/common/flowDecoders.ts
+function strings(value) {
+	return Array.isArray(value) ? value.map(string) : invalidResponse();
+}
+function resourceReferences(input) {
+	const source = record(input);
+	const draft = source.draft === null ? null : record(source.draft);
+	const shared = record(source.sharedAccess);
+	if (draft != null && !Array.isArray(draft.connections)) return invalidResponse();
+	if (!Array.isArray(shared.bindings)) return invalidResponse();
+	const accessRevision = integer(shared.accessRevision);
+	if (accessRevision < 0) return invalidResponse();
+	return {
+		draft: draft == null ? null : {
+			variableNames: strings(draft.variableNames),
+			errorSourceFlowIds: strings(draft.errorSourceFlowIds),
+			connections: draft.connections.map((value) => {
+				const connection = record(value);
+				return {
+					providerId: string(connection.providerId),
+					connectionId: string(connection.connectionId)
+				};
+			})
+		},
+		sharedAccess: {
+			accessRevision,
+			providerIds: strings(shared.providerIds),
+			bindings: shared.bindings.map((value) => {
+				const binding = record(value);
+				return {
+					providerId: string(binding.providerId),
+					connectionId: binding.connectionId === null ? null : string(binding.connectionId),
+					accessBindingId: string(binding.accessBindingId)
+				};
+			})
+		}
+	};
+}
 function flow(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const status = source.status;
 	if (source.version != 1) return invalidResponse();
 	if (status != "active" && status != "retiring") return invalidResponse();
-	const target = source.live == null ? void 0 : record$1(source.live);
+	const target = source.live == null ? void 0 : record(source.live);
 	if (target != null && typeof target.enabled != "boolean") return invalidResponse();
 	return {
 		...target == null ? {} : { live: {
 			enabled: target.enabled,
-			publicationId: string$1(target.publicationId),
-			revisionId: string$1(target.revisionId)
+			publicationId: string(target.publicationId),
+			revisionId: string(target.revisionId)
 		} },
-		createdAt: string$1(source.createdAt),
-		...source.connectorTeamId == null ? {} : { connectorTeamId: string$1(source.connectorTeamId) },
-		draftRevisionId: string$1(source.draftRevisionId),
-		flowId: string$1(source.flowId),
-		name: string$1(source.name),
+		createdAt: string(source.createdAt),
+		...source.connectorTeamId == null ? {} : { connectorTeamId: string(source.connectorTeamId) },
+		draftRevisionId: string(source.draftRevisionId),
+		resourceReferences: resourceReferences(source.resourceReferences),
+		flowId: string(source.flowId),
+		name: string(source.name),
 		status,
-		updatedAt: string$1(source.updatedAt),
+		updatedAt: string(source.updatedAt),
 		version: 1
 	};
 }
 function flowPage(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (source.version != 1 || !Array.isArray(source.flows)) return invalidResponse();
 	const nextCursor = source.nextCursor;
 	const total = source.total;
@@ -10781,7 +11103,7 @@ function flowPage(value) {
 	};
 }
 function variable(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"name",
 		"updatedAt",
@@ -10789,35 +11111,35 @@ function variable(value) {
 		"version"
 	]);
 	if (source.version != 1 || typeof source.value != "string") return invalidResponse();
-	const updatedAt = string$1(source.updatedAt);
+	const updatedAt = string(source.updatedAt);
 	try {
 		if (new Date(updatedAt).toISOString() != updatedAt) return invalidResponse();
 	} catch {
 		return invalidResponse();
 	}
 	return {
-		name: string$1(source.name),
+		name: string(source.name),
 		updatedAt,
 		value: source.value,
 		version: 1
 	};
 }
 function errorListener(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (typeof source.enabled != "boolean") return invalidResponse();
 	return {
-		flowId: string$1(source.flowId),
-		flowName: string$1(source.flowName),
-		nodeId: string$1(source.nodeId),
-		nodeName: string$1(source.nodeName),
+		flowId: string(source.flowId),
+		flowName: string(source.flowName),
+		nodeId: string(source.nodeId),
+		nodeName: string(source.nodeName),
 		enabled: source.enabled
 	};
 }
 //#endregion
 //#region src/control/common/publicationDecoders.ts
 function publication(value) {
-	const source = record$1(value);
-	const liveEnd = source.liveEnd == null ? void 0 : record$1(source.liveEnd);
+	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;
@@ -10827,32 +11149,32 @@ function publication(value) {
 	return {
 		...liveEnd == null ? {} : { liveEnd: {
 			enabled: liveEnd.enabled,
-			endedAt: string$1(liveEnd.endedAt)
+			endedAt: string(liveEnd.endedAt)
 		} },
-		actorId: string$1(source.actorId),
-		closureDigest: string$1(source.closureDigest),
-		createdAt: string$1(source.createdAt),
-		engineContract: string$1(source.engineContract),
-		flowId: string$1(source.flowId),
-		modelVersion: integer$1(source.modelVersion),
+		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$1(source.publicationId),
-		sharedAccessDigest: string$1(source.sharedAccessDigest),
-		revisionDigest: string$1(source.revisionDigest),
-		revisionId: string$1(source.revisionId),
+		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$1(value);
+	const source = record(value);
 	const status = source.status;
 	const common = {
-		createdAt: string$1(source.createdAt),
-		flowId: string$1(source.flowId),
-		operationId: string$1(source.operationId),
-		revisionId: string$1(source.revisionId),
-		updatedAt: string$1(source.updatedAt),
+		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();
@@ -10884,7 +11206,7 @@ function publishOperation(value) {
 			]);
 			return {
 				...common,
-				publicationId: string$1(source.publicationId),
+				publicationId: string(source.publicationId),
 				status
 			};
 		case "failed": {
@@ -10898,7 +11220,7 @@ function publishOperation(value) {
 				"updatedAt",
 				"version"
 			]);
-			const issue = record$1(source.issue);
+			const issue = record(source.issue);
 			const nodeId = issue.nodeId;
 			exact(issue, [
 				"code",
@@ -10908,9 +11230,9 @@ function publishOperation(value) {
 			return {
 				...common,
 				issue: {
-					code: string$1(issue.code),
-					message: string$1(issue.message),
-					...nodeId == null ? {} : { nodeId: string$1(nodeId) }
+					code: string(issue.code),
+					message: string(issue.message),
+					...nodeId == null ? {} : { nodeId: string(nodeId) }
 				},
 				status
 			};
@@ -10919,7 +11241,7 @@ function publishOperation(value) {
 	}
 }
 function live(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const status = source.status;
 	const candidate = source.publication;
 	if (source.version != 1 || typeof source.hasUnpublishedChanges != "boolean") return invalidResponse();
@@ -10927,16 +11249,16 @@ function live(value) {
 	if (status == "not-published" && candidate !== null) return invalidResponse();
 	if (status != "not-published" && candidate === null) return invalidResponse();
 	return {
-		flowId: string$1(source.flowId),
+		flowId: string(source.flowId),
 		hasUnpublishedChanges: source.hasUnpublishedChanges,
 		publication: candidate === null ? null : publication(candidate),
-		revision: integer$1(source.revision),
+		revision: integer(source.revision),
 		status,
 		version: 1
 	};
 }
 function publicationPage(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const nextCursor = source.nextCursor;
 	const total = source.total;
 	if (source.version != 1 || !Array.isArray(source.publications)) return invalidResponse();
@@ -10952,22 +11274,22 @@ function publicationPage(value) {
 //#endregion
 //#region src/control/common/revisionDecoders.ts
 function revisionMetadata(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const parentRevisionId = source.parentRevisionId;
 	if (source.version != 1 || parentRevisionId !== null && typeof parentRevisionId != "string") return invalidResponse();
 	return {
-		actorId: string$1(source.actorId),
-		createdAt: string$1(source.createdAt),
-		digest: string$1(source.digest),
-		flowId: string$1(source.flowId),
-		modelVersion: integer$1(source.modelVersion),
+		actorId: string(source.actorId),
+		createdAt: string(source.createdAt),
+		digest: string(source.digest),
+		flowId: string(source.flowId),
+		modelVersion: integer(source.modelVersion),
 		parentRevisionId,
-		revisionId: string$1(source.revisionId),
+		revisionId: string(source.revisionId),
 		version: 1
 	};
 }
 function draft(value) {
-	const source = record$1(value);
+	const source = record(value);
 	try {
 		return {
 			...revisionMetadata(source),
@@ -10978,17 +11300,17 @@ function draft(value) {
 	}
 }
 function presentation(value) {
-	const source = record$1(value);
-	if (source.version != 1 || integer$1(source.revision) < 1) return invalidResponse();
+	const source = record(value);
+	if (source.version != 1 || integer(source.revision) < 1) return invalidResponse();
 	return {
-		revision: integer$1(source.revision),
-		updatedAt: string$1(source.updatedAt),
-		value: Object.fromEntries(Object.entries(record$1(source.value)).map(([key, item]) => [key, jsonValue(item)])),
+		revision: integer(source.revision),
+		updatedAt: string(source.updatedAt),
+		value: Object.fromEntries(Object.entries(record(source.value)).map(([key, item]) => [key, jsonValue(item)])),
 		version: 1
 	};
 }
 function draftChange(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (source.version != 1) return invalidResponse();
 	return {
 		revision: revisionMetadata(source.revision),
@@ -10996,7 +11318,7 @@ function draftChange(value) {
 	};
 }
 function draftSync(value) {
-	const source = record$1(value);
+	const source = record(value);
 	if (source.version != 1 || source.kind != "snapshot") return invalidResponse();
 	return {
 		draft: draft(source.draft),
@@ -11022,7 +11344,7 @@ function runStatus(value) {
 	return typeof value == "string" && runStatusSet.has(value) ? value : invalidResponse();
 }
 function run(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const kind = source.source;
 	const startedAt = source.startedAt;
 	const finishedAt = source.finishedAt;
@@ -11030,11 +11352,11 @@ function run(value) {
 	if (startedAt != null && typeof startedAt != "string") return invalidResponse();
 	if (finishedAt != null && typeof finishedAt != "string") return invalidResponse();
 	return {
-		createdAt: string$1(source.createdAt),
+		createdAt: string(source.createdAt),
 		...finishedAt == null ? {} : { finishedAt },
-		flowId: string$1(source.flowId),
-		revisionId: string$1(source.revisionId),
-		runId: string$1(source.runId),
+		flowId: string(source.flowId),
+		revisionId: string(source.revisionId),
+		runId: string(source.runId),
 		source: kind,
 		...startedAt == null ? {} : { startedAt },
 		status: runStatus(source.status),
@@ -11042,7 +11364,7 @@ function run(value) {
 	};
 }
 function runWaiting(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"actions",
 		"expiresAt",
@@ -11055,15 +11377,15 @@ function runWaiting(value) {
 	if (!Array.isArray(actions) || !(actions.length == 1 && actions[0] == "continue" || actions.length == 2 && actions[0] == "approve" && actions[1] == "reject")) return invalidResponse();
 	return {
 		actions,
-		expiresAt: string$1(source.expiresAt),
-		nodeId: string$1(source.nodeId),
-		prompt: string$1(source.prompt),
-		waitId: string$1(source.waitId),
-		waitingSince: string$1(source.waitingSince)
+		expiresAt: string(source.expiresAt),
+		nodeId: string(source.nodeId),
+		prompt: string(source.prompt),
+		waitId: string(source.waitId),
+		waitingSince: string(source.waitingSince)
 	};
 }
 function runDetails(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const summary = run(source);
 	const eventsExpiresAt = source.eventsExpiresAt;
 	if (eventsExpiresAt != null && typeof eventsExpiresAt != "string") return invalidResponse();
@@ -11083,13 +11405,13 @@ function runDetails(value) {
 	const details = {
 		...summary,
 		...errorHandling(source),
-		closureDigest: string$1(source.closureDigest),
-		engineContract: string$1(source.engineContract),
-		engineDigest: string$1(source.engineDigest),
+		closureDigest: string(source.closureDigest),
+		engineContract: string(source.engineContract),
+		engineDigest: string(source.engineDigest),
 		...eventsExpiresAt == null ? {} : { eventsExpiresAt },
-		modelVersion: integer$1(source.modelVersion),
-		sharedAccessDigest: string$1(source.sharedAccessDigest),
-		revisionDigest: string$1(source.revisionDigest),
+		modelVersion: integer(source.modelVersion),
+		sharedAccessDigest: string(source.sharedAccessDigest),
+		revisionDigest: string(source.revisionDigest),
 		...state
 	};
 	switch (summary.source) {
@@ -11099,40 +11421,40 @@ function runDetails(value) {
 		};
 		case "live": return {
 			...details,
-			publicationId: string$1(source.publicationId),
+			publicationId: string(source.publicationId),
 			source: "live",
 			...source.occurrenceId === void 0 ? {} : {
-				occurrenceId: string$1(source.occurrenceId),
-				triggerNodeId: string$1(source.triggerNodeId)
+				occurrenceId: string(source.occurrenceId),
+				triggerNodeId: string(source.triggerNodeId)
 			}
 		};
 	}
 }
 function runPage(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const nextCursor = source.nextCursor;
 	if (source.version != 1 || !Array.isArray(source.runs)) return invalidResponse();
 	if (nextCursor != null && typeof nextCursor != "string") return invalidResponse();
 	return {
-		flowId: string$1(source.flowId),
+		flowId: string(source.flowId),
 		...nextCursor == null ? {} : { nextCursor },
 		runs: source.runs.map(run),
 		version: 1
 	};
 }
 function runCancellation(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const status = runStatus(source.status);
 	if (source.version != 1 || typeof source.cancelAccepted != "boolean" || status == "queued" || status == "starting" || status == "running" || status == "waiting") return invalidResponse();
 	return {
 		cancelAccepted: source.cancelAccepted,
-		runId: string$1(source.runId),
+		runId: string(source.runId),
 		status,
 		version: 1
 	};
 }
 function waitResolution(value) {
-	const source = record$1(value);
+	const source = record(value);
 	exact(source, [
 		"action",
 		"comment",
@@ -11151,19 +11473,19 @@ function waitResolution(value) {
 		comment: source.comment,
 		resolutionAccepted: source.resolutionAccepted,
 		resolvedAt,
-		runId: string$1(source.runId),
+		runId: string(source.runId),
 		status: runStatus(source.status),
 		version: 1,
-		waitId: string$1(source.waitId)
+		waitId: string(source.waitId)
 	};
 }
 function runResult(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const status = source.status;
 	if (source.version != 1) return invalidResponse();
 	const base = {
-		finishedAt: string$1(source.finishedAt),
-		runId: string$1(source.runId),
+		finishedAt: string(source.finishedAt),
+		runId: string(source.runId),
 		version: 1
 	};
 	if (status == "completed") {
@@ -11179,7 +11501,7 @@ function runResult(value) {
 		status: "canceled"
 	};
 	if (status == "failed") {
-		const error = record$1(source.error);
+		const error = record(source.error);
 		return {
 			...base,
 			error: runFailure(error),
@@ -11187,7 +11509,7 @@ function runResult(value) {
 		};
 	}
 	if (status == "indeterminate") {
-		const error = record$1(source.error);
+		const error = record(source.error);
 		return {
 			...base,
 			error: runFailure(error),
@@ -11197,16 +11519,16 @@ function runResult(value) {
 	return invalidResponse();
 }
 function errorHandling(source) {
-	const errorSource = source.errorSource == null ? void 0 : record$1(source.errorSource);
+	const errorSource = source.errorSource == null ? void 0 : record(source.errorSource);
 	if (source.errorDispatches != null && !Array.isArray(source.errorDispatches)) return invalidResponse();
 	return {
 		...errorSource == null ? {} : { errorSource: {
-			flowId: string$1(errorSource.flowId),
-			runId: string$1(errorSource.runId)
+			flowId: string(errorSource.flowId),
+			runId: string(errorSource.runId)
 		} },
 		...source.errorDispatches == null ? {} : { errorDispatches: source.errorDispatches.map((value) => {
-			const dispatch = record$1(value);
-			const flowId = string$1(dispatch.flowId);
+			const dispatch = record(value);
+			const flowId = string(dispatch.flowId);
 			switch (dispatch.status) {
 				case "pending": return {
 					status: "pending",
@@ -11215,12 +11537,12 @@ function errorHandling(source) {
 				case "dispatched": return {
 					status: "dispatched",
 					flowId,
-					runId: string$1(dispatch.runId)
+					runId: string(dispatch.runId)
 				};
 				case "failed": return {
 					status: "failed",
 					flowId,
-					message: string$1(dispatch.message)
+					message: string(dispatch.message)
 				};
 				default: return invalidResponse();
 			}
@@ -11229,11 +11551,11 @@ function errorHandling(source) {
 }
 function runFailure(error) {
 	return {
-		code: string$1(error.code),
-		message: string$1(error.message),
-		...error.nodeId === void 0 ? {} : { nodeId: string$1(error.nodeId) },
-		...error.jobId === void 0 ? {} : { jobId: string$1(error.jobId) },
-		...error.path === void 0 ? {} : { path: (Array.isArray(error.path) ? error.path : invalidResponse()).map(string$1) }
+		code: string(error.code),
+		message: string(error.message),
+		...error.nodeId === void 0 ? {} : { nodeId: string(error.nodeId) },
+		...error.jobId === void 0 ? {} : { jobId: string(error.jobId) },
+		...error.path === void 0 ? {} : { path: (Array.isArray(error.path) ? error.path : invalidResponse()).map(string) }
 	};
 }
 //#endregion
@@ -11260,14 +11582,14 @@ function isRunTerminalEvent(event) {
 	return event?.kind == "run.completed" || event?.kind == "run.failed" || event?.kind == "run.canceled" || event?.kind == "run.indeterminate";
 }
 function decodeRunEvent(value) {
-	const source = record$1(value);
-	const sequence = integer$1(source.sequence);
+	const source = record(value);
+	const sequence = integer(source.sequence);
 	if (sequence < 0) return invalidResponse();
 	const base = {
-		createdAt: string$1(source.createdAt),
+		createdAt: string(source.createdAt),
 		sequence
 	};
-	const payload = record$1(source.payload);
+	const payload = record(source.payload);
 	const kind = source.kind;
 	switch (kind) {
 		case "run.queued": return {
@@ -11279,17 +11601,17 @@ function decodeRunEvent(value) {
 			...base,
 			kind,
 			payload: {
-				flowId: string$1(payload.flowId),
-				scopeId: string$1(payload.scopeId),
-				...payload.parentScopeId === void 0 ? {} : { parentScopeId: string$1(payload.parentScopeId) }
+				flowId: string(payload.flowId),
+				scopeId: string(payload.scopeId),
+				...payload.parentScopeId === void 0 ? {} : { parentScopeId: string(payload.parentScopeId) }
 			}
 		};
 		case "run.progress": return {
 			...base,
 			kind,
 			payload: {
-				flowId: string$1(payload.flowId),
-				scopeId: string$1(payload.scopeId),
+				flowId: string(payload.flowId),
+				scopeId: string(payload.scopeId),
 				progress: eventProgress(payload.progress)
 			}
 		};
@@ -11298,16 +11620,16 @@ function decodeRunEvent(value) {
 			return {
 				...base,
 				kind,
-				payload: { waitIds: payload.waitIds.map((id) => string$1(id)) }
+				payload: { waitIds: payload.waitIds.map((id) => string(id)) }
 			};
 		case "wait.created": return {
 			...base,
 			kind,
 			payload: {
-				expiresAt: string$1(payload.expiresAt),
-				nodeId: string$1(payload.nodeId),
-				waitId: string$1(payload.waitId),
-				waitingSince: string$1(payload.waitingSince)
+				expiresAt: string(payload.expiresAt),
+				nodeId: string(payload.nodeId),
+				waitId: string(payload.waitId),
+				waitingSince: string(payload.waitingSince)
 			}
 		};
 		case "run.resolved": {
@@ -11320,8 +11642,8 @@ function decodeRunEvent(value) {
 				payload: {
 					action,
 					comment: payload.comment,
-					resolvedAt: string$1(payload.resolvedAt),
-					waitId: string$1(payload.waitId)
+					resolvedAt: string(payload.resolvedAt),
+					waitId: string(payload.waitId)
 				}
 			};
 		}
@@ -11345,23 +11667,23 @@ function decodeRunEvent(value) {
 		case "node.progress":
 		case "node.artifact": {
 			const node = {
-				flowId: string$1(payload.flowId),
-				scopeId: string$1(payload.scopeId),
-				nodeId: string$1(payload.nodeId),
-				executionId: string$1(payload.executionId)
+				flowId: string(payload.flowId),
+				scopeId: string(payload.scopeId),
+				nodeId: string(payload.nodeId),
+				executionId: string(payload.executionId)
 			};
 			switch (kind) {
 				case "node.started": {
 					const nodeKind = payload.nodeKind;
-					if (nodeKind !== void 0 && nodeKind !== "approval" && nodeKind !== "condition" && nodeKind !== "connector" && nodeKind !== "javascript" && nodeKind !== "decision" && nodeKind !== "openapi" && nodeKind !== "llm" && nodeKind !== "agent" && nodeKind !== "subflow" && nodeKind !== "value" && nodeKind !== "wait") return invalidResponse();
+					if (nodeKind !== void 0 && nodeKind !== "approval" && nodeKind !== "condition" && nodeKind !== "connector" && nodeKind !== "javascript" && nodeKind !== "decision" && nodeKind !== "openapi" && nodeKind !== "llm" && nodeKind !== "agent" && nodeKind !== "value" && nodeKind !== "wait") return invalidResponse();
 					return {
 						...base,
 						kind,
 						payload: {
 							...node,
 							...nodeKind === void 0 ? {} : { nodeKind },
-							...payload.nodeTitle === void 0 ? {} : { nodeTitle: string$1(payload.nodeTitle) },
-							...payload.operation === void 0 ? {} : { operation: string$1(payload.operation) }
+							...payload.nodeTitle === void 0 ? {} : { nodeTitle: string(payload.nodeTitle) },
+							...payload.operation === void 0 ? {} : { operation: string(payload.operation) }
 						}
 					};
 				}
@@ -11370,19 +11692,19 @@ function decodeRunEvent(value) {
 					kind,
 					payload: {
 						...node,
-						outputs: Object.fromEntries(Object.entries(record$1(payload.outputs)).map(([key, item]) => [key, jsonValue(item)]))
+						outputs: Object.fromEntries(Object.entries(record(payload.outputs)).map(([key, item]) => [key, jsonValue(item)]))
 					}
 				};
 				case "node.failed": {
-					const error = record$1(payload.error);
+					const error = record(payload.error);
 					return {
 						...base,
 						kind,
 						payload: {
 							...node,
 							error: {
-								code: string$1(error.code),
-								message: string$1(error.message)
+								code: string(error.code),
+								message: string(error.message)
 							}
 						}
 					};
@@ -11396,7 +11718,7 @@ function decodeRunEvent(value) {
 						payload: {
 							...node,
 							level,
-							message: string$1(payload.message)
+							message: string(payload.message)
 						}
 					};
 				}
@@ -11409,9 +11731,9 @@ function decodeRunEvent(value) {
 					}
 				};
 				case "node.artifact": {
-					const artifact = record$1(payload.artifact);
-					const size = integer$1(artifact.size);
-					const digest = string$1(artifact.digest);
+					const artifact = record(payload.artifact);
+					const size = integer(artifact.size);
+					const digest = string(artifact.digest);
 					if (artifact.kind != "artifact" || size < 0 || !/^sha256:[0-9a-f]{64}$/.test(digest)) return invalidResponse();
 					return {
 						...base,
@@ -11420,11 +11742,11 @@ function decodeRunEvent(value) {
 							...node,
 							artifact: {
 								kind: "artifact",
-								id: string$1(artifact.id),
-								name: string$1(artifact.name),
+								id: string(artifact.id),
+								name: string(artifact.name),
 								size,
 								digest,
-								...artifact.mediaType === void 0 ? {} : { mediaType: string$1(artifact.mediaType) }
+								...artifact.mediaType === void 0 ? {} : { mediaType: string(artifact.mediaType) }
 							}
 						}
 					};
@@ -11438,9 +11760,9 @@ function eventProgress(value) {
 	return typeof value == "number" && Number.isFinite(value) && value >= 0 && value <= 100 ? value : invalidResponse();
 }
 function runEvents(value) {
-	const source = record$1(value);
+	const source = record(value);
 	const eventsExpiresAt = source.eventsExpiresAt;
-	const nextAfter = integer$1(source.nextAfter);
+	const nextAfter = integer(source.nextAfter);
 	if (source.version != 1 || !Array.isArray(source.events) || typeof source.done != "boolean" || typeof source.historyComplete != "boolean") return invalidResponse();
 	if (eventsExpiresAt != null && typeof eventsExpiresAt != "string") return invalidResponse();
 	if (nextAfter < 0) return invalidResponse();
@@ -11450,7 +11772,7 @@ function runEvents(value) {
 		...eventsExpiresAt == null ? {} : { eventsExpiresAt },
 		historyComplete: source.historyComplete,
 		nextAfter,
-		runId: string$1(source.runId),
+		runId: string(source.runId),
 		version: 1
 	};
 }
@@ -11463,7 +11785,7 @@ var ControlClient = class {
 		this.requestControl = requestControl;
 	}
 	async loadOpenApiDocument(url, signal) {
-		const result = record$1(await this.request("/v1/openapi/document", {
+		const result = record(await this.request("/v1/openapi/document", {
 			method: "POST",
 			body: JSON.stringify({
 				url,
@@ -11486,7 +11808,7 @@ var ControlClient = class {
 		return decodeEventSources(await this.request("/v1/event-sources" + (flowId == null ? "" : `?flowId=${segment(flowId)}`), { signal }));
 	}
 	async listEventSourceConnections(teamId, signal) {
-		const source = record$1(await this.request(`/v1/event-sources/connections${teamId == null ? "" : `?teamId=${segment(teamId)}`}`, { signal }));
+		const source = record(await this.request(`/v1/event-sources/connections${teamId == null ? "" : `?teamId=${segment(teamId)}`}`, { signal }));
 		exact(source, ["version", "connections"]);
 		if (source.version != 1 || !Array.isArray(source.connections)) return invalidResponse();
 		return source.connections.map(connection);
@@ -11513,7 +11835,7 @@ var ControlClient = class {
 		});
 	}
 	async listVariables() {
-		const source = record$1(await this.request("/v1/variables"));
+		const source = record(await this.request("/v1/variables"));
 		exact(source, ["variables", "version"]);
 		if (source.version != 1 || !Array.isArray(source.variables)) return invalidResponse();
 		return {
@@ -11531,7 +11853,7 @@ var ControlClient = class {
 		}));
 	}
 	async deleteVariable(name) {
-		const source = record$1(await this.request(`/v1/variables/${segment(name)}`, { method: "DELETE" }));
+		const source = record(await this.request(`/v1/variables/${segment(name)}`, { method: "DELETE" }));
 		exact(source, ["version"]);
 		if (source.version != 1) return invalidResponse();
 	}
@@ -11550,7 +11872,7 @@ var ControlClient = class {
 		return flow(await this.request(`/v1/flows/${segment(flowId)}`));
 	}
 	async getErrorListeners(flowId, signal) {
-		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/error-listeners`, { signal }));
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/error-listeners`, { signal }));
 		if (source.version != 1 || !Array.isArray(source.listeners)) return invalidResponse();
 		return source.listeners.map(errorListener);
 	}
@@ -11567,12 +11889,12 @@ var ControlClient = class {
 		return flow(await this.request(`/v1/flows/${segment(flowId)}`, { method: "DELETE" }));
 	}
 	async listTriggerKeys(signal, locale) {
-		const source = record$1(await this.request(`/v1/trigger-keys${locale == null ? "" : `?locale=${encodeURIComponent(locale)}`}`, { signal }));
+		const source = record(await this.request(`/v1/trigger-keys${locale == null ? "" : `?locale=${encodeURIComponent(locale)}`}`, { signal }));
 		if (source.version != 1 || !Array.isArray(source.keys)) return invalidResponse();
 		return source.keys.map(triggerKeySummary);
 	}
 	async listTriggerDefinitions(signal) {
-		const source = record$1(await this.request("/v1/trigger-keys/catalog", { signal }));
+		const source = record(await this.request("/v1/trigger-keys/catalog", { signal }));
 		if (source.version != 2 || !Array.isArray(source.definitions)) return invalidResponse();
 		return source.definitions.map(triggerKey);
 	}
@@ -11614,13 +11936,13 @@ var ControlClient = class {
 		};
 	}
 	async getTriggerKey(key, signal) {
-		const source = record$1(await this.request(`/v1/trigger-keys/${segment(key)}`, { signal }));
+		const source = record(await this.request(`/v1/trigger-keys/${segment(key)}`, { signal }));
 		if (source.version != 1) return invalidResponse();
 		return triggerKey(source.definition);
 	}
 	async listFlowTriggerBindings(flowId, signal) {
-		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/triggers`, { signal }));
-		if (source.version != 1 || string$1(source.flowId) != flowId || !Array.isArray(source.bindings)) return invalidResponse();
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/triggers`, { signal }));
+		if (source.version != 1 || string(source.flowId) != flowId || !Array.isArray(source.bindings)) return invalidResponse();
 		return source.bindings.map(triggerBinding);
 	}
 	async getFlowTriggerBinding(flowId, triggerNodeId) {
@@ -11652,7 +11974,7 @@ var ControlClient = class {
 		}));
 	}
 	async getEditor(flowId) {
-		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/editor`));
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/editor`));
 		if (source.version != 1) return invalidResponse();
 		const result = {
 			flow: flow(source.flow),
@@ -11665,7 +11987,7 @@ var ControlClient = class {
 		return result;
 	}
 	async getPublicationPresentation(flowId, publicationId, signal) {
-		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/publications/${segment(publicationId)}/presentation`, { signal }));
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/publications/${segment(publicationId)}/presentation`, { signal }));
 		if (source.version != 1) return invalidResponse();
 		return {
 			version: 1,
@@ -11685,30 +12007,30 @@ var ControlClient = class {
 		return draft(await this.request(`/v1/flows/${segment(flowId)}/revisions/${segment(revisionId)}`, { signal }));
 	}
 	async listTriggerConfigOptions(flowId, nodeId, field, signal) {
-		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/triggers/${segment(nodeId)}/options/${segment(field)}`, { signal }));
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/triggers/${segment(nodeId)}/options/${segment(field)}`, { signal }));
 		exact(source, ["options", "version"]);
 		if (source.version != 1 || !Array.isArray(source.options) || source.options.length > 1e3) return invalidResponse();
 		return source.options.map((value) => {
-			const item = record$1(value);
+			const item = record(value);
 			exact(item, [
 				"value",
 				"label",
 				...item.color == null ? [] : ["color"]
 			]);
-			const color = item.color == null ? void 0 : string$1(item.color);
+			const color = item.color == null ? void 0 : string(item.color);
 			if (color != null && !/^#[0-9a-fA-F]{6}$/.test(color)) return invalidResponse();
 			return color == null ? {
-				value: string$1(item.value),
-				label: string$1(item.label)
+				value: string(item.value),
+				label: string(item.label)
 			} : {
-				value: string$1(item.value),
-				label: string$1(item.label),
+				value: string(item.value),
+				label: string(item.label),
 				color
 			};
 		});
 	}
 	async listConnectorTeams(signal) {
-		const source = record$1(await this.request("/v1/connector/teams", { signal }));
+		const source = record(await this.request("/v1/connector/teams", { signal }));
 		exact(source, [
 			"enabled",
 			"teams",
@@ -11718,7 +12040,7 @@ var ControlClient = class {
 		return {
 			enabled: source.enabled,
 			teams: source.teams.map((value) => {
-				const team = record$1(value);
+				const team = record(value);
 				exact(team, [
 					"id",
 					"name",
@@ -11726,8 +12048,8 @@ var ControlClient = class {
 				]);
 				if (typeof team.systemCreated != "boolean") return invalidResponse();
 				return {
-					id: string$1(team.id),
-					name: string$1(team.name),
+					id: string(team.id),
+					name: string(team.name),
 					systemCreated: team.systemCreated
 				};
 			}),
@@ -11825,20 +12147,51 @@ var ControlClient = class {
 		const parameters = new URLSearchParams();
 		if (flowId != null) parameters.set("flowId", flowId);
 		if (teamId != null) parameters.set("teamId", teamId);
-		const source = record$1(await this.request(`/v1/connector/connections/${segment(serviceId)}/page${parameters.size == 0 ? "" : `?${parameters}`}`, {
+		const source = record(await this.request(`/v1/connector/connections/${segment(serviceId)}/page${parameters.size == 0 ? "" : `?${parameters}`}`, {
 			body: JSON.stringify({ version: 1 }),
 			method: "POST"
 		}));
 		exact(source, ["url", "version"]);
 		if (source.version != 1) return invalidResponse();
 		try {
-			const url = new URL(string$1(source.url));
+			const url = new URL(string(source.url));
 			if (url.protocol != "http:" && url.protocol != "https:") return invalidResponse();
 			return url.href;
 		} catch {
 			return invalidResponse();
 		}
 	}
+	async readAuthoring(flowId, query = {}) {
+		return authoringReadResponse.parse(await this.request(`/v1/flows/${segment(flowId)}/authoring/read`, {
+			method: "POST",
+			body: JSON.stringify(query)
+		}));
+	}
+	async searchAuthoring(flowId, query) {
+		return authoringSearchResponse.parse(await this.request(`/v1/flows/${segment(flowId)}/authoring/search`, {
+			method: "POST",
+			body: JSON.stringify(query)
+		}));
+	}
+	async authoringSchema(flowId, query) {
+		return record(await this.request(`/v1/flows/${segment(flowId)}/authoring/schema`, {
+			method: "POST",
+			body: JSON.stringify(query)
+		}));
+	}
+	async editAuthoring(flowId, request) {
+		return authoringEditResponse.parse(await this.request(`/v1/flows/${segment(flowId)}/authoring/edit`, {
+			method: "POST",
+			headers: { "idempotency-key": request.requestId },
+			body: JSON.stringify(request)
+		}));
+	}
+	async checkAuthoring(flowId, revisionId) {
+		return authoringCheckResponse.parse(await this.request(`/v1/flows/${segment(flowId)}/authoring/check`, {
+			method: "POST",
+			body: JSON.stringify({ revisionId })
+		}));
+	}
 	async changeDraft(flowId, expectedRevisionId, operations, changeId = operationKey("change")) {
 		return draftChange(await this.request(`/v1/flows/${segment(flowId)}/draft/changes`, {
 			body: JSON.stringify({
@@ -11996,7 +12349,7 @@ var ControlClient = class {
 		const query = Object.entries(parameters).map(([key, value]) => `${segment(key)}=${segment(value)}`).join("&");
 		const suffix = query == "" ? "" : `?${query}`;
 		return this.connectorRequest(`/v1/connector/actions${suffix}`, "actions", signal, (value) => {
-			const source = record$1(value);
+			const source = record(value);
 			exact(source, ["actions", "version"]);
 			if (source.version != 1 || !Array.isArray(source.actions)) return invalidResponse();
 			return source.actions.map(connectorAction);
@@ -12019,9 +12372,9 @@ var ControlClient = class {
 			} catch {
 				return invalidResponse();
 			}
-			const error = record$1(value).error;
-			const source = error == null ? void 0 : record$1(error);
-			throw new ApiError(response.status, typeof source?.code == "string" ? source.code : "request.failed", typeof source?.message == "string" ? source.message : `Request failed with status ${response.status}.`);
+			const error = record(value).error;
+			const source = error == null ? void 0 : record(error);
+			throw new ApiError(response.status, typeof source?.code == "string" ? source.code : "request.failed", typeof source?.message == "string" ? source.message : `Request failed with status ${response.status}.`, source?.details == null ? void 0 : record(source.details));
 		}
 		return response;
 	}