@burdenoff/fluidgrids-fe-sdk 2026.1022.13 → 2026.1022.17

package/dist/chunk-VI2RFS65.js

@@ -1,880 +0,0 @@
-import { nanoid } from 'nanoid/non-secure';
-import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
-import { create } from 'zustand';
-import { produce } from 'immer';
-import { useCallback } from 'react';
-
-// src/builder/lib/node-role.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readRecord(value) {
-  return isRecord(value) ? value : void 0;
-}
-function readString(value) {
-  return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
-function operationRole(operation) {
-  const metadata = readRecord(operation);
-  const role = readString(metadata?.role);
-  if (role) return role === "trigger" ? "trigger" : "action";
-  const type = readString(metadata?.type);
-  if (type === "trigger" || type === "subscription" || readString(metadata?.delivery)) {
-    return "trigger";
-  }
-  if (type === "action" || type === "query" || type === "mutation") {
-    return "action";
-  }
-  return void 0;
-}
-function isTriggerOperation(operation) {
-  return operationRole(operation) === "trigger";
-}
-function isLegacyTriggerType(type) {
-  return type === "trigger" || type.startsWith("trigger:") || type.startsWith("internal:schedule") || type.startsWith("internal:webhook") || type.startsWith("internal:api") || type.startsWith("internal:form") || type.startsWith("internal:mcp") || type.endsWith("_trigger") || type.endsWith("Trigger") || type.endsWith("-trigger");
-}
-function getSelectedOperationRole(nodeType, nodeData) {
-  const data = readRecord(nodeData);
-  const operationName = data?.operation_name;
-  if (typeof operationName !== "string" || !operationName.trim())
-    return void 0;
-  const manifest = readRecord(data?.nodeData);
-  const declared = manifest?.operations;
-  const operations = Array.isArray(declared) ? declared : readRecord(declared)?.operations;
-  const operation = Array.isArray(operations) ? operations.find(
-    (entry) => readRecord(entry)?.name === operationName
-  ) : void 0;
-  const selectedRole = operationRole(operation) ?? operationRole({ type: data?.operation_type });
-  if (selectedRole) return selectedRole;
-  if (nodeType === "integration/channel" || nodeType?.startsWith("store/")) {
-    return operationName.startsWith("on") ? "trigger" : "action";
-  }
-  return void 0;
-}
-function isNodeTrigger(node) {
-  const data = readRecord(node.data);
-  const selectedRole = getSelectedOperationRole(node.type, data);
-  if (selectedRole) return selectedRole === "trigger";
-  const state = readRecord(readRecord(data?.args)?.state);
-  for (const legacyRole of [data?.role, state?.role]) {
-    const explicitRole = readString(legacyRole);
-    if (explicitRole === "trigger" || explicitRole === "action") {
-      return explicitRole === "trigger";
-    }
-  }
-  const savedRole = operationRole({ type: data?.operation_type });
-  if (savedRole) return savedRole === "trigger";
-  const type = node.type ?? "";
-  if (isLegacyTriggerType(type)) return true;
-  const manifest = readRecord(data?.nodeData);
-  if (!data?.operation_name && Array.isArray(manifest?.kind) && manifest.kind.includes("trigger")) {
-    return true;
-  }
-  return false;
-}
-
-// src/builder/hooks/use-is-valid-connection.ts
-function isLoopController(source) {
-  const type = source?.type?.toLowerCase();
-  const disabled = source?.data?.disabled === true || source !== void 0 && "disabled" in source && source.disabled === true;
-  return (type === "internal:loop" || type === "loop") && !disabled;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readRecord2(value) {
-  return isRecord2(value) ? value : void 0;
-}
-function loopBodyHandle(source) {
-  const node = readRecord2(source);
-  const data = readRecord2(node?.data);
-  const parameters = {
-    ...data,
-    ...readRecord2(node?.config),
-    ...readRecord2(readRecord2(data?.args)?.state),
-    ...readRecord2(readRecord2(node?.args)?.state)
-  };
-  return typeof parameters.loopHandle === "string" && parameters.loopHandle ? parameters.loopHandle : "loop";
-}
-function isLoopBodyEdge(edge, nodes) {
-  const source = nodes.find((node) => node.id === edge.source);
-  return source !== void 0 && isLoopController(source) && edge.sourceHandle === loopBodyHandle(source);
-}
-function adjacency(edges) {
-  const outgoing = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const targets = outgoing.get(edge.source) ?? /* @__PURE__ */ new Set();
-    targets.add(edge.target);
-    outgoing.set(edge.source, targets);
-  }
-  return outgoing;
-}
-function reachable(starts, outgoing, blocked = /* @__PURE__ */ new Set()) {
-  const pending = [...starts];
-  const visited = /* @__PURE__ */ new Set();
-  while (pending.length > 0) {
-    const current = pending.pop();
-    if (current === void 0 || visited.has(current) || blocked.has(current))
-      continue;
-    visited.add(current);
-    pending.push(...outgoing.get(current) ?? []);
-  }
-  return visited;
-}
-function controlledReturns(nodes, edges) {
-  const outgoing = adjacency(edges);
-  const incomingTargets = new Set(edges.map((edge) => edge.target));
-  const entries = nodes.filter((node) => !incomingTargets.has(node.id) || isNodeTrigger(node)).map((node) => node.id);
-  const returns = /* @__PURE__ */ new Set();
-  for (const controller of nodes.filter(isLoopController)) {
-    const bodyHandle = loopBodyHandle(controller);
-    const controllerEdges = edges.filter(
-      (edge) => edge.source === controller.id
-    );
-    const outside = reachable(
-      [
-        ...entries,
-        ...controllerEdges.filter((edge) => edge.sourceHandle !== bodyHandle).map((edge) => edge.target)
-      ],
-      outgoing,
-      /* @__PURE__ */ new Set([controller.id])
-    );
-    const body = reachable(
-      controllerEdges.filter((edge) => edge.sourceHandle === bodyHandle).map((edge) => edge.target),
-      outgoing,
-      /* @__PURE__ */ new Set([controller.id, ...outside])
-    );
-    for (const edge of edges) {
-      if (edge.target === controller.id && body.has(edge.source))
-        returns.add(edge);
-    }
-  }
-  return returns;
-}
-function isValidWorkflowConnection(nodes, edges, connection) {
-  if (connection.target === connection.source) return false;
-  const candidates = [...edges, connection];
-  const previousReturns = controlledReturns(nodes, edges);
-  const nextReturns = controlledReturns(nodes, candidates);
-  const outgoing = adjacency(
-    candidates.filter((edge) => !nextReturns.has(edge))
-  );
-  const invalidated = [connection, ...previousReturns].filter(
-    (edge) => !nextReturns.has(edge)
-  );
-  return invalidated.every(
-    (edge) => !reachable([edge.target], outgoing).has(edge.source)
-  );
-}
-function useIsValidConnection(nodes, edges) {
-  return useCallback(
-    (connection) => isValidWorkflowConnection(nodes, edges, connection),
-    [nodes, edges]
-  );
-}
-
-// src/builder/stores/flow-store.ts
-var HISTORY_LIMIT = 100;
-var CLONE_OFFSET = 48;
-function cloneValue(value) {
-  try {
-    return structuredClone(value);
-  } catch {
-    return JSON.parse(JSON.stringify(value));
-  }
-}
-var TAGS = [
-  { value: "marketing", label: "Marketing", color: "var(--color-chart-5)" },
-  { value: "support", label: "Support", color: "var(--color-chart-5)" },
-  { value: "lead", label: "Lead", color: "var(--color-chart-4)" },
-  { value: "new", label: "New", color: "var(--color-chart-7)" }
-];
-var INITIAL_EXECUTION = {
-  isExecuting: false,
-  executingNodeId: null,
-  currentRunId: null,
-  sourceRun: null,
-  stepPlan: null,
-  logs: [],
-  selectedLogId: null,
-  panelExpanded: false,
-  nodeStatuses: {},
-  nodeItemCounts: {},
-  followRequest: null
-};
-var INITIAL_HISTORY = { past: [], future: [] };
-var useFlowStore = create()((set, get) => {
-  let lastCheckpointKind = null;
-  let lastCheckpointAt = 0;
-  function pushCheckpoint(kind, coalesce) {
-    const now = Date.now();
-    const isCoalesced = coalesce && kind === lastCheckpointKind && now - lastCheckpointAt < 800;
-    if (!isCoalesced) {
-      const state = get();
-      const snapshot = {
-        nodes: cloneValue(state.workflow.nodes),
-        edges: cloneValue(state.workflow.edges)
-      };
-      set((s) => ({
-        history: {
-          past: [...s.history.past, snapshot].slice(-HISTORY_LIMIT),
-          future: []
-        }
-      }));
-    } else if (get().history.future.length > 0) {
-      set((s) => ({ history: { ...s.history, future: [] } }));
-    }
-    lastCheckpointKind = kind;
-    lastCheckpointAt = now;
-  }
-  const REMOVAL_KINDS = /* @__PURE__ */ new Set(["nodes:remove", "edges:remove"]);
-  const SAME_ACTION_WINDOW_MS = 150;
-  function joinsPrecedingRemoval(kind) {
-    return lastCheckpointKind !== null && lastCheckpointKind !== kind && REMOVAL_KINDS.has(kind) && REMOVAL_KINDS.has(lastCheckpointKind) && Date.now() - lastCheckpointAt < SAME_ACTION_WINDOW_MS;
-  }
-  function resetCoalescing() {
-    lastCheckpointKind = null;
-    lastCheckpointAt = 0;
-  }
-  return {
-    tags: TAGS,
-    history: { ...INITIAL_HISTORY },
-    workflow: {
-      id: nanoid(),
-      workflowKey: "",
-      name: "",
-      version: "",
-      alias: "",
-      edges: [],
-      nodes: [],
-      ndv: null,
-      quickConfig: null,
-      pendingConnection: null,
-      renamingNodeId: null,
-      sidebar: {
-        active: "none",
-        panels: {
-          nodeProperties: {
-            selectedNode: null
-          }
-        }
-      }
-    },
-    execution: { ...INITIAL_EXECUTION },
-    actions: {
-      saveWorkflow: () => {
-        const { workflow } = get();
-        const { id, name, version, alias, dbId, status, nodes, edges } = workflow;
-        set({ workflow });
-        return { id, name, version, alias, dbId, status, nodes, edges };
-      },
-      setWorkflow: (workflow) => {
-        set((state) => ({
-          workflow: {
-            ...state.workflow,
-            ...workflow
-          }
-        }));
-      },
-      resetWorkflow: () => {
-        resetCoalescing();
-        set(() => ({
-          workflow: {
-            id: nanoid(),
-            workflowKey: "",
-            name: "",
-            version: "",
-            alias: "",
-            dbId: void 0,
-            status: void 0,
-            edges: [],
-            nodes: [],
-            ndv: null,
-            quickConfig: null,
-            pendingConnection: null,
-            renamingNodeId: null,
-            sidebar: {
-              active: "none",
-              panels: {
-                nodeProperties: {
-                  selectedNode: null
-                }
-              }
-            }
-          },
-          // Wipe run state too — resetWorkflow fires when the builder loads a
-          // (different) workflow, so the previous workflow's logs must not carry
-          // over into this one's Logs panel.
-          execution: { ...INITIAL_EXECUTION },
-          // A freshly loaded workflow must not be undo-able back to empty —
-          // undo/redo only ever applies within the currently open workflow.
-          history: { ...INITIAL_HISTORY }
-        }));
-      },
-      history: {
-        undo: () => {
-          const { past, future } = get().history;
-          const previous = past[past.length - 1];
-          if (!previous) return;
-          const { nodes, edges } = get().workflow;
-          const current = {
-            nodes: cloneValue(nodes),
-            edges: cloneValue(edges)
-          };
-          resetCoalescing();
-          set((s) => ({
-            workflow: {
-              ...s.workflow,
-              nodes: previous.nodes,
-              edges: previous.edges
-            },
-            history: {
-              past: past.slice(0, -1),
-              future: [current, ...future].slice(0, HISTORY_LIMIT)
-            }
-          }));
-        },
-        redo: () => {
-          const { past, future } = get().history;
-          const next = future[0];
-          if (!next) return;
-          const { nodes, edges } = get().workflow;
-          const current = {
-            nodes: cloneValue(nodes),
-            edges: cloneValue(edges)
-          };
-          resetCoalescing();
-          set((s) => ({
-            workflow: {
-              ...s.workflow,
-              nodes: next.nodes,
-              edges: next.edges
-            },
-            history: {
-              past: [...past, current].slice(-HISTORY_LIMIT),
-              future: future.slice(1)
-            }
-          }));
-        },
-        clear: () => {
-          resetCoalescing();
-          set({ history: { ...INITIAL_HISTORY } });
-        }
-      },
-      ndv: {
-        // Opening the full NDV supersedes the floating quick-config panel — the
-        // two edit the same node data, so only one should be visible at a time.
-        open: (node) => set((state) => ({
-          workflow: { ...state.workflow, ndv: node, quickConfig: null }
-        })),
-        close: () => set((state) => ({
-          workflow: { ...state.workflow, ndv: null }
-        }))
-      },
-      quickConfig: {
-        open: (node) => set((state) => ({
-          workflow: { ...state.workflow, quickConfig: node }
-        })),
-        close: () => set((state) => ({
-          workflow: { ...state.workflow, quickConfig: null }
-        }))
-      },
-      pendingConnection: {
-        start: (connection) => set((state) => ({
-          workflow: {
-            ...state.workflow,
-            pendingConnection: connection,
-            sidebar: { ...state.workflow.sidebar, active: "store-browse" }
-          }
-        })),
-        clear: () => set((state) => ({
-          workflow: { ...state.workflow, pendingConnection: null }
-        }))
-      },
-      sidebar: {
-        // Leaving the store panel abandons any armed "+" attach mode — the
-        // pending handle would otherwise silently capture a later insert.
-        setActivePanel: (panel) => set((state) => ({
-          workflow: {
-            ...state.workflow,
-            sidebar: { ...state.workflow.sidebar, active: panel },
-            ...panel !== "store-browse" ? { pendingConnection: null } : {}
-          }
-        })),
-        showNodePropertiesOf: (node) => {
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              pendingConnection: null,
-              sidebar: {
-                ...state.workflow.sidebar,
-                active: "node-properties",
-                panels: {
-                  ...state.workflow.sidebar.panels,
-                  nodeProperties: {
-                    ...state.workflow.sidebar.panels.nodeProperties,
-                    selectedNode: node
-                  }
-                }
-              }
-            }
-          }));
-        },
-        panels: {
-          nodeProperties: {
-            setSelectedNode: (node) => set((state) => ({
-              workflow: {
-                ...state.workflow,
-                sidebar: {
-                  ...state.workflow.sidebar,
-                  panels: {
-                    ...state.workflow.sidebar.panels,
-                    nodeProperties: {
-                      ...state.workflow.sidebar.panels.nodeProperties,
-                      selectedNode: node
-                    }
-                  }
-                }
-              }
-            }))
-          },
-          tags: {
-            setTags: (tags) => set({ tags }),
-            createTag: (tag) => set((state) => ({
-              tags: [...state.tags, tag]
-            })),
-            updateTag: (tag, newTag) => set((state) => ({
-              tags: state.tags.map(
-                (f) => f.value === tag.value ? newTag : f
-              )
-            })),
-            deleteTag: (tag) => set((state) => ({
-              tags: state.tags.filter((f) => f.value !== tag.value)
-            }))
-          }
-        }
-      },
-      nodes: {
-        onNodesChange: (changes) => {
-          const removedIds = new Set(
-            changes.filter(
-              (c) => c.type === "remove"
-            ).map((c) => c.id)
-          );
-          const addedCount = changes.filter((c) => c.type === "add").length;
-          if (removedIds.size > 0) {
-            const stillPresent = get().workflow.nodes.some(
-              (n) => removedIds.has(n.id)
-            );
-            if (stillPresent && !joinsPrecedingRemoval("nodes:remove")) {
-              pushCheckpoint("nodes:remove", false);
-            }
-          } else if (addedCount > 0) {
-            pushCheckpoint("nodes:add", false);
-          } else {
-            const finishedDragIds = changes.filter(
-              (c) => c.type === "position" && c.dragging === false
-            );
-            const actuallyMoved = finishedDragIds.some((c) => {
-              const current = get().workflow.nodes.find((n) => n.id === c.id);
-              return current && c.position && (current.position.x !== c.position.x || current.position.y !== c.position.y);
-            });
-            if (actuallyMoved) pushCheckpoint("nodes:move", false);
-          }
-          set(
-            (state) => produce(state, (draft) => {
-              const updatedNodes = applyNodeChanges(
-                changes,
-                draft.workflow.nodes
-              );
-              draft.workflow.nodes = updatedNodes;
-            })
-          );
-        },
-        setNodes: (nodes, opts) => {
-          if (!opts?.skipHistory) {
-            pushCheckpoint(
-              opts?.historyKind ?? "nodes:set",
-              !!opts?.historyKind
-            );
-          }
-          set({ workflow: { ...get().workflow, nodes } });
-        },
-        deleteNode: (node) => {
-          const exists = get().workflow.nodes.some((n) => n.id === node.id);
-          if (exists) pushCheckpoint("nodes:delete", false);
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: state.workflow.nodes.filter((n) => n.id !== node.id),
-              // Drop any UI state pointing at the removed node.
-              ...state.workflow.quickConfig?.nodeId === node.id ? { quickConfig: null } : {},
-              ...state.workflow.pendingConnection?.nodeId === node.id ? { pendingConnection: null } : {}
-            }
-          }));
-        },
-        deleteNodes: (nodes) => {
-          const ids = new Set(nodes.map((n) => n.id));
-          if (ids.size === 0) return;
-          const anyExist = get().workflow.nodes.some((n) => ids.has(n.id));
-          if (anyExist) pushCheckpoint("nodes:delete", false);
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: state.workflow.nodes.filter((n) => !ids.has(n.id)),
-              edges: state.workflow.edges.filter(
-                (e) => !ids.has(e.source) && !ids.has(e.target)
-              ),
-              ...state.workflow.quickConfig && ids.has(state.workflow.quickConfig.nodeId) ? { quickConfig: null } : {},
-              ...state.workflow.pendingConnection && ids.has(state.workflow.pendingConnection.nodeId) ? { pendingConnection: null } : {}
-            }
-          }));
-        },
-        duplicateNodes: (nodeIds) => {
-          const { nodes, edges } = get().workflow;
-          const idSet = new Set(nodeIds);
-          const selected = nodes.filter((n) => idSet.has(n.id));
-          if (selected.length === 0) return;
-          pushCheckpoint("nodes:duplicate", false);
-          const idMap = /* @__PURE__ */ new Map();
-          const clones = selected.map((n) => {
-            const newId = nanoid();
-            idMap.set(n.id, newId);
-            const cloned = cloneValue(n);
-            return {
-              ...cloned,
-              id: newId,
-              position: {
-                x: cloned.position.x + CLONE_OFFSET,
-                y: cloned.position.y + CLONE_OFFSET
-              },
-              selected: true
-            };
-          });
-          const clonedEdges = edges.filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((e) => {
-            const cloned = cloneValue(e);
-            return {
-              ...cloned,
-              id: nanoid(),
-              source: idMap.get(e.source),
-              target: idMap.get(e.target),
-              selected: false
-            };
-          });
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: [
-                ...state.workflow.nodes.map(
-                  (n) => idSet.has(n.id) ? { ...n, selected: false } : n
-                ),
-                ...clones
-              ],
-              edges: [...state.workflow.edges, ...clonedEdges]
-            }
-          }));
-        },
-        pasteNodes: (payload) => {
-          const pasteNodesIn = payload.nodes ?? [];
-          if (pasteNodesIn.length === 0) return;
-          pushCheckpoint("nodes:paste", false);
-          const idMap = /* @__PURE__ */ new Map();
-          const clones = pasteNodesIn.map((n) => {
-            const newId = nanoid();
-            idMap.set(n.id, newId);
-            const cloned = cloneValue(n);
-            return {
-              ...cloned,
-              id: newId,
-              position: {
-                x: (cloned.position?.x ?? 0) + CLONE_OFFSET,
-                y: (cloned.position?.y ?? 0) + CLONE_OFFSET
-              },
-              selected: true
-            };
-          });
-          const clonedEdges = (payload.edges ?? []).filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((e) => {
-            const cloned = cloneValue(e);
-            return {
-              ...cloned,
-              id: nanoid(),
-              source: idMap.get(e.source),
-              target: idMap.get(e.target),
-              selected: false
-            };
-          });
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: [
-                ...state.workflow.nodes.map((n) => ({ ...n, selected: false })),
-                ...clones
-              ],
-              edges: [...state.workflow.edges, ...clonedEdges]
-            }
-          }));
-        },
-        toggleDisabled: (nodeId) => {
-          const { nodes, edges } = get().workflow;
-          const updatedNodes = nodes.map((node) => {
-            if (node.id !== nodeId) return node;
-            const data = node.data ?? {};
-            return {
-              ...node,
-              data: { ...data, disabled: !(data.disabled === true) }
-            };
-          });
-          const breaksLoop = edges.some(
-            (edge) => edge.source === nodeId && isLoopBodyEdge(edge, nodes) && !isValidWorkflowConnection(updatedNodes, edges, edge)
-          );
-          if (breaksLoop) return false;
-          pushCheckpoint("nodes:disable", false);
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: updatedNodes
-            }
-          }));
-          return true;
-        },
-        renameNode: (nodeId, label) => {
-          pushCheckpoint("nodes:rename", false);
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              nodes: state.workflow.nodes.map(
-                (n) => n.id === nodeId ? { ...n, data: { ...n.data ?? {}, label } } : n
-              ),
-              renamingNodeId: null
-            }
-          }));
-        },
-        startRename: (nodeId) => {
-          set((state) => ({
-            workflow: { ...state.workflow, renamingNodeId: nodeId }
-          }));
-        },
-        endRename: () => {
-          set((state) => ({
-            workflow: { ...state.workflow, renamingNodeId: null }
-          }));
-        }
-      },
-      edges: {
-        onEdgesChange: (changes) => {
-          const removedIds = new Set(
-            changes.filter(
-              (c) => c.type === "remove"
-            ).map((c) => c.id)
-          );
-          if (removedIds.size > 0) {
-            const stillPresent = get().workflow.edges.some(
-              (e) => removedIds.has(e.id)
-            );
-            if (stillPresent && !joinsPrecedingRemoval("edges:remove")) {
-              pushCheckpoint("edges:remove", false);
-            }
-          } else if (changes.some((c) => c.type === "add")) {
-            pushCheckpoint("edges:add", false);
-          }
-          set(
-            (state) => produce(state, (draft) => {
-              const updatedEdges = applyEdgeChanges(
-                changes,
-                draft.workflow.edges
-              );
-              draft.workflow.edges = updatedEdges;
-            })
-          );
-        },
-        onConnect: (connection) => {
-          pushCheckpoint("edges:connect", false);
-          const edge = {
-            ...connection,
-            id: nanoid(),
-            type: "deletable"
-          };
-          set({
-            workflow: {
-              ...get().workflow,
-              edges: addEdge(edge, get().workflow.edges)
-            }
-          });
-        },
-        setEdges: (edges, opts) => {
-          if (!opts?.skipHistory) {
-            pushCheckpoint(
-              opts?.historyKind ?? "edges:set",
-              !!opts?.historyKind
-            );
-          }
-          set({ workflow: { ...get().workflow, edges } });
-        },
-        deleteEdge: (edge) => {
-          const exists = get().workflow.edges.some((e) => e.id === edge.id);
-          if (exists) pushCheckpoint("edges:delete", false);
-          set((state) => ({
-            workflow: {
-              ...state.workflow,
-              edges: state.workflow.edges.filter((e) => e.id !== edge.id)
-            }
-          }));
-        }
-      },
-      execution: {
-        startExecution: (nodeId, runId, metadata) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              isExecuting: true,
-              executingNodeId: nodeId,
-              currentRunId: runId,
-              sourceRun: metadata ? { runId, ...metadata } : { runId, workflowKey: "", version: "" },
-              panelExpanded: true,
-              nodeStatuses: {
-                ...state.execution.nodeStatuses,
-                [nodeId]: "running"
-              }
-            }
-          }));
-        },
-        setRunMetadata: (metadata) => {
-          set((state) => {
-            if (state.execution.currentRunId !== metadata.runId && state.execution.sourceRun?.runId !== metadata.runId) {
-              return state;
-            }
-            return {
-              execution: {
-                ...state.execution,
-                currentRunId: metadata.runId,
-                sourceRun: metadata
-              }
-            };
-          });
-        },
-        setStepPlan: (plan) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              stepPlan: plan
-            }
-          }));
-        },
-        addLog: (log) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              logs: [...state.execution.logs, log],
-              selectedLogId: log.id
-            }
-          }));
-        },
-        updateLog: (logId, updates) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              logs: state.execution.logs.map(
-                (log) => log.id === logId ? { ...log, ...updates } : log
-              )
-            }
-          }));
-        },
-        setNodeStatus: (nodeId, status) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              nodeStatuses: {
-                ...state.execution.nodeStatuses,
-                [nodeId]: status
-              }
-            }
-          }));
-        },
-        setNodeItemCount: (nodeId, count) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              nodeItemCounts: {
-                ...state.execution.nodeItemCounts,
-                [nodeId]: count
-              }
-            }
-          }));
-        },
-        selectLog: (logId) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              selectedLogId: logId
-            }
-          }));
-        },
-        togglePanel: () => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              panelExpanded: !state.execution.panelExpanded
-            }
-          }));
-        },
-        clearLogs: () => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              logs: [],
-              stepPlan: null,
-              currentRunId: null,
-              sourceRun: null,
-              selectedLogId: null,
-              nodeStatuses: {},
-              nodeItemCounts: {}
-            }
-          }));
-        },
-        completeExecution: () => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              isExecuting: false,
-              executingNodeId: null
-            }
-          }));
-        },
-        requestFollowRun: (runId, triggerNodeId) => {
-          set((state) => ({
-            execution: {
-              ...state.execution,
-              followRequest: { runId, triggerNodeId }
-            }
-          }));
-        },
-        clearFollowRequest: () => {
-          set((state) => ({
-            execution: { ...state.execution, followRequest: null }
-          }));
-        },
-        loadDebugRun: (runId, logs, metadata) => {
-          const nodeStatuses = {};
-          for (const log of logs) {
-            nodeStatuses[log.nodeId] = log.status === "completed" ? "success" : log.status === "failed" ? "error" : log.status === "running" ? "running" : "idle";
-          }
-          set(() => ({
-            execution: {
-              ...INITIAL_EXECUTION,
-              currentRunId: runId,
-              sourceRun: metadata ? { runId, ...metadata } : { runId, workflowKey: "", version: "" },
-              logs,
-              nodeStatuses,
-              panelExpanded: true
-            }
-          }));
-        }
-      }
-    }
-  };
-});
-if (typeof window !== "undefined" && import.meta.env?.DEV) {
-  window.__fgFlowStore = useFlowStore;
-}
-
-export { isNodeTrigger, isTriggerOperation, useFlowStore, useIsValidConnection };