@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.18

package/dist/popover-BJHvrFGR.js

@@ -0,0 +1,472 @@
+"use client";
+import { An as newConnectionProviderKey, Dn as connectionsForAdapter, On as isOptionalAdapter, jn as replaceAdapterConnections, kn as matchesAdapterProvider } from "./FluidGridsProvider-dvZSNtSW.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { r as useAgentsUsingConnection } from "./useAgentDefinitions-B0dam3_o.js";
+import { t as cn } from "./cn-QqidFIgr.js";
+import { o as ConnectionFormDialog } from "./flow-builder-CZDKRc6f.js";
+import { a as SdkPermissionGate, t as FLUIDGRIDS_PERMISSIONS } from "./constants-B2lhWNoN.js";
+import { n as useConnections } from "./useConnections-Cs7LCWEM.js";
+import { a as useRunners, t as RunnerStatusPill } from "./RunnerStatusPill-Ctg4TJcP.js";
+import * as React$1 from "react";
+import { useCallback, useMemo, useState } from "react";
+import { Icon } from "@iconify/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Button, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@burdenoff/fe-libs/ui";
+import { ProviderIcon } from "@burdenoff/fe-libs/connections";
+import { formatDistanceToNow } from "date-fns";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+
+// src/modules/agent-definitions/components/ConnectionAgentUsage.tsx
+/**
+* A connection's "used by agents" list (BOFF-9962).
+*
+* Shows which agents may use a connection, so whoever edits or reuses it knows an agent can act
+* with it. The list comes from `agentDefinitionsUsingConnection`; it renders nothing when no agent
+* uses the connection or the viewer cannot read agent definitions.
+*/
+function ConnectionAgentUsage({ connectionId, connectionName }) {
+	const tr = useTr();
+	const agents = useAgentsUsingConnection(connectionId);
+	if (agents.length === 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-start gap-1.5 text-xs text-muted-foreground",
+		"data-testid": `connection-agent-usage-${connectionId}`,
+		children: [/* @__PURE__ */ jsx(Icon, {
+			icon: "mdi:robot-outline",
+			className: "w-3.5 h-3.5 mt-0.5 shrink-0"
+		}), /* @__PURE__ */ jsxs("span", { children: [
+			connectionName ? tr("fluidgrids.agents.usedBy.namedLabel", "{{connection}} is used by agents:", { connection: connectionName }) : tr("fluidgrids.agents.usedBy.label", "Used by agents:"),
+			" ",
+			agents.map((agent) => agent.status === "ACTIVE" ? agent.name : tr("fluidgrids.agents.usedBy.disabled", "{{name}} (disabled)", { name: agent.name })).join(", ")
+		] })]
+	});
+}
+
+// src/modules/connections/components/ConnectionSelector.tsx
+/**
+* ConnectionSelector Component
+*
+* A dropdown selector for choosing integration connections in workflow nodes.
+* Replaces the legacy CredentialSelector and queries the integrations service.
+*
+* This component:
+* - Fetches connections from wspace-integrations-svc via the federated gateway
+* - Filters connections by provider adapters defined in node manifests
+* - Supports single and multiple selection modes
+* - Opens an inline ConnectionFormDialog popup for creating new connections (n8n-style)
+*/
+function formatAge(dateString) {
+	try {
+		return formatDistanceToNow(new Date(dateString), { addSuffix: true });
+	} catch {
+		return "";
+	}
+}
+function getStatusColor(status) {
+	switch (status) {
+		case "ACTIVE": return "text-[var(--color-status-success-text)]";
+		case "INACTIVE": return "text-text-secondary";
+		case "ERROR":
+		case "REVOKED": return "text-[var(--color-status-error-text)]";
+		case "EXPIRED":
+		case "PENDING_AUTH": return "text-[var(--color-status-warning-text)]";
+		default: return "text-text-secondary";
+	}
+}
+function getStatusIcon(status) {
+	switch (status) {
+		case "ACTIVE": return "mdi:check-circle";
+		case "INACTIVE": return "mdi:pause-circle";
+		case "ERROR":
+		case "REVOKED": return "mdi:alert-circle";
+		case "EXPIRED": return "mdi:clock-alert";
+		case "PENDING_AUTH": return "mdi:account-clock";
+		default: return "mdi:help-circle";
+	}
+}
+function ConnectionChip({ connection, connectionData, onRemove }) {
+	const tr = useTr();
+	const name = connectionData?.name || connection.connectionId;
+	const status = connectionData?.status;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-center gap-1.5 px-2 py-1 bg-accent/30 rounded-md text-sm group",
+		children: [
+			/* @__PURE__ */ jsx(ProviderIcon, {
+				variant: "bare",
+				provider: connectionData?.provider ?? {
+					key: connection.adapter,
+					icon: void 0,
+					category: "CUSTOM"
+				},
+				size: 16
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "truncate max-w-32",
+				children: name
+			}),
+			status && /* @__PURE__ */ jsx(Icon, {
+				icon: getStatusIcon(status),
+				className: `w-3.5 h-3.5 ${getStatusColor(status)}`
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				"aria-label": tr("fluidgrids.connections.connectionSelector.removeConnection", "Remove connection"),
+				onClick: (e) => {
+					e.stopPropagation();
+					onRemove();
+				},
+				className: "text-text-secondary hover:text-status-error-text opacity-0 group-hover:opacity-100 transition-opacity",
+				children: /* @__PURE__ */ jsx(Icon, {
+					icon: "mdi:close",
+					className: "w-3.5 h-3.5"
+				})
+			})
+		]
+	});
+}
+function ConnectionSelector(props) {
+	const connectionList = useConnections();
+	if (props.adapters.length <= 1) return /* @__PURE__ */ jsx(AdapterConnectionSelector, {
+		...props,
+		connectionList
+	});
+	return /* @__PURE__ */ jsx("div", {
+		className: props.compact ? "space-y-2" : "space-y-3",
+		children: props.adapters.map((adapter) => /* @__PURE__ */ jsxs("fieldset", {
+			className: "min-w-0 space-y-1.5",
+			children: [/* @__PURE__ */ jsx("legend", {
+				className: "text-xs font-medium text-text-secondary",
+				children: adapter.name
+			}), /* @__PURE__ */ jsx(AdapterConnectionSelector, {
+				...props,
+				adapters: [adapter],
+				selectedConnections: connectionsForAdapter(props.selectedConnections, adapter.name),
+				onChange: (connections) => props.onChange(replaceAdapterConnections(props.selectedConnections, adapter.name, connections.map((connection) => connection.connectionId))),
+				showRequired: false,
+				connectionList
+			})]
+		}, adapter.name))
+	});
+}
+function AdapterConnectionSelector({ adapters, selectedConnections, onChange, multiple = false, showStatus = true, compact = false, showRequired = true, connectionList }) {
+	const tr = useTr();
+	const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+	const [dialogOpen, setDialogOpen] = useState(false);
+	const [dialogProviderKey, setDialogProviderKey] = useState();
+	const { connections, loading: connectionsLoading, refetch } = connectionList;
+	const availableConnections = useMemo(() => {
+		if (!adapters || adapters.length === 0) return [];
+		return connections.filter((connection) => connection.canUse !== false && adapters.some((adapter) => matchesAdapterProvider(adapter, connection.provider?.key ?? "")));
+	}, [connections, adapters]);
+	const mergedConnections = useMemo(() => {
+		const allConnections = [...availableConnections];
+		selectedConnections.forEach((selected) => {
+			if (!availableConnections.some((c) => c.id === selected.connectionId)) {
+				const fullConn = connections.find((c) => c.id === selected.connectionId);
+				if (fullConn && fullConn.canUse !== false) allConnections.push(fullConn);
+			}
+		});
+		return allConnections;
+	}, [
+		availableConnections,
+		selectedConnections,
+		connections
+	]);
+	const groupedConnections = useMemo(() => {
+		const groups = {};
+		mergedConnections.forEach((conn) => {
+			const providerName = conn.provider?.name || "Other";
+			if (!groups[providerName]) groups[providerName] = [];
+			groups[providerName].push(conn);
+		});
+		return groups;
+	}, [mergedConnections]);
+	const handleSelect = useCallback((connection) => {
+		const providerKey = connection.provider?.key || "";
+		const adapter = adapters.find((candidate) => matchesAdapterProvider(candidate, providerKey));
+		if (!adapter) return;
+		const newSelection = {
+			connectionId: connection.id,
+			adapter: adapter.name
+		};
+		if (multiple) {
+			if (selectedConnections.some((c) => c.connectionId === connection.id)) onChange(selectedConnections.filter((c) => c.connectionId !== connection.id));
+			else onChange([...selectedConnections, newSelection]);
+		} else {
+			onChange([newSelection]);
+			setIsDropdownOpen(false);
+		}
+	}, [
+		adapters,
+		selectedConnections,
+		onChange,
+		multiple
+	]);
+	const handleRemove = useCallback((connectionId) => {
+		onChange(selectedConnections.filter((c) => c.connectionId !== connectionId));
+	}, [selectedConnections, onChange]);
+	const handleNewConnection = useCallback((providerKey) => {
+		setDialogProviderKey(providerKey);
+		setDialogOpen(true);
+		setIsDropdownOpen(false);
+	}, []);
+	const handleConnectionCreated = useCallback((conn) => {
+		const providerKey = conn.provider?.key || "";
+		const adapter = adapters.find((candidate) => matchesAdapterProvider(candidate, providerKey));
+		if (adapter) {
+			const newSelection = {
+				connectionId: conn.id,
+				adapter: adapter.name
+			};
+			if (multiple) onChange([...selectedConnections, newSelection]);
+			else onChange([newSelection]);
+		}
+		setDialogOpen(false);
+		refetch();
+	}, [
+		adapters,
+		selectedConnections,
+		onChange,
+		multiple,
+		refetch
+	]);
+	const getConnectionData = useCallback((connectionId) => connections.find((c) => c.id === connectionId), [connections]);
+	if (!adapters || adapters.length === 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: compact ? "space-y-2" : "space-y-3",
+		children: [
+			selectedConnections.length > 0 && /* @__PURE__ */ jsx("div", {
+				className: "flex flex-wrap gap-1.5",
+				children: selectedConnections.map((conn) => {
+					const connData = getConnectionData(conn.connectionId);
+					return /* @__PURE__ */ jsx(ConnectionChip, {
+						connection: conn,
+						connectionData: connData,
+						onRemove: () => handleRemove(conn.connectionId)
+					}, conn.connectionId);
+				})
+			}),
+			selectedConnections.map((conn) => /* @__PURE__ */ jsx(ConnectionAgentUsage, {
+				connectionId: conn.connectionId,
+				connectionName: selectedConnections.length > 1 ? getConnectionData(conn.connectionId)?.name : null
+			}, `agents-${conn.connectionId}`)),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2",
+				children: [/* @__PURE__ */ jsxs(DropdownMenu, {
+					open: isDropdownOpen,
+					onOpenChange: setIsDropdownOpen,
+					children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+						asChild: true,
+						children: /* @__PURE__ */ jsxs(Button, {
+							variant: "outline",
+							size: compact ? "sm" : "default",
+							className: "justify-between min-w-[200px]",
+							children: [/* @__PURE__ */ jsxs("span", {
+								className: "flex items-center gap-2",
+								children: [/* @__PURE__ */ jsx(Icon, {
+									icon: "mdi:link-variant",
+									className: "w-4 h-4 text-text-secondary"
+								}), selectedConnections.length === 0 ? tr("fluidgrids.connections.connectionSelector.selectConnection", "Select connection") : multiple ? `${selectedConnections.length} selected` : tr("fluidgrids.connections.connectionSelector.changeConnection", "Change connection")]
+							}), /* @__PURE__ */ jsx(Icon, {
+								icon: "mdi:chevron-down",
+								className: "w-4 h-4 text-text-secondary"
+							})]
+						})
+					}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+						align: "start",
+						style: { zIndex: 1100 },
+						className: "w-[280px] max-h-[400px] overflow-y-auto",
+						children: [connectionsLoading ? /* @__PURE__ */ jsxs("div", {
+							className: "p-4 text-center text-sm text-text-secondary",
+							children: [/* @__PURE__ */ jsx(Icon, {
+								icon: "mdi:loading",
+								className: "w-6 h-6 mx-auto mb-2 animate-spin"
+							}), /* @__PURE__ */ jsx("p", { children: tr("fluidgrids.connections.connectionSelector.loading", "Loading connections...") })]
+						}) : Object.keys(groupedConnections).length === 0 ? /* @__PURE__ */ jsxs("div", {
+							className: "p-4 text-center text-sm text-text-secondary",
+							children: [
+								/* @__PURE__ */ jsx(Icon, {
+									icon: "mdi:link-off",
+									className: "w-8 h-8 mx-auto mb-2 opacity-50"
+								}),
+								/* @__PURE__ */ jsx("p", { children: tr("fluidgrids.connections.connectionSelector.emptyTitle", "No matching connections") }),
+								/* @__PURE__ */ jsx("p", {
+									className: "text-xs mt-1",
+									children: tr("fluidgrids.connections.connectionSelector.emptyHint", "Create one in Integrations")
+								})
+							]
+						}) : Object.entries(groupedConnections).map(([providerName, conns]) => /* @__PURE__ */ jsxs("div", { children: [
+							/* @__PURE__ */ jsxs(DropdownMenuLabel, {
+								className: "flex items-center gap-2 text-xs font-semibold text-text-secondary uppercase tracking-wide",
+								children: [/* @__PURE__ */ jsx(ProviderIcon, {
+									variant: "bare",
+									provider: conns[0]?.provider ?? {
+										key: "generic",
+										icon: void 0,
+										category: "CUSTOM"
+									},
+									size: 16
+								}), providerName]
+							}),
+							conns.map((conn) => {
+								const isSelected = selectedConnections.some((c) => c.connectionId === conn.id);
+								const isActive = conn.status === "ACTIVE";
+								return /* @__PURE__ */ jsxs(DropdownMenuItem, {
+									onSelect: (event) => {
+										if (multiple) event.preventDefault();
+										handleSelect(conn);
+									},
+									className: `flex items-center justify-between cursor-pointer ${isSelected ? "bg-action-primary-bg/10" : ""} ${!isActive ? "opacity-60" : ""}`,
+									children: [/* @__PURE__ */ jsxs("div", {
+										className: "flex flex-col min-w-0",
+										children: [/* @__PURE__ */ jsxs("span", {
+											className: "font-medium truncate flex items-center gap-1.5",
+											children: [conn.name, showStatus && /* @__PURE__ */ jsx("span", {
+												title: conn.status,
+												children: /* @__PURE__ */ jsx(Icon, {
+													icon: getStatusIcon(conn.status),
+													className: `w-3.5 h-3.5 ${getStatusColor(conn.status)}`
+												})
+											})]
+										}), /* @__PURE__ */ jsx("span", {
+											className: "text-xs text-text-secondary",
+											children: conn.externalAccountEmail || conn.updatedAt && `Updated ${formatAge(conn.updatedAt)}`
+										})]
+									}), isSelected && /* @__PURE__ */ jsx(Icon, {
+										icon: "mdi:check",
+										className: "w-4 h-4 text-primary flex-shrink-0"
+									})]
+								}, conn.id);
+							}),
+							/* @__PURE__ */ jsx(DropdownMenuSeparator, {})
+						] }, providerName)), /* @__PURE__ */ jsx(SdkPermissionGate, {
+							permission: FLUIDGRIDS_PERMISSIONS.INTEGRATION_CONNECTION_CREATE,
+							children: /* @__PURE__ */ jsxs(DropdownMenuItem, {
+								onClick: () => {
+									handleNewConnection(newConnectionProviderKey(adapters));
+								},
+								className: "text-primary cursor-pointer",
+								children: [/* @__PURE__ */ jsx(Icon, {
+									icon: "mdi:plus",
+									className: "w-4 h-4 mr-2"
+								}), tr("fluidgrids.connections.connectionSelector.newConnection", "New connection")]
+							})
+						})]
+					})]
+				}), selectedConnections.length === 0 && !compact && /* @__PURE__ */ jsx(SdkPermissionGate, {
+					permission: FLUIDGRIDS_PERMISSIONS.INTEGRATION_CONNECTION_CREATE,
+					children: /* @__PURE__ */ jsxs(Button, {
+						variant: "ghost",
+						size: "sm",
+						onClick: () => handleNewConnection(newConnectionProviderKey(adapters)),
+						className: "text-primary hover:text-primary/80",
+						children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "mdi:plus",
+							className: "w-4 h-4 mr-1"
+						}), tr("fluidgrids.connections.connectionSelector.new", "New")]
+					})
+				})]
+			}),
+			showStatus && showRequired && selectedConnections.length === 0 && adapters.some((adapter) => !isOptionalAdapter(adapter)) && /* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-1.5 text-xs text-[var(--color-status-warning-text)]",
+				children: [/* @__PURE__ */ jsx(Icon, {
+					icon: "mdi:alert-circle",
+					className: "w-3.5 h-3.5"
+				}), /* @__PURE__ */ jsx("span", { children: tr("fluidgrids.connections.connectionSelector.connectionRequired", "Connection required for this node") })]
+			}),
+			/* @__PURE__ */ jsx(ConnectionFormDialog, {
+				open: dialogOpen,
+				onClose: () => setDialogOpen(false),
+				providerKey: dialogProviderKey,
+				onConnectionCreated: handleConnectionCreated
+			})
+		]
+	});
+}
+
+// src/modules/runners/components/RunOnSection.tsx
+/**
+* NDV Settings → "Run on": FluidGrids Cloud (default) or one of the
+* workspace's self-hosted runners.
+*
+* Persisted at `node.data.executionSettings.runOn = { kind: "runner", runnerId }`
+* (absent = FluidGrids Cloud). fluidgrids-workers reads exactly that and the
+* node then runs on the runner — or fails if it is offline; it never falls
+* back to the cloud.
+*/
+const CLOUD = "__fluidgrids_cloud__";
+function RunOnSection({ value, onChange, sectionLabelClassName }) {
+	const tr = useTr();
+	const { runners, loading } = useRunners({ pollMs: 15e3 });
+	const selected = value ? runners.find((r) => r.id === value.runnerId) : void 0;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "space-y-2",
+		"data-testid": "ndv-settings-run-on",
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: sectionLabelClassName,
+				children: tr("fluidgrids.builder.nodeSettings.runOn", "Run on")
+			}),
+			/* @__PURE__ */ jsxs(Select, {
+				value: value?.runnerId ?? CLOUD,
+				onValueChange: (v) => onChange(v === CLOUD ? null : {
+					kind: "runner",
+					runnerId: v
+				}),
+				children: [/* @__PURE__ */ jsx(SelectTrigger, {
+					className: "w-full",
+					"data-testid": "ndv-settings-run-on-select",
+					children: /* @__PURE__ */ jsx(SelectValue, {})
+				}), /* @__PURE__ */ jsxs(SelectContent, {
+					style: { zIndex: 1100 },
+					"data-testid": "ndv-settings-run-on-options",
+					children: [
+						/* @__PURE__ */ jsx(SelectItem, {
+							value: CLOUD,
+							"data-testid": "run-on-cloud",
+							children: tr("fluidgrids.builder.nodeSettings.runOnCloud", "FluidGrids Cloud (default)")
+						}),
+						runners.map((runner) => /* @__PURE__ */ jsxs(SelectItem, {
+							value: runner.id,
+							"data-testid": "run-on-runner-option",
+							children: [runner.name, runner.status !== "ONLINE" ? ` (${runner.status === "OFFLINE" ? tr("fluidgrids.runners.offline", "Offline") : tr("fluidgrids.runners.neverConnected", "Not connected yet")})` : ""]
+						}, runner.id)),
+						value && !loading && !selected && /* @__PURE__ */ jsx(SelectItem, {
+							value: value.runnerId,
+							disabled: true,
+							children: tr("fluidgrids.builder.nodeSettings.runOnMissing", "Removed runner")
+						})
+					]
+				})]
+			}),
+			value ? /* @__PURE__ */ jsxs("div", {
+				className: "space-y-1 text-xs text-text-secondary",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-start gap-2",
+					children: [selected && /* @__PURE__ */ jsx(RunnerStatusPill, { status: selected.status }), /* @__PURE__ */ jsx("span", { children: tr("fluidgrids.builder.nodeSettings.runOnRunnerHint", "This node runs on your runner, in a local sandbox. If the runner is offline the node fails — it never falls back to FluidGrids Cloud. The node's input and the credentials it uses are sent to that machine.") })]
+				}), selected && /* @__PURE__ */ jsx("p", {
+					"data-testid": "run-on-private-network",
+					children: (selected.privateNetwork ?? []).length === 0 ? tr("fluidgrids.builder.nodeSettings.runOnPublicOnly", "On this runner, nodes reach the public internet only. Private destinations are opened on the runner machine (fluidgrids-runner network allow).") : tr("fluidgrids.builder.nodeSettings.runOnPrivateNetwork", "This runner opens {{count}} private destination(s) — see Runners for which nodes may use them.", { count: (selected.privateNetwork ?? []).length })
+				})]
+			}) : /* @__PURE__ */ jsx("p", {
+				className: "text-xs text-text-secondary",
+				children: runners.length === 0 && !loading ? tr("fluidgrids.builder.nodeSettings.runOnNoRunners", "Runs in FluidGrids Cloud. Add a runner under Workflows → Runners to run nodes on your own machine.") : tr("fluidgrids.builder.nodeSettings.runOnCloudHint", "Runs in FluidGrids Cloud.")
+			})
+		]
+	});
+}
+
+// src/ui/popover.tsx
+const Popover$1 = PopoverPrimitive.Root;
+const PopoverTrigger$1 = PopoverPrimitive.Trigger;
+const PopoverContent$1 = React$1.forwardRef(({ className, align = "center", sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx(PopoverPrimitive.Portal, { children: /* @__PURE__ */ jsx(PopoverPrimitive.Content, {
+	ref,
+	"data-slot": "popover-content",
+	align,
+	sideOffset,
+	className: cn("z-50 w-72 rounded-card border border-border-subtle bg-bg-elevated p-4 text-text-primary shadow-elevation-3 outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className),
+	...props
+}) }));
+PopoverContent$1.displayName = PopoverPrimitive.Content.displayName;
+
+export { ConnectionSelector as a, RunOnSection as i, PopoverContent$1 as n, PopoverTrigger$1 as r, Popover$1 as t };

package/dist/{quick-config-panel-D3ogsaFL.js → quick-config-panel-ws3pLvbt.js}

@@ -1,8 +1,9 @@
 "use client";
 import { A as nodeAccent, H as useFlowStore, j as NodeTypeIcon } from "./node-operation-selection--oy-yEq_.js";
-import { G as nodeSubtitle, K as nodeTitle, Kn as getNodeDetail, X as useNodeConfig, rn as useNodeExecution } from "./FluidGridsProvider-DmvFADFa.js";
-import { H as NodeEditorTabBody, V as NodeExecutionActions, dt as NodeInputFields, lt as NodeEditorTabs, ot as useNodeEditorTab } from "./flow-builder-DEzT8TQu.js";
+import { G as nodeSubtitle, K as nodeTitle, Mn as getNodeDetail, X as useNodeConfig, rn as useNodeExecution } from "./FluidGridsProvider-dvZSNtSW.js";
+import { i as NodeInputFields, n as useNodeEditorTab, r as NodeEditorTabs, t as NodeEditorTabBody } from "./node-editor-tab-body-DU-dh35X.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { r as NodeExecutionActions } from "./schedule-panel-C0mfGQSD.js";
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useReactFlow, useStore } from "@xyflow/react";
 import { Icon } from "@iconify/react";

package/dist/rolldown-runtime-hDbaFkMy.js

@@ -0,0 +1,18 @@
+"use client";
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, flags) => {
+	let target = Object.setPrototypeOf({}, null);
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!(flags & 1)) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return flags & 2 ? target : Object.preventExtensions(target);
+};
+
+export { __exportAll as t };

package/dist/run-display-BycKYSU0.js

@@ -0,0 +1,46 @@
+"use client";
+// src/modules/executions/utils/run-display.ts
+/**
+* Versions are stored as "v1"/"v2" (legacy: "1.0.0"). Render without
+* double-prefixing: "v1" stays "v1", "1.0.0" becomes "v1.0.0".
+*/
+function formatRunVersion(version) {
+	if (!version) return "";
+	return version.startsWith("v") ? version : `v${version}`;
+}
+function asString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+/**
+* Build a nodeId → display mapping from a workflow definitionJson.
+* Label priority: user-set node label → manifest name → node type.
+* Returns an empty map for missing/malformed definitions (e.g. runs of
+* deleted workflows) — callers fall back to the raw nodeId.
+*/
+function buildNodeDisplayMap(definitionJson) {
+	const map = {};
+	const nodes = definitionJson?.data?.nodes;
+	if (!Array.isArray(nodes)) return map;
+	for (const node of nodes) {
+		const id = asString(node?.id);
+		if (!id) continue;
+		const label = asString(node?.data?.label) ?? asString(node?.data?.nodeData?.name) ?? asString(node?.type);
+		if (!label) continue;
+		const operation = asString(node?.data?.operation_name);
+		map[id] = {
+			label,
+			operation: operation === "execute" ? void 0 : operation
+		};
+	}
+	return map;
+}
+/**
+* "GitHub · searchIssues" title for a node, falling back to the raw nodeId
+* when the definition doesn't know this node.
+*/
+function nodeDisplayTitle(display, fallback) {
+	if (!display) return fallback;
+	return display.operation ? `${display.label} · ${display.operation}` : display.label;
+}
+
+export { formatRunVersion as n, nodeDisplayTitle as r, buildNodeDisplayMap as t };

package/dist/run-list-links-ByYC0OlV.js

@@ -0,0 +1,98 @@
+"use client";
+import { $u as ErrorType } from "./graphql-types-CDKVWH2R.js";
+
+// src/modules/executions/utils/run-list-links.ts
+/**
+* Links into the Runs list that carry its filters in the query string
+* (BOFF-9974), and the reading of them on the list.
+*
+* Insights' error panel links each failing node, error type, workflow and day
+* to "the failed runs behind it". The two halves live together so a link and
+* the filter it opens cannot drift apart.
+*
+*   ../runs?status=FAILED&failedNodeType=internal%3Ahttp&from=…&to=…
+*
+* `from` / `to` are ISO instants (the list's custom date range); `workflowKey`
+* is read by the list on its own, as it always was.
+*/
+/** The filters a link may set; `workflowKey` stays with the list's own sync. */
+const RUN_LIST_LINK_PARAMS = [
+	"status",
+	"errorType",
+	"failedNodeType",
+	"from",
+	"to"
+];
+const RUN_STATUSES = [
+	"PENDING",
+	"RUNNING",
+	"COMPLETED",
+	"FAILED",
+	"CANCELLED",
+	"WAITING",
+	"TERMINATED"
+];
+function isRunStatus(value) {
+	return RUN_STATUSES.some((status) => status === value);
+}
+/** A classification the service knows (its ErrorType enum). */
+function isErrorType(value) {
+	return Object.values(ErrorType).some((type) => type === value);
+}
+function validDate(value) {
+	return value instanceof Date && Number.isFinite(value.getTime());
+}
+/** The Runs list with `link`'s filters, relative to an SDK page route. */
+function runListPath(link) {
+	const params = new URLSearchParams();
+	if (link.workflowKey) params.set("workflowKey", link.workflowKey);
+	if (link.status) params.set("status", link.status);
+	if (link.errorType) params.set("errorType", link.errorType);
+	if (link.failedNodeType) params.set("failedNodeType", link.failedNodeType);
+	if (validDate(link.from)) params.set("from", link.from.toISOString());
+	if (validDate(link.to)) params.set("to", link.to.toISOString());
+	const query = params.toString();
+	return query ? `../runs?${query}` : "../runs";
+}
+function parseDate(value) {
+	if (!value) return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date : null;
+}
+/**
+* The list filters a link's query string sets, or null when it carries none.
+* Unknown values are ignored rather than trusted (the URL is user input); a
+* reversed range is dropped, like the custom range inputs do.
+*/
+function runListFilterFromSearch(params) {
+	const filter = {};
+	const status = params.get("status")?.trim().toUpperCase() ?? "";
+	if (isRunStatus(status)) filter.status = status;
+	const errorType = params.get("errorType")?.trim().toUpperCase() ?? "";
+	if (isErrorType(errorType)) filter.errorType = errorType;
+	const failedNodeType = params.get("failedNodeType")?.trim() ?? "";
+	if (failedNodeType) filter.failedNodeType = failedNodeType;
+	const from = parseDate(params.get("from"));
+	const to = parseDate(params.get("to"));
+	if ((from || to) && !(from && to && from.getTime() > to.getTime())) filter.dateRange = {
+		start: from,
+		end: to,
+		preset: "custom"
+	};
+	return Object.keys(filter).length > 0 ? filter : null;
+}
+/** A stable key of the link parameters in `params`, to apply each link once. */
+function runListLinkKey(params) {
+	return RUN_LIST_LINK_PARAMS.map((name) => params.get(name) ?? "").join("|");
+}
+/** The UTC day [00:00, 24:00) of an ISO calendar date such as "2026-11-10". */
+function utcDay(date) {
+	const from = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+	if (!Number.isFinite(from.getTime())) return null;
+	return {
+		from,
+		to: /* @__PURE__ */ new Date(from.getTime() + 864e5 - 1)
+	};
+}
+
+export { utcDay as i, runListLinkKey as n, runListPath as r, runListFilterFromSearch as t };