@oomol-lab/open-flow 0.1.0-beta.81 → 0.1.0-beta.82

package/dist/common/control-api.js

@@ -8617,6 +8617,31 @@ function isSchemaKeyword(value) {
 	return schemaKeywords.has(value);
 }
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
+}
+//#endregion
 //#region src/workflow/common/workflow.ts
 var portSchema = object({
 	handle: string$1().min(1),
@@ -10547,7 +10572,7 @@ var entrySchema = discriminatedUnion("type", [
 /** Project only the selected published definition and its current bindings. */
 function liveEntries(content, current, bindings) {
 	const byNode = new Map(bindings.filter((item) => item.flowId == current.flowId && item.currentPublicationId == current.publicationId && item.currentRevisionId == current.revisionId).map((item) => [item.triggerNodeId, item]));
-	return decodeEntries(Object.entries(content.document.graph.nodes).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([nodeId, node]) => {
+	return decodeEntries$1(Object.entries(content.document.graph.nodes).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).flatMap(([nodeId, node]) => {
 		if (node.kind != "start" && node.kind != "manual" && node.kind != "webhook" && node.kind != "cron" && node.kind != "error" && node.kind != "poll" && node.kind != "integration") return [];
 		const config = triggerConfiguration(node);
 		return [{
@@ -10595,12 +10620,12 @@ function decodeLiveDetails(value) {
 		publication: current,
 		status,
 		enabled: source.enabled,
-		entries: decodeEntries(source.entries, current),
+		entries: decodeEntries$1(source.entries, current),
 		version: 1
 	};
 }
 /** Both producers and consumers enforce the same published-entry invariants. */
-function decodeEntries(values, current) {
+function decodeEntries$1(values, current) {
 	const parsed = array(entrySchema).safeParse(values);
 	if (!parsed.success) return invalidResponse();
 	const ids = /* @__PURE__ */ new Set();
@@ -10670,17 +10695,134 @@ function conditionInputPorts(node) {
 		nullable: operand.kind === "value" ? operand.value === null : true
 	}]));
 }
+function clearConditionBinding(operand) {
+	return operand.kind == "source" && operand.source.kind == "binding" ? { kind: "value" } : operand;
+}
+function clearConditionBindings(node) {
+	return {
+		...node,
+		cases: node.cases.map((item) => ({
+			...item,
+			groups: item.groups.map((group) => ({
+				...group,
+				expressions: group.expressions.map((expression) => ({
+					...expression,
+					left: clearConditionBinding(expression.left),
+					...expression.right == null ? {} : { right: clearConditionBinding(expression.right) }
+				}))
+			}))
+		}))
+	};
+}
 //#endregion
 //#region src/flow/common/model.ts
 function portsByHandle(ports) {
 	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
 }
 //#endregion
+//#region src/trigger/common/config.ts
+/** Deployment-bound selections owned by the Trigger configuration contract. */
+function clearTriggerExternalConfig(key, config) {
+	const fields = key == "jira.on_issue_event" || key == "intercom.on_conversation_event" || key == "sentry.on_issue_alert" || key == "zoom.on_recording_ready" || key == "fireflies.on_meeting_ready" ? ["sourceId", "eventTypes"] : key == "slackbot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"channelIds"
+	] : key == "feishu_app_bot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"resource",
+		"chatIds"
+	] : key == "linear.on_issue_changed" ? ["teamId", "stateIds"] : [];
+	return {
+		...config,
+		...Object.fromEntries(fields.map((field) => [field, { kind: "unset" }]))
+	};
+}
+//#endregion
+//#region src/flow/common/connectionUsage.ts
+function clearNodeConnections(graph, connectionId) {
+	return {
+		...graph,
+		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
+			if ((node.kind == "poll" || node.kind == "integration") && (connectionId == null || node.connectionId == connectionId)) {
+				const { connectionId: _, ...remaining } = node;
+				return [id, remaining];
+			}
+			if (node.kind != "task") return [id, node];
+			if ("executor" in node.task) {
+				const executor = node.task.executor;
+				const clear = (value) => {
+					if (value.connectionId === "") return value;
+					if (connectionId != null && value.connectionId != connectionId) return value;
+					const { connectionId: _, ...rest } = value;
+					return rest;
+				};
+				if (executor.kind == "connector") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: clear(executor)
+					}
+				}];
+				if (executor.kind == "agent") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: {
+							...executor,
+							tools: executor.tools.map(clear),
+							...executor.notification == null ? {} : { notification: clear(executor.notification) }
+						}
+					}
+				}];
+				return [id, node];
+			}
+			const capabilities = node.task.capabilities?.map((capability) => {
+				if (capability.kind == "workflow" || capability.kind == "http") return capability;
+				if (!("mode" in capability)) {
+					if ("action" in capability) {
+						const { connectionId: selected, ...rest } = capability;
+						return {
+							...rest,
+							connections: capability.connections.filter((item) => connectionId != null && item.connectionId != connectionId),
+							...selected != null && connectionId != null && selected != connectionId ? { connectionId: selected } : {}
+						};
+					}
+					return {
+						...capability,
+						...connectionId == null && (capability.connectionHints?.length ?? 0) > 0 ? { actionHints: [.../* @__PURE__ */ new Set([...capability.actionHints ?? [], ...capability.connectionHints.map((hint) => hint.action)])] } : {},
+						...capability.connectionHints == null ? {} : { connectionHints: capability.connectionHints.filter((item) => connectionId != null && item.connectionId != connectionId) }
+					};
+				}
+				if (capability.mode != "independent") return capability;
+				return {
+					...capability,
+					actions: capability.actions.map((action) => {
+						if (action.connectionId === "") return action;
+						if (connectionId != null && action.connectionId != connectionId) return action;
+						const { connectionId: _, ...remaining } = action;
+						return remaining;
+					})
+				};
+			});
+			return [id, capabilities == null ? node : {
+				...node,
+				task: {
+					...node.task,
+					capabilities
+				}
+			}];
+		}))
+	};
+}
+//#endregion
 //#region src/flow/common/workflowFile.ts
 var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string$1().optional(),
+	icon: string$1().optional(),
+	description: string$1().optional(),
 	content: unknown(),
 	presentation: record$2(string$1(), json$3()).optional()
 });
@@ -10693,6 +10835,126 @@ function decodeWorkflowFile(value) {
 		content: decodeRevisionContent(file.content)
 	};
 }
+function cleanInput(input) {
+	if (input.kind != "sources" || !input.sources.some((source) => source.kind == "binding")) return input;
+	const sources = input.sources.filter((source) => source.kind != "binding");
+	return sources.length == 0 ? { kind: "unset" } : {
+		kind: "sources",
+		sources
+	};
+}
+/** Clear only owned structured references, never strings in code or business values. */
+function cleanWorkflowFile(value) {
+	const file = decodeWorkflowFile(value);
+	const original = file.content.document.graph;
+	const graph = clearNodeConnections(original);
+	const nodes = Object.fromEntries(Object.entries(graph.nodes).map(([id, source]) => {
+		let node = source;
+		if ("inputs" in node) node = {
+			...node,
+			inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "outputs") node = {
+			...node,
+			outputMappings: Object.fromEntries(Object.entries(node.outputMappings).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "condition") node = clearConditionBindings(node);
+		if (node.kind == "error" && node.sourceFlowIds != null) node = {
+			...node,
+			sourceFlowIds: []
+		};
+		if (node.kind == "poll" || node.kind == "integration") node = {
+			...node,
+			config: clearTriggerExternalConfig(node.definition.key, node.config)
+		};
+		return [id, node];
+	}));
+	return {
+		file: {
+			...file,
+			content: {
+				...file.content,
+				document: {
+					...file.content.document,
+					bindings: {},
+					graph: {
+						...graph,
+						nodes
+					}
+				}
+			}
+		},
+		summary: {
+			changedNodeIds: Object.keys(nodes).filter((id) => !dequal(nodes[id], original.nodes[id])),
+			removedBindings: Object.keys(file.content.document.bindings).length
+		}
+	};
+}
+//#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries = array(strictObject({
+	flowId: string$1().min(1),
+	file: unknown()
+})).min(1);
+var bundleSchema = strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries
+});
+var previewSchema = strictObject({
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries,
+	unavailableFlowIds: array(string$1().min(1))
+});
+function decodeEntries(value, entryFlowId, unavailableFlowIds = []) {
+	const workflows = value.map(({ flowId, file }) => ({
+		flowId,
+		file: decodeWorkflowFile(file)
+	}));
+	const ids = new Set(workflows.map(({ flowId }) => flowId));
+	if (ids.size != workflows.length || !ids.has(entryFlowId)) throw new TypeError("Workflow identities must be unique and include the entry workflow.");
+	const unavailable = new Set(unavailableFlowIds);
+	if (unavailable.size != unavailableFlowIds.length || unavailableFlowIds.some((id) => ids.has(id))) throw new TypeError("Invalid unavailable workflow identities.");
+	for (const { file } of workflows) for (const node of Object.values(file.content.document.graph.nodes)) for (const { target } of nodeWorkflowReferences(node)) if (target.flowId && !ids.has(target.flowId) && !unavailable.has(target.flowId)) throw new TypeError("A referenced workflow is missing from the bundle.");
+	return workflows;
+}
+function decodeWorkflowBundle(value) {
+	checkJsonDepth(value, -4);
+	const bundle = bundleSchema.parse(value);
+	return {
+		...bundle,
+		workflows: decodeEntries(bundle.workflows, bundle.entryFlowId)
+	};
+}
+function decodeWorkflowExportPreview(value) {
+	checkJsonDepth(value, -4);
+	const preview = previewSchema.parse(value);
+	return {
+		...preview,
+		workflows: decodeEntries(preview.workflows, preview.entryFlowId, preview.unavailableFlowIds)
+	};
+}
+function cleanWorkflowBundle(value) {
+	const bundle = decodeWorkflowBundle(value);
+	return {
+		...bundle,
+		workflows: bundle.workflows.map(({ flowId, file }) => ({
+			flowId,
+			file: cleanWorkflowFile(file).file
+		}))
+	};
+}
+function workflowBundleFromPreview(preview) {
+	if (preview.unavailableFlowIds.length) throw new TypeError("Some referenced workflows are unavailable.");
+	return cleanWorkflowBundle({
+		kind: "open-flow-workflow-bundle",
+		version: 1,
+		entryFlowId: preview.entryFlowId,
+		workflows: preview.workflows
+	});
+}
 //#endregion
 //#region src/flow/common/encoding.ts
 var encoder$1 = new TextEncoder();
@@ -11996,6 +12258,8 @@ function flow(value) {
 		resourceReferences: resourceReferences(source.resourceReferences),
 		flowId: string(source.flowId),
 		name: string(source.name),
+		...source.icon === void 0 ? {} : { icon: string(source.icon) },
+		...source.description === void 0 ? {} : { description: string(source.description) },
 		status,
 		updatedAt: string(source.updatedAt),
 		version: 1
@@ -12482,6 +12746,18 @@ function decodeTagListItem(value) {
 }
 //#endregion
 //#region src/control/common/api.ts
+function decodeWorkflowBundleImportResult(value) {
+	const source = record(value);
+	if (source.version != 1 || !Array.isArray(source.flows) || source.flows.length == 0) return invalidResponse();
+	const entry = flow(source.flow);
+	const flows = source.flows.map(flow);
+	if (new Set(flows.map((item) => item.flowId)).size != flows.length || !flows.some((item) => item.flowId == entry.flowId)) return invalidResponse();
+	return {
+		version: 1,
+		flow: entry,
+		flows
+	};
+}
 function isRunTerminalEvent(event) {
 	return event?.kind == "run.completed" || event?.kind == "run.failed" || event?.kind == "run.canceled" || event?.kind == "run.indeterminate";
 }
@@ -12799,6 +13075,32 @@ var ControlClient = class {
 			return invalidResponse();
 		}
 	}
+	async getFlowExportPreview(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export-preview`);
+		try {
+			return decodeWorkflowExportPreview(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async exportFlowBundle(flowId) {
+		const preview = await this.getFlowExportPreview(flowId);
+		if (preview.unavailableFlowIds.length) throw new ApiError(400, "flow.invalid", "Some referenced workflows are unavailable.");
+		return workflowBundleFromPreview(preview);
+	}
+	async importFlowBundle(file, options = {}) {
+		return decodeWorkflowBundleImportResult(await this.request("/v1/flows/import-bundle", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				tagIds: options.tagIds,
+				version: 1
+			})
+		}));
+	}
 	async importFlow(file, options = {}) {
 		return flow(await this.request("/v1/flows/import", {
 			method: "POST",
@@ -13455,4 +13757,4 @@ var ControlClient = class {
 	}
 };
 //#endregion
-export { ApiError, ControlClient, actionSummary, controlErrorCode, controlErrorMetadata, connectorAccess as decodeConnectorAccess, connectorAccessSnapshot as decodeConnectorAccessSnapshot, decodeEventSource, decodeEventSources, decodeResultList, decodeResultRead, decodeRunEvent, decodeTriggerCatalog, flowInputDefinitions, flowInspection, inspectFlowDraft, isRunTerminalEvent, liveEntries, nodeDetails, normalizeFlowQuery, parseProviderAccessSource, parseResultQuery, providerAccessBindingId, providerIconAppearance, readResult, searchTriggerKeys };
+export { ApiError, ControlClient, actionSummary, controlErrorCode, controlErrorMetadata, connectorAccess as decodeConnectorAccess, connectorAccessSnapshot as decodeConnectorAccessSnapshot, decodeEventSource, decodeEventSources, decodeResultList, decodeResultRead, decodeRunEvent, decodeTriggerCatalog, decodeWorkflowBundleImportResult, flowInputDefinitions, flowInspection, inspectFlowDraft, isRunTerminalEvent, liveEntries, nodeDetails, normalizeFlowQuery, parseProviderAccessSource, parseResultQuery, providerAccessBindingId, providerIconAppearance, readResult, searchTriggerKeys };

package/dist/common/control-requests.d.ts

@@ -224,12 +224,10 @@ export declare const controlRequests: {
         version: 1;
     };
     updateFlow: (value: unknown) => {
-        name: string;
-        tagIds?: string[] | undefined;
-        version: 1;
-    } | {
         name?: string | undefined;
-        tagIds: string[];
+        icon?: string | null | undefined;
+        description?: string | null | undefined;
+        tagIds?: string[] | undefined;
         version: 1;
     };
     renameFlow: (value: unknown) => {

package/dist/common/control-requests.js

@@ -17948,15 +17948,13 @@ var schemas = {
 		tagIds,
 		version
 	}),
-	updateFlow: union([strictObject({
-		name: flowName,
-		tagIds: tagIds.optional(),
-		version
-	}), strictObject({
+	updateFlow: strictObject({
 		name: flowName.optional(),
-		tagIds,
+		icon: string().nullable().optional(),
+		description: string().nullable().optional(),
+		tagIds: tagIds.optional(),
 		version
-	})]),
+	}).refine((value) => value.name !== void 0 || value.icon !== void 0 || value.description !== void 0 || value.tagIds !== void 0, "Flow settings are empty."),
 	renameFlow: strictObject({
 		name: flowName,
 		version

package/dist/common/flow-encoding.d.ts

@@ -1,5 +1,6 @@
 import type { CodeModule, FlowDocument, Graph, Group, InputMapping, InputPort, JsonValue, ManagedTaskDefinition, Port, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
 export * from './flow-workflowFile.js';
+export * from './flow-workflowBundle.js';
 export { maxJsonDepth } from './flow-json.js';
 export { decodeFlowDocument, decodeRevisionContent, upgradeWorkflowInterfaceDocument } from './flow-change-schema.js';
 export { upgradeRevisionContent } from '@oomol-lab/open-flow/flow-change';

package/dist/common/flow-encoding.js

@@ -9856,6 +9856,8 @@ var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string().optional(),
+	icon: string().optional(),
+	description: string().optional(),
 	content: unknown(),
 	presentation: record$1(string(), json$1()).optional()
 });
@@ -9936,6 +9938,170 @@ function workflowNameFromFile(name) {
 	return name.replace(/(?:\.openflow)?\.json$/i, "");
 }
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Rewrite only declared workflow identities, preserving business values and saved ports. */
+function mapNodeWorkflowTargets(node, map) {
+	if (node.kind != "task") return node;
+	const task = node.task;
+	if ("moduleId" in task) return task.capabilities?.some((item) => item.kind == "workflow") ? {
+		...node,
+		task: {
+			...task,
+			capabilities: task.capabilities.map((item) => item.kind == "workflow" ? Object.assign({}, item, map(item)) : item)
+		}
+	} : node;
+	const executor = task.executor;
+	if (executor.kind == "workflow") return {
+		...node,
+		task: {
+			...task,
+			executor: {
+				...executor,
+				...map(executor)
+			}
+		}
+	};
+	if (executor.kind == "agent") return {
+		...node,
+		task: {
+			...task,
+			executor: {
+				...executor,
+				tools: executor.tools.map((tool) => tool.kind == "workflow" ? Object.assign({}, tool, map(tool)) : tool)
+			}
+		}
+	};
+	return node;
+}
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
+}
+//#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries$1 = array(strictObject({
+	flowId: string().min(1),
+	file: unknown()
+})).min(1);
+var bundleSchema = strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$1
+});
+var previewSchema = strictObject({
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$1,
+	unavailableFlowIds: array(string().min(1))
+});
+function decodeEntries(value, entryFlowId, unavailableFlowIds = []) {
+	const workflows = value.map(({ flowId, file }) => ({
+		flowId,
+		file: decodeWorkflowFile(file)
+	}));
+	const ids = new Set(workflows.map(({ flowId }) => flowId));
+	if (ids.size != workflows.length || !ids.has(entryFlowId)) throw new TypeError("Workflow identities must be unique and include the entry workflow.");
+	const unavailable = new Set(unavailableFlowIds);
+	if (unavailable.size != unavailableFlowIds.length || unavailableFlowIds.some((id) => ids.has(id))) throw new TypeError("Invalid unavailable workflow identities.");
+	for (const { file } of workflows) for (const node of Object.values(file.content.document.graph.nodes)) for (const { target } of nodeWorkflowReferences(node)) if (target.flowId && !ids.has(target.flowId) && !unavailable.has(target.flowId)) throw new TypeError("A referenced workflow is missing from the bundle.");
+	return workflows;
+}
+function decodeWorkflowBundle(value) {
+	checkJsonDepth(value, -4);
+	const bundle = bundleSchema.parse(value);
+	return {
+		...bundle,
+		workflows: decodeEntries(bundle.workflows, bundle.entryFlowId)
+	};
+}
+function decodeWorkflowExportPreview(value) {
+	checkJsonDepth(value, -4);
+	const preview = previewSchema.parse(value);
+	return {
+		...preview,
+		workflows: decodeEntries(preview.workflows, preview.entryFlowId, preview.unavailableFlowIds)
+	};
+}
+function cleanWorkflowBundle(value) {
+	const bundle = decodeWorkflowBundle(value);
+	return {
+		...bundle,
+		workflows: bundle.workflows.map(({ flowId, file }) => ({
+			flowId,
+			file: cleanWorkflowFile(file).file
+		}))
+	};
+}
+function workflowBundleFromPreview(preview) {
+	if (preview.unavailableFlowIds.length) throw new TypeError("Some referenced workflows are unavailable.");
+	return cleanWorkflowBundle({
+		kind: "open-flow-workflow-bundle",
+		version: 1,
+		entryFlowId: preview.entryFlowId,
+		workflows: preview.workflows
+	});
+}
+function encodeWorkflowBundle(bundle) {
+	return `${JSON.stringify(cleanWorkflowBundle(bundle), null, 2)}\n`;
+}
+function parseWorkflowImportFile(text) {
+	const value = JSON.parse(text);
+	return value != null && typeof value == "object" && "kind" in value && value.kind == "open-flow-workflow-bundle" ? decodeWorkflowBundle(value) : decodeWorkflowFile(value);
+}
+/** A bundle creates new drafts, so old published interface provenance must be refreshed. */
+function remapWorkflowBundle(bundle, flowIds) {
+	const cleaned = cleanWorkflowBundle(bundle);
+	function identity(flowId) {
+		const mapped = flowIds.get(flowId);
+		if (mapped == null || mapped.length == 0) throw new TypeError("Missing imported workflow identity.");
+		return mapped;
+	}
+	const workflows = cleaned.workflows.map(({ flowId, file }) => ({
+		flowId: identity(flowId),
+		file: {
+			...file,
+			content: {
+				...file.content,
+				document: {
+					...file.content.document,
+					graph: {
+						...file.content.document.graph,
+						nodes: Object.fromEntries(Object.entries(file.content.document.graph.nodes).map(([id, node]) => [id, mapNodeWorkflowTargets(node, (target) => ({
+							flowId: target.flowId ? identity(target.flowId) : "",
+							revisionId: ""
+						}))]))
+					}
+				}
+			}
+		}
+	}));
+	return decodeWorkflowBundle({
+		...cleaned,
+		entryFlowId: identity(cleaned.entryFlowId),
+		workflows
+	});
+}
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder = new TextEncoder();
 function canonicalText(value) {
@@ -10315,4 +10481,4 @@ function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));
 }
 //#endregion
-export { canonicalDocument, canonicalGraph, canonicalInputs, canonicalJsonBytes, canonicalModule, canonicalPorts, canonicalRevisionGraph, canonicalTask, cleanWorkflowFile, decodeFlowDocument, decodeRevision, decodeRevisionContent, decodeWorkflowFile, digestBytes, encodeRevision, encodeWorkflowFile, maxJsonDepth, parseWorkflowFile, repairRevision, revisionRepairKind, triggerRuntimeJson, upgradeRevisionContent, upgradeWorkflowInterfaceDocument, workflowFileName, workflowNameFromFile };
+export { canonicalDocument, canonicalGraph, canonicalInputs, canonicalJsonBytes, canonicalModule, canonicalPorts, canonicalRevisionGraph, canonicalTask, cleanWorkflowBundle, cleanWorkflowFile, decodeFlowDocument, decodeRevision, decodeRevisionContent, decodeWorkflowBundle, decodeWorkflowExportPreview, decodeWorkflowFile, digestBytes, encodeRevision, encodeWorkflowBundle, encodeWorkflowFile, maxJsonDepth, parseWorkflowFile, parseWorkflowImportFile, remapWorkflowBundle, repairRevision, revisionRepairKind, triggerRuntimeJson, upgradeRevisionContent, upgradeWorkflowInterfaceDocument, workflowBundleFromPreview, workflowFileName, workflowNameFromFile };

package/dist/common/flow-semantics.js

@@ -12336,10 +12336,30 @@ strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string().optional(),
+	icon: string().optional(),
+	description: string().optional(),
 	content: unknown(),
 	presentation: record$1(string(), json$1()).optional()
 });
 //#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries$2 = array(strictObject({
+	flowId: string().min(1),
+	file: unknown()
+})).min(1);
+strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$2
+});
+strictObject({
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$2,
+	unavailableFlowIds: array(string().min(1))
+});
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder = new TextEncoder();
 function canonicalText(value) {

package/dist/common/flow-workflowBundle.d.ts

@@ -0,0 +1,27 @@
+import type { WorkflowFile } from './flow-workflowFile.js';
+export interface WorkflowBundleEntry {
+    readonly flowId: string;
+    readonly file: WorkflowFile;
+}
+export interface WorkflowBundle {
+    readonly kind: 'open-flow-workflow-bundle';
+    readonly version: 1;
+    readonly entryFlowId: string;
+    readonly workflows: readonly WorkflowBundleEntry[];
+}
+/** A saved export snapshot; unavailable targets carry no account metadata. */
+export interface WorkflowExportPreview {
+    readonly version: 1;
+    readonly entryFlowId: string;
+    readonly workflows: readonly WorkflowBundleEntry[];
+    readonly unavailableFlowIds: readonly string[];
+}
+export declare function decodeWorkflowBundle(value: unknown): WorkflowBundle;
+export declare function decodeWorkflowExportPreview(value: unknown): WorkflowExportPreview;
+export declare function cleanWorkflowBundle(value: unknown): WorkflowBundle;
+export declare function workflowBundleFromPreview(preview: WorkflowExportPreview): WorkflowBundle;
+export declare function encodeWorkflowBundle(bundle: WorkflowBundle): string;
+export type WorkflowImportFile = WorkflowFile | WorkflowBundle;
+export declare function parseWorkflowImportFile(text: string): WorkflowImportFile;
+/** A bundle creates new drafts, so old published interface provenance must be refreshed. */
+export declare function remapWorkflowBundle(bundle: WorkflowBundle, flowIds: ReadonlyMap<string, string>): WorkflowBundle;

package/dist/common/flow-workflowFile.d.ts

@@ -3,6 +3,8 @@ export interface WorkflowFile {
     readonly kind: 'open-flow-workflow';
     readonly version: 1;
     readonly name?: string;
+    readonly icon?: string;
+    readonly description?: string;
     readonly content: RevisionContent;
     readonly presentation?: Readonly<Record<string, JsonValue>>;
 }