@oomol-lab/open-flow 0.1.0-beta.51 → 0.1.0-beta.53

package/dist/browser/workbench.js

@@ -1,7 +1,7 @@
-import { $t as EmptyTitle, An as connection, At as flowDependencies, Ct as resetInputValues, Dt as setTriggerConnection, En as isJsonObject, Et as setInputSources, F as deriveAddNodeOptions, Fn as record, Ft as PopoverContent, G as resourceValue, Gt as InputGroup, H as Resource, In as string, Jt as Empty, K as designerGraph, Kt as InputGroupAddon, L as feishuResourceKind, Ln as providerIconAppearance, Mn as inputValue, Mt as followWorkbenchLink, Nn as invalidResponse, Nt as Switch, Ot as updateTriggerConfig, P as addNodeIntent, Pn as jsonValue, Pt as Popover, Qt as EmptyMedia, R as supportsFeishuChatFilter, Rn as ApiError, Rt as PopoverTitle, St as repairNodeNames, Tn as triggerOutputDefinitions, Tt as setConnectorConnection, V as scopedValue, Vn as IconThemeContext, W as resourceData, X as providerIcon, Xt as EmptyDescription, Yt as EmptyContent, Zt as EmptyHeader, _ as updateTaskAdditionalInputs, _n as WorkbenchClient, _t as setComment, a as deleteSelection, at as Latest, b as updateWebhook, bt as setNodePositions, c as setInputVariable, d as updateNodeIcon, dt as actionWithConnections, en as EventSourcesPage, f as updateNodeName, ft as connectionCatalog, g as updateTask, gn as errorNotice, gt as restoreCanvasPresentation, h as updateSubflow, ht as removeComments, i as createResource, it as revisionView, jn as connectorActionMetadata, jt as IdTooltip, kt as updateTriggerSchedule, l as updateCondition, m as updateResolution, mt as commentIds, o as nameCreatedNodes, ot as deriveInspectorDiagnostics, p as updateNodeSettings, pt as canvasPresentationChange, qt as InputGroupInput, r as applyFlowChanges, rn as createI18n, s as setInputValue, st as diagnosticItems, t as addNode, tt as RunStore, u as updateNodeDescription, v as updateTaskPorts, vn as randomId, vt as setFlowViewport, wn as sampleErrorOutputs, wt as setCodeActions, xn as decodeTriggerCatalog, xt as targetPresentation, y as updateValue, yn as allConnectorConnectionsQuery, yt as setNodeContentHidden, z as combineSources, zn as controlErrorCode, zt as PopoverTrigger } from "./flowChanges-BWSXSnMX.js";
+import { $t as InputGroup, At as flowDependencies, Bn as inputValue, Bt as followWorkbenchLink, Ct as resetInputValues, Dn as allConnectorConnectionsQuery, Dt as setTriggerConnection, En as randomId, Et as setInputSources, F as deriveAddNodeOptions, G as resourceValue, Gn as providerIconAppearance, H as CacheResource, Hn as jsonValue, Ht as Popover, K as designerGraph, Kn as ApiError, Kt as PopoverTitle, L as feishuResourceKind, Mn as sampleErrorOutputs, Nn as triggerOutputDefinitions, Ot as updateTriggerConfig, P as addNodeIntent, Pn as isJsonObject, R as supportsFeishuChatFilter, Rn as connection, St as repairNodeNames, Tn as WorkbenchClient, Tt as setConnectorConnection, Un as record, Ut as PopoverContent, V as scopedValue, Vn as invalidResponse, Vt as Switch, W as resourceData, Wn as string, X as providerIcon, Yn as IconThemeContext, _ as updateTaskAdditionalInputs, _t as setComment, a as deleteSelection, an as EmptyHeader, at as Latest, b as updateWebhook, bt as setNodePositions, c as setInputVariable, cn as EventSourcesPage, d as updateNodeIcon, dn as createI18n, dt as actionWithConnections, en as InputGroupAddon, f as updateNodeName, ft as connectionCatalog, g as updateTask, gt as restoreCanvasPresentation, h as updateSubflow, ht as removeComments, i as createResource, in as EmptyDescription, it as revisionView, kn as decodeTriggerCatalog, kt as updateTriggerSchedule, l as updateCondition, m as updateResolution, mt as commentIds, nn as Empty, o as nameCreatedNodes, on as EmptyMedia, ot as deriveInspectorDiagnostics, p as updateNodeSettings, pt as canvasPresentationChange, qn as controlErrorCode, qt as PopoverTrigger, r as applyFlowChanges, rn as EmptyContent, s as setInputValue, sn as EmptyTitle, st as diagnosticItems, t as addNode, tn as InputGroupInput, tt as RunStore, u as updateNodeDescription, v as updateTaskPorts, vt as setFlowViewport, wn as errorNotice, wt as setCodeActions, xt as targetPresentation, y as updateValue, yt as setNodeContentHidden, z as combineSources, zn as connectorActionMetadata, zt as IdTooltip } from "./flowChanges-CcscgZsW.js";
 import { a as derive, i as compute, l as val } from "./dist-bO8nvHFH.js";
 import { a as useVal, i as useTranslate, r as useLang, t as I18nProvider } from "./main-BPABKzwN.js";
-import { D as FlowChangeError, E as FieldLabel, Fr as Button, L as mapConditionSources, Lr as cn, Mn as Input, N as portsByHandle, O as applyFlowChanges$1, P as resourceNameIssue, R as nodeInputMappings, S as Field, T as FieldGroup, a as DialogContent, c as DialogHeader, d as Tooltip, f as TooltipContent, i as DialogClose, l as DialogTitle, m as TooltipTrigger, n as Icon, o as DialogDescription, q as dequal$1, r as Dialog, s as DialogFooter, t as WorkbenchSelect, w as FieldError, x as Spinner } from "./workbenchSelect-C9kwcUmN.js";
+import { C as FieldError, D as applyFlowChanges$1, E as FlowChangeError, I as mapConditionSources, Ir as cn, K as dequal$1, L as nodeInputMappings, N as resourceNameIssue, Pr as Button, T as FieldLabel, a as DialogDescription, b as Spinner, c as DialogTitle, d as TooltipContent, i as DialogContent, jn as Input, n as Dialog, o as DialogFooter, p as TooltipTrigger, r as DialogClose, s as DialogHeader, t as Icon, u as Tooltip, w as FieldGroup, x as Field } from "./icons-0s-Q_3lp.js";
 import { a as toPlainObject } from "./dist-BDBTOgS5.js";
 import { c as isUiLanguage, d as uiLanguages, l as resolveUiLanguage, u as uiLanguageNames } from "./value-DL_poNiC.js";
 import { Suspense, lazy, useEffect, useRef, useState } from "react";
@@ -196,34 +196,11 @@ function Skeleton({ className, ...props }) {
 }
 //#endregion
 //#region src/workbench/browser/runtime/shell/resourceBrowser.tsx
-var CreateResourceDialog = lazy(() => import("./createResourceDialog-BDtXpRSt.js"));
-var languageOptions = uiLanguages.map((language) => ({
-	label: uiLanguageNames[language],
-	value: language
-}));
+var CreateResourceDialog = lazy(() => import("./createResourceDialog-BsaBMf7_.js"));
 var flowIdTooltipAlignOffset = 44;
 var renamePopoverAlignOffset = -12;
 var renamePopoverVerticalShift = 8;
 var rowControlSelector = "a, button, input, select, textarea, [data-slot=\"tooltip-trigger\"]";
-function LanguageSelect({ language, onLanguageChange }) {
-	const t = useTranslate();
-	const [portalRoot, setPortalRoot] = useState(null);
-	if (onLanguageChange == null) return null;
-	return /* @__PURE__ */ jsxs("div", {
-		className: "resource-language",
-		ref: setPortalRoot,
-		children: [/* @__PURE__ */ jsx("span", {
-			className: "sr-only",
-			children: t("language.label")
-		}), /* @__PURE__ */ jsx(WorkbenchSelect, {
-			ariaLabel: t("language.label"),
-			onValueChange: (value) => onLanguageChange(value),
-			options: languageOptions,
-			portalRoot,
-			value: language
-		})]
-	});
-}
 function compactFlowId(flowId) {
 	return flowId.length <= 20 ? flowId : `${flowId.slice(0, 10)}…${flowId.slice(-6)}`;
 }
@@ -504,12 +481,19 @@ function FlowItem({ badge, busy, flow, href, onSelect, store }) {
 								"aria-hidden": "true",
 								className: cn("status-dot", publicationTone)
 							}),
-							t(publicationStatus),
-							flow.live != null && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
-								"aria-hidden": "true",
-								className: "resource-status-separator",
-								children: "·"
-							}), /* @__PURE__ */ jsx("span", { children: t(flow.live.enabled ? "resource.enabled" : "resource.disabled") })] })
+							/* @__PURE__ */ jsx("span", { children: t(publicationStatus) }),
+							flow.live != null && /* @__PURE__ */ jsxs("span", {
+								className: "resource-enabled-status",
+								"aria-busy": pending == "enabled",
+								children: [/* @__PURE__ */ jsx("span", { children: t(flow.live.enabled ? "resource.enabled" : "resource.disabled") }), /* @__PURE__ */ jsx(Switch, {
+									"aria-label": t("resource.enableFlow", { name: flow.name }),
+									checked: flow.live.enabled,
+									disabled: flow.status != "active" || busy != null || pending != null,
+									onCheckedChange: (enabled) => void update(enabled),
+									size: "sm",
+									title: t("resource.enabledHint")
+								})]
+							})
 						]
 					})
 				]
@@ -519,14 +503,6 @@ function FlowItem({ badge, busy, flow, href, onSelect, store }) {
 				"aria-busy": pending != null,
 				onClick: openFromRow,
 				children: [
-					flow.live != null && /* @__PURE__ */ jsx(Switch, {
-						"aria-label": t("resource.enableFlow", { name: flow.name }),
-						checked: flow.live.enabled,
-						disabled: flow.status != "active" || busy != null || pending != null,
-						onCheckedChange: (enabled) => void update(enabled),
-						size: "sm",
-						title: t("resource.enabledHint")
-					}),
 					flow.status == "active" && /* @__PURE__ */ jsx(Button, {
 						onClick: () => onSelect(flow),
 						size: "sm",
@@ -619,7 +595,7 @@ function FlowSkeleton() {
 		})]
 	});
 }
-function FlowBrowser({ catalogWidth, createFlowDisabled, createFlowField, flowBadges, hrefForFlow, language, onCreateFlow, onLanguageChange, onSelectFlow, store }) {
+function FlowBrowser({ catalogWidth, createFlowDisabled, createFlowField, flowBadges, hrefForFlow, onCreateFlow, onSelectFlow, store }) {
 	const t = useTranslate();
 	const busy = useVal(store.workspace.$.busy);
 	const loadFailed = useVal(store.workspace.$.flowLoadFailed);
@@ -666,107 +642,105 @@ function FlowBrowser({ catalogWidth, createFlowDisabled, createFlowField, flowBa
 								}), !loading && /* @__PURE__ */ jsx("span", { children: t("resource.flowCount", { count: total ?? flows.length }) })]
 							}), /* @__PURE__ */ jsxs("div", {
 								className: "resource-list-actions",
-								children: [
-									/* @__PURE__ */ jsx(LanguageSelect, {
-										language,
-										onLanguageChange
-									}),
-									/* @__PURE__ */ jsxs(InputGroup, {
-										className: "w-full sm:w-56",
-										children: [/* @__PURE__ */ jsx(InputGroupAddon, { children: /* @__PURE__ */ jsx(Icon, {
-											name: "search",
-											size: 17
-										}) }), /* @__PURE__ */ jsx(InputGroupInput, {
-											autoComplete: "off",
-											"aria-label": t("resource.searchByName"),
-											name: "flow-search",
-											onChange: (event) => setFilter(event.target.value),
-											placeholder: t("resource.searchByName"),
-											value: filter
-										})]
-									}),
-									/* @__PURE__ */ jsxs(Button, {
-										className: "pr-3",
-										disabled: busy != null,
-										onClick: () => setCreating(true),
-										children: [/* @__PURE__ */ jsx(Icon, {
-											"data-icon": "inline-start",
-											name: "plus"
-										}), t("resource.newFlow")]
-									})
-								]
-							})]
-						}),
-						/* @__PURE__ */ jsxs("div", {
-							"aria-hidden": "true",
-							className: "resource-list-columns-shell",
-							children: [/* @__PURE__ */ jsxs("div", {
-								className: "resource-list-columns flow-columns",
-								children: [
-									/* @__PURE__ */ jsx("span", { children: t("resource.name") }),
-									/* @__PURE__ */ jsx("span", {
-										className: "resource-flow-id-heading",
-										children: t("resource.flowId")
-									}),
-									/* @__PURE__ */ jsx("span", {
-										className: "resource-updated-heading",
-										children: t("resource.updated")
-									}),
-									/* @__PURE__ */ jsx("span", { children: t("resource.status") })
-								]
-							}), /* @__PURE__ */ jsx("span", {
-								className: "resource-actions-heading",
-								children: t("resource.actions")
-							})]
-						}),
-						/* @__PURE__ */ jsx("div", {
-							className: "resource-list",
-							children: loading ? Array.from({ length: 5 }, (_, index) => /* @__PURE__ */ jsx(FlowSkeleton, {}, index)) : loadFailed ? /* @__PURE__ */ jsxs(Empty, {
-								className: "min-h-64",
-								role: "alert",
-								children: [/* @__PURE__ */ jsxs(EmptyHeader, { children: [
-									/* @__PURE__ */ jsx(EmptyMedia, {
-										variant: "icon",
-										children: /* @__PURE__ */ jsx(Icon, {
-											name: "alert",
-											size: 20
-										})
-									}),
-									/* @__PURE__ */ jsx(EmptyTitle, { children: t("resource.flowsLoadFailed") }),
-									/* @__PURE__ */ jsx(EmptyDescription, { children: t("resource.flowsLoadFailedDescription") })
-								] }), /* @__PURE__ */ jsx(EmptyContent, { children: /* @__PURE__ */ jsx(Button, {
-									onClick: () => void store.retryFlows(),
-									variant: "outline",
-									children: t("empty.retry")
-								}) })]
-							}) : visible.length == 0 ? /* @__PURE__ */ jsxs(Empty, {
-								className: "min-h-64",
-								children: [/* @__PURE__ */ jsxs(EmptyHeader, { children: [
-									/* @__PURE__ */ jsx(EmptyMedia, {
-										variant: "icon",
-										children: /* @__PURE__ */ jsx(Icon, {
-											name: "flow",
-											size: 20
-										})
-									}),
-									/* @__PURE__ */ jsx(EmptyTitle, { children: t(normalized.length == 0 ? "resource.noFlows" : "resource.noMatchingFlows") }),
-									/* @__PURE__ */ jsx(EmptyDescription, { children: t(normalized.length == 0 ? "resource.noFlowsDescription" : "resource.noMatchingDescription") })
-								] }), normalized.length == 0 && /* @__PURE__ */ jsx(EmptyContent, { children: /* @__PURE__ */ jsxs(Button, {
+								children: [/* @__PURE__ */ jsxs(InputGroup, {
+									className: "w-full sm:w-56",
+									children: [/* @__PURE__ */ jsx(InputGroupAddon, { children: /* @__PURE__ */ jsx(Icon, {
+										name: "search",
+										size: 17
+									}) }), /* @__PURE__ */ jsx(InputGroupInput, {
+										autoComplete: "off",
+										"aria-label": t("resource.searchByName"),
+										name: "flow-search",
+										onChange: (event) => setFilter(event.target.value),
+										placeholder: t("resource.searchByName"),
+										value: filter
+									})]
+								}), /* @__PURE__ */ jsxs(Button, {
+									className: "pr-3",
+									disabled: busy != null,
 									onClick: () => setCreating(true),
-									variant: "outline",
 									children: [/* @__PURE__ */ jsx(Icon, {
 										"data-icon": "inline-start",
 										name: "plus"
 									}), t("resource.newFlow")]
-								}) })]
-							}) : visible.map((flow) => /* @__PURE__ */ jsx(FlowItem, {
-								badge: flowBadges?.[flow.flowId],
-								busy,
-								flow,
-								href: hrefForFlow(flow),
-								onSelect: onSelectFlow,
-								store
-							}, flow.flowId))
+								})]
+							})]
+						}),
+						/* @__PURE__ */ jsx("div", {
+							className: "resource-table-scroll",
+							children: /* @__PURE__ */ jsxs("div", {
+								className: "resource-table",
+								children: [/* @__PURE__ */ jsxs("div", {
+									"aria-hidden": "true",
+									className: "resource-list-columns-shell",
+									children: [/* @__PURE__ */ jsxs("div", {
+										className: "resource-list-columns flow-columns",
+										children: [
+											/* @__PURE__ */ jsx("span", { children: t("resource.name") }),
+											/* @__PURE__ */ jsx("span", {
+												className: "resource-flow-id-heading",
+												children: t("resource.flowId")
+											}),
+											/* @__PURE__ */ jsx("span", {
+												className: "resource-updated-heading",
+												children: t("resource.updated")
+											}),
+											/* @__PURE__ */ jsx("span", { children: t("resource.status") })
+										]
+									}), /* @__PURE__ */ jsx("span", {
+										className: "resource-actions-heading",
+										children: t("resource.actions")
+									})]
+								}), /* @__PURE__ */ jsx("div", {
+									className: "resource-list",
+									children: loading ? Array.from({ length: 5 }, (_, index) => /* @__PURE__ */ jsx(FlowSkeleton, {}, index)) : loadFailed ? /* @__PURE__ */ jsxs(Empty, {
+										className: "min-h-64",
+										role: "alert",
+										children: [/* @__PURE__ */ jsxs(EmptyHeader, { children: [
+											/* @__PURE__ */ jsx(EmptyMedia, {
+												variant: "icon",
+												children: /* @__PURE__ */ jsx(Icon, {
+													name: "alert",
+													size: 20
+												})
+											}),
+											/* @__PURE__ */ jsx(EmptyTitle, { children: t("resource.flowsLoadFailed") }),
+											/* @__PURE__ */ jsx(EmptyDescription, { children: t("resource.flowsLoadFailedDescription") })
+										] }), /* @__PURE__ */ jsx(EmptyContent, { children: /* @__PURE__ */ jsx(Button, {
+											onClick: () => void store.retryFlows(),
+											variant: "outline",
+											children: t("empty.retry")
+										}) })]
+									}) : visible.length == 0 ? /* @__PURE__ */ jsxs(Empty, {
+										className: "min-h-64",
+										children: [/* @__PURE__ */ jsxs(EmptyHeader, { children: [
+											/* @__PURE__ */ jsx(EmptyMedia, {
+												variant: "icon",
+												children: /* @__PURE__ */ jsx(Icon, {
+													name: "flow",
+													size: 20
+												})
+											}),
+											/* @__PURE__ */ jsx(EmptyTitle, { children: t(normalized.length == 0 ? "resource.noFlows" : "resource.noMatchingFlows") }),
+											/* @__PURE__ */ jsx(EmptyDescription, { children: t(normalized.length == 0 ? "resource.noFlowsDescription" : "resource.noMatchingDescription") })
+										] }), normalized.length == 0 && /* @__PURE__ */ jsx(EmptyContent, { children: /* @__PURE__ */ jsxs(Button, {
+											onClick: () => setCreating(true),
+											variant: "outline",
+											children: [/* @__PURE__ */ jsx(Icon, {
+												"data-icon": "inline-start",
+												name: "plus"
+											}), t("resource.newFlow")]
+										}) })]
+									}) : visible.map((flow) => /* @__PURE__ */ jsx(FlowItem, {
+										badge: flowBadges?.[flow.flowId],
+										busy,
+										flow,
+										href: hrefForFlow(flow),
+										onSelect: onSelectFlow,
+										store
+									}, flow.flowId))
+								})]
+							})
 						}),
 						nextCursor != null && /* @__PURE__ */ jsx("div", {
 							className: "resource-list-footer",
@@ -1506,93 +1480,35 @@ var PublicationStore = class {
 //#endregion
 //#region src/workbench/browser/runtime/runs/runRequestStore.ts
 var initialState$5 = { starting: false };
-function inputPorts$1(node) {
-	switch (node.kind) {
-		case "condition": return {};
-		case "subflow": return portsByHandle(node.definition?.inputs ?? []);
-		case "task": return portsByHandle(node.definition?.inputs ?? []);
-		case "value": return {};
-		case "approval":
-		case "wait": return portsByHandle(node.node.inputDefinitions);
-	}
-}
-function nodeTitle(node) {
-	if (node.node.name != null) return node.node.name;
-	if (node.kind == "task" || node.kind == "subflow") return node.definition?.name ?? node.id;
-	return node.id;
-}
-function inputSpecs(draft, triggerId) {
-	const revision = revisionView(draft);
-	const graph = revision.graph({ kind: "flow" });
-	if (graph == null) return [];
-	const reachable = /* @__PURE__ */ new Set([triggerId]);
-	const pending = [triggerId];
-	while (pending.length > 0) {
-		const source = pending.pop();
-		for (const edge of graph.edges) {
-			if (edge.source != source || reachable.has(edge.target)) continue;
-			reachable.add(edge.target);
-			pending.push(edge.target);
-		}
-	}
-	return Object.entries(graph.nodes).filter(([id]) => reachable.has(id)).toSorted(([left], [right]) => left.localeCompare(right)).flatMap(([nodeId, node]) => {
-		const resolved = revision.resolveNode(nodeId, node);
-		if (resolved.kind == "trigger") {
-			if (resolved.trigger.kind == "manual" || resolved.trigger.kind == "cron") return [];
-			return [{
-				definitions: triggerOutputDefinitions(resolved.trigger),
-				samples: resolved.trigger.kind == "error" ? sampleErrorOutputs : void 0,
-				nodeId,
-				title: resolved.trigger.name
-			}];
-		}
-		const definitions = Object.entries(inputPorts$1(resolved)).filter(([handle, port]) => resolved.node.inputs[handle] == null && !Object.hasOwn(port, "value")).toSorted(([left], [right]) => left.localeCompare(right)).map(([handle, port]) => Object.assign({
-			handle,
-			jsonSchema: port.jsonSchema,
-			nullable: port.nullable
-		}, port.description == null ? {} : { description: port.description }));
-		return definitions.length == 0 ? [] : [{
-			definitions,
-			samples: void 0,
-			nodeId,
-			title: nodeTitle(resolved)
-		}];
-	});
+function inputSpec(draft, triggerId) {
+	const trigger = revisionView(draft).graph({ kind: "flow" })?.nodes[triggerId];
+	if (trigger == null || "inputs" in trigger || trigger.kind == "manual" || trigger.kind == "cron") return void 0;
+	const definitions = triggerOutputDefinitions(trigger);
+	return definitions.length === 0 ? void 0 : {
+		definitions,
+		samples: trigger.kind == "error" ? sampleErrorOutputs : void 0
+	};
 }
-function inputSignature(specs) {
-	return JSON.stringify(specs.map((group) => [group.nodeId, group.definitions.map((definition) => [
+function inputSignature(spec) {
+	return JSON.stringify(spec?.definitions.map((definition) => [
 		definition.handle,
 		definition.jsonSchema,
 		definition.nullable
-	])]));
+	]) ?? []);
 }
-async function inputGroups(specs, language, values) {
+async function inputEditor(spec, language, values) {
+	if (spec == null) return void 0;
 	const { FlowRunInputEditorStore } = await import("./flowRunInputEditorStore-Dsxyfwae.js").then((n) => n.t);
-	return specs.map((group) => {
-		const editor = new FlowRunInputEditorStore(group.definitions, language);
-		const initial = values?.[group.nodeId] ?? group.samples;
-		if (initial != null) editor.replaceValues(initial);
-		return {
-			editor,
-			nodeId: group.nodeId,
-			title: group.title
-		};
-	});
-}
-function groupValues(groups) {
-	return Object.fromEntries(groups.map((group) => [group.nodeId, group.editor.values()]));
+	const editor = new FlowRunInputEditorStore(spec.definitions, language);
+	const initial = values ?? spec.samples;
+	if (initial != null) editor.replaceValues(initial);
+	return editor;
 }
 function testOutputs(revision, triggerId) {
 	const node = revisionView(revision).graph({ kind: "flow" })?.nodes[triggerId];
 	if (node?.kind == "error") return sampleErrorOutputs;
 	return node?.kind === "cron" ? { scheduledAt: (/* @__PURE__ */ new Date()).toISOString() } : {};
 }
-function runValues(groups, triggerId, revision) {
-	return {
-		inputs: Object.fromEntries(groups.filter((group) => group.nodeId != triggerId).map((group) => [group.nodeId, group.editor.values()])),
-		outputs: groups.find((group) => group.nodeId == triggerId)?.editor.values() ?? testOutputs(revision, triggerId)
-	};
-}
 var RunRequestStore = class {
 	#prepareDraft;
 	#client;
@@ -1657,10 +1573,10 @@ var RunRequestStore = class {
 		}
 	}
 	inputStatus(flowId, draft, triggerId) {
-		const specs = inputSpecs(draft, triggerId);
-		if (specs.length == 0) return "none";
+		const spec = inputSpec(draft, triggerId);
+		if (spec == null) return "none";
 		const saved = this.#savedInputs.get(this.#inputKey(flowId, triggerId));
-		return saved?.valid == true && saved.signature == inputSignature(specs) ? "ready" : "missing";
+		return saved?.valid == true && saved.signature == inputSignature(spec) ? "ready" : "missing";
 	}
 	async requestLive(flow) {
 		const current = this.#requests.begin();
@@ -1695,11 +1611,11 @@ var RunRequestStore = class {
 			return false;
 		}
 		this.#rememberInputs(request);
-		const { inputs, outputs } = runValues(request.groups, request.triggerId, request.revision);
+		const outputs = request.editor?.values() ?? testOutputs(request.revision, request.triggerId);
 		const started = await this.#start(request.source, request.flow, request.revisionId, {
 			nodeId: request.triggerId,
 			outputs
-		}, inputs, request.publicationId);
+		}, request.publicationId);
 		if (started && this.#state.value.inputRequest === request) this.dismissInputs();
 		return started;
 	}
@@ -1710,18 +1626,18 @@ var RunRequestStore = class {
 		this.#rememberInputs(request);
 		this.#set({ starting: true });
 		try {
-			const specs = inputSpecs(request.revision, triggerId);
+			const spec = inputSpec(request.revision, triggerId);
 			const saved = this.#savedInputs.get(this.#inputKey(request.flow.flowId, triggerId));
-			const groups = await inputGroups(specs, this.#i18n.lang$, saved?.values);
+			const editor = await inputEditor(spec, this.#i18n.lang$, saved?.values);
 			if (!current() || this.#state.value.inputRequest !== request) {
-				for (const group of groups) group.editor.dispose();
+				editor?.dispose();
 				return;
 			}
-			const valid = compute((get) => groups.every((group) => get(group.editor.valid$)));
+			const valid = compute((get) => editor == null || get(editor.valid$));
 			this.#set({ inputRequest: {
 				...request,
 				attempted: false,
-				groups,
+				editor,
 				triggerId,
 				valid
 			} });
@@ -1763,32 +1679,32 @@ var RunRequestStore = class {
 			});
 			return "unavailable";
 		}
-		const specs = only == null ? [] : inputSpecs(revision, only.nodeId);
-		const signature = inputSignature(specs);
+		const spec = only == null ? void 0 : inputSpec(revision, only.nodeId);
+		const signature = inputSignature(spec);
 		const saved = only == null ? void 0 : this.#savedInputs.get(this.#inputKey(flow.flowId, only.nodeId));
-		const groups = only == null ? [] : await inputGroups(specs, this.#i18n.lang$, saved?.values);
+		const editor = await inputEditor(spec, this.#i18n.lang$, saved?.values);
 		if (!current()) {
-			for (const group of groups) group.editor.dispose();
+			editor?.dispose();
 			return "unavailable";
 		}
-		if (!edit && only != null && groups.length == 0) return await this.#start(source, flow, revisionId, {
+		if (!edit && only != null && editor == null) return await this.#start(source, flow, revisionId, {
 			nodeId: only.nodeId,
 			outputs: testOutputs(revision, only.nodeId)
-		}, {}, publicationId) ? "started" : "unavailable";
-		if (!edit && only != null && saved?.valid == true && saved.signature == signature && groups.every((group) => group.editor.valid$.value)) {
-			const values = runValues(groups, only.nodeId, revision);
-			for (const group of groups) group.editor.dispose();
+		}, publicationId) ? "started" : "unavailable";
+		if (!edit && only != null && saved?.valid == true && saved.signature == signature && editor != null && editor.valid$.value) {
+			const outputs = editor.values();
+			editor?.dispose();
 			return await this.#start(source, flow, revisionId, {
 				nodeId: only.nodeId,
-				outputs: values.outputs
-			}, values.inputs, publicationId) ? "started" : "unavailable";
+				outputs
+			}, publicationId) ? "started" : "unavailable";
 		}
-		const valid = compute((get) => only != null && groups.every((group) => get(group.editor.valid$)));
+		const valid = compute((get) => only != null && (editor == null || get(editor.valid$)));
 		this.#set({
 			inputRequest: {
 				attempted: false,
 				flow,
-				groups,
+				editor,
 				revision,
 				triggers,
 				triggerId: only?.nodeId,
@@ -1802,7 +1718,7 @@ var RunRequestStore = class {
 		});
 		return "input";
 	}
-	async #start(source, flow, revisionId, trigger, inputs = {}, publicationId) {
+	async #start(source, flow, revisionId, trigger, publicationId) {
 		if (source == "live" && publicationId == null) return false;
 		const alive = this.#lifetime.capture();
 		const current = this.#runs.prepareStart();
@@ -1821,7 +1737,6 @@ var RunRequestStore = class {
 				revisionId
 			} : { publicationId };
 			const signature = JSON.stringify({
-				inputs,
 				trigger,
 				source,
 				...target
@@ -1833,11 +1748,11 @@ var RunRequestStore = class {
 			this.#attempt = attempt;
 			const run = source == "draft" ? await this.#client.createDraftRun(flow.flowId, revisionId, {
 				idempotencyKey: attempt.key,
-				inputs,
+				inputs: {},
 				trigger
 			}) : await this.#client.createLiveRun(publicationId, {
 				idempotencyKey: attempt.key,
-				inputs,
+				inputs: {},
 				trigger
 			});
 			if (!alive() || !current()) return false;
@@ -1856,17 +1771,17 @@ var RunRequestStore = class {
 	#disposeInputRequest(request = this.#state.value.inputRequest) {
 		if (request == null) return;
 		request.valid.dispose();
-		for (const group of request.groups) group.editor.dispose();
+		request.editor?.dispose();
 	}
 	#inputKey(flowId, triggerId) {
 		return `${flowId}\u0000${triggerId}`;
 	}
 	#rememberInputs(request) {
-		if (request?.triggerId == null || request.groups.length == 0) return;
+		if (request?.triggerId == null || request.editor == null) return;
 		this.#savedInputs.set(this.#inputKey(request.flow.flowId, request.triggerId), {
-			signature: inputSignature(inputSpecs(request.revision, request.triggerId)),
+			signature: inputSignature(inputSpec(request.revision, request.triggerId)),
 			valid: request.valid.value,
-			values: groupValues(request.groups)
+			values: request.editor.values()
 		});
 	}
 	#set(patch) {
@@ -1961,48 +1876,591 @@ function createStore(dbName, storeName) {
 	};
 	return (txMode, callback) => getDB().then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
 }
-var defaultGetStoreFunc;
-function defaultGetStore() {
-	if (!defaultGetStoreFunc) defaultGetStoreFunc = createStore("keyval-store", "keyval");
-	return defaultGetStoreFunc;
-}
-/**
-* Get a value by its key.
-*
-* @param key
-* @param customStore Method to get a custom store. Use with caution (see the docs).
-*/
-function get(key, customStore = defaultGetStore()) {
-	return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+//#endregion
+//#region ../../node_modules/.bun/@oomol-lab+resource-cache@0.1.4/node_modules/@oomol-lab/resource-cache/dist/src-bwD0r9NQ.mjs
+function abortError() {
+	return new DOMException("Cache operation aborted", "AbortError");
 }
-/**
-* Set a value with a key.
-*
-* @param key
-* @param value
-* @param customStore Method to get a custom store. Use with caution (see the docs).
-*/
-function set(key, value, customStore = defaultGetStore()) {
-	return customStore("readwrite", (store) => {
-		store.put(value, key);
-		return promisifyRequest(store.transaction);
+function wait(promise, lifetime, caller) {
+	const signals = caller ? [lifetime, caller] : [lifetime];
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			for (const signal of signals) signal.removeEventListener("abort", abort);
+		};
+		const abort = () => {
+			cleanup();
+			reject(abortError());
+		};
+		for (const signal of signals) signal.addEventListener("abort", abort, { once: true });
+		promise.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
 	});
 }
+/** @internal */
+function validateOptions(options) {
+	if (typeof options.namespace !== "string" || !options.namespace.trim()) throw new TypeError("namespace must be nonempty");
+	if (!Number.isSafeInteger(options.schemaVersion) || options.schemaVersion <= 0) throw new TypeError("schemaVersion must be a positive safe integer");
+	if (!Number.isFinite(options.maxAge) || options.maxAge < 0) throw new TypeError("maxAge must be finite and nonnegative");
+	for (const name of [
+		"key",
+		"decode",
+		"load"
+	]) if (typeof options[name] !== "function") throw new TypeError(`${name} must be a function`);
+}
+/** @internal */
+function createCache(options, backend, session) {
+	const states = /* @__PURE__ */ new Map();
+	let disposed = false;
+	let scopeBlocked = false;
+	let disposal;
+	let io = Promise.resolve();
+	function storage(action) {
+		const result = io.then(action);
+		io = result.catch(() => {});
+		return result;
+	}
+	function checkOpen() {
+		if (disposed) throw new Error("Cache is disposed");
+	}
+	function identity(query) {
+		checkOpen();
+		const key = options.key(query);
+		if (typeof key !== "string") throw new TypeError("key must return a string");
+		return key;
+	}
+	function stateFor(key) {
+		let state = states.get(key);
+		if (!state) {
+			state = {
+				controller: new AbortController(),
+				blocked: scopeBlocked
+			};
+			states.set(key, state);
+		}
+		return state;
+	}
+	function checkState(state) {
+		if (state.controller.signal.aborted) throw abortError();
+	}
+	function fresh(entry) {
+		const now = Date.now();
+		return !entry.invalidated && entry.validatedAt <= now && now - entry.validatedAt < options.maxAge;
+	}
+	function restore(value, previous) {
+		return {
+			...value.meta,
+			data: value.body ? options.decode(value.body.data) : previous.data
+		};
+	}
+	async function read(key, state) {
+		if (state.entry && fresh(state.entry)) return state.entry;
+		const entry = await storage(async () => {
+			checkState(state);
+			if (state.blocked) return state.entry;
+			try {
+				const value = await backend.read(key, state.entry?.version);
+				return value ? restore(value, state.entry) : state.entry;
+			} catch {
+				return state.entry;
+			}
+		});
+		checkState(state);
+		state.entry = entry;
+		return entry;
+	}
+	function schedule(key, query, state, force) {
+		const job = {
+			started: false,
+			force
+		};
+		job.promise = (async () => {
+			const previous = await read(key, state);
+			checkState(state);
+			if (!job.force && previous && fresh(previous)) return previous.data;
+			job.started = true;
+			const result = await options.load(query, {
+				etag: previous?.etag ?? null,
+				signal: state.controller.signal
+			});
+			checkState(state);
+			let entry;
+			if (result.modified) entry = {
+				data: result.data,
+				etag: result.etag,
+				version: crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4)).join("-"),
+				validatedAt: Date.now(),
+				invalidated: false
+			};
+			else {
+				if (!previous) throw new Error("Load protocol error: unmodified response without cached data");
+				entry = {
+					...previous,
+					etag: result.etag === void 0 ? previous.etag : result.etag,
+					validatedAt: Date.now(),
+					invalidated: false
+				};
+			}
+			await storage(async () => {
+				checkState(state);
+				try {
+					if (await backend.write(key, entry, result.modified)) state.blocked = false;
+				} catch {
+					state.blocked = true;
+				}
+				checkState(state);
+				state.entry = entry;
+			});
+			checkState(state);
+			return entry.data;
+		})();
+		state.job = job;
+		const release = () => {
+			state.job = void 0;
+		};
+		job.promise.then(release, release);
+		return job;
+	}
+	function refresh(key, query, state, force) {
+		const active = state.job;
+		if (!active) return schedule(key, query, state, force).promise;
+		if (!force) return active.promise;
+		if (!active.started) {
+			active.force = true;
+			return active.promise;
+		}
+		if (!state.queued) {
+			const start = () => {
+				checkState(state);
+				state.queued = void 0;
+				return schedule(key, query, state, true).promise;
+			};
+			state.queued = active.promise.then(start, start);
+		}
+		return state.queued;
+	}
+	function reset(key, keep) {
+		const old = states.get(key);
+		const state = {
+			controller: new AbortController(),
+			blocked: true
+		};
+		if (keep && old?.entry) state.entry = {
+			...old.entry,
+			invalidated: true
+		};
+		states.set(key, state);
+		return {
+			state,
+			cancel: () => old?.controller.abort()
+		};
+	}
+	function resetAll() {
+		const old = [...states.values()];
+		states.clear();
+		const barrier = {};
+		scopeBlocked = barrier;
+		return {
+			barrier,
+			cancel() {
+				for (const state of old) state.controller.abort();
+			}
+		};
+	}
+	return {
+		async get(query, getOptions = {}) {
+			const key = identity(query);
+			if (getOptions.signal?.aborted) throw abortError();
+			const state = stateFor(key);
+			if (!getOptions.revalidate && state.entry && fresh(state.entry)) return state.entry.data;
+			return wait(refresh(key, query, state, getOptions.revalidate === true), state.controller.signal, getOptions.signal);
+		},
+		async peek(query) {
+			const key = identity(query);
+			const state = stateFor(key);
+			const entry = await wait(read(key, state), state.controller.signal);
+			return entry ? {
+				data: entry.data,
+				etag: entry.etag,
+				validatedAt: entry.validatedAt,
+				fresh: fresh(entry)
+			} : void 0;
+		},
+		async invalidate(query) {
+			const key = identity(query);
+			const canRestore = !(states.get(key)?.blocked ?? scopeBlocked);
+			const { state, cancel } = reset(key, true);
+			const cleanup = storage(async () => {
+				const value = await backend.invalidate(key);
+				if (canRestore) state.blocked = false;
+				if (canRestore && !state.controller.signal.aborted && !state.entry && value) try {
+					state.entry = restore(value);
+				} catch {}
+			});
+			cancel();
+			await cleanup;
+		},
+		async remove(query) {
+			const key = identity(query);
+			const { state, cancel } = reset(key, false);
+			const cleanup = storage(async () => {
+				await backend.remove(key);
+				state.blocked = false;
+			});
+			cancel();
+			await cleanup;
+		},
+		async clear() {
+			checkOpen();
+			const { barrier, cancel } = resetAll();
+			const cleanup = storage(async () => {
+				await backend.clear(false);
+				if (scopeBlocked === barrier) scopeBlocked = false;
+				for (const state of states.values()) if (state.blocked === barrier) state.blocked = false;
+			});
+			cancel();
+			await cleanup;
+		},
+		dispose() {
+			if (!disposal) {
+				disposed = true;
+				const { cancel } = resetAll();
+				disposal = storage(async () => {
+					if (session) await backend.clear(true);
+				});
+				disposal = disposal.catch((error) => {
+					disposal = void 0;
+					throw error;
+				});
+				cancel();
+			}
+			return disposal;
+		}
+	};
+}
+function object(value) {
+	return typeof value === "object" && value !== null;
+}
+function metadata(value) {
+	if (!object(value) || typeof value.version !== "string" || !value.version || !(value.etag === null || typeof value.etag === "string") || typeof value.invalidated !== "boolean") return void 0;
+	const validTime = typeof value.validatedAt === "number" && Number.isFinite(value.validatedAt) && value.validatedAt >= 0;
+	return {
+		version: value.version,
+		etag: value.etag,
+		validatedAt: validTime ? value.validatedAt : 0,
+		invalidated: !validTime || value.invalidated === true
+	};
+}
+function stored(meta, body) {
+	if (!object(body) || body.version !== meta.version || !Object.hasOwn(body, "data")) return void 0;
+	return {
+		meta,
+		body: { data: body.data }
+	};
+}
+var storagePrefix = "@oomol-lab/resource-cache:";
+/** Delimit identity fields without ambiguous string concatenation. @internal */
+function scope(namespace) {
+	return storagePrefix + JSON.stringify(namespace);
+}
+/** @internal */
+function sessionScope(namespace, sessionId) {
+	return storagePrefix + JSON.stringify([namespace, sessionId]);
+}
+/** @internal */
+function persistentStorage(namespace, schemaVersion) {
+	const useStore = createStore("@oomol-lab/resource-cache", "records");
+	const prefix = `${scope(namespace)}:${schemaVersion}:`;
+	const identity = (key, part) => prefix + JSON.stringify([key, part]);
+	function transaction(mode, work) {
+		return useStore(mode, (store) => new Promise((resolve, reject) => {
+			const tx = store.transaction;
+			let value;
+			let failure;
+			tx.oncomplete = () => resolve(value);
+			tx.onabort = () => reject(failure ?? tx.error);
+			const guard = (fn) => {
+				try {
+					fn();
+				} catch (error) {
+					failure = error;
+					tx.abort();
+				}
+			};
+			const read = (request, fn) => {
+				request.onsuccess = () => guard(() => fn(request.result));
+			};
+			guard(() => work(store, read, (result) => {
+				value = result;
+			}));
+		}));
+	}
+	return {
+		read(key, version) {
+			return transaction("readonly", (store, read, result) => {
+				read(store.get(identity(key, "meta")), (raw) => {
+					const meta = metadata(raw);
+					if (!meta) return;
+					if (meta.version === version) {
+						result({ meta });
+						return;
+					}
+					read(store.get(identity(key, "body")), (body) => result(stored(meta, body)));
+				});
+			});
+		},
+		write(key, entry, modified) {
+			return transaction("readwrite", (store, read, result) => {
+				const { data, ...meta } = entry;
+				if (modified) {
+					store.put(meta, identity(key, "meta"));
+					store.put({
+						version: meta.version,
+						data
+					}, identity(key, "body"));
+					result(true);
+				} else read(store.get(identity(key, "meta")), (raw) => {
+					const matches = metadata(raw)?.version === meta.version;
+					if (matches) store.put(meta, identity(key, "meta"));
+					result(matches);
+				});
+			});
+		},
+		invalidate(key) {
+			return transaction("readwrite", (store, read, result) => {
+				read(store.get(identity(key, "meta")), (raw) => {
+					const meta = metadata(raw);
+					if (!meta) return;
+					meta.invalidated = true;
+					store.put(meta, identity(key, "meta"));
+					read(store.get(identity(key, "body")), (body) => result(stored(meta, body)));
+				});
+			});
+		},
+		remove(key) {
+			return transaction("readwrite", (store) => {
+				store.delete(identity(key, "meta"));
+				store.delete(identity(key, "body"));
+			});
+		},
+		clear() {
+			return transaction("readwrite", (store, read) => {
+				read(store.getAllKeys(), (keys) => {
+					for (const key of keys) if (typeof key === "string" && key.startsWith(prefix)) store.delete(key);
+				});
+			});
+		}
+	};
+}
+/** @internal */
+function sessionStorageBackend(namespace, schemaVersion, sessionId) {
+	const base = `${sessionScope(namespace, sessionId)}:`;
+	const prefix = `${base}${schemaVersion}:`;
+	const identity = (key) => prefix + JSON.stringify(key);
+	const record = (key) => {
+		const text = globalThis.sessionStorage.getItem(identity(key));
+		if (text === null) return void 0;
+		const raw = JSON.parse(text);
+		const meta = metadata(raw);
+		return meta ? stored(meta, raw) : void 0;
+	};
+	return {
+		async read(key, version) {
+			const value = record(key);
+			if (value && value.meta.version === version) return { meta: value.meta };
+			return value;
+		},
+		async write(key, entry, modified) {
+			if (modified) {
+				globalThis.sessionStorage.setItem(identity(key), JSON.stringify(entry));
+				return true;
+			} else {
+				const value = record(key);
+				if (value?.meta.version === entry.version) {
+					const { data: _data, ...meta } = entry;
+					globalThis.sessionStorage.setItem(identity(key), JSON.stringify({
+						...meta,
+						data: value.body.data
+					}));
+					return true;
+				}
+				return false;
+			}
+		},
+		async invalidate(key) {
+			const value = record(key);
+			if (value) {
+				value.meta.invalidated = true;
+				globalThis.sessionStorage.setItem(identity(key), JSON.stringify({
+					...value.meta,
+					...value.body
+				}));
+			}
+			return value;
+		},
+		async remove(key) {
+			globalThis.sessionStorage.removeItem(identity(key));
+		},
+		async clear(allVersions) {
+			const storage = globalThis.sessionStorage;
+			const matches = [];
+			for (let i = 0; i < storage.length; i++) {
+				const key = storage.key(i);
+				if (key.startsWith(allVersions ? base : prefix)) matches.push(key);
+			}
+			for (const key of matches) storage.removeItem(key);
+		}
+	};
+}
+/** Create an IndexedDB cache. Storage failures preserve successful network results. */
+function createPersistentCache(options) {
+	validateOptions(options);
+	return createCache({ ...options }, persistentStorage(options.namespace, options.schemaVersion), false);
+}
+/** Create a login-scoped sessionStorage cache. Data must survive JSON serialization and decoding. */
+function createSessionCache(options) {
+	validateOptions(options);
+	if (typeof options.sessionId !== "string" || !options.sessionId.trim()) throw new TypeError("sessionId must be nonempty");
+	return createCache({ ...options }, sessionStorageBackend(options.namespace, options.schemaVersion, options.sessionId), true);
+}
 //#endregion
-//#region src/workbench/browser/runtime/stores/catalogStorage.ts
-var responses = createStore("open-flow-cache", "responses");
-var indexedStorage = {
-	get: (key) => get(key, responses),
-	set: (key, value) => set(key, value, responses)
+//#region ../../node_modules/.bun/@oomol-lab+resource-cache@0.1.4/node_modules/@oomol-lab/resource-cache/dist/oomol.mjs
+/** Namespaces reserved for the OOMOL response factories. */
+var oomolNamespaces = {
+	providers: "oomol:providers",
+	actions: "oomol:actions",
+	appCatalog: "oomol:app-catalog",
+	connections: "oomol:connections"
 };
-function catalogPersistence(options, kind, query) {
-	if (options == null) return void 0;
-	const storage = options.storage ?? indexedStorage;
+/** Join identity fields without nesting JSON in the storage key. */
+function readableKey(...parts) {
+	return parts.map((part) => encodeURIComponent(String(part)).replaceAll("%3A", ":")).join("/");
+}
+var singletonRegistrySymbol = Symbol.for("oomol-lab.resource-cache.oomol-singletons");
+var singletonCaches = Reflect.get(globalThis, singletonRegistrySymbol) ?? (() => {
+	const registry = /* @__PURE__ */ new Map();
+	Reflect.set(globalThis, singletonRegistrySymbol, registry);
+	return registry;
+})();
+function createOomolCache(resource, options, query) {
+	const environment = validateOomolOptions(options);
+	const { load } = options;
+	const key = readableKey(query.locale);
+	return createPersistentCache({
+		namespace: readableKey(resource, environment),
+		schemaVersion: options.schemaVersion,
+		maxAge: options.maxAge,
+		key: () => key,
+		decode: options.decode,
+		load: (_query, validation) => load({ ...query }, validation)
+	});
+}
+function createConnectionsCacheInternal(options, validated) {
+	const { environment, ownerId } = validated;
+	const { load } = options;
+	const key = readableKey(ownerId);
+	return createSessionCache({
+		namespace: readableKey(oomolNamespaces.connections, environment),
+		schemaVersion: options.schemaVersion,
+		maxAge: options.maxAge,
+		sessionId: options.sessionId,
+		key: () => key,
+		decode: options.decode,
+		load: (_query, validation) => load({ ownerId }, validation)
+	});
+}
+function validateOomolOptions(options) {
+	const environment = normalizeEnvironment(options.environment);
+	if (typeof options.locale !== "string" || !options.locale.trim()) throw new TypeError("locale must be nonempty");
+	if (typeof options.load !== "function") throw new TypeError("load must be a function");
+	return environment;
+}
+function normalizeEnvironment(value) {
+	const environment = value === void 0 ? "production" : value;
+	if (typeof environment !== "string" || !environment.trim()) throw new TypeError("environment must be nonempty");
+	return environment;
+}
+function normalizeOwnerId(value) {
+	if (typeof value !== "string" || !value.trim()) throw new TypeError("ownerId must be nonempty");
+	return value;
+}
+function validateConnectionsOptions(options) {
+	const environment = normalizeEnvironment(options.environment);
+	if (typeof options.sessionId !== "string" || !options.sessionId.trim()) throw new TypeError("sessionId must be nonempty");
+	const ownerId = normalizeOwnerId(options.ownerId);
+	if (typeof options.load !== "function") throw new TypeError("load must be a function");
 	return {
-		key: `${kind}:v1:${query}`,
-		storage
+		environment,
+		ownerId
 	};
 }
+/** Create an IndexedDB cache for the account-independent GET /v1/providers response, keyed by environment and locale. */
+function createProvidersCacheInternal(options) {
+	return createOomolCache(oomolNamespaces.providers, options, { locale: options.locale });
+}
+/** Create an IndexedDB cache for account-independent GET /v1/actions?service=…, keyed by environment, locale and service. */
+function createActionsCacheInternal(options) {
+	const environment = validateOomolOptions(options);
+	const { locale, load } = options;
+	return createPersistentCache({
+		namespace: readableKey(oomolNamespaces.actions, environment),
+		schemaVersion: options.schemaVersion,
+		maxAge: options.maxAge,
+		key: (service) => {
+			if (typeof service !== "string" || !service.trim()) throw new TypeError("service must be nonempty");
+			return readableKey(locale, service);
+		},
+		decode: options.decode,
+		load: (service, validation) => load({
+			locale,
+			service
+		}, validation)
+	});
+}
+function singletonKey(resource, options, query, sessionId) {
+	const environment = normalizeEnvironment(options.environment);
+	return sessionId === void 0 ? readableKey(resource, environment, options.schemaVersion, ...query) : readableKey(resource, environment, options.schemaVersion, sessionId, ...query);
+}
+function getSingleton(key, create) {
+	const existing = singletonCaches.get(key);
+	if (existing) return existing;
+	const cache = create();
+	let disposal;
+	const singleton = {
+		...cache,
+		dispose() {
+			if (!disposal) disposal = cache.dispose().then(() => {
+				singletonCaches.delete(key);
+			}, (error) => {
+				disposal = void 0;
+				throw error;
+			});
+			return disposal;
+		}
+	};
+	singletonCaches.set(key, singleton);
+	return singleton;
+}
+/** Return the shared Providers cache for one environment, locale and schema version. */
+function getProvidersCache(options) {
+	const query = { locale: options.locale };
+	return getSingleton(singletonKey(oomolNamespaces.providers, options, [query.locale]), () => createProvidersCacheInternal(options));
+}
+/** Return the shared Actions cache for one environment, locale and schema version. */
+function getActionsCache(options) {
+	const query = { locale: options.locale };
+	return getSingleton(singletonKey(oomolNamespaces.actions, options, [query.locale]), () => createActionsCacheInternal(options));
+}
+/** Return the shared sessionStorage cache for one login session and owner scope. */
+function getConnectionsCache(options) {
+	const validated = validateConnectionsOptions(options);
+	const query = { ownerId: validated.ownerId };
+	return getSingleton(singletonKey(oomolNamespaces.connections, options, [query.ownerId], options.sessionId), () => createConnectionsCacheInternal(options, validated));
+}
 //#endregion
 //#region src/connector/common/actionSchema.ts
 function connectorActionPorts(inputSchema, outputSchema) {
@@ -2176,46 +2634,178 @@ function action(source, providers) {
 }
 //#endregion
 //#region src/workbench/browser/runtime/stores/catalogStores.ts
-function actionsResponse(value) {
+var catalogMaxAge = {
+	providers: 3e5,
+	actions: 3e4,
+	connections: 3e4
+};
+var identity = (...parts) => JSON.stringify(parts);
+function proxyCatalogPath(kind, flowId, locale, service) {
+	return `/v1/connector/proxy/${kind}?${new URLSearchParams({
+		...flowId == null ? {} : { flowId },
+		...service == null ? {} : { service },
+		locale
+	})}`;
+}
+function mapCache(cache, toValue, toSnapshot, query) {
+	return {
+		get: async (value, options) => toValue(await cache.get(query(value), options)),
+		peek: async (value) => {
+			const snapshot = await cache.peek(query(value));
+			return snapshot == null ? void 0 : {
+				...snapshot,
+				data: toSnapshot(snapshot.data)
+			};
+		},
+		invalidate: (value) => cache.invalidate(query(value)),
+		remove: (value) => cache.remove(query(value)),
+		clear: () => cache.clear(),
+		dispose: () => cache.dispose()
+	};
+}
+function providerCacheValue(value) {
+	return proxyResponse(value);
+}
+function actionCacheValue(value) {
+	return proxyResponse(value);
+}
+function connectionsCacheValue(value) {
 	const source = record(value);
-	if (source.version != 1 || !Array.isArray(source.actions)) return invalidResponse();
-	return source.actions.map(connectorActionMetadata);
+	if (source.success === true && Array.isArray(source.data)) return source;
+	if (source.version == 1 && Array.isArray(source.connections)) return {
+		success: true,
+		message: "",
+		data: source.connections,
+		meta: { summary: {
+			providerCount: 0,
+			connectableProviderCount: 0,
+			connectedProviderCount: 0,
+			activeConnectedProviderCount: 0,
+			connectedAppCount: source.connections.length,
+			activeConnectedAppCount: source.connections.length,
+			filteredAppCount: source.connections.length
+		} }
+	};
+	return invalidResponse();
 }
-var identity = (...parts) => JSON.stringify(parts);
-/** Each entry owns one complete upstream response, never a merged entity catalog. */
+function connectionsAsProxy(value) {
+	return value.data.map(connection);
+}
+/** Shared cache construction for one Workbench session. */
+var CacheFactory = class {
+	#caches = /* @__PURE__ */ new Set();
+	#entries = /* @__PURE__ */ new Map();
+	#disposed = false;
+	constructor(scope) {
+		this.scope = scope;
+	}
+	cache(key, create, owned = true) {
+		let entry = this.#entries.get(key);
+		if (entry == null) {
+			entry = create().then((cache) => {
+				if (owned) {
+					if (this.#disposed) cache.dispose();
+					else this.#caches.add(cache);
+				}
+				return cache;
+			});
+			this.#entries.set(key, entry);
+		}
+		return entry;
+	}
+	async dispose() {
+		this.#disposed = true;
+		await Promise.all([...this.#caches].map((cache) => cache.dispose()));
+		this.#caches.clear();
+		this.#entries.clear();
+	}
+	get environment() {
+		return this.scope.environment ?? "production";
+	}
+	get sessionId() {
+		return this.scope.sessionId;
+	}
+	get connectorOwnerId() {
+		return this.scope.connectorOwnerId;
+	}
+};
+/** Each entry owns one complete upstream response; views are derived below. */
 var ProxyStore = class {
-	constructor(client, kind, options) {
+	#factory;
+	constructor(client, kind, scope) {
 		this.client = client;
 		this.kind = kind;
-		this.options = options;
 		this.entries = /* @__PURE__ */ new Map();
+		this.#factory = new CacheFactory(scope);
 	}
-	get(flowId, locale, service, force = false) {
-		const params = new URLSearchParams({
-			...flowId == null ? {} : { flowId },
-			...service == null ? {} : { service },
-			...locale == null ? {} : { locale }
-		});
-		const path = `/v1/connector/proxy/${this.kind}${params.size ? `?${params}` : ""}`;
+	get(flowId, locale = "en", service, force = false) {
+		const path = proxyCatalogPath(this.kind, flowId, locale, service);
 		let entry = this.entries.get(path);
 		if (entry == null) {
-			const decode = (value) => proxyResponse(value, this.kind == "providers" ? provider : void 0);
-			const cacheParams = new URLSearchParams(params);
-			cacheParams.delete("flowId");
-			const persistence = catalogPersistence(this.options, this.kind, cacheParams.toString());
-			entry = new Resource((etag, signal) => this.client.readProxyCatalog({
-				path,
-				decode
-			}, etag, signal), this.kind == "providers" ? 3e5 : 3e4, persistence == null ? void 0 : {
-				...persistence,
-				decode
-			});
+			entry = new CacheResource(() => this.#cache(flowId, locale, service, path), void 0, false, catalogMaxAge[this.kind]);
 			this.entries.set(path, entry);
 		}
 		return entry.get(force);
 	}
+	async #cache(flowId, locale, service, path) {
+		const ownerId = this.#factory.connectorOwnerId;
+		const key = JSON.stringify([
+			this.kind,
+			flowId ?? null,
+			locale,
+			service ?? null,
+			ownerId ?? null
+		]);
+		return this.#factory.cache(key, async () => {
+			if (ownerId != null) {
+				if (this.kind == "providers") return mapCache(getProvidersCache({
+					environment: this.#factory.environment,
+					locale,
+					schemaVersion: 1,
+					maxAge: catalogMaxAge.providers,
+					decode: providerCacheValue,
+					load: async (_query, validation) => {
+						return await this.client.readProxyCatalog({
+							path,
+							decode: providerCacheValue
+						}, validation.etag, validation.signal);
+					}
+				}), (value) => value, (value) => value, () => void 0);
+				return mapCache(getActionsCache({
+					environment: this.#factory.environment,
+					locale,
+					schemaVersion: 1,
+					maxAge: catalogMaxAge.actions,
+					decode: actionCacheValue,
+					load: async ({ service: requestedService }, validation) => {
+						return await this.client.readProxyCatalog({
+							path: proxyCatalogPath("actions", flowId, locale, requestedService),
+							decode: actionCacheValue
+						}, validation.etag, validation.signal);
+					}
+				}), (value) => value, (value) => value, () => service ?? "");
+			}
+			return createSessionCache({
+				namespace: JSON.stringify([
+					"open-flow:connector-proxy",
+					this.#factory.environment,
+					this.kind,
+					flowId ?? null
+				]),
+				schemaVersion: 1,
+				sessionId: this.#factory.sessionId,
+				maxAge: this.kind == "providers" ? catalogMaxAge.providers : catalogMaxAge.actions,
+				key: () => JSON.stringify([locale, service ?? null]),
+				decode: proxyResponse,
+				load: async (_query, validation) => this.client.readProxyCatalog({
+					path,
+					decode: proxyResponse
+				}, validation.etag, validation.signal)
+			});
+		}, ownerId == null);
+	}
 	retryFailed() {
-		for (const entry of this.entries.values()) if (entry.state.value.error != null) entry.refresh();
+		for (const entry of this.entries.values()) if (entry.state.value.error != null) entry.refresh(true);
 	}
 	refreshFlow(flowId) {
 		for (const [path, entry] of this.entries) if (new URL(path, "https://open-flow.invalid").searchParams.get("flowId") == flowId) entry.refresh(true);
@@ -2223,6 +2813,7 @@ var ProxyStore = class {
 	dispose() {
 		for (const entry of this.entries.values()) entry.dispose();
 		this.entries.clear();
+		this.#factory.dispose();
 	}
 };
 var Views = class {
@@ -2273,8 +2864,8 @@ var Views = class {
 };
 var ProviderStore = class {
 	#views = new Views();
-	constructor(client, options) {
-		this.raw = new ProxyStore(client, "providers", options);
+	constructor(client, scope) {
+		this.raw = new ProxyStore(client, "providers", scope);
 	}
 	get(flowId, locale = "en", force = false) {
 		return this.#views.get(identity(flowId, locale), [this.raw.get(flowId, locale, void 0, force)], (response) => response.data.map((item) => provider(item, response.meta?.iconSprite)));
@@ -2291,33 +2882,17 @@ var ProviderStore = class {
 	}
 };
 var ConnectionStore = class {
-	#storage = {
-		get: async (key) => {
-			const raw = (this.options?.storage ?? window.sessionStorage).getItem(key);
-			return raw == null ? void 0 : JSON.parse(raw);
-		},
-		set: async (key, value) => {
-			(this.options?.storage ?? window.sessionStorage).setItem(key, JSON.stringify(value));
-		}
-	};
 	#entries = /* @__PURE__ */ new Map();
 	#views = /* @__PURE__ */ new Map();
-	constructor(client, options) {
+	#factory;
+	constructor(client, scope) {
 		this.client = client;
-		this.options = options;
+		this.#factory = new CacheFactory(scope);
 	}
 	get(serviceId, flowId, force = false) {
 		let entry = this.#entries.get(flowId);
 		if (entry == null) {
-			const query = allConnectorConnectionsQuery(flowId);
-			entry = new Resource((etag, signal) => this.client.readCatalog(query, etag, signal), 3e4, this.options == null ? void 0 : {
-				key: `open-flow:connections:v1:${query.path}`,
-				storage: this.#storage,
-				decode: (value) => {
-					if (!Array.isArray(value)) return invalidResponse();
-					return value.map(connection);
-				}
-			});
+			entry = new CacheResource(() => this.#cache(flowId), void 0, false, catalogMaxAge.connections);
 			this.#entries.set(flowId, entry);
 		}
 		const source = entry.get(force);
@@ -2333,8 +2908,54 @@ var ConnectionStore = class {
 		}
 		return view;
 	}
+	async #cache(flowId) {
+		const query = allConnectorConnectionsQuery(flowId);
+		const ownerId = this.#factory.connectorOwnerId;
+		const key = JSON.stringify([
+			"connections",
+			flowId ?? null,
+			ownerId ?? null
+		]);
+		return this.#factory.cache(key, async () => {
+			if (ownerId != null) return mapCache(getConnectionsCache({
+				environment: this.#factory.environment,
+				sessionId: this.#factory.sessionId,
+				ownerId,
+				schemaVersion: 1,
+				maxAge: catalogMaxAge.connections,
+				decode: connectionsCacheValue,
+				load: async (_query, validation) => {
+					const result = await this.client.readCatalog(query, validation.etag, validation.signal);
+					return result.modified ? {
+						modified: true,
+						data: connectionsCacheValue({
+							version: 1,
+							connections: result.data
+						}),
+						etag: result.etag
+					} : result;
+				}
+			}), connectionsAsProxy, connectionsAsProxy, () => void 0);
+			return createSessionCache({
+				namespace: JSON.stringify([
+					"open-flow:connections",
+					this.#factory.environment,
+					flowId ?? null
+				]),
+				schemaVersion: 1,
+				sessionId: this.#factory.sessionId,
+				maxAge: catalogMaxAge.connections,
+				key: () => "all",
+				decode: (value) => {
+					if (!Array.isArray(value)) return invalidResponse();
+					return value.map(connection);
+				},
+				load: async (_query, validation) => this.client.readCatalog(query, validation.etag, validation.signal)
+			});
+		}, ownerId == null);
+	}
 	retryFailed() {
-		for (const entry of this.#entries.values()) if (entry.state.value.error != null) entry.refresh();
+		for (const entry of this.#entries.values()) if (entry.state.value.error != null) entry.refresh(true);
 	}
 	refreshFlow(flowId) {
 		this.#entries.get(flowId)?.refresh(true);
@@ -2344,6 +2965,7 @@ var ConnectionStore = class {
 		this.#views.clear();
 		for (const entry of this.#entries.values()) entry.dispose();
 		this.#entries.clear();
+		this.#factory.dispose();
 	}
 };
 var ActionStore = class {
@@ -2352,10 +2974,10 @@ var ActionStore = class {
 	#details = /* @__PURE__ */ new Map();
 	#searches = /* @__PURE__ */ new Set();
 	#searchSessions = /* @__PURE__ */ new WeakMap();
-	constructor(client, providers, options) {
+	constructor(client, providers, scope) {
 		this.client = client;
 		this.providers = providers;
-		this.#raw = new ProxyStore(client, "actions", options);
+		this.#raw = new ProxyStore(client, "actions", scope);
 	}
 	get(serviceId, flowId, locale = "en", force = false) {
 		return this.#views.get(identity(flowId, serviceId, locale), [this.#raw.get(flowId, locale, serviceId, force), this.providers.raw.get(flowId, locale)], (actions, providers) => actions.data.flatMap((item) => {
@@ -2399,7 +3021,6 @@ var ActionStore = class {
 			q: query.trim(),
 			locale
 		});
-		const key = params.toString();
 		let entries = this.#searchSessions.get(signal);
 		if (entries == null) {
 			entries = /* @__PURE__ */ new Map();
@@ -2414,21 +3035,38 @@ var ActionStore = class {
 				this.#searchSessions.delete(signal);
 			}, { once: true });
 		}
+		const key = params.toString();
 		const cached = entries.get(key);
 		if (cached != null) {
-			cached.refresh();
+			cached.refresh(true);
 			return cached;
 		}
-		const resource = new Resource((_etag, requestSignal) => this.client.readCatalog({
-			path: `/v1/connector/action-metadata?${params}`,
-			decode: actionsResponse
-		}, null, requestSignal), 3e4);
-		if (signal.aborted) resource.dispose();
+		const cache = createSessionCache({
+			namespace: JSON.stringify(["open-flow:action-search", crypto.randomUUID()]),
+			schemaVersion: 1,
+			sessionId: "search",
+			maxAge: 0,
+			key: () => "result",
+			decode: (value) => {
+				if (!Array.isArray(value)) return invalidResponse();
+				return value.map(connectorActionMetadata);
+			},
+			load: async (_query, validation) => this.client.readCatalog({
+				path: `/v1/connector/action-metadata?${params}`,
+				decode: (value) => {
+					const source = record(value);
+					if (source.version != 1 || !Array.isArray(source.actions)) return invalidResponse();
+					return source.actions.map(connectorActionMetadata);
+				}
+			}, validation.etag, validation.signal)
+		});
+		const result = new CacheResource(async () => cache, void 0, true, 0);
+		if (signal.aborted) result.dispose();
 		else {
-			entries.set(key, resource);
-			this.#searches.add(resource);
+			entries.set(key, result);
+			this.#searches.add(result);
 		}
-		return resource;
+		return result;
 	}
 	retryFailed() {
 		this.#raw.retryFailed();
@@ -2446,10 +3084,10 @@ var ActionStore = class {
 	}
 };
 var CatalogStores = class {
-	constructor(client, options, connections) {
-		this.providers = new ProviderStore(client, options);
-		this.actions = new ActionStore(client, this.providers, options);
-		this.connections = new ConnectionStore(client, connections);
+	constructor(client, scope = { sessionId: crypto.randomUUID() }) {
+		this.providers = new ProviderStore(client, scope);
+		this.actions = new ActionStore(client, this.providers, scope);
+		this.connections = new ConnectionStore(client, scope);
 	}
 	dispose() {
 		this.actions.dispose();
@@ -2625,6 +3263,26 @@ var ConnectorAccessStore = class {
 		}
 		return false;
 	}
+	allowedTriggerCandidates(providerId, triggerId) {
+		return this.#state.value.candidates[providerId]?.candidates.filter((candidate) => candidate.permissions == null || candidate.permissions.allTriggers || candidate.permissions.triggerIds.includes(triggerId));
+	}
+	async filterTriggerConnections(flowId, definition, connections) {
+		if (this.#disposed || flowId != this.#flowId) return [];
+		const access = this.#state.value.access;
+		if (access?.mode == "implicit") return connections;
+		if (access == null) return [];
+		await this.loadCandidates([definition.provider]);
+		if (this.#disposed || flowId != this.#flowId) return [];
+		const candidates = this.allowedTriggerCandidates(definition.provider, definition.key);
+		if (candidates == null) return [];
+		const allowed = new Set(candidates.map((candidate) => candidate.connectionId));
+		const filtered = connections.filter((connection) => allowed.has(connection.connectionId));
+		if (!filtered.some((connection) => connection.status == "active") && connections.some((connection) => connection.status == "active")) this.setNotice({
+			kind: "error",
+			message: this.i18n.t("connectorAccess.noAvailablePermissions")
+		});
+		return filtered;
+	}
 	async setService(providerId, selected) {
 		const flowId = this.#flowId;
 		const access = this.#state.value.access;
@@ -2829,8 +3487,9 @@ var ConnectorStore = class {
 		};
 		this.provideAddNodeOptionChoices = (optionId, signal) => {
 			const service = optionId.slice(19);
-			const source = this.data.actions.get(service, void 0, this.#language);
-			const providers = this.data.providers.get(void 0, this.#language);
+			const flowId = this.#workspace.$.flowId.value;
+			const source = this.data.actions.get(service, flowId, this.#language);
+			const providers = this.data.providers.get(flowId, this.#language);
 			return scopedValue(signal, (get) => {
 				const state = get(source);
 				const provider = get(providers).data?.find((item) => item.serviceId == service);
@@ -2961,12 +3620,22 @@ var ConnectorStore = class {
 		this.#actionIds.set([]);
 		this.#services.set([]);
 	}
+	retryAction(actionId) {
+		const flowId = this.#workspace.$.flowId.value;
+		if (flowId == null || this.#disposed) return;
+		const actionState = this.data.actions.detail(actionId, flowId, this.#language, true);
+		if (this.data.providers.get(flowId, this.#language).value.error != null) this.data.providers.get(flowId, this.#language, true);
+		if (actionState.value.data?.authenticated !== false) this.data.connections.refreshFlow(flowId);
+	}
 	async resolveAction(actionId) {
 		const flowId = this.#workspace.$.flowId.value;
 		if (flowId == null || this.#disposed) throw new Error("Connector Action cannot be resolved without an active Flow.");
+		const actionState = this.data.actions.detail(actionId, flowId, this.#language);
+		await Promise.resolve();
+		const action = await resourceValue(actionState, void 0, true);
+		const connectionState = action.authenticated ? this.data.connections.get(action.serviceId, flowId) : void 0;
 		await Promise.resolve();
-		const action = await resourceValue(this.data.actions.detail(actionId, flowId, this.#language), void 0, true);
-		const connections = action.authenticated ? await resourceValue(this.data.connections.get(action.serviceId, flowId), void 0, true) : [];
+		const connections = connectionState == null ? [] : await resourceValue(connectionState, void 0, true);
 		this.#remember(this.#actionIds, [actionId]);
 		if (action.authenticated) this.#remember(this.#services, [action.serviceId]);
 		return {
@@ -3143,9 +3812,9 @@ var ConnectorStore = class {
 var TriggerCatalogStore = class {
 	#language;
 	#entries;
-	constructor(client, language, host) {
+	constructor(client, language, environment = "production") {
 		this.client = client;
-		this.host = host;
+		this.environment = environment;
 		this.#entries = /* @__PURE__ */ new Map();
 		this.retry = () => {
 			this.get(true);
@@ -3161,14 +3830,18 @@ var TriggerCatalogStore = class {
 				if (data.locale != locale) throw new Error("Unexpected Trigger catalog language.");
 				return data;
 			};
-			const persistence = catalogPersistence(this.host.catalogCache, "triggers", locale);
-			entry = new Resource((etag, signal) => this.client.readCatalog({
-				path: `/v1/trigger-keys/catalog?locale=${encodeURIComponent(locale)}`,
-				decode
-			}, etag, signal), 3e5, persistence == null ? void 0 : {
-				...persistence,
-				decode
+			const cache = createPersistentCache({
+				namespace: JSON.stringify(["open-flow:trigger-catalog", this.environment]),
+				schemaVersion: 1,
+				maxAge: 3e5,
+				key: () => locale,
+				decode,
+				load: async (_query, validation) => this.client.readCatalog({
+					path: `/v1/trigger-keys/catalog?locale=${encodeURIComponent(locale)}`,
+					decode
+				}, validation.etag, validation.signal)
 			});
+			entry = new CacheResource(async () => cache, void 0, true, 3e5);
 			this.#entries.set(locale, entry);
 		}
 		return entry;
@@ -3247,7 +3920,7 @@ var TriggerStore = class {
 		this.#disposed = false;
 		this.browseAddNodeOptions = (signal) => this.#options("", signal);
 		this.provideAddNodeOptions = (searchTerm, signal) => this.#options(searchTerm, signal);
-		this.catalog = new TriggerCatalogStore(client, resolveUiLanguage([i18n.lang]), host);
+		this.catalog = new TriggerCatalogStore(client, resolveUiLanguage([i18n.lang]), host.cacheEnvironment);
 		this.#client = client;
 		this.#host = host;
 		this.#i18n = i18n;
@@ -3262,7 +3935,7 @@ var TriggerStore = class {
 			if (trigger.kind != "poll" && trigger.kind != "integration") return { authorizationPending: false };
 			const connections = current == null ? void 0 : get(workspace.catalogs.connections.get(current.provider, get(workspace.$.flowId))).data;
 			const catalog = connections == null ? void 0 : connectionCatalog(connections);
-			const connectionError = current == null ? void 0 : get(workspace.catalogs.connections.get(current.provider, get(workspace.$.flowId))).error;
+			const connectionError = current == null ? void 0 : state.connectionError?.provider == current.provider ? new Error(state.connectionError.message) : get(workspace.catalogs.connections.get(current.provider, get(workspace.$.flowId))).error;
 			return {
 				activeConnections: catalog?.active,
 				authorizationPending: state.authorizationProvider == current?.provider,
@@ -3628,6 +4301,7 @@ function inverseFlowChanges(content, operations) {
 					value: operation.before
 				});
 				break;
+			case "task.openapi.set":
 			case "task.agent.set":
 				restore.push({
 					...operation,
@@ -4699,10 +5373,11 @@ var WorkspaceStore = class {
 	#pendingRepair;
 	#stopCatalogWatch;
 	#stopFlowWatch;
-	constructor(client, setNotice, identity = createAuthoringId, i18n = createI18n(), runChanged = () => {}, catalogs = new CatalogStores(client), flowCreated = () => {}, accessChanged = () => {}) {
+	constructor(client, setNotice, identity = createAuthoringId, i18n = createI18n(), runChanged = () => {}, catalogs = new CatalogStores(client), flowCreated = () => {}, accessChanged = () => {}, filterTriggerConnections) {
 		this.catalogs = catalogs;
 		this.flowCreated = flowCreated;
 		this.accessChanged = accessChanged;
+		this.filterTriggerConnections = filterTriggerConnections;
 		this.#draftSession = new Latest();
 		this.#history = new CanvasHistory();
 		this.history$ = this.#history.state$;
@@ -5022,9 +5697,10 @@ var WorkspaceStore = class {
 		if (intent.kind == "provider-trigger" && intent.connectionId == null) {
 			try {
 				const connections = await resourceValue(this.catalogs.connections.get(intent.definition.provider, draft.flowId));
+				const allowed = this.filterTriggerConnections == null ? connections : await this.filterTriggerConnections(draft.flowId, intent.definition, connections);
 				intent = {
 					...intent,
-					connectionId: connectionCatalog(connections).preferred?.connectionId
+					connectionId: connectionCatalog(allowed).preferred?.connectionId
 				};
 			} catch (error) {
 				if (!this.#disposed && this.#model.value.draft == draft) this.#setNotice(errorNotice(error, this.#i18n.t));
@@ -5268,6 +5944,9 @@ var WorkspaceStore = class {
 			position
 		}));
 	}
+	loadOpenApiDocument(url, signal) {
+		return this.#client.loadOpenApiDocument(url, signal);
+	}
 	async saveTaskSettings(nodeId, settings) {
 		const revision = this.$.revision.value;
 		const target = this.#model.value.target;
@@ -5817,7 +6496,7 @@ var WorkbenchStore = class {
 	#openingCreatedFlow;
 	#stopAccessReaction;
 	#accessLoading;
-	constructor(client, preferences, identity = randomId, i18n = createI18n(), host = blockedExternalPages, variables = true) {
+	constructor(client, preferences, identity = randomId, i18n = createI18n(), host = blockedExternalPages, variables = true, cacheSessionId = crypto.randomUUID()) {
 		this.#externalRuns = new Latest();
 		this.#notice = val();
 		this.#variableNames = val([]);
@@ -5851,9 +6530,16 @@ var WorkbenchStore = class {
 		this.workspace = new WorkspaceStore(client, setNotice, createAuthoringId, i18n, (event) => {
 			if (event.kind == "run.created") this.#followExternalRun(client, event);
 			else this.runs.changed(event.runId);
-		}, new CatalogStores(client, host.catalogCache, host.connectionCache), (flowId) => void this.#openCreatedFlow(flowId), (flowId) => {
+		}, new CatalogStores(client, {
+			sessionId: cacheSessionId,
+			environment: host.cacheEnvironment,
+			connectorOwnerId: host.connectorOwnerId
+		}), (flowId) => void this.#openCreatedFlow(flowId), (flowId) => {
 			this.connectorAccess.changed(flowId);
 			this.workspace.catalogs.refreshFlow(flowId);
+		}, async (flowId, definition, connections) => {
+			await this.#accessLoading;
+			return this.connectorAccess.filterTriggerConnections(flowId, definition, connections);
 		});
 		this.#stopAccessReaction = this.workspace.$.flowId.reaction((flowId) => {
 			this.#accessLoading = this.connectorAccess.load(flowId);
@@ -6229,7 +6915,7 @@ var WorkbenchStore = class {
 };
 //#endregion
 //#region src/workbench/browser/runtime/openFlowWorkbench.tsx
-var FlowWorkspace = lazy(() => import("./flowWorkspace-DBaq2Eks.js"));
+var FlowWorkspace = lazy(() => import("./flowWorkspace-CoT_ewLX.js"));
 function OpenFlowSessionGate({ action, description, error, onSubmit, onTokenChange, pending = false, title, token, tokenLabel }) {
 	const hasToken = token != null && tokenLabel != null && onTokenChange != null;
 	const tokenValue = token ?? "";
@@ -6364,17 +7050,17 @@ function Workbench({ catalogWidth, createFlow, createFlowDisabled, createFlowFie
 		})
 	});
 }
-function Session({ catalogWidth, createFlow, createFlowDisabled, createFlowField, flowBadges, connectionHref, host, hrefFor, language, location, onConfigureConnector, onManageConnectorAccess, onLanguageChange, onNavigate, preferences, theme, variables = true }) {
+function Session({ catalogWidth, createFlow, createFlowDisabled, createFlowField, flowBadges, connectionHref, host, hrefFor, language, location, onConfigureConnector, onManageConnectorAccess, onLanguageChange, onNavigate, preferences, sessionKey, theme, variables = true }) {
 	const navigate = useRef(onNavigate);
 	navigate.current = onNavigate;
 	const [{ i18n, navigation, store }] = useState(() => {
 		const workbenchI18n = createI18n(language);
 		const workbenchStore = new WorkbenchStore(new WorkbenchClient((input, init) => host.request(input, init), (flowId, listener) => host.subscribeFlow(flowId, listener), (listener) => host.subscribeFlowCatalog(listener)), preferences, randomId, workbenchI18n, {
 			openExternalPage: (resolveUrl) => host.openExternalPage(resolveUrl),
-			catalogCache: host.catalogCache,
-			connectionCache: host.connectionCache,
+			cacheEnvironment: host.cacheEnvironment,
+			connectorOwnerId: host.connectorOwnerId,
 			resolveActor: actorResolver(host, globalThis.location?.origin)
-		}, variables);
+		}, variables, sessionKey);
 		return {
 			i18n: workbenchI18n,
 			navigation: new NavigationStore(workbenchStore, location, (nextLocation, options) => navigate.current(nextLocation, options)),
@@ -6445,7 +7131,10 @@ function Session({ catalogWidth, createFlow, createFlowDisabled, createFlowField
 	});
 }
 function OpenFlowWorkbench({ sessionKey, ...props }) {
-	return /* @__PURE__ */ jsx(Session, { ...props }, sessionKey);
+	return /* @__PURE__ */ jsx(Session, {
+		sessionKey,
+		...props
+	}, `${sessionKey}:${props.host.connectorOwnerId ?? ""}`);
 }
 //#endregion
 export { EventSourcesPage, OpenFlowSessionGate, OpenFlowWorkbench, isUiLanguage as isWorkbenchLanguage, resolveUiLanguage as resolveWorkbenchLanguage, uiLanguageNames as workbenchLanguageNames, uiLanguages as workbenchLanguages };