@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.18

package/dist/{VersionDiffDialog-Dq2xlPFI.js → VersionDiffDialog-DSN0mU0f.js}

@@ -1,6 +1,7 @@
 "use client";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
-import { Bi as describeOperationError, Dr as WorkflowDefinitionDocument, Oi as getFluidGridsClient, Ui as throwIfResultError, bi as WorkflowVersionDiffDocument } from "./node-endpoint-configs-DHFGA5MQ.js";
+import { _ as throwIfResultError, m as describeOperationError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { Er as WorkflowDefinitionDocument, yi as WorkflowVersionDiffDocument } from "./graphql-operation-types-kX-MMjgW.js";
 import { t as canvasFromDefinition } from "./definition-canvas--3MPHoP-.js";
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Background, Controls, Handle, MiniMap, Position, ReactFlow, ReactFlowProvider } from "@xyflow/react";

package/dist/WorkflowBuilder-CPnXEL5J.js

@@ -0,0 +1,555 @@
+"use client";
+import { hn as useCanvasEdges, n as FluidGridsProvider } from "./FluidGridsProvider-dvZSNtSW.js";
+import { H as useFlowStore } from "./node-operation-selection--oy-yEq_.js";
+import { t as Button } from "./button-DG7y_FVJ.js";
+import { d as Input } from "./dialog-Cjb4lB4D.js";
+import { b as Card } from "./TemplateCard-DsC0KNH1.js";
+import { t as cn } from "./cn-QqidFIgr.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { S as FluidGridsMark, x as useNodeSelectedEvent } from "./flow-builder-CZDKRc6f.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Background, Controls, Handle, MarkerType, MiniMap, Position, ReactFlow, ReactFlowProvider, useReactFlow } from "@xyflow/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Toaster } from "sonner";
+import { edgeColor, nodeCategoryColor } from "@burdenoff/fe-libs/shared/utils";
+import { useShallow } from "zustand/shallow";
+import { ThemeProvider } from "@burdenoff/fe-libs/shared/providers/shell";
+import { useTheme, useThemeOrNull } from "@burdenoff/fe-libs/shared/hooks/shell";
+import "@xyflow/react/dist/style.css";
+import { ArrowLeft, Play, Save, Trash2 } from "lucide-react";
+
+// src/theme/EnsureThemeProvider.tsx
+/**
+* Give the SDK's components a fe-libs theme context when the host has none.
+*
+* Several SDK components (the toast host, theme toggles, editors) read the
+* theme through fe-libs `useTheme`, which throws outside a `ThemeProvider`.
+* The Burdenoff app shells always mount one, but a third-party page that
+* renders `<WorkflowBuilder>` or `<FluidGridsRoot>` directly does not. This
+* wrapper mounts the SDK's own provider only in that case: when the host
+* already has a provider, its children render inside the host's context
+* unchanged, so there is never a second provider fighting over the
+* document's theme attributes.
+*/
+function EnsureThemeProvider({ children }) {
+	if (useThemeOrNull()) return /* @__PURE__ */ jsx(Fragment, { children });
+	return /* @__PURE__ */ jsx(ThemeProvider, { children });
+}
+
+// src/builder/components/ui/sonner.tsx
+const Toaster$1 = ({ ...props }) => {
+	const { resolvedTheme = "light" } = useTheme();
+	return /* @__PURE__ */ jsx(Toaster, {
+		theme: resolvedTheme,
+		className: "toaster group",
+		toastOptions: { classNames: {
+			toast: "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
+			description: "group-[.toast]:text-muted-foreground",
+			actionButton: "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
+			cancelButton: "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground"
+		} },
+		...props
+	});
+};
+
+// src/components/WorkflowBuilderCore.tsx
+const defaultEdgeOptions = {
+	type: "smoothstep",
+	markerEnd: {
+		type: MarkerType.ArrowClosed,
+		width: 21,
+		height: 21
+	},
+	style: { stroke: edgeColor("default") }
+};
+const handleStyle = {
+	width: 10,
+	height: 10,
+	background: "var(--color-node-handle-connected)",
+	border: "2px solid var(--color-node-bg)"
+};
+const baseNodeStyle = {
+	padding: "8px 16px",
+	borderRadius: "8px",
+	fontWeight: 500,
+	boxShadow: "var(--shadow-elevation-2)",
+	position: "relative",
+	color: "var(--color-action-primary-text)"
+};
+const NODE_CATEGORY_BY_TYPE = {
+	"trigger:api": "trigger",
+	end: "end",
+	"internal:if": "logic",
+	"internal:switch": "logic",
+	"internal:loop": "loop",
+	"internal:merge": "utility",
+	"internal:set": "data",
+	"internal:filter": "data",
+	"internal:aggregate": "data",
+	"internal:wait": "utility",
+	"internal:noop": "utility",
+	"internal:http": "integration"
+};
+function getNodeColor(type) {
+	return nodeCategoryColor(NODE_CATEGORY_BY_TYPE[type] ?? "default");
+}
+function TriggerNode({ data }) {
+	const tr = useTr();
+	const label = data.label;
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			...baseNodeStyle,
+			background: getNodeColor("trigger:api")
+		},
+		children: [label || tr("fluidgrids.components.workflowBuilderCore.triggerNodeLabel", "API Trigger"), /* @__PURE__ */ jsx(Handle, {
+			type: "source",
+			position: Position.Bottom,
+			style: handleStyle
+		})]
+	});
+}
+function EndNode({ data }) {
+	const tr = useTr();
+	const label = data.label;
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			...baseNodeStyle,
+			background: getNodeColor("end")
+		},
+		children: [/* @__PURE__ */ jsx(Handle, {
+			type: "target",
+			position: Position.Top,
+			style: handleStyle
+		}), label || tr("fluidgrids.components.workflowBuilderCore.endNodeLabel", "End")]
+	});
+}
+function ActionNode({ data, type }) {
+	const tr = useTr();
+	const label = data.label;
+	const color = getNodeColor(type || "default");
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			...baseNodeStyle,
+			background: color,
+			minWidth: 120,
+			textAlign: "center"
+		},
+		children: [
+			/* @__PURE__ */ jsx(Handle, {
+				type: "target",
+				position: Position.Top,
+				style: handleStyle
+			}),
+			label || tr("fluidgrids.components.workflowBuilderCore.actionNodeLabel", "Action"),
+			/* @__PURE__ */ jsx(Handle, {
+				type: "source",
+				position: Position.Bottom,
+				style: handleStyle
+			})
+		]
+	});
+}
+const NODE_TYPES = {
+	"trigger:api": TriggerNode,
+	end: EndNode,
+	"internal:if": ActionNode,
+	"internal:switch": ActionNode,
+	"internal:loop": ActionNode,
+	"internal:merge": ActionNode,
+	"internal:set": ActionNode,
+	"internal:filter": ActionNode,
+	"internal:aggregate": ActionNode,
+	"internal:wait": ActionNode,
+	"internal:noop": ActionNode,
+	"internal:http": ActionNode,
+	"internal:subworkflow": ActionNode,
+	default: ActionNode
+};
+let nodeIdCounter = 0;
+function FlowBuilderInner({ workflow, readonly = false, hideHeader = false, hideSidebar = false, hideLogsPanel = false, onSave, onExecute, onNodeClick, onBack, className }) {
+	const reactFlowInstance = useReactFlow();
+	const tr = useTr();
+	useNodeSelectedEvent();
+	const setWorkflow = useFlowStore((s) => s.actions.setWorkflow);
+	const resetWorkflow = useFlowStore((s) => s.actions.resetWorkflow);
+	const deleteNode = useFlowStore((s) => s.actions.nodes.deleteNode);
+	const setNodes = useFlowStore((s) => s.actions.nodes.setNodes);
+	const [nodes, edges, onNodesChange, onEdgesChange, onConnect] = useFlowStore(useShallow((s) => [
+		s.workflow.nodes,
+		s.workflow.edges,
+		s.actions.nodes.onNodesChange,
+		s.actions.edges.onEdgesChange,
+		s.actions.edges.onConnect
+	]));
+	const canvasEdges = useCanvasEdges(nodes, edges);
+	const [workflowName, setWorkflowName] = useState(workflow?.name || "Untitled Workflow");
+	const [selectedNodeId, setSelectedNodeId] = useState(null);
+	const reactFlowWrapper = useRef(null);
+	useEffect(() => {
+		resetWorkflow();
+		if (workflow) {
+			setWorkflow(workflow);
+			setWorkflowName(workflow.name || "Untitled Workflow");
+		}
+	}, [
+		workflow,
+		resetWorkflow,
+		setWorkflow
+	]);
+	const handleNameChange = (e) => {
+		setWorkflowName(e.target.value);
+		setWorkflow({ name: e.target.value });
+	};
+	const handleSave = () => {
+		const savedWorkflow = {
+			id: workflow?.id || "",
+			workflowKey: workflow?.workflowKey || "",
+			name: workflowName,
+			version: workflow?.version || "1",
+			alias: workflow?.alias,
+			nodes,
+			edges,
+			sidebar: {
+				active: "none",
+				panels: { nodeProperties: { selectedNode: null } }
+			}
+		};
+		onSave?.(savedWorkflow);
+	};
+	const handleExecute = () => {
+		const runId = `run-${Date.now()}`;
+		onExecute?.(runId);
+	};
+	const handleNodeClick = useCallback((_event, node) => {
+		setSelectedNodeId(node.id);
+		onNodeClick?.(node);
+	}, [onNodeClick]);
+	const handlePaneClick = useCallback(() => {
+		setSelectedNodeId(null);
+	}, []);
+	const handleDragOver = useCallback((event) => {
+		event.preventDefault();
+		event.dataTransfer.dropEffect = "copy";
+	}, []);
+	const handleDrop = useCallback((event) => {
+		event.preventDefault();
+		const raw = event.dataTransfer.getData("application/json");
+		if (!raw) return;
+		let payload;
+		try {
+			payload = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		const nodeType = payload.type || payload.id || "default";
+		const label = payload.label || nodeType;
+		const bounds = reactFlowWrapper.current?.getBoundingClientRect();
+		if (!bounds) return;
+		const position = reactFlowInstance.screenToFlowPosition({
+			x: event.clientX - bounds.left,
+			y: event.clientY - bounds.top
+		});
+		nodeIdCounter += 1;
+		const newNode = {
+			id: `${nodeType}-${Date.now()}-${nodeIdCounter}`,
+			type: nodeType,
+			position,
+			data: { label }
+		};
+		const currentNodes = useFlowStore.getState().workflow.nodes;
+		setNodes([...currentNodes, newNode]);
+	}, [reactFlowInstance, setNodes]);
+	const selectedNode = selectedNodeId ? nodes.find((n) => n.id === selectedNodeId) : null;
+	const handleSelectedNodeLabelChange = useCallback((newLabel) => {
+		if (!selectedNodeId) return;
+		const updated = useFlowStore.getState().workflow.nodes.map((n) => n.id === selectedNodeId ? {
+			...n,
+			data: {
+				...n.data,
+				label: newLabel
+			}
+		} : n);
+		setNodes(updated);
+	}, [selectedNodeId, setNodes]);
+	const handleDeleteSelectedNode = useCallback(() => {
+		if (!selectedNode) return;
+		if (selectedNode.deletable === false) return;
+		deleteNode(selectedNode);
+		setSelectedNodeId(null);
+	}, [selectedNode, deleteNode]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex flex-col flex-1 h-full w-full min-h-0", className),
+		children: [
+			!hideHeader && /* @__PURE__ */ jsxs(Card, {
+				className: "h-14 shrink-0 border-0 rounded-none bg-gradient-to-r from-primary/20 to-transparent p-2 flex items-center justify-between border-b",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [onBack && /* @__PURE__ */ jsx(Button, {
+						variant: "ghost",
+						size: "icon",
+						onClick: onBack,
+						children: /* @__PURE__ */ jsx(ArrowLeft, { className: "size-5" })
+					}), /* @__PURE__ */ jsx(Input, {
+						className: "font-semibold max-w-[300px]",
+						value: workflowName,
+						onChange: handleNameChange,
+						placeholder: tr("fluidgrids.components.workflowBuilderCore.workflowNamePlaceholder", "Workflow Name"),
+						disabled: readonly
+					})]
+				}), !readonly && /* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2",
+					children: [/* @__PURE__ */ jsxs(Button, {
+						"data-agent": "confirm",
+						variant: "outline",
+						size: "sm",
+						onClick: handleSave,
+						children: [/* @__PURE__ */ jsx(Save, { className: "size-4 mr-1" }), tr("fluidgrids.components.workflowBuilderCore.save", "Save")]
+					}), /* @__PURE__ */ jsxs(Button, {
+						"data-agent": "confirm",
+						size: "sm",
+						onClick: handleExecute,
+						children: [/* @__PURE__ */ jsx(Play, { className: "size-4 mr-1" }), tr("fluidgrids.components.workflowBuilderCore.run", "Run")]
+					})]
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-1 min-h-0 overflow-hidden",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex-1 h-full relative",
+					ref: reactFlowWrapper,
+					children: [/* @__PURE__ */ jsxs(ReactFlow, {
+						nodes,
+						edges: canvasEdges,
+						onNodesChange: readonly ? void 0 : onNodesChange,
+						onEdgesChange: readonly ? void 0 : onEdgesChange,
+						onConnect: readonly ? void 0 : onConnect,
+						onNodeClick: readonly ? void 0 : handleNodeClick,
+						onPaneClick: handlePaneClick,
+						onDragOver: readonly ? void 0 : handleDragOver,
+						onDrop: readonly ? void 0 : handleDrop,
+						nodeTypes: NODE_TYPES,
+						defaultEdgeOptions,
+						fitView: true,
+						snapToGrid: true,
+						snapGrid: [16, 16],
+						proOptions: { hideAttribution: true },
+						deleteKeyCode: readonly ? null : "Backspace",
+						children: [
+							/* @__PURE__ */ jsx(Background, { gap: 24 }),
+							/* @__PURE__ */ jsx(Controls, {}),
+							/* @__PURE__ */ jsx(MiniMap, {})
+						]
+					}), /* @__PURE__ */ jsx(FluidGridsMark, {})]
+				}), !hideSidebar && !readonly && /* @__PURE__ */ jsxs("div", {
+					className: "w-60 shrink-0 border-l bg-card overflow-y-auto",
+					children: [/* @__PURE__ */ jsx("div", {
+						className: "p-4 border-b",
+						children: /* @__PURE__ */ jsx("div", {
+							className: "text-sm font-semibold",
+							children: tr("fluidgrids.components.workflowBuilderCore.nodePropertiesHeading", "Node Properties")
+						})
+					}), selectedNode ? /* @__PURE__ */ jsxs("div", {
+						className: "p-4 space-y-4",
+						children: [
+							/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("label", {
+								className: "block text-xs font-medium text-muted-foreground mb-1",
+								children: tr("fluidgrids.components.workflowBuilderCore.nodeIdLabel", "Node ID")
+							}), /* @__PURE__ */ jsx("code", {
+								className: "block text-xs bg-muted px-2 py-1 rounded font-mono break-all",
+								children: selectedNode.id
+							})] }),
+							/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("label", {
+								className: "block text-xs font-medium text-muted-foreground mb-1",
+								children: tr("fluidgrids.components.workflowBuilderCore.nodeTypeLabel", "Type")
+							}), /* @__PURE__ */ jsxs("div", {
+								className: "flex items-center gap-2",
+								children: [/* @__PURE__ */ jsx("span", {
+									className: "inline-block w-3 h-3 rounded-full shrink-0",
+									style: { background: getNodeColor(selectedNode.type || "default") }
+								}), /* @__PURE__ */ jsx("code", {
+									className: "text-xs font-mono",
+									children: selectedNode.type
+								})]
+							})] }),
+							/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("label", {
+								className: "block text-xs font-medium text-muted-foreground mb-1",
+								children: tr("fluidgrids.components.workflowBuilderCore.nodeLabelLabel", "Label")
+							}), /* @__PURE__ */ jsx(Input, {
+								value: selectedNode.data?.label ?? "",
+								onChange: (e) => handleSelectedNodeLabelChange(e.target.value),
+								className: "text-sm",
+								placeholder: tr("fluidgrids.components.workflowBuilderCore.nodeLabelPlaceholder", "Node label")
+							})] }),
+							/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("label", {
+								className: "block text-xs font-medium text-muted-foreground mb-1",
+								children: tr("fluidgrids.components.workflowBuilderCore.positionLabel", "Position")
+							}), /* @__PURE__ */ jsxs("div", {
+								className: "grid grid-cols-2 gap-2 text-xs text-muted-foreground",
+								children: [/* @__PURE__ */ jsxs("div", { children: [
+									"X:",
+									" ",
+									/* @__PURE__ */ jsx("span", {
+										className: "font-mono",
+										children: Math.round(selectedNode.position.x)
+									})
+								] }), /* @__PURE__ */ jsxs("div", { children: [
+									"Y:",
+									" ",
+									/* @__PURE__ */ jsx("span", {
+										className: "font-mono",
+										children: Math.round(selectedNode.position.y)
+									})
+								] })]
+							})] }),
+							/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("label", {
+								className: "block text-xs font-medium text-muted-foreground mb-1",
+								children: tr("fluidgrids.components.workflowBuilderCore.connectionsLabel", "Connections")
+							}), /* @__PURE__ */ jsx("div", {
+								className: "text-xs text-muted-foreground",
+								children: (() => {
+									const inbound = edges.filter((e) => e.target === selectedNode.id);
+									const outbound = edges.filter((e) => e.source === selectedNode.id);
+									return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs("div", { children: [
+										inbound.length,
+										" inbound, ",
+										outbound.length,
+										" outbound"
+									] }) });
+								})()
+							})] }),
+							selectedNode.deletable !== false && /* @__PURE__ */ jsx("div", {
+								className: "pt-2 border-t",
+								children: /* @__PURE__ */ jsxs(Button, {
+									variant: "destructive",
+									size: "sm",
+									className: "w-full",
+									onClick: handleDeleteSelectedNode,
+									children: [/* @__PURE__ */ jsx(Trash2, { className: "size-4 mr-1" }), tr("fluidgrids.components.workflowBuilderCore.deleteNode", "Delete Node")]
+								})
+							})
+						]
+					}) : /* @__PURE__ */ jsxs("div", {
+						className: "p-4",
+						children: [/* @__PURE__ */ jsx("p", {
+							className: "text-xs text-muted-foreground",
+							children: tr("fluidgrids.components.workflowBuilderCore.noSelectionHint", "Click a node on the canvas to view and edit its properties.")
+						}), /* @__PURE__ */ jsx("p", {
+							className: "text-xs text-muted-foreground mt-2",
+							children: tr("fluidgrids.components.workflowBuilderCore.dragPaletteHint", "Drag nodes from the palette on the left to add them to the workflow.")
+						})]
+					})]
+				})]
+			}),
+			!hideLogsPanel && /* @__PURE__ */ jsxs("div", {
+				className: "h-32 border-t bg-card p-2",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "text-sm font-medium mb-2",
+					children: tr("fluidgrids.components.workflowBuilderCore.executionLogsHeading", "Execution Logs")
+				}), /* @__PURE__ */ jsx("p", {
+					className: "text-xs text-muted-foreground",
+					children: tr("fluidgrids.components.workflowBuilderCore.executionLogsEmpty", "Execution logs will appear here when you run the workflow")
+				})]
+			})
+		]
+	});
+}
+/**
+* Lightweight, local-only workflow canvas.
+*
+* Host events (`FluidGridsEventMap`): reports `node:selected` exactly like the
+* full builder canvas. Save and Run only hand data to `onSave` / `onExecute`
+* and call no backend, so it emits no `workflow:saved`, `run:started` or
+* `error` events: the host performs those actions and already knows their
+* outcome. Works without a host `ThemeProvider`.
+*/
+function WorkflowBuilderCore(props) {
+	return /* @__PURE__ */ jsx(EnsureThemeProvider, { children: /* @__PURE__ */ jsxs(ReactFlowProvider, { children: [/* @__PURE__ */ jsx(FlowBuilderInner, { ...props }), /* @__PURE__ */ jsx(Toaster$1, {
+		richColors: true,
+		position: "bottom-center",
+		duration: 2e3
+	})] }) });
+}
+
+// src/components/WorkflowBuilder.tsx
+/**
+* WorkflowBuilder - Standalone workflow builder component with Apollo client support
+*
+* Use this component when you want to embed the workflow builder in any React app.
+* You can either:
+* 1. Provide pre-configured Apollo clients (workspaceClient + globalClient) - Recommended
+* 2. Provide URLs and let the component create clients internally
+*
+* It needs no host `ThemeProvider` (one is mounted only when the page has
+* none). Host events: `onEvent` receives `node:selected`; Save and Run are
+* local (they call `onSave` / `onExecute` and no backend), so they emit no
+* `workflow:saved` / `run:started`. See `WorkflowBuilderCore`.
+*
+* @example Dual Client Injection (Recommended)
+* ```tsx
+* import { createFluidGridsClients } from '@fluidgrids/fe-sdk';
+*
+* const { workspaceClient, globalClient } = createFluidGridsClients({
+*   workspaceApiUrl: 'http://localhost:4000/workspaces/graphql',
+*   globalApiUrl: 'http://localhost:4000/global/graphql',
+*   authToken: token,
+*   workspaceId: 'ws-123',
+* });
+*
+* <WorkflowBuilder
+*   workspaceClient={workspaceClient}
+*   globalClient={globalClient}
+*   workspaceId="ws-123"
+*   onSave={(workflow) => console.log(workflow)}
+* />
+* ```
+*
+* @example URL-based (Simpler, less flexible)
+* ```tsx
+* <WorkflowBuilder
+*   apiGatewayUrl="http://localhost:4000/workspaces/graphql"
+*   globalApiUrl="http://localhost:4000/global/graphql"
+*   authToken={token}
+*   workspaceId="ws-123"
+*   onSave={(workflow) => console.log(workflow)}
+* />
+* ```
+*/
+function WorkflowBuilder({ workflowId, workflowVersion, initialWorkflow, apiGatewayUrl, globalApiUrl, authToken, workspaceId, tenantId, productId, userId, workspaceToken, organizationId, workspaceClient, globalClient, theme, auth, onEvent, ...coreProps }) {
+	const workflow = initialWorkflow || createDefaultWorkflow(workflowId, workflowVersion);
+	return /* @__PURE__ */ jsx(FluidGridsProvider, {
+		apiGatewayUrl,
+		globalApiUrl,
+		authToken,
+		workspaceId,
+		tenantId,
+		productId,
+		userId,
+		workspaceToken,
+		organizationId,
+		workspaceClient,
+		globalClient,
+		theme,
+		auth,
+		onEvent,
+		children: /* @__PURE__ */ jsx(WorkflowBuilderCore, {
+			workflow,
+			...coreProps
+		})
+	});
+}
+function createDefaultWorkflow(id, version) {
+	return {
+		id: id || `workflow-${Date.now()}`,
+		workflowKey: id || `workflow-${Date.now()}`,
+		name: "Untitled Workflow",
+		version: version || "1",
+		nodes: [],
+		edges: [],
+		sidebar: {
+			active: "store-browse",
+			panels: { nodeProperties: { selectedNode: null } }
+		}
+	};
+}
+
+export { WorkflowBuilderCore as n, EnsureThemeProvider as r, WorkflowBuilder as t };