@burdenoff/fluidgrids-fe-sdk 2026.1105.2 → 2026.1105.3

package/dist/chunk-5DVP2UYH.js

@@ -0,0 +1,1924 @@
+import { editorSeverity } from './chunk-Y7FKJJMF.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { nanoid } from 'nanoid/non-secure';
+import { addEdge, applyEdgeChanges, applyNodeChanges, useUpdateNodeInternals, Position, useStore, useNodeId, getConnectedEdges, Handle } from '@xyflow/react';
+import { create } from 'zustand';
+import { produce } from 'immer';
+import * as React from 'react';
+import { useCallback, useMemo, useEffect } from 'react';
+import { Icon } from '@iconify/react';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { nodeCategoryColor, chartSeriesColor, chartSeriesIndex } from '@burdenoff/fe-libs/shared/utils';
+
+// 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;
+    noteEdit();
+  }
+  function noteEdit() {
+    set((s) => ({ editRevision: s.editRevision + 1 }));
+  }
+  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 },
+    editRevision: 0,
+    loadGeneration: 0,
+    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) => {
+        const current = get().workflow;
+        if (workflow.name !== void 0 && workflow.name !== current.name || workflow.alias !== void 0 && workflow.alias !== current.alias) {
+          noteEdit();
+        }
+        const nodes = workflow.nodes?.map(
+          (node) => node.data === void 0 || node.data === null ? { ...node, data: {} } : node
+        );
+        set((state) => ({
+          workflow: {
+            ...state.workflow,
+            ...workflow,
+            ...nodes ? { nodes } : {}
+          }
+        }));
+      },
+      resetWorkflow: () => {
+        resetCoalescing();
+        set((s) => ({
+          loadGeneration: s.loadGeneration + 1,
+          workflow: {
+            id: nanoid(),
+            workflowKey: "",
+            name: "",
+            version: "",
+            alias: "",
+            dbId: void 0,
+            status: void 0,
+            codeBuildId: 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();
+          noteEdit();
+          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();
+          noteEdit();
+          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 startsDrag = changes.some(
+              (c) => c.type === "position" && c.dragging === true && !get().workflow.nodes.find((n) => n.id === c.id)?.dragging
+            );
+            if (startsDrag) noteEdit();
+            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;
+}
+function isImageIcon(icon) {
+  return !!icon && (/^https?:\/\//.test(icon) || icon.startsWith("data:"));
+}
+function NodeTypeIcon({
+  icon,
+  alt,
+  className,
+  fallbackIcon = "mynaui:puzzle"
+}) {
+  if (isImageIcon(icon)) {
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: icon,
+        alt: alt ?? "",
+        className: cn("object-contain", className)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(Icon, { icon: icon || fallbackIcon, className });
+}
+var PROVIDER_ACCENTS = [
+  [/gmail|google/, "var(--color-chart-5)"],
+  [/slack/, "var(--color-chart-3)"],
+  [/github|gitlab/, nodeCategoryColor("utility")],
+  [/stripe/, "var(--color-chart-12)"],
+  [/discord|telegram/, "var(--color-chart-1)"],
+  [/notion/, "var(--color-text-primary)"],
+  [/whatsapp|sheet|excel/, "var(--color-chart-7)"],
+  [/openai|anthropic|claude/, nodeCategoryColor("ai")],
+  [/twilio/, "var(--color-chart-10)"],
+  [/http|api|webhook|rest/, nodeCategoryColor("integration")],
+  [/db|sql|postgres|mysql|mongo/, nodeCategoryColor("data")]
+];
+function nodeAccent(key) {
+  const k = (key || "").toLowerCase();
+  for (const [re, color] of PROVIDER_ACCENTS) if (re.test(k)) return color;
+  return chartSeriesColor(chartSeriesIndex(k));
+}
+function tint(color, pct = 14) {
+  return `color-mix(in srgb, ${color} ${pct}%, transparent)`;
+}
+function InlineEditableLabel({
+  value,
+  placeholder,
+  editing,
+  onStartEdit,
+  onCommit,
+  onCancel,
+  className,
+  inputClassName
+}) {
+  const tr = useTr();
+  const [draft, setDraft] = React.useState(value);
+  const inputRef = React.useRef(null);
+  React.useEffect(() => {
+    if (!editing) return;
+    setDraft(value);
+    const raf = requestAnimationFrame(() => {
+      inputRef.current?.focus();
+      inputRef.current?.select();
+    });
+    return () => cancelAnimationFrame(raf);
+  }, [editing, value]);
+  if (editing) {
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref: inputRef,
+        value: draft,
+        onChange: (e) => setDraft(e.target.value),
+        onClick: (e) => e.stopPropagation(),
+        onDoubleClick: (e) => e.stopPropagation(),
+        onMouseDown: (e) => e.stopPropagation(),
+        onKeyDown: (e) => {
+          e.stopPropagation();
+          if (e.key === "Enter") {
+            e.preventDefault();
+            onCommit(draft.trim());
+          } else if (e.key === "Escape") {
+            e.preventDefault();
+            onCancel();
+          }
+        },
+        onBlur: () => onCommit(draft.trim()),
+        className: cn(
+          "min-w-0 flex-1 rounded border border-primary/50 bg-card px-1 text-inherit outline-none",
+          inputClassName
+        )
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn("cursor-text truncate", className),
+      title: tr(
+        "fluidgrids.builder.nodeCard.renameTooltip",
+        "Double-click or press F2 to rename"
+      ),
+      onDoubleClick: (e) => {
+        e.stopPropagation();
+        onStartEdit();
+      },
+      children: value || placeholder
+    }
+  );
+}
+var NodeCard = React.forwardRef(
+  ({
+    className,
+    selected = false,
+    executionStatus = "idle",
+    itemCount,
+    isTrigger = false,
+    accent = nodeCategoryColor("action"),
+    onSettings,
+    onExecute,
+    onDelete,
+    isExecuting = false,
+    infoButton,
+    disabled = false,
+    onToggleDisabled,
+    children,
+    ...props
+  }, ref) => {
+    const tr = useTr();
+    const [hovered, setHovered] = React.useState(false);
+    const statusRing = executionStatus === "running" ? "ring-2 ring-[var(--color-status-success-border)] animate-pulse-border" : executionStatus === "success" ? "ring-2 ring-[var(--color-status-success-border)]" : executionStatus === "error" ? "ring-2 ring-[var(--color-status-error-border)]" : "";
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "group/node relative",
+        onMouseEnter: () => setHovered(true),
+        onMouseLeave: () => setHovered(false),
+        children: [
+          itemCount !== void 0 && itemCount > 0 && /* @__PURE__ */ jsx("div", { className: "absolute -top-7 left-1/2 -translate-x-1/2 z-10", children: /* @__PURE__ */ jsxs("div", { className: "rounded-full border border-border bg-card px-2 py-0.5 text-[10px] font-medium text-muted-foreground shadow-sm", children: [
+            itemCount,
+            " ",
+            itemCount !== 1 ? tr("fluidgrids.builder.nodeCard.itemCountOther", "items") : tr("fluidgrids.builder.nodeCard.itemCountOne", "item")
+          ] }) }),
+          (onSettings || onExecute || onDelete || onToggleDisabled || infoButton) && /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: cn(
+                "absolute right-1 z-20 flex items-center gap-0.5 rounded-lg border border-border bg-card p-0.5 shadow-md transition-all duration-150",
+                hovered ? "pointer-events-auto opacity-100" : "pointer-events-none opacity-0"
+              ),
+              style: {
+                // Inline offset (not a `-top-*` class) so it survives the host
+                // app's Tailwind scan of fe-sdk source, which drops some spacing
+                // utilities. The toolbar is ~30px tall; top:-15px centers it on
+                // the card's top edge (half outside, half over the card).
+                top: -15,
+                transform: hovered ? "translateY(0)" : "translateY(4px)"
+              },
+              onClick: (e) => e.stopPropagation(),
+              onDoubleClick: (e) => e.stopPropagation(),
+              children: [
+                onSettings && /* @__PURE__ */ jsx(
+                  ToolbarButton,
+                  {
+                    title: tr(
+                      "fluidgrids.builder.nodeCard.configureTooltip",
+                      "Configure"
+                    ),
+                    onClick: onSettings,
+                    children: /* @__PURE__ */ jsx(Icon, { icon: "lucide:sliders-horizontal", className: "size-4" })
+                  }
+                ),
+                onExecute && /* @__PURE__ */ jsx(
+                  ToolbarButton,
+                  {
+                    "data-agent": "confirm",
+                    title: tr(
+                      "fluidgrids.builder.nodeCard.executeTooltip",
+                      "Execute step"
+                    ),
+                    onClick: onExecute,
+                    disabled: isExecuting,
+                    children: isExecuting ? /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "svg-spinners:ring-resize",
+                        className: "size-4 text-[var(--color-status-success-text)]"
+                      }
+                    ) : /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "mdi:play",
+                        className: "size-4 text-[var(--color-status-success-text)]"
+                      }
+                    )
+                  }
+                ),
+                infoButton,
+                onToggleDisabled && /* @__PURE__ */ jsx(
+                  ToolbarButton,
+                  {
+                    title: disabled ? tr(
+                      "fluidgrids.builder.nodeCard.enableTooltip",
+                      "Enable node"
+                    ) : tr(
+                      "fluidgrids.builder.nodeCard.disableTooltip",
+                      "Disable node (skip on run)"
+                    ),
+                    onClick: onToggleDisabled,
+                    children: /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: disabled ? "mdi:power" : "mdi:power-off",
+                        className: cn(
+                          "size-4",
+                          disabled ? "text-[var(--color-status-warning-text)]" : "text-muted-foreground"
+                        )
+                      }
+                    )
+                  }
+                ),
+                onDelete && /* @__PURE__ */ jsx(
+                  ToolbarButton,
+                  {
+                    title: tr(
+                      "fluidgrids.builder.nodeCard.deleteTooltip",
+                      "Delete"
+                    ),
+                    onClick: onDelete,
+                    children: /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "mynaui:trash",
+                        className: "size-4 text-[var(--color-status-error-text)]"
+                      }
+                    )
+                  }
+                )
+              ]
+            }
+          ),
+          disabled && /* @__PURE__ */ jsx("div", { className: "absolute -top-2 right-2 z-10", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1 rounded-full border border-[var(--color-status-warning-border)] bg-[var(--color-status-warning-bg)] px-1.5 py-0.5 text-[9px] font-semibold uppercase tracking-wide text-[var(--color-status-warning-text)] shadow-sm", children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:power-off", className: "size-2.5" }),
+            tr("fluidgrids.builder.nodeCard.disabledBadge", "Disabled")
+          ] }) }),
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              ref,
+              "data-selected": selected,
+              className: cn(
+                "relative w-72 rounded-xl border border-border bg-card shadow-sm will-change-transform",
+                statusRing,
+                executionStatus === "success" && "animate-success-glow",
+                disabled && "opacity-50 grayscale-[0.6]",
+                className
+              ),
+              style: {
+                borderTop: `3px solid ${accent}`,
+                transition: "transform 0.15s ease, box-shadow 0.15s ease",
+                transform: hovered ? "translateY(-2px)" : "none",
+                boxShadow: hovered ? "var(--shadow-float)" : void 0
+              },
+              ...props,
+              children: [
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "pointer-events-none absolute -inset-0.5 transition-opacity duration-150",
+                    style: {
+                      borderRadius: 14,
+                      opacity: selected || hovered ? 1 : 0,
+                      boxShadow: selected ? `0 0 0 2px ${accent}, 0 0 0 5px ${tint(accent, 18)}` : `0 0 0 2px ${accent}`
+                    }
+                  }
+                ),
+                isTrigger && /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "absolute -top-2 -left-2 z-10 flex size-5 items-center justify-center rounded-full shadow-md ring-2 ring-card",
+                    style: { backgroundColor: "var(--color-status-success-text)" },
+                    children: /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "mdi:lightning-bolt",
+                        className: "size-3",
+                        style: { color: "var(--color-status-success-text-inverse)" }
+                      }
+                    )
+                  }
+                ),
+                children
+              ]
+            }
+          ),
+          executionStatus === "success" && /* @__PURE__ */ jsx(StatusCorner, { icon: "mdi:check", tone: "success" }),
+          executionStatus === "error" && /* @__PURE__ */ jsx(StatusCorner, { icon: "mdi:close", tone: "error" }),
+          executionStatus === "running" && /* @__PURE__ */ jsx(StatusCorner, { icon: "svg-spinners:ring-resize", tone: "success" })
+        ]
+      }
+    );
+  }
+);
+NodeCard.displayName = "NodeCard";
+function ToolbarButton({
+  title,
+  onClick,
+  disabled,
+  children,
+  "data-agent": agent
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      "data-agent": agent,
+      title,
+      disabled,
+      onClick: (e) => {
+        e.stopPropagation();
+        onClick?.();
+      },
+      className: "flex size-6 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground disabled:opacity-50",
+      children
+    }
+  );
+}
+function StatusCorner({
+  icon,
+  tone
+}) {
+  const bg = tone === "success" ? "var(--color-status-success-bg)" : "var(--color-status-error-bg)";
+  const fg = tone === "success" ? "var(--color-status-success-text-inverse)" : "var(--color-status-error-text-inverse)";
+  return /* @__PURE__ */ jsx("div", { className: "absolute -bottom-1.5 -right-1.5 z-10", children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "rounded-full p-0.5 shadow-md animate-in zoom-in duration-200",
+      style: { backgroundColor: bg },
+      children: /* @__PURE__ */ jsx(Icon, { icon, className: "size-3", style: { color: fg } })
+    }
+  ) });
+}
+var NodeCardHeader = React.forwardRef(
+  ({
+    icon,
+    appName,
+    accentKey,
+    missingCredentials = false,
+    label,
+    isRenaming = false,
+    onStartRename,
+    onCommitRename,
+    onCancelRename
+  }, ref) => {
+    const tr = useTr();
+    const accent = nodeAccent(accentKey);
+    return /* @__PURE__ */ jsxs("div", { ref, className: "flex items-center gap-2.5 px-3 pb-3 pt-4", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "flex size-8 shrink-0 items-center justify-center rounded-lg",
+          style: {
+            backgroundColor: tint(accent, 13),
+            color: accent,
+            border: `1px solid ${tint(accent, 26)}`
+          },
+          children: /* @__PURE__ */ jsx(NodeTypeIcon, { icon, alt: appName, className: "size-[18px]" })
+        }
+      ),
+      onStartRename && onCommitRename && onCancelRename ? /* @__PURE__ */ jsx(
+        InlineEditableLabel,
+        {
+          value: label ?? "",
+          placeholder: appName,
+          editing: isRenaming,
+          onStartEdit: onStartRename,
+          onCommit: onCommitRename,
+          onCancel: onCancelRename,
+          className: "min-w-0 flex-1 truncate text-[11px] font-semibold uppercase tracking-wide text-muted-foreground",
+          inputClassName: "text-[11px] font-semibold uppercase tracking-wide"
+        }
+      ) : /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate text-[11px] font-semibold uppercase tracking-wide text-muted-foreground", children: label || appName }),
+      missingCredentials && /* @__PURE__ */ jsx(
+        "span",
+        {
+          title: tr(
+            "fluidgrids.builder.nodeCard.missingCredentialsTooltip",
+            "Credentials not configured"
+          ),
+          className: "flex items-center text-[var(--color-status-warning-text)]",
+          "aria-label": tr(
+            "fluidgrids.builder.nodeCard.missingCredentialsAriaLabel",
+            "Credentials not configured"
+          ),
+          children: /* @__PURE__ */ jsx(Icon, { icon: "lucide:alert-triangle", className: "size-4" })
+        }
+      )
+    ] });
+  }
+);
+NodeCardHeader.displayName = "NodeCardHeader";
+var NodeCardBody = React.forwardRef(
+  ({ operationName, description }, ref) => {
+    const tr = useTr();
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        className: "rounded-b-xl border-t border-border/60 px-3 pb-3 pt-2.5",
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "text-[10px] font-semibold uppercase tracking-wider text-muted-foreground", children: tr("fluidgrids.builder.nodeCard.operationLabel", "Operation") }),
+          /* @__PURE__ */ jsx("div", { className: "mt-0.5 truncate font-mono text-[13px] font-bold text-card-foreground", children: operationName }),
+          description ? /* @__PURE__ */ jsx("p", { className: "mt-1 line-clamp-2 text-xs leading-snug text-muted-foreground", children: description }) : null
+        ]
+      }
+    );
+  }
+);
+NodeCardBody.displayName = "NodeCardBody";
+
+// src/builder/components/flow-builder/components/blocks/nodes/node/handle-spec.ts
+function isDynamicSpec(spec) {
+  return !!spec && !Array.isArray(spec) && typeof spec.fromStateRecord === "string";
+}
+var DEFAULT_HANDLES = [{ id: "source", label: "" }];
+var BUILTIN_OUTPUT_HANDLES = {
+  "internal:wait-for-signal": [
+    { id: "received", label: "Received", tone: "success" },
+    { id: "timedOut", label: "Timed out", tone: "warning" }
+  ]
+};
+function resolveOutputHandles(data, nodeType) {
+  const nodeData = data?.nodeData;
+  const operationsBlob = Array.isArray(nodeData?.operations) ? void 0 : nodeData?.operations;
+  const operationList = Array.isArray(nodeData?.operations) ? nodeData.operations : operationsBlob?.operations ?? [];
+  const operationName = typeof data?.operation_name === "string" ? data.operation_name : void 0;
+  const operationSpec = operationName ? operationList.find((op) => op?.name === operationName)?.outputHandles : void 0;
+  const spec = operationSpec ?? nodeData?.outputHandles ?? operationsBlob?.outputHandles;
+  if (!spec)
+    return nodeType && BUILTIN_OUTPUT_HANDLES[nodeType] || DEFAULT_HANDLES;
+  if (isDynamicSpec(spec)) {
+    const args = data?.args;
+    const record = args?.state?.[spec.fromStateRecord] ?? data?.[spec.fromStateRecord] ?? {};
+    const dynamic = Object.entries(record).filter(([, handleId]) => typeof handleId === "string" && handleId).map(([label, handleId]) => ({ id: handleId, label }));
+    return [...dynamic, ...spec.extra ?? []];
+  }
+  if (spec.length === 0) return DEFAULT_HANDLES;
+  return spec;
+}
+var DEFAULT_INPUT_HANDLES = [{ id: "target", label: "" }];
+function resolveInputHandles(data) {
+  const nodeData = data?.nodeData;
+  const spec = nodeData?.inputHandles ?? nodeData?.operations?.inputHandles;
+  if (!Array.isArray(spec) || spec.length === 0) return DEFAULT_INPUT_HANDLES;
+  return spec;
+}
+function outputHandlesSpacerHeight(count) {
+  return count > 2 ? (count - 2) * 26 : 0;
+}
+
+// src/builder/components/code-workflow/code-workflow-state.ts
+var CODE_WORKFLOW_NODE_TYPE = "internal:code-workflow";
+var WAIT_FOR_SIGNAL_NODE_TYPE = "internal:wait-for-signal";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readCodeWorkflowState(state) {
+  const s = isRecord3(state) ? state : {};
+  const waitForCompletion = s.waitForCompletion !== false;
+  const policy = s.parentClosePolicy;
+  return {
+    workflowFn: str(s.workflowFn),
+    taskQueue: str(s.taskQueue) ?? "managed",
+    waitForCompletion,
+    parentClosePolicy: policy === "TERMINATE" || policy === "ABANDON" || policy === "REQUEST_CANCEL" ? policy : waitForCompletion ? "TERMINATE" : "ABANDON",
+    timeout: typeof s.timeout === "number" && s.timeout > 0 ? s.timeout : 0
+  };
+}
+function readSignalName(state) {
+  return isRecord3(state) ? str(state.signalName) : void 0;
+}
+function typeLabel(schema) {
+  if (!isRecord3(schema)) return "any";
+  if (Array.isArray(schema.enum)) return schema.enum.map(String).join(" | ");
+  if (Array.isArray(schema.type)) return schema.type.map(String).join(" | ");
+  if (schema.type === "array") return `${typeLabel(schema.items)}[]`;
+  return typeof schema.type === "string" ? schema.type : "any";
+}
+function interfaceFields(schema) {
+  if (!isRecord3(schema) || !isRecord3(schema.properties)) return [];
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.map(String) : []
+  );
+  return Object.entries(schema.properties).map(([name, property]) => ({
+    name,
+    type: typeLabel(property),
+    required: required.has(name),
+    description: isRecord3(property) ? str(property.description) : void 0
+  }));
+}
+function interfaceHandlers(iface) {
+  const of = (key) => isRecord3(iface) && isRecord3(iface[key]) ? Object.keys(iface[key]).sort() : [];
+  return {
+    signals: of("signals"),
+    queries: of("queries"),
+    updates: of("updates")
+  };
+}
+function childRunIdOf(nodeStates, nodeId) {
+  const states = nodeStates.filter((state) => state.nodeId === nodeId);
+  for (let i = states.length - 1; i >= 0; i -= 1) {
+    const state = states[i];
+    const fromColumn = str(state.childRunId);
+    if (fromColumn) return fromColumn;
+    if (isRecord3(state.output)) {
+      const fromOutput = str(state.output._childRunId);
+      if (fromOutput) return fromOutput;
+    }
+  }
+  return void 0;
+}
+function sourceLanguageOf(path) {
+  if (/\.(ts|tsx|mts|cts)$/.test(path)) return "typescript";
+  if (/\.py$/.test(path)) return "python";
+  if (/\.json$/.test(path)) return "json";
+  return "text";
+}
+function isEditableSourcePath(path) {
+  if (path.startsWith(".fluidgrids/")) return false;
+  const language = sourceLanguageOf(path);
+  return language === "typescript" || language === "json";
+}
+function projectLanguage(files) {
+  return files.some(
+    (file) => file.path.startsWith("workflows/") && file.path.endsWith(".py")
+  ) ? "python" : "typescript";
+}
+function changedSourceFiles(loaded, current) {
+  return loaded.filter((file) => {
+    const now = current[file.path];
+    return now !== void 0 && now !== file.content;
+  }).map((file) => ({ path: file.path, content: current[file.path] })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function defaultSourcePath(files, entry) {
+  if (entry && files.some((file) => file.path === entry)) return entry;
+  return files.find(
+    (file) => file.path.startsWith("workflows/") && isEditableSourcePath(file.path)
+  )?.path ?? files[0]?.path;
+}
+function diagnosticsByPath(diagnostics) {
+  const result = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    const path = diagnostic.path?.replace(/^\.\//, "") ?? "";
+    const list = result.get(path) ?? [];
+    list.push({
+      line: diagnostic.line,
+      column: diagnostic.column,
+      severity: editorSeverity(diagnostic.severity),
+      code: diagnostic.code,
+      message: diagnostic.message
+    });
+    result.set(path, list);
+  }
+  return result;
+}
+
+// src/builder/contants/symbols.ts
+var NODE_TYPE_DRAG_DATA_FORMAT = "application/flow-builder.node-type";
+var NODE_OPERATION_DRAG_DATA_FORMAT = "application/flow-builder.node-operation";
+var STICKY_NOTE_TYPE = "sticky-note";
+
+// src/builder/lib/sticky-notes.ts
+function isStickyNode(node) {
+  return node?.type === STICKY_NOTE_TYPE;
+}
+function partitionStickyNotes(nodes) {
+  return {
+    nodes: nodes.filter((n) => !isStickyNode(n)),
+    stickyNotes: nodes.filter((n) => isStickyNode(n))
+  };
+}
+function mergeStickyNotes(def) {
+  const nodes = Array.isArray(def.nodes) ? def.nodes : [];
+  const stickies = Array.isArray(def.stickyNotes) ? def.stickyNotes : [];
+  const seen = new Set(nodes.map((n) => n.id));
+  return [...nodes, ...stickies.filter((s) => s?.id && !seen.has(s.id))];
+}
+
+// src/builder/lib/node-operation-selection.ts
+function resolveOperationName(selectedOperation, fallback) {
+  return typeof selectedOperation === "string" && selectedOperation.trim() ? selectedOperation : fallback;
+}
+function canRenderOperationPanel(selectedOperation, supportedOperations) {
+  const operationName = resolveOperationName(selectedOperation, "");
+  return operationName === "" || supportedOperations.includes(operationName);
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRecord3(value) {
+  return isRecord4(value) ? value : void 0;
+}
+function readOperations(value) {
+  const operations = Array.isArray(value) ? value : readRecord3(value)?.operations;
+  return Array.isArray(operations) ? operations : [];
+}
+function synchronizeOperationUpdate(currentData, updates, registeredOperations) {
+  const operationName = resolveOperationName(updates.operation_name, "");
+  if (!operationName || operationName === currentData.operation_name)
+    return updates;
+  const manifest = readRecord3(updates.nodeData ?? currentData.nodeData);
+  const operations = [
+    ...readOperations(manifest?.operations),
+    ...readOperations(registeredOperations)
+  ];
+  const selected = readRecord3(
+    operations.find(
+      (operation) => readRecord3(operation)?.name === operationName
+    )
+  );
+  return {
+    ...updates,
+    operation_type: typeof selected?.type === "string" ? selected.type : updates.operation_type,
+    nodeData: { ...manifest, operations: selected ? [selected] : [] }
+  };
+}
+function CustomHandle({
+  className,
+  isConnectable,
+  accent,
+  ...props
+}) {
+  const { nodeLookup, edges } = useStore(({ nodeLookup: nodeLookup2, edges: edges2 }) => ({
+    nodeLookup: nodeLookup2,
+    edges: edges2
+  }));
+  const nodeId = useNodeId();
+  const isHandleConnectable = useMemo(() => {
+    if (!nodeId) return false;
+    const node = nodeLookup.get(nodeId);
+    if (!node) return false;
+    const connectedEdges = getConnectedEdges([node], edges);
+    if (typeof isConnectable === "function")
+      return isConnectable({ node, connectedEdges });
+    if (typeof isConnectable === "number")
+      return connectedEdges.length < isConnectable;
+    return isConnectable;
+  }, [edges, isConnectable, nodeId, nodeLookup]);
+  return /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(
+    Handle,
+    {
+      className: cn(
+        "cursor-crosshair transition-transform hover:scale-110",
+        !accent && "size-3 border-2 border-card-foreground/40 hover:border-primary/50",
+        className
+      ),
+      isConnectable: isHandleConnectable,
+      style: accent ? {
+        width: 14,
+        height: 14,
+        borderRadius: "50%",
+        background: "var(--color-node-bg)",
+        border: `2.5px solid ${accent}`,
+        boxShadow: `0 0 0 3px color-mix(in srgb, ${accent} 12%, transparent)`
+      } : void 0,
+      ...props
+    }
+  ) });
+}
+var TONE_COLORS = {
+  success: "var(--color-status-success-text)",
+  error: "var(--color-status-error-text)",
+  warning: "var(--color-status-warning-text)",
+  info: "var(--color-status-info-text)",
+  neutral: "var(--color-text-muted)"
+};
+function HandlePlusStub({
+  nodeId,
+  handleId,
+  color,
+  isConnectable,
+  isOnlyHandle,
+  anchor
+}) {
+  const tr = useTr();
+  const startAttach = useFlowStore((s) => s.actions.pendingConnection.start);
+  const isArmedHere = useFlowStore(
+    (s) => s.workflow.pendingConnection?.nodeId === nodeId && s.workflow.pendingConnection?.handleId === handleId
+  );
+  const hasOutgoing = useStore(
+    (s) => s.edges.some(
+      (e) => e.source === nodeId && (e.sourceHandle === handleId || isOnlyHandle && (e.sourceHandle === null || e.sourceHandle === void 0))
+    )
+  );
+  if (hasOutgoing || isConnectable === false) return null;
+  const containerStyle = anchor === "card" ? {
+    left: "100%",
+    top: "50%",
+    transform: "translateY(-50%)",
+    marginLeft: 10
+  } : { left: 10, top: 0, transform: "translateY(-50%)" };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "nodrag nopan absolute flex items-center",
+      style: { ...containerStyle, pointerEvents: "none", zIndex: 5 },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              width: 16,
+              borderTop: `1.5px dashed ${color}`,
+              opacity: 0.5
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            title: tr(
+              "fluidgrids.builder.outputHandles.addNextNodeTooltip",
+              "Add next node"
+            ),
+            "aria-label": `Add next node from ${handleId}`,
+            "data-testid": `handle-plus-${nodeId}-${handleId}`,
+            onClick: (e) => {
+              e.stopPropagation();
+              startAttach({ nodeId, handleId });
+            },
+            onDoubleClick: (e) => e.stopPropagation(),
+            onMouseDown: (e) => e.stopPropagation(),
+            className: "cursor-pointer transition-transform hover:scale-110",
+            style: {
+              pointerEvents: "all",
+              width: 16,
+              height: 16,
+              borderRadius: "50%",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              border: `1.5px solid ${color}`,
+              background: isArmedHere ? color : "var(--color-node-bg)",
+              color: isArmedHere ? "var(--color-node-bg)" : color,
+              boxShadow: isArmedHere ? `0 0 0 3px color-mix(in srgb, ${color} 22%, transparent)` : `0 0 0 2px color-mix(in srgb, ${color} 10%, transparent)`,
+              transition: "transform .12s ease, background .12s ease, color .12s ease"
+            },
+            children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "size-2.5" })
+          }
+        )
+      ]
+    }
+  );
+}
+function OutputHandles({
+  nodeId,
+  handles,
+  accent,
+  isConnectable
+}) {
+  const updateNodeInternals = useUpdateNodeInternals();
+  const signature = useMemo(
+    () => handles.map((h) => h.id).join("|"),
+    [handles]
+  );
+  useEffect(() => {
+    updateNodeInternals(nodeId);
+  }, [nodeId, signature, updateNodeInternals]);
+  if (handles.length === 1) {
+    const handle = handles[0];
+    const color = handle.tone ? TONE_COLORS[handle.tone] : accent;
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        CustomHandle,
+        {
+          type: "source",
+          id: handle.id,
+          position: Position.Right,
+          isConnectable,
+          accent: color
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        HandlePlusStub,
+        {
+          nodeId,
+          handleId: handle.id,
+          color,
+          isConnectable,
+          isOnlyHandle: true,
+          anchor: "card"
+        }
+      )
+    ] });
+  }
+  const total = handles.length;
+  return /* @__PURE__ */ jsx(Fragment, { children: handles.map((handle, index) => {
+    const top = `${(index + 1) / (total + 1) * 100}%`;
+    const color = handle.tone ? TONE_COLORS[handle.tone] : accent;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "absolute right-0",
+        style: { top, transform: "translateY(-50%)" },
+        children: [
+          /* @__PURE__ */ jsx(
+            CustomHandle,
+            {
+              type: "source",
+              id: handle.id,
+              position: Position.Right,
+              isConnectable,
+              accent: color
+            }
+          ),
+          handle.label && /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "pointer-events-none absolute whitespace-nowrap text-[10px] font-medium leading-none",
+              style: { color, left: 12, bottom: 8 },
+              title: handle.label,
+              children: handle.label
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            HandlePlusStub,
+            {
+              nodeId,
+              handleId: handle.id,
+              color,
+              isConnectable,
+              isOnlyHandle: false,
+              anchor: "point"
+            }
+          )
+        ]
+      },
+      handle.id
+    );
+  }) });
+}
+function InputHandles({
+  nodeId,
+  handles,
+  accent,
+  isConnectable
+}) {
+  const updateNodeInternals = useUpdateNodeInternals();
+  const signature = useMemo(
+    () => handles.map((h) => h.id).join("|"),
+    [handles]
+  );
+  useEffect(() => {
+    updateNodeInternals(nodeId);
+  }, [nodeId, signature, updateNodeInternals]);
+  if (handles.length === 1) {
+    const handle = handles[0];
+    return /* @__PURE__ */ jsx(
+      CustomHandle,
+      {
+        type: "target",
+        id: handle.id,
+        position: Position.Left,
+        isConnectable,
+        accent: handle.tone ? TONE_COLORS[handle.tone] : accent
+      }
+    );
+  }
+  const total = handles.length;
+  return /* @__PURE__ */ jsx(Fragment, { children: handles.map((handle, index) => {
+    const top = `${(index + 1) / (total + 1) * 100}%`;
+    const color = handle.tone ? TONE_COLORS[handle.tone] : accent;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "absolute left-0",
+        style: { top, transform: "translateY(-50%)" },
+        children: [
+          /* @__PURE__ */ jsx(
+            CustomHandle,
+            {
+              type: "target",
+              id: handle.id,
+              position: Position.Left,
+              isConnectable,
+              accent: color
+            }
+          ),
+          handle.label && /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "pointer-events-none absolute whitespace-nowrap text-[10px] font-medium leading-none",
+              style: {
+                color,
+                right: "100%",
+                marginRight: 16,
+                top: "50%",
+                transform: "translateY(-50%)"
+              },
+              title: handle.label,
+              children: handle.label
+            }
+          )
+        ]
+      },
+      handle.id
+    );
+  }) });
+}
+function LogicNodeCard({
+  title,
+  subtitle,
+  icon,
+  accent,
+  selected,
+  executionStatus,
+  itemCount,
+  isTrigger,
+  isExecuting,
+  nodeId,
+  inputHandles,
+  outputHandles,
+  isConnectable,
+  onClick,
+  onDoubleClick,
+  onSettings,
+  onExecute,
+  onDelete,
+  infoButton,
+  disabled = false,
+  onToggleDisabled,
+  isRenaming = false,
+  onStartRename,
+  onCommitRename,
+  onCancelRename
+}) {
+  const minHeight = Math.max(
+    64,
+    Math.max(outputHandles.length, inputHandles.length) * 30 + 24
+  );
+  return /* @__PURE__ */ jsxs(
+    NodeCard,
+    {
+      className: "w-48",
+      "data-selected": selected,
+      selected,
+      onClick,
+      onDoubleClick,
+      executionStatus,
+      itemCount,
+      isTrigger,
+      accent,
+      isExecuting,
+      onSettings,
+      onExecute,
+      onDelete,
+      infoButton,
+      disabled,
+      onToggleDisabled,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "flex flex-col items-center justify-center gap-1 px-3 py-3 text-center",
+            style: { minHeight },
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "flex size-9 items-center justify-center rounded-lg bg-muted", children: /* @__PURE__ */ jsx(Icon, { icon, className: "size-5", style: { color: accent } }) }),
+              onStartRename && onCommitRename && onCancelRename ? /* @__PURE__ */ jsx(
+                InlineEditableLabel,
+                {
+                  value: title,
+                  placeholder: title,
+                  editing: isRenaming,
+                  onStartEdit: onStartRename,
+                  onCommit: onCommitRename,
+                  onCancel: onCancelRename,
+                  className: "max-w-full truncate text-sm font-semibold leading-tight",
+                  inputClassName: "text-sm font-semibold text-center"
+                }
+              ) : /* @__PURE__ */ jsx("span", { className: "max-w-full truncate text-sm font-semibold leading-tight", children: title }),
+              subtitle && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "max-w-full truncate font-mono text-[10px] text-muted-foreground",
+                  title: subtitle,
+                  children: subtitle
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          InputHandles,
+          {
+            nodeId,
+            handles: inputHandles,
+            accent,
+            isConnectable
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          OutputHandles,
+          {
+            nodeId,
+            handles: outputHandles,
+            accent,
+            isConnectable
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { CODE_WORKFLOW_NODE_TYPE, InputHandles, LogicNodeCard, NODE_OPERATION_DRAG_DATA_FORMAT, NODE_TYPE_DRAG_DATA_FORMAT, NodeCard, NodeCardBody, NodeCardHeader, NodeTypeIcon, OutputHandles, STICKY_NOTE_TYPE, WAIT_FOR_SIGNAL_NODE_TYPE, canRenderOperationPanel, changedSourceFiles, childRunIdOf, defaultSourcePath, diagnosticsByPath, interfaceFields, interfaceHandlers, isEditableSourcePath, isImageIcon, isNodeTrigger, isTriggerOperation, mergeStickyNotes, nodeAccent, outputHandlesSpacerHeight, partitionStickyNotes, projectLanguage, readCodeWorkflowState, readSignalName, resolveInputHandles, resolveOperationName, resolveOutputHandles, sourceLanguageOf, synchronizeOperationUpdate, useFlowStore, useIsValidConnection };