@oomol-lab/open-flow 0.1.0-beta.65 → 0.1.0-beta.66

package/dist/common/flow-semantics.js

@@ -6619,6 +6619,7 @@ var port = object$1({
 	nullable: boolean(),
 	handle: text
 });
+var workflowInputDefs = array(port.strict());
 var input = port.extend({ value: json.optional() });
 var group = object$1({
 	collapsed: boolean().optional(),
@@ -6776,6 +6777,11 @@ var managedFields = object$1({
 				messageHandle: text,
 				inputs: record$1(text, agentValue)
 			}).optional()
+		}),
+		strictObject({
+			kind: literal("workflow"),
+			flowId: text,
+			revisionId: text
 		})
 	])
 });
@@ -6884,6 +6890,12 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
+	strictObject({
+		...base,
+		kind: literal("outputs"),
+		outputDefs: array(port.strict()),
+		outputMappings: inputs
+	}).omit({ inputs: true }),
 	object$1({
 		...base,
 		inputs: record$1(text, never()),
@@ -6916,6 +6928,11 @@ var node = union([
 		...trigger,
 		kind: literal("manual")
 	}),
+	strictObject({
+		...trigger,
+		kind: literal("start"),
+		inputDefs: workflowInputDefs
+	}),
 	strictObject({
 		...trigger,
 		kind: literal("error"),
@@ -6980,7 +6997,7 @@ var module = object$1({
 	imports: strings,
 	source: text
 });
-var document = preprocess(rejectRetiredDefinitions, object$1({
+var document = preprocess(normalizeDocument, object$1({
 	bindings: record$1(text, binding),
 	graph
 }));
@@ -6989,7 +7006,9 @@ object$1({
 		literal(2),
 		literal(4),
 		literal(5),
-		literal(6)
+		literal(6),
+		literal(7),
+		literal(8)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -6997,13 +7016,19 @@ object$1({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
-function rejectRetiredDefinitions(value) {
+function normalizeDocument(value) {
 	const candidate = record(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(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(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(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	if ([
+		"inputDefs",
+		"outputDefs",
+		"outputMappings"
+	].some((field) => Object.hasOwn(candidate, field))) throw new TypeError("Workflow interface configuration must belong to Start and Outputs nodes.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind == "start" && Object.hasOwn(record(candidateNode), "parameters"))) throw new TypeError("Legacy Start.parameters is unsupported; configure node.inputDefs.");
 	return value;
 }
 function record(value) {
@@ -7203,6 +7228,7 @@ function conditionOperands(node) {
 	}] : []])));
 }
 function nodeInputMappings(node) {
+	if (node.kind == "outputs") return node.outputMappings;
 	if (node.kind != "condition") return "inputs" in node ? node.inputs : {};
 	return Object.fromEntries(conditionOperands(node).flatMap(({ handle, operand }) => operand.kind == "source" ? [[handle, {
 		kind: "sources",
@@ -7433,6 +7459,17 @@ function decodeConnectorCapabilities(value) {
 		};
 	});
 }
+function isTriggerNode(node) {
+	return [
+		"manual",
+		"start",
+		"error",
+		"webhook",
+		"cron",
+		"poll",
+		"integration"
+	].includes(node.kind);
+}
 //#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
@@ -11298,6 +11335,7 @@ function triggerOutputDefinitions(trigger) {
 	switch (trigger.kind) {
 		case "error": return errorOutputs;
 		case "manual": return [];
+		case "start": return trigger.inputDefs;
 		case "cron": return cronOutputs;
 		case "poll":
 		case "integration": return trigger.definition.outputs;
@@ -11317,6 +11355,15 @@ function matchesTriggerOutputs(trigger, outputs) {
 	const ports = triggerOutputDefinitions(trigger);
 	return new Set(ports.map((port) => port.handle)).size === ports.length && Object.keys(outputs).length === ports.length && ports.every((port) => Object.hasOwn(outputs, port.handle) && (outputs[port.handle] === null && port.nullable || matchesSchema(outputs[port.handle], port.jsonSchema)));
 }
+/** Resolve caller-supplied Start parameters into the complete output snapshot used by execution. */
+function normalizeTriggerOutputs(trigger, outputs) {
+	if (!isJsonObject(outputs)) return;
+	const normalized = trigger.kind == "start" ? {
+		...outputs,
+		...Object.fromEntries(trigger.inputDefs.filter((port) => port.nullable && !Object.hasOwn(outputs, port.handle)).map((port) => [port.handle, null]))
+	} : outputs;
+	return matchesTriggerOutputs(trigger, normalized) ? normalized : void 0;
+}
 //#endregion
 //#region src/execution/common/engineContract.ts
 var currentEngineContract = "open-flow-engine/v5";
@@ -11711,16 +11758,22 @@ function canonicalOperand(operand) {
 	};
 }
 function canonicalNode(value) {
-	if (!("inputs" in value)) return canonicalTriggerNode(value);
+	if (isTriggerNode(value)) return canonicalTriggerNode(value);
 	const common = {
 		...value.description == null ? {} : { description: value.description },
 		...value.icon == null ? {} : { icon: value.icon },
-		inputs: canonicalInputs(value.inputs),
+		...value.kind == "outputs" ? {} : { inputs: canonicalInputs(value.inputs) },
 		...value.name == null ? {} : { name: value.name },
 		...value.maxExecutions == null ? {} : { maxExecutions: value.maxExecutions },
 		...value.timeoutMs == null ? {} : { timeoutMs: value.timeoutMs }
 	};
 	switch (value.kind) {
+		case "outputs": return {
+			...common,
+			kind: value.kind,
+			outputDefs: canonicalPorts(value.outputDefs),
+			outputMappings: canonicalInputs(value.outputMappings)
+		};
 		case "condition": return {
 			...common,
 			cases: value.cases.map((item) => ({
@@ -11900,6 +11953,10 @@ function canonicalTriggerNode(trigger) {
 			...trigger.sourceFlowIds == null ? {} : { sourceFlowIds: [...trigger.sourceFlowIds] }
 		};
 		case "manual": return common(trigger.kind);
+		case "start": return {
+			...common(trigger.kind),
+			inputDefs: canonicalPorts(trigger.inputDefs)
+		};
 		case "webhook": return {
 			...common(trigger.kind),
 			bodyFields: trigger.bodyFields.map((input) => ({
@@ -11982,7 +12039,10 @@ function graphDiagnostic(code, message, path, values, mismatch) {
 	};
 }
 function validateTrigger(triggerId, trigger, path, diagnostics) {
-	const outputHandles = triggerOutputDefinitions(trigger).map((port) => port.handle);
+	if (trigger.kind == "start") return;
+	const outputs = triggerOutputDefinitions(trigger);
+	if (outputs.some((port) => hasRetiredRef(port.jsonSchema))) diagnostics.push(graphDiagnostic("graph.schema-unsupported", "Runtime Ref schemas are not supported.", path));
+	const outputHandles = outputs.map((port) => port.handle);
 	if (new Set(outputHandles).size !== outputHandles.length) diagnostics.push(graphDiagnostic("graph.port-duplicate", "Trigger output handles must be unique.", `${path}/definition/outputs`));
 	if (trigger.kind == "webhook") {
 		if (!webhookSupportsBody(trigger.method) && trigger.bodyFields.length > 0) diagnostics.push(graphDiagnostic("trigger.webhook-body-unsupported", "GET Webhook triggers cannot declare request body fields.", `${path}/bodyFields`));
@@ -12008,6 +12068,7 @@ function validateTrigger(triggerId, trigger, path, diagnostics) {
 }
 function nodeInputPorts(node) {
 	switch (node.kind) {
+		case "outputs": return portsByHandle(node.outputDefs);
 		case "condition": return conditionInputPorts(node);
 		case "value": return {};
 		case "task": return portsByHandle([...node.task.inputs, ...node.additionalInputs ?? []]);
@@ -12018,6 +12079,7 @@ function nodeInputPorts(node) {
 		case "poll":
 		case "error":
 		case "manual":
+		case "start":
 		case "webhook": return {};
 	}
 }
@@ -12064,6 +12126,7 @@ function resolutionOutputPorts(node) {
 }
 function nodeOutputPorts(node) {
 	switch (node.kind) {
+		case "outputs":
 		case "condition": return {};
 		case "value": return portsByHandle(node.values);
 		case "task": return portsByHandle(node.task.outputs);
@@ -12074,6 +12137,7 @@ function nodeOutputPorts(node) {
 		case "poll":
 		case "error":
 		case "manual":
+		case "start":
 		case "webhook": return triggerOutputPorts(node);
 	}
 }
@@ -12191,7 +12255,7 @@ function graphPaths(graph) {
 					routes.push(next);
 				}
 			}
-			const nextRoutes = edges.length == 0 ? "inputs" in node ? [{}] : [{ $trigger: id }] : routes;
+			const nextRoutes = edges.length == 0 ? isTriggerNode(node) ? [{ $trigger: id }] : [{}] : routes;
 			const previous = paths.get(id) ?? [];
 			if (parents.size != (ancestors.get(id)?.size ?? 0) || resolutions.size != (resolutionOutputs.get(id)?.size ?? 0) || nextRoutes.length != previous.length || nextRoutes.some((route) => !previous.some((known) => routeCovers(known, route) && routeCovers(route, known)))) changed = true;
 			ancestors.set(id, parents);
@@ -12274,14 +12338,16 @@ function validateGraph(graph, document, path, diagnostics) {
 	const analysis = graphPaths(graph);
 	const errorTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "error");
 	if (errorTriggers.length > 1) for (const [nodeId] of errorTriggers) diagnostics.push(graphDiagnostic("graph.error-trigger-duplicate", "A graph can contain only one Flow Error node.", `${path}/nodes/${nodeId}`));
-	const manualTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "manual");
-	if (manualTriggers.length > 1) for (const [nodeId] of manualTriggers) diagnostics.push(graphDiagnostic("graph.manual-trigger-duplicate", "A graph can contain only one manual Trigger.", `${path}/nodes/${nodeId}`));
+	const outputNodes = Object.entries(graph.nodes).filter(([, node]) => node.kind == "outputs");
+	if (outputNodes.length > 1) for (const [nodeId] of outputNodes) diagnostics.push(graphDiagnostic("graph.outputs-duplicate", "A graph can contain only one Outputs node.", `${path}/nodes/${nodeId}`));
+	const startTriggers = Object.entries(graph.nodes).filter(([, node]) => node.kind == "manual" || node.kind == "start");
+	if (startTriggers.length > 1) for (const [nodeId] of startTriggers) diagnostics.push(graphDiagnostic("graph.start-trigger-duplicate", "A graph can contain only one Start Trigger.", `${path}/nodes/${nodeId}`));
 	const seen = /* @__PURE__ */ new Set();
 	for (const [index, edge] of graph.edges.entries()) {
 		const edgePath = `${path}/edges/${index}`;
 		const source = graph.nodes[edge.source];
 		const target = graph.nodes[edge.target];
-		if (source == null || target == null || !("inputs" in target)) diagnostics.push(graphDiagnostic("graph.edge-invalid", "Execution edges require an existing source and an executable target.", edgePath));
+		if (source == null || source.kind == "outputs" || target == null || isTriggerNode(target)) diagnostics.push(graphDiagnostic("graph.edge-invalid", "Execution edges require an existing source and an executable target.", edgePath));
 		else if (source.kind == "condition" || isResolutionNode(source)) {
 			const exits = isResolutionNode(source) ? Object.keys(resolutionOutputPorts(source)) : [...source.cases.map((item) => item.output), otherwiseOutput];
 			if (edge.sourceHandle == null || !exits.some((exit) => exit == edge.sourceHandle)) diagnostics.push(graphDiagnostic("graph.edge-invalid", "Choose a declared execution branch.", edgePath));
@@ -12296,13 +12362,12 @@ function validateGraph(graph, document, path, diagnostics) {
 	}
 	for (const [nodeId, node] of Object.entries(graph.nodes)) {
 		const nodePath = `${path}/nodes/${nodeId}`;
-		if ("inputs" in node && node.maxExecutions != null && (!Number.isSafeInteger(node.maxExecutions) || node.maxExecutions < 1)) diagnostics.push(graphDiagnostic("node.max-executions-invalid", "Maximum executions must be a positive safe integer.", `${nodePath}/maxExecutions`));
-		if (!("inputs" in node)) {
-			if (triggerOutputDefinitions(node).some((port) => hasRetiredRef(port.jsonSchema))) diagnostics.push(graphDiagnostic("graph.schema-unsupported", "Runtime Ref schemas are not supported.", nodePath));
+		if (!isTriggerNode(node) && node.maxExecutions != null && (!Number.isSafeInteger(node.maxExecutions) || node.maxExecutions < 1)) diagnostics.push(graphDiagnostic("node.max-executions-invalid", "Maximum executions must be a positive safe integer.", `${nodePath}/maxExecutions`));
+		if (isTriggerNode(node)) {
 			validateTrigger(nodeId, node, nodePath, diagnostics);
 			continue;
 		}
-		for (const [handle, mapping] of Object.entries(nodeInputMappings(node))) if (!mappingAvailable(graph, nodeId, mapping, analysis)) diagnostics.push(graphDiagnostic("graph.source-unavailable", "Input sources must reference execution ancestors, respect pending Wait decisions, and never provide multiple values on the same path.", `${nodePath}/inputs/${handle}`));
+		for (const [handle, mapping] of Object.entries(nodeInputMappings(node))) if (!mappingAvailable(graph, nodeId, mapping, analysis)) diagnostics.push(graphDiagnostic("graph.source-unavailable", "Input sources must reference execution ancestors, respect pending Wait decisions, and never provide multiple values on the same path.", node.kind == "outputs" ? `${nodePath}/outputMappings/${handle.replaceAll("~", "~0").replaceAll("/", "~1")}` : `${nodePath}/inputs/${handle}`));
 		const inputPorts = nodeInputPorts(node);
 		if (node.kind == "task") {
 			const ports = [...node.task.inputs, ...node.additionalInputs ?? []];
@@ -12319,7 +12384,7 @@ function validateGraph(graph, document, path, diagnostics) {
 		if ([...Object.values(inputPorts), ...Object.values(nodeOutputPorts(node))].some((port) => hasRetiredRef(port.jsonSchema))) diagnostics.push(graphDiagnostic("graph.schema-unsupported", "Runtime Ref schemas are not supported.", nodePath));
 		const inputs = new Set(Object.keys(inputPorts));
 		for (const [handle, mapping] of Object.entries(nodeInputMappings(node))) {
-			const mappingPath = `${nodePath}/inputs/${handle}`;
+			const mappingPath = node.kind == "outputs" ? `${nodePath}/outputMappings/${handle.replaceAll("~", "~0").replaceAll("/", "~1")}` : `${nodePath}/inputs/${handle}`;
 			if (!inputs.has(handle)) diagnostics.push(graphDiagnostic("graph.input-missing", `Node "${nodeId}" does not expose input "${handle}".`, mappingPath, {
 				handle,
 				nodeId
@@ -12369,6 +12434,14 @@ function validateGraph(graph, document, path, diagnostics) {
 }
 function validateFlowGraph(revision) {
 	const diagnostics = [];
+	for (const [id, node] of Object.entries(revision.document.graph.nodes)) {
+		if (node.kind != "start" && node.kind != "outputs") continue;
+		const field = node.kind == "start" ? "inputDefs" : "outputDefs";
+		const ports = node.kind == "start" ? node.inputDefs : node.outputDefs;
+		const path = `/document/graph/nodes/${id.replaceAll("~", "~0").replaceAll("/", "~1")}/${field}`;
+		if (new Set(ports.map((port) => port.handle)).size != ports.length) diagnostics.push(graphDiagnostic("graph.port-duplicate", "Workflow interface names must be unique.", path));
+		if (ports.some((port) => hasRetiredRef(port.jsonSchema))) diagnostics.push(graphDiagnostic("graph.schema-unsupported", "Runtime Ref schemas are not supported.", path));
+	}
 	for (const [bindingId, binding] of Object.entries(revision.document.bindings)) if (binding.kind == "variable" && !validVariableName(binding.target)) diagnostics.push(graphDiagnostic("binding.variable-invalid", `Variable binding "${bindingId}" has an invalid target.`, `/document/bindings/${bindingId}/target`, { bindingId }));
 	validateGraph(revision.document.graph, revision.document, "/document/graph", diagnostics);
 	return diagnostics;
@@ -24056,7 +24129,7 @@ function flowDependencies(content, triggerId) {
 	}
 	function visitGraph(value) {
 		for (const [, node] of entries(value.nodes)) {
-			if ("inputs" in node) visitInputMappings(nodeInputMappings(node));
+			if (!isTriggerNode(node)) visitInputMappings(nodeInputMappings(node));
 			switch (node.kind) {
 				case "condition": break;
 				case "task": if ("moduleId" in node.task) visitModule(node.task.moduleId);
@@ -24072,21 +24145,29 @@ function flowDependencies(content, triggerId) {
 }
 async function flowClosure(content) {
 	const dependencies = flowDependencies(content);
-	const { bindings, modules } = dependencies;
 	return {
 		dependencies,
-		digest: await digestBytes(canonicalJsonBytes({
-			bindings: Object.fromEntries([...bindings].toSorted().map((id) => [id, content.document.bindings[id] ?? null])),
-			graph: canonicalRevisionGraph(content, content.document.graph),
-			kind: "open-flow-semantic-closure",
-			...content.modelVersion < 6 ? { subflows: {} } : {},
-			modelVersion: content.modelVersion,
-			modules: Object.fromEntries([...modules].toSorted().map((id) => [id, content.modules[id] == null ? null : canonicalModule(content.modules[id])])),
-			...content.modelVersion < 6 ? { tasks: {} } : {},
-			version: 2
-		}))
+		digest: await digestBytes(closureBytes(content, dependencies))
 	};
 }
+/** Canonical semantic bytes, also used by transactional storage upgrades. */
+function encodeFlowClosure(content, triggerId) {
+	const scoped = triggerId == null ? content : runRevision(content, triggerId);
+	return closureBytes(scoped, flowDependencies(scoped));
+}
+function closureBytes(content, dependencies) {
+	const { bindings, modules } = dependencies;
+	return canonicalJsonBytes({
+		bindings: Object.fromEntries([...bindings].toSorted().map((id) => [id, content.document.bindings[id] ?? null])),
+		graph: canonicalRevisionGraph(content, content.document.graph),
+		kind: "open-flow-semantic-closure",
+		...content.modelVersion < 6 ? { subflows: {} } : {},
+		modelVersion: content.modelVersion,
+		modules: Object.fromEntries([...modules].toSorted().map((id) => [id, content.modules[id] == null ? null : canonicalModule(content.modules[id])])),
+		...content.modelVersion < 6 ? { tasks: {} } : {},
+		version: 2
+	});
+}
 function variableBindings(revision, bindingIds) {
 	return Object.fromEntries([...bindingIds].flatMap((bindingId) => {
 		const binding = revision.document.bindings[bindingId];
@@ -24103,6 +24184,7 @@ function flowResourceReferences(content) {
 		});
 	}
 	return {
+		calledFlowIds: [...new Set(Object.values(content.document.graph.nodes).flatMap((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "workflow" && node.task.executor.flowId ? [node.task.executor.flowId] : []))].toSorted(),
 		variableNames: [...new Set(Object.values(variableBindings(content, flowDependencies(content).bindings)))].toSorted(),
 		connections: [...connections].toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, value]) => value),
 		errorSourceFlowIds: [...new Set(Object.values(content.document.graph.nodes).flatMap((node) => node.kind == "error" ? node.sourceFlowIds ?? [] : []))].toSorted()
@@ -24113,18 +24195,30 @@ function validRunTrigger(revision, value) {
 	const trigger = value;
 	if (Object.keys(trigger).some((key) => key != "nodeId" && key != "outputs") || typeof trigger.nodeId != "string" || !Object.hasOwn(trigger, "outputs")) return false;
 	const node = revision.document.graph.nodes[trigger.nodeId];
-	return node != null && !("inputs" in node) && matchesTriggerOutputs(node, trigger.outputs);
+	return node != null && isTriggerNode(node) && matchesTriggerOutputs(node, trigger.outputs);
+}
+function normalizeRunTrigger(revision, value) {
+	if (value == null || typeof value != "object" || Array.isArray(value)) return;
+	const trigger = value;
+	if (Object.keys(trigger).some((key) => key != "nodeId" && key != "outputs") || typeof trigger.nodeId != "string" || !Object.hasOwn(trigger, "outputs")) return;
+	const node = revision.document.graph.nodes[trigger.nodeId];
+	if (node == null || !isTriggerNode(node)) return;
+	const outputs = normalizeTriggerOutputs(node, trigger.outputs);
+	return outputs == null ? void 0 : {
+		nodeId: trigger.nodeId,
+		outputs
+	};
 }
 function validateFlowInputs(revision, value) {
 	if (value == null || typeof value != "object" || Array.isArray(value)) return "invalid";
 	const graph = revision.document.graph;
 	for (const [nodeId, candidate] of Object.entries(value)) {
 		const node = graph.nodes[nodeId];
-		if (node == null || !("inputs" in node) || node.kind == "condition" || candidate == null || typeof candidate != "object" || Array.isArray(candidate)) return "invalid";
+		if (node == null || isTriggerNode(node) || node.kind == "condition" || candidate == null || typeof candidate != "object" || Array.isArray(candidate)) return "invalid";
 		const inputs = nodeInputPorts(node);
 		for (const handle of Object.keys(candidate)) {
 			const port = inputs[handle];
-			if (port == null || hasRetiredRef(port.jsonSchema) || node.inputs[handle] != null || Object.hasOwn(port, "value")) return "invalid";
+			if (port == null || hasRetiredRef(port.jsonSchema) || nodeInputMappings(node)[handle] != null || Object.hasOwn(port, "value")) return "invalid";
 		}
 	}
 	return "valid";
@@ -24208,6 +24302,17 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
+		if (task.executor.kind == "connector" && task.executor.action == "leina.send_notification") {
+			const mapping = node.inputs.leinaId;
+			const value = inputValue(mapping, nodeInputPorts(node).leinaId?.value);
+			if ((mapping?.kind != "sources" || mapping.sources.length == 0) && (typeof value != "string" || value.trim().length == 0)) checked.diagnostics.push({
+				code: "leina.robot-required",
+				column: 0,
+				line: 1,
+				message: "Select a Leina robot or bind its identifier to an input source.",
+				path: `/document/graph/nodes/${nodeId}/inputs/leinaId`
+			});
+		}
 		if (task.executor.kind == "connector" && task.executor.action.length == 0) checked.diagnostics.push({
 			code: "task.connector-incomplete",
 			column: 0,
@@ -24241,7 +24346,10 @@ function runRevision(revision, triggerId) {
 	for (const nodeId of reachable) {
 		const node = graph.nodes[nodeId];
 		if (node == null) continue;
-		nodes[nodeId] = !("inputs" in node) ? node : {
+		nodes[nodeId] = node.kind == "outputs" ? {
+			...node,
+			outputMappings: inputs(nodeId, node.outputMappings)
+		} : isTriggerNode(node) ? node : {
 			...node,
 			inputs: inputs(nodeId, node.inputs)
 		};
@@ -24270,7 +24378,7 @@ async function prepareFlow(revision, engineContract, triggerId) {
 	if (engine == null) return { kind: "engine-unsupported" };
 	if (triggerId != null) {
 		const trigger = revision.document.graph.nodes[triggerId];
-		if (trigger == null || "inputs" in trigger) return {
+		if (trigger == null || !isTriggerNode(trigger)) return {
 			kind: "flow-invalid",
 			validation: {
 				closure: await flowClosure(revision),
@@ -24293,10 +24401,15 @@ async function prepareFlow(revision, engineContract, triggerId) {
 		validation
 	};
 	const { closure } = validation;
+	const start = Object.values(revision.document.graph.nodes).find((node) => node.kind == "start");
+	const outputs = Object.values(revision.document.graph.nodes).find((node) => node.kind == "outputs");
 	return {
 		flow: {
 			closureDigest: closure.digest,
 			engineContract,
+			inputDefs: start?.inputDefs ?? [],
+			outputDefs: outputs?.outputDefs ?? [],
+			outputMappings: outputs?.outputMappings ?? {},
 			graph: revision.document.graph,
 			modules: Object.fromEntries([...closure.dependencies.modules].toSorted().map((id) => [id, revision.modules[id]]))
 		},
@@ -24330,4 +24443,4 @@ function codeActions(flow) {
 	return Object.values(flow.graph.nodes).flatMap((node) => node.kind == "task" && "moduleId" in node.task ? node.task.capabilities ?? [] : []);
 }
 //#endregion
-export { agentActions, agentInput, agentToolInput, agentToolSchema, availableOutputs, codeActions, connectionUsage, createRuntimeProgram, flowClosure, flowDependencies, flowResourceReferences, graphOrder, matchesSchema, matchesTriggerOutputs, nodeInputPorts, prepareFlow, removeConnectionUsage, renderPrompt, schemaValidationErrors, triggerOutputDefinitions, triggerOutputPorts, validRunTrigger, validateFlow, validateFlowInputs, validateModules, variableBindings, variableInputCompatible };
+export { agentActions, agentInput, agentToolInput, agentToolSchema, availableOutputs, codeActions, connectionUsage, createRuntimeProgram, encodeFlowClosure, flowClosure, flowDependencies, flowResourceReferences, graphOrder, matchesSchema, matchesTriggerOutputs, nodeInputPorts, normalizeRunTrigger, normalizeTriggerOutputs, prepareFlow, removeConnectionUsage, renderPrompt, schemaValidationErrors, triggerOutputDefinitions, triggerOutputPorts, validRunTrigger, validateFlow, validateFlowInputs, validateModules, variableBindings, variableInputCompatible };

package/dist/common/integration-trigger.js

@@ -6702,6 +6702,7 @@ var port = object({
 	nullable: boolean(),
 	handle: text
 });
+var workflowInputDefs = array(port.strict());
 var input = port.extend({ value: json.optional() });
 var group = object({
 	collapsed: boolean().optional(),
@@ -6859,6 +6860,11 @@ var managedFields = object({
 				messageHandle: text,
 				inputs: record$2(text, agentValue)
 			}).optional()
+		}),
+		strictObject({
+			kind: literal("workflow"),
+			flowId: text,
+			revisionId: text
 		})
 	])
 });
@@ -6967,6 +6973,12 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
+	strictObject({
+		...base,
+		kind: literal("outputs"),
+		outputDefs: array(port.strict()),
+		outputMappings: inputs
+	}).omit({ inputs: true }),
 	object({
 		...base,
 		inputs: record$2(text, never()),
@@ -6999,6 +7011,11 @@ var node = union([
 		...trigger,
 		kind: literal("manual")
 	}),
+	strictObject({
+		...trigger,
+		kind: literal("start"),
+		inputDefs: workflowInputDefs
+	}),
 	strictObject({
 		...trigger,
 		kind: literal("error"),
@@ -7063,7 +7080,7 @@ var module = object({
 	imports: strings,
 	source: text
 });
-var document = preprocess(rejectRetiredDefinitions, object({
+var document = preprocess(normalizeDocument, object({
 	bindings: record$2(text, binding),
 	graph
 }));
@@ -7072,7 +7089,9 @@ object({
 		literal(2),
 		literal(4),
 		literal(5),
-		literal(6)
+		literal(6),
+		literal(7),
+		literal(8)
 	]),
 	document,
 	modules: record$2(text, module)
@@ -7080,13 +7099,19 @@ object({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
-function rejectRetiredDefinitions(value) {
+function normalizeDocument(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.");
+	if ([
+		"inputDefs",
+		"outputDefs",
+		"outputMappings"
+	].some((field) => Object.hasOwn(candidate, field))) throw new TypeError("Workflow interface configuration must belong to Start and Outputs nodes.");
+	if (Object.values(record$1(record$1(candidate.graph).nodes)).some((candidateNode) => record$1(candidateNode).kind == "start" && Object.hasOwn(record$1(candidateNode), "parameters"))) throw new TypeError("Legacy Start.parameters is unsupported; configure node.inputDefs.");
 	return value;
 }
 function record$1(value) {

package/dist/common/liveDetails.d.ts

@@ -1,13 +1,26 @@
 import type { RevisionContent } from '../browser/flow-change.js';
 import type { Publication, TriggerBinding } from './control-api.js';
 import { z } from 'zod';
+import { flowInputFieldsView } from './authoringSchema.js';
 declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    nodeId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"start">;
+    config: z.ZodObject<{
+        inputDefs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodOptional<z.ZodJSONSchema>;
+            nullable: z.ZodOptional<z.ZodBoolean>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"manual">;
-    config: z.ZodObject<{}, z.core.$strict>;
-}, z.core.$strict>, z.ZodObject<{
+    config: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -36,7 +49,7 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>;
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<TriggerBinding, unknown>>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -59,7 +72,7 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>]>>;
     }, z.core.$strict>;
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<TriggerBinding, unknown>>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -68,7 +81,7 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         sourceFlowIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<TriggerBinding, unknown>>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -76,9 +89,9 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"value">;
         value: z.ZodJSONSchema;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"unset">;
-    }, z.core.$strict>], "kind">>;
+    }, z.core.$strip>], "kind">>;
     type: z.ZodLiteral<"poll">;
     config: z.ZodObject<{
         key: z.ZodString;
@@ -100,7 +113,7 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>]>>;
     }, z.core.$strict>;
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<TriggerBinding, unknown>>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     nodeId: z.ZodString;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -108,25 +121,27 @@ declare const entrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     inputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"value">;
         value: z.ZodJSONSchema;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"unset">;
-    }, z.core.$strict>], "kind">>;
+    }, z.core.$strip>], "kind">>;
     type: z.ZodLiteral<"integration">;
     config: z.ZodObject<{
         key: z.ZodString;
         connectionId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<TriggerBinding, unknown>>;
-}, z.core.$strict>], "type">;
+}, z.core.$strip>], "type">;
 export type LiveEntry = z.infer<typeof entrySchema>;
 export type LiveDetails = {
     readonly flowId: string;
     readonly version: 1;
 } & ({
+    readonly inputDefs: null;
     readonly publication: null;
     readonly status: 'not-published';
     readonly entries: readonly [];
 } | {
+    readonly inputDefs: z.infer<typeof flowInputFieldsView>;
     readonly publication: Publication;
     readonly status: 'runnable' | 'suspended';
     readonly enabled: boolean;

package/dist/common/mcp.d.ts

@@ -161,7 +161,7 @@ export declare const mcpTools: {
                     value: {
                         revision?: string | undefined;
                         query: string;
-                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "manual" | "openapi" | "poll" | "value" | "wait" | "webhook" | undefined;
+                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow" | undefined;
                         offset: number;
                         limit: number;
                         flowId: string;
@@ -193,7 +193,7 @@ export declare const mcpTools: {
                 };
                 validate(value: unknown): {
                     value: {
-                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "manual" | "openapi" | "poll" | "value" | "wait" | "webhook" | undefined;
+                        type?: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow" | undefined;
                         action?: string | undefined;
                         flowId?: string | undefined;
                     };
@@ -321,7 +321,7 @@ export declare const mcpTools: {
                         edits: ({
                             op: "node.add";
                             as: string;
-                            type: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "manual" | "openapi" | "poll" | "value" | "wait" | "webhook";
+                            type: "agent" | "approval" | "code" | "condition" | "connector" | "cron" | "decision" | "error" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "start" | "value" | "wait" | "webhook" | "workflow";
                             name: string;
                             config?: Record<string, z.JSONType> | undefined;
                             inputs?: Record<string, {
@@ -365,6 +365,9 @@ export declare const mcpTools: {
                                 config?: Record<string, z.JSONType> | undefined;
                             } | undefined;
                             clear?: string[][] | undefined;
+                        } | {
+                            op: "node.refresh";
+                            node: string;
                         } | {
                             op: "node.remove";
                             node: string;