@genfeedai/workflow-ui 0.2.2 → 0.2.4

package/dist/{chunk-R727OFBR.mjs → chunk-GPYIIWD5.mjs}

@@ -1,7 +1,7 @@
 import { temporal } from 'zundo';
 import { create } from 'zustand';
 import { NODE_DEFINITIONS, CONNECTION_RULES } from '@genfeedai/types';
-import { addEdge, applyEdgeChanges, applyNodeChanges } from '@xyflow/react';
+import { applyNodeChanges, applyEdgeChanges, addEdge } from '@xyflow/react';
 import { nanoid } from 'nanoid';
 
 // src/stores/workflow/helpers/equality.ts
@@ -24,7 +24,8 @@ function nodeEquals(a, b) {
   if (a === b) return true;
   if (a.id !== b.id) return false;
   if (a.type !== b.type) return false;
-  if (a.position.x !== b.position.x || a.position.y !== b.position.y) return false;
+  if (a.position.x !== b.position.x || a.position.y !== b.position.y)
+    return false;
   if (a.width !== b.width || a.height !== b.height) return false;
   const aData = a.data;
   const bData = b.data;
@@ -68,34 +69,34 @@ function groupEquals(a, b) {
 
 // src/stores/workflow/slices/chatSlice.ts
 var createChatSlice = (set, get) => ({
-  chatMessages: [],
-  isChatOpen: false,
   addChatMessage: (role, content) => {
     set((state) => ({
       chatMessages: [
         ...state.chatMessages,
         {
+          content,
           id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
           role,
-          content,
           timestamp: Date.now()
         }
       ]
     }));
   },
+  applyChatEditOperations: (operations) => {
+    const state = get();
+    state.captureSnapshot();
+    return state.applyEditOperations(operations);
+  },
+  chatMessages: [],
   clearChatMessages: () => {
     set({ chatMessages: [] });
   },
-  toggleChat: () => {
-    set((state) => ({ isChatOpen: !state.isChatOpen }));
-  },
+  isChatOpen: false,
   setChatOpen: (open) => {
     set({ isChatOpen: open });
   },
-  applyChatEditOperations: (operations) => {
-    const state = get();
-    state.captureSnapshot();
-    return state.applyEditOperations(operations);
+  toggleChat: () => {
+    set((state) => ({ isChatOpen: !state.isChatOpen }));
   }
 });
 function generateId() {
@@ -111,23 +112,48 @@ function getHandleType(nodeType, handleId, direction) {
 
 // src/stores/workflow/slices/edgeSlice.ts
 var createEdgeSlice = (set, get) => ({
-  onNodesChange: (changes) => {
-    const hasMeaningfulChange = changes.some(
-      (change) => change.type === "add" || change.type === "remove" || change.type === "replace"
+  findCompatibleHandle: (sourceNodeId, sourceHandleId, targetNodeId) => {
+    const { nodes, edges } = get();
+    const sourceNode = nodes.find((n) => n.id === sourceNodeId);
+    const targetNode = nodes.find((n) => n.id === targetNodeId);
+    if (!sourceNode || !targetNode) return null;
+    const sourceType = getHandleType(
+      sourceNode.type,
+      sourceHandleId,
+      "source"
     );
-    set((state) => ({
-      nodes: applyNodeChanges(changes, state.nodes),
-      ...hasMeaningfulChange && { isDirty: true }
-    }));
+    if (!sourceType) return null;
+    const targetDef = NODE_DEFINITIONS[targetNode.type];
+    if (!targetDef) return null;
+    const existingTargetHandles = new Set(
+      edges.filter((e) => e.target === targetNodeId).map((e) => e.targetHandle)
+    );
+    for (const input of targetDef.inputs) {
+      const hasExistingConnection = existingTargetHandles.has(input.id);
+      if (hasExistingConnection && !input.multiple) continue;
+      if (CONNECTION_RULES[sourceType]?.includes(input.type)) {
+        return input.id;
+      }
+    }
+    return null;
   },
-  onEdgesChange: (changes) => {
-    const hasMeaningfulChange = changes.some(
-      (change) => change.type === "add" || change.type === "remove" || change.type === "replace"
+  isValidConnection: (connection) => {
+    const { nodes } = get();
+    const sourceNode = nodes.find((n) => n.id === connection.source);
+    const targetNode = nodes.find((n) => n.id === connection.target);
+    if (!sourceNode || !targetNode) return false;
+    const sourceType = getHandleType(
+      sourceNode.type,
+      connection.sourceHandle ?? null,
+      "source"
     );
-    set((state) => ({
-      edges: applyEdgeChanges(changes, state.edges),
-      ...hasMeaningfulChange && { isDirty: true }
-    }));
+    const targetType = getHandleType(
+      targetNode.type,
+      connection.targetHandle ?? null,
+      "target"
+    );
+    if (!sourceType || !targetType) return false;
+    return CONNECTION_RULES[sourceType]?.includes(targetType) ?? false;
   },
   onConnect: (connection) => {
     const { isValidConnection, propagateOutputsDownstream } = get();
@@ -147,6 +173,24 @@ var createEdgeSlice = (set, get) => ({
       propagateOutputsDownstream(connection.source);
     }
   },
+  onEdgesChange: (changes) => {
+    const hasMeaningfulChange = changes.some(
+      (change) => change.type === "add" || change.type === "remove" || change.type === "replace"
+    );
+    set((state) => ({
+      edges: applyEdgeChanges(changes, state.edges),
+      ...hasMeaningfulChange && { isDirty: true }
+    }));
+  },
+  onNodesChange: (changes) => {
+    const hasMeaningfulChange = changes.some(
+      (change) => change.type === "add" || change.type === "remove" || change.type === "replace"
+    );
+    set((state) => ({
+      nodes: applyNodeChanges(changes, state.nodes),
+      ...hasMeaningfulChange && { isDirty: true }
+    }));
+  },
   removeEdge: (edgeId) => {
     set((state) => ({
       edges: state.edges.filter((edge) => edge.id !== edgeId),
@@ -173,45 +217,6 @@ var createEdgeSlice = (set, get) => ({
       ),
       isDirty: true
     }));
-  },
-  isValidConnection: (connection) => {
-    const { nodes } = get();
-    const sourceNode = nodes.find((n) => n.id === connection.source);
-    const targetNode = nodes.find((n) => n.id === connection.target);
-    if (!sourceNode || !targetNode) return false;
-    const sourceType = getHandleType(
-      sourceNode.type,
-      connection.sourceHandle ?? null,
-      "source"
-    );
-    const targetType = getHandleType(
-      targetNode.type,
-      connection.targetHandle ?? null,
-      "target"
-    );
-    if (!sourceType || !targetType) return false;
-    return CONNECTION_RULES[sourceType]?.includes(targetType) ?? false;
-  },
-  findCompatibleHandle: (sourceNodeId, sourceHandleId, targetNodeId) => {
-    const { nodes, edges } = get();
-    const sourceNode = nodes.find((n) => n.id === sourceNodeId);
-    const targetNode = nodes.find((n) => n.id === targetNodeId);
-    if (!sourceNode || !targetNode) return null;
-    const sourceType = getHandleType(sourceNode.type, sourceHandleId, "source");
-    if (!sourceType) return null;
-    const targetDef = NODE_DEFINITIONS[targetNode.type];
-    if (!targetDef) return null;
-    const existingTargetHandles = new Set(
-      edges.filter((e) => e.target === targetNodeId).map((e) => e.targetHandle)
-    );
-    for (const input of targetDef.inputs) {
-      const hasExistingConnection = existingTargetHandles.has(input.id);
-      if (hasExistingConnection && !input.multiple) continue;
-      if (CONNECTION_RULES[sourceType]?.includes(input.type)) {
-        return input.id;
-      }
-    }
-    return null;
   }
 });
 
@@ -227,17 +232,25 @@ var DEFAULT_GROUP_COLORS = [
   "gray"
 ];
 var createGroupSlice = (set, get) => ({
+  addToGroup: (groupId, nodeIds) => {
+    set((state) => ({
+      groups: state.groups.map(
+        (g) => g.id === groupId ? { ...g, nodeIds: [.../* @__PURE__ */ new Set([...g.nodeIds, ...nodeIds])] } : g
+      ),
+      isDirty: true
+    }));
+  },
   createGroup: (nodeIds, name) => {
     if (nodeIds.length === 0) return "";
     const groupId = generateId();
     const { groups } = get();
     const colorIndex = groups.length % DEFAULT_GROUP_COLORS.length;
     const newGroup = {
+      color: DEFAULT_GROUP_COLORS[colorIndex],
       id: groupId,
-      name: name ?? `Group ${groups.length + 1}`,
-      nodeIds,
       isLocked: false,
-      color: DEFAULT_GROUP_COLORS[colorIndex]
+      name: name ?? `Group ${groups.length + 1}`,
+      nodeIds
     };
     set((state) => ({
       groups: [...state.groups, newGroup],
@@ -251,19 +264,29 @@ var createGroupSlice = (set, get) => ({
       isDirty: true
     }));
   },
-  addToGroup: (groupId, nodeIds) => {
+  getGroupById: (groupId) => {
+    return get().groups.find((g) => g.id === groupId);
+  },
+  getGroupByNodeId: (nodeId) => {
+    return get().groups.find((g) => g.nodeIds.includes(nodeId));
+  },
+  removeFromGroup: (groupId, nodeIds) => {
     set((state) => ({
       groups: state.groups.map(
-        (g) => g.id === groupId ? { ...g, nodeIds: [.../* @__PURE__ */ new Set([...g.nodeIds, ...nodeIds])] } : g
+        (g) => g.id === groupId ? { ...g, nodeIds: g.nodeIds.filter((id) => !nodeIds.includes(id)) } : g
       ),
       isDirty: true
     }));
   },
-  removeFromGroup: (groupId, nodeIds) => {
+  renameGroup: (groupId, name) => {
     set((state) => ({
-      groups: state.groups.map(
-        (g) => g.id === groupId ? { ...g, nodeIds: g.nodeIds.filter((id) => !nodeIds.includes(id)) } : g
-      ),
+      groups: state.groups.map((g) => g.id === groupId ? { ...g, name } : g),
+      isDirty: true
+    }));
+  },
+  setGroupColor: (groupId, color) => {
+    set((state) => ({
+      groups: state.groups.map((g) => g.id === groupId ? { ...g, color } : g),
       isDirty: true
     }));
   },
@@ -272,7 +295,9 @@ var createGroupSlice = (set, get) => ({
     const group = groups.find((g) => g.id === groupId);
     if (!group) return;
     set((state) => ({
-      groups: state.groups.map((g) => g.id === groupId ? { ...g, isLocked: !g.isLocked } : g),
+      groups: state.groups.map(
+        (g) => g.id === groupId ? { ...g, isLocked: !g.isLocked } : g
+      ),
       isDirty: true
     }));
     if (!group.isLocked) {
@@ -280,24 +305,6 @@ var createGroupSlice = (set, get) => ({
     } else {
       unlockMultipleNodes(group.nodeIds);
     }
-  },
-  renameGroup: (groupId, name) => {
-    set((state) => ({
-      groups: state.groups.map((g) => g.id === groupId ? { ...g, name } : g),
-      isDirty: true
-    }));
-  },
-  setGroupColor: (groupId, color) => {
-    set((state) => ({
-      groups: state.groups.map((g) => g.id === groupId ? { ...g, color } : g),
-      isDirty: true
-    }));
-  },
-  getGroupByNodeId: (nodeId) => {
-    return get().groups.find((g) => g.nodeIds.includes(nodeId));
-  },
-  getGroupById: (groupId) => {
-    return get().groups.find((g) => g.id === groupId);
   }
 });
 
@@ -316,9 +323,15 @@ function getOutputType(sourceType) {
   if (["prompt", "llm", "tweetParser", "transcribe"].includes(sourceType)) {
     return "text";
   }
-  if (["imageGen", "image", "imageInput", "upscale", "resize", "reframe", "imageGridSplit"].includes(
-    sourceType
-  )) {
+  if ([
+    "imageGen",
+    "image",
+    "imageInput",
+    "upscale",
+    "resize",
+    "reframe",
+    "imageGridSplit"
+  ].includes(sourceType)) {
     return "image";
   }
   if ([
@@ -345,10 +358,10 @@ function mapOutputToInput(output, sourceType, targetType) {
   const outputType = getOutputType(sourceType);
   if (targetType === "download") {
     if (outputType === "video") {
-      return { inputVideo: output, inputImage: null, inputType: "video" };
+      return { inputImage: null, inputType: "video", inputVideo: output };
     }
     if (outputType === "image") {
-      return { inputImage: output, inputVideo: null, inputType: "image" };
+      return { inputImage: output, inputType: "image", inputVideo: null };
     }
     return null;
   }
@@ -362,11 +375,16 @@ function mapOutputToInput(output, sourceType, targetType) {
   }
   if (outputType === "image") {
     if (["upscale", "reframe"].includes(targetType)) {
-      return { inputImage: output, inputVideo: null, inputType: "image" };
+      return { inputImage: output, inputType: "image", inputVideo: null };
     }
-    if (["videoGen", "lipSync", "voiceChange", "motionControl", "resize", "animation"].includes(
-      targetType
-    )) {
+    if ([
+      "videoGen",
+      "lipSync",
+      "voiceChange",
+      "motionControl",
+      "resize",
+      "animation"
+    ].includes(targetType)) {
       return { inputImage: output };
     }
     if (targetType === "imageGen") {
@@ -375,7 +393,7 @@ function mapOutputToInput(output, sourceType, targetType) {
   }
   if (outputType === "video") {
     if (["upscale", "reframe"].includes(targetType)) {
-      return { inputVideo: output, inputImage: null, inputType: "video" };
+      return { inputImage: null, inputType: "video", inputVideo: output };
     }
     if ([
       "lipSync",
@@ -407,7 +425,13 @@ function collectGalleryUpdate(sourceData, currentOutput, existingGalleryImages,
   }
   if (allImages.length === 0) return null;
   return {
-    images: [.../* @__PURE__ */ new Set([...existingGalleryImages, ...pendingUpdateImages, ...allImages])]
+    images: [
+      .../* @__PURE__ */ new Set([
+        ...existingGalleryImages,
+        ...pendingUpdateImages,
+        ...allImages
+      ])
+    ]
   };
 }
 function computeDownstreamUpdates(sourceNodeId, initialOutput, nodes, edges) {
@@ -443,7 +467,11 @@ function computeDownstreamUpdates(sourceNodeId, initialOutput, nodes, edges) {
         }
         continue;
       }
-      const inputUpdate = mapOutputToInput(current.output, currentNode.type, targetNode.type);
+      const inputUpdate = mapOutputToInput(
+        current.output,
+        currentNode.type,
+        targetNode.type
+      );
       if (inputUpdate) {
         const existing = updates.get(edge.target) ?? {};
         updates.set(edge.target, { ...existing, ...inputUpdate });
@@ -495,50 +523,52 @@ function propagateExistingOutputs(nodes, propagateFn) {
 var createLockingSlice = (set, get) => ({
   _setNodeLockState: (predicate, lock) => {
     set((state) => ({
+      isDirty: true,
       nodes: state.nodes.map(
         (n) => predicate(n.id) ? {
           ...n,
-          draggable: !lock,
           data: {
             ...n.data,
             isLocked: lock,
             lockTimestamp: lock ? Date.now() : void 0,
             ...lock && { cachedOutput: getNodeOutput(n) }
-          }
+          },
+          draggable: !lock
         } : n
-      ),
-      isDirty: true
+      )
     }));
   },
-  toggleNodeLock: (nodeId) => {
-    const node = get().getNodeById(nodeId);
-    if (!node) return;
-    const shouldLock = !(node.data.isLocked ?? false);
-    get()._setNodeLockState((id) => id === nodeId, shouldLock);
+  isNodeLocked: (nodeId) => {
+    const { nodes, groups } = get();
+    const node = nodes.find((n) => n.id === nodeId);
+    if (!node) return false;
+    if (node.data.isLocked) return true;
+    return groups.some(
+      (group) => group.isLocked && group.nodeIds.includes(nodeId)
+    );
+  },
+  lockMultipleNodes: (nodeIds) => {
+    get()._setNodeLockState((id) => nodeIds.includes(id), true);
   },
   lockNode: (nodeId) => {
     const node = get().getNodeById(nodeId);
     if (!node || node.data.isLocked) return;
     get()._setNodeLockState((id) => id === nodeId, true);
   },
-  unlockNode: (nodeId) => {
-    get()._setNodeLockState((id) => id === nodeId, false);
+  toggleNodeLock: (nodeId) => {
+    const node = get().getNodeById(nodeId);
+    if (!node) return;
+    const shouldLock = !(node.data.isLocked ?? false);
+    get()._setNodeLockState((id) => id === nodeId, shouldLock);
   },
-  lockMultipleNodes: (nodeIds) => {
-    get()._setNodeLockState((id) => nodeIds.includes(id), true);
+  unlockAllNodes: () => {
+    get()._setNodeLockState(() => true, false);
   },
   unlockMultipleNodes: (nodeIds) => {
     get()._setNodeLockState((id) => nodeIds.includes(id), false);
   },
-  unlockAllNodes: () => {
-    get()._setNodeLockState(() => true, false);
-  },
-  isNodeLocked: (nodeId) => {
-    const { nodes, groups } = get();
-    const node = nodes.find((n) => n.id === nodeId);
-    if (!node) return false;
-    if (node.data.isLocked) return true;
-    return groups.some((group) => group.isLocked && group.nodeIds.includes(nodeId));
+  unlockNode: (nodeId) => {
+    get()._setNodeLockState((id) => id === nodeId, false);
   }
 });
 var createNodeSlice = (set, get) => ({
@@ -547,28 +577,28 @@ var createNodeSlice = (set, get) => ({
     if (!nodeDef) return "";
     const id = generateId();
     const newNode = {
-      id,
-      type,
-      position,
       data: {
         ...nodeDef.defaultData,
         label: nodeDef.label,
         status: "idle"
       },
-      ...type === "download" && { width: 280, height: 320 }
+      id,
+      position,
+      type,
+      ...type === "download" && { height: 320, width: 280 }
     };
     set((state) => ({
-      nodes: [...state.nodes, newNode],
-      isDirty: true
+      isDirty: true,
+      nodes: [...state.nodes, newNode]
     }));
     return id;
   },
   addNodesAndEdges: (newNodes, newEdges) => {
     if (newNodes.length === 0) return;
     set((state) => ({
-      nodes: [...state.nodes, ...newNodes],
       edges: [...state.edges, ...newEdges],
-      isDirty: true
+      isDirty: true,
+      nodes: [...state.nodes, ...newNodes]
     }));
     const { propagateOutputsDownstream } = get();
     const sourceNodeIds = new Set(newEdges.map((e) => e.source));
@@ -576,49 +606,17 @@ var createNodeSlice = (set, get) => ({
       propagateOutputsDownstream(sourceId);
     }
   },
-  updateNodeData: (nodeId, data) => {
-    const { nodes, propagateOutputsDownstream } = get();
-    const node = nodes.find((n) => n.id === nodeId);
-    const TRANSIENT_KEYS = /* @__PURE__ */ new Set(["status", "progress", "error", "jobId"]);
-    const dataKeys = Object.keys(data);
-    const hasPersistedChange = dataKeys.some((key) => !TRANSIENT_KEYS.has(key));
+  addToGlobalHistory: (item) => {
+    const id = `history-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     set((state) => ({
-      nodes: state.nodes.map((n) => n.id === nodeId ? { ...n, data: { ...n.data, ...data } } : n),
-      ...hasPersistedChange && { isDirty: true }
+      globalImageHistory: [{ ...item, id }, ...state.globalImageHistory].slice(
+        0,
+        100
+      )
     }));
-    const inputNodeTypes = [
-      "prompt",
-      "image",
-      "imageInput",
-      "video",
-      "videoInput",
-      "audio",
-      "audioInput",
-      "tweetParser"
-    ];
-    const hasOutputUpdate = "outputImage" in data || "outputImages" in data || "outputVideo" in data || "outputAudio" in data || "outputText" in data;
-    if (node && (inputNodeTypes.includes(node.type) || hasOutputUpdate)) {
-      if (hasOutputUpdate) {
-        const dataRecord = data;
-        if ("outputImages" in dataRecord) {
-          propagateOutputsDownstream(nodeId);
-        } else {
-          const outputValue = dataRecord.outputImage ?? dataRecord.outputVideo ?? dataRecord.outputAudio ?? dataRecord.outputText;
-          if (typeof outputValue === "string") {
-            propagateOutputsDownstream(nodeId, outputValue);
-          }
-        }
-      } else {
-        propagateOutputsDownstream(nodeId);
-      }
-    }
   },
-  removeNode: (nodeId) => {
-    set((state) => ({
-      nodes: state.nodes.filter((node) => node.id !== nodeId),
-      edges: state.edges.filter((edge) => edge.source !== nodeId && edge.target !== nodeId),
-      isDirty: true
-    }));
+  clearGlobalHistory: () => {
+    set({ globalImageHistory: [] });
   },
   duplicateNode: (nodeId) => {
     const { nodes, edges, edgeStyle, propagateOutputsDownstream } = get();
@@ -627,18 +625,20 @@ var createNodeSlice = (set, get) => ({
     const newId = generateId();
     const newNode = {
       ...node,
+      data: {
+        ...node.data,
+        jobId: null,
+        status: "idle"
+      },
       id: newId,
       position: {
         x: node.position.x + 50,
         y: node.position.y + 50
-      },
-      data: {
-        ...node.data,
-        status: "idle",
-        jobId: null
       }
     };
-    const incomingEdges = edges.filter((e) => e.target === nodeId && e.source !== nodeId);
+    const incomingEdges = edges.filter(
+      (e) => e.target === nodeId && e.source !== nodeId
+    );
     const clonedEdges = incomingEdges.map((edge) => ({
       ...edge,
       id: generateId(),
@@ -646,9 +646,9 @@ var createNodeSlice = (set, get) => ({
       type: edgeStyle
     }));
     set((state) => ({
-      nodes: [...state.nodes, newNode],
       edges: [...state.edges, ...clonedEdges],
-      isDirty: true
+      isDirty: true,
+      nodes: [...state.nodes, newNode]
     }));
     const sourcesNotified = /* @__PURE__ */ new Set();
     for (const edge of incomingEdges) {
@@ -665,22 +665,66 @@ var createNodeSlice = (set, get) => ({
     if (!sourceNode) return;
     const output = outputValue ?? getNodeOutput(sourceNode);
     if (!output) return;
-    const updates = computeDownstreamUpdates(sourceNodeId, output, nodes, edges);
+    const updates = computeDownstreamUpdates(
+      sourceNodeId,
+      output,
+      nodes,
+      edges
+    );
     if (updates.size === 0) return;
     if (!hasStateChanged(updates, nodes)) return;
     set((state) => ({
-      nodes: applyNodeUpdates(state.nodes, updates),
-      isDirty: true
+      isDirty: true,
+      nodes: applyNodeUpdates(state.nodes, updates)
     }));
   },
-  addToGlobalHistory: (item) => {
-    const id = `history-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  removeNode: (nodeId) => {
     set((state) => ({
-      globalImageHistory: [{ ...item, id }, ...state.globalImageHistory].slice(0, 100)
+      edges: state.edges.filter(
+        (edge) => edge.source !== nodeId && edge.target !== nodeId
+      ),
+      isDirty: true,
+      nodes: state.nodes.filter((node) => node.id !== nodeId)
     }));
   },
-  clearGlobalHistory: () => {
-    set({ globalImageHistory: [] });
+  updateNodeData: (nodeId, data) => {
+    const { nodes, propagateOutputsDownstream } = get();
+    const node = nodes.find((n) => n.id === nodeId);
+    const TRANSIENT_KEYS = /* @__PURE__ */ new Set(["status", "progress", "error", "jobId"]);
+    const dataKeys = Object.keys(data);
+    const hasPersistedChange = dataKeys.some((key) => !TRANSIENT_KEYS.has(key));
+    set((state) => ({
+      nodes: state.nodes.map(
+        (n) => n.id === nodeId ? { ...n, data: { ...n.data, ...data } } : n
+      ),
+      ...hasPersistedChange && { isDirty: true }
+    }));
+    const inputNodeTypes = [
+      "prompt",
+      "image",
+      "imageInput",
+      "video",
+      "videoInput",
+      "audio",
+      "audioInput",
+      "tweetParser"
+    ];
+    const hasOutputUpdate = "outputImage" in data || "outputImages" in data || "outputVideo" in data || "outputAudio" in data || "outputText" in data;
+    if (node && (inputNodeTypes.includes(node.type) || hasOutputUpdate)) {
+      if (hasOutputUpdate) {
+        const dataRecord = data;
+        if ("outputImages" in dataRecord) {
+          propagateOutputsDownstream(nodeId);
+        } else {
+          const outputValue = dataRecord.outputImage ?? dataRecord.outputVideo ?? dataRecord.outputAudio ?? dataRecord.outputText;
+          if (typeof outputValue === "string") {
+            propagateOutputsDownstream(nodeId, outputValue);
+          }
+        }
+      } else {
+        propagateOutputsDownstream(nodeId);
+      }
+    }
   }
 });
 function normalizeEdgeTypes(edges) {
@@ -703,49 +747,46 @@ function hydrateWorkflowNodes(nodes) {
   });
 }
 var createPersistenceSlice = (set, get) => ({
-  loadWorkflow: (workflow) => {
-    const hydratedNodes = hydrateWorkflowNodes(workflow.nodes);
-    set({
-      nodes: hydratedNodes,
-      edges: normalizeEdgeTypes(workflow.edges),
-      edgeStyle: workflow.edgeStyle,
-      workflowName: workflow.name,
-      workflowId: null,
-      isDirty: true,
-      groups: workflow.groups ?? [],
-      selectedNodeIds: []
-    });
-    propagateExistingOutputs(hydratedNodes, get().propagateOutputsDownstream);
-    set({ isDirty: false });
-  },
   clearWorkflow: () => {
     set({
-      nodes: [],
       edges: [],
-      workflowName: "Untitled Workflow",
-      workflowId: null,
-      isDirty: false,
       groups: [],
-      selectedNodeIds: []
+      isDirty: false,
+      nodes: [],
+      selectedNodeIds: [],
+      workflowId: null,
+      workflowName: "Untitled Workflow"
     });
   },
+  createNewWorkflow: async () => {
+    throw new Error(
+      "createNewWorkflow not implemented - consuming app must provide API integration"
+    );
+  },
+  deleteWorkflow: async () => {
+    throw new Error(
+      "deleteWorkflow not implemented - consuming app must provide API integration"
+    );
+  },
+  duplicateWorkflowApi: async () => {
+    throw new Error(
+      "duplicateWorkflowApi not implemented - consuming app must provide API integration"
+    );
+  },
   exportWorkflow: () => {
     const { nodes, edges, edgeStyle, workflowName, groups } = get();
     return {
-      version: 1,
-      name: workflowName,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       description: "",
-      nodes,
-      edges,
       edgeStyle,
+      edges,
       groups,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      name: workflowName,
+      nodes,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: 1
     };
   },
-  getNodeById: (id) => {
-    return get().nodes.find((node) => node.id === id);
-  },
   getConnectedInputs: (nodeId) => {
     const { nodes, edges } = get();
     const inputs = /* @__PURE__ */ new Map();
@@ -800,25 +841,95 @@ var createPersistenceSlice = (set, get) => ({
     }
     return Array.from(connected);
   },
+  getNodeById: (id) => {
+    return get().nodes.find((node) => node.id === id);
+  },
+  getNodesWithComments: () => {
+    const { nodes } = get();
+    return nodes.filter((node) => {
+      const data = node.data;
+      return data.comment?.trim();
+    }).sort((a, b) => {
+      if (Math.abs(a.position.y - b.position.y) < 50) {
+        return a.position.x - b.position.x;
+      }
+      return a.position.y - b.position.y;
+    });
+  },
+  getUnviewedCommentCount: () => {
+    const { nodes, viewedCommentIds } = get();
+    return nodes.filter((node) => {
+      const data = node.data;
+      return data.comment?.trim() && !viewedCommentIds.has(node.id);
+    }).length;
+  },
+  listWorkflows: async () => {
+    throw new Error(
+      "listWorkflows not implemented - consuming app must provide API integration"
+    );
+  },
+  loadWorkflow: (workflow) => {
+    const hydratedNodes = hydrateWorkflowNodes(workflow.nodes);
+    set({
+      edgeStyle: workflow.edgeStyle,
+      edges: normalizeEdgeTypes(workflow.edges),
+      groups: workflow.groups ?? [],
+      isDirty: true,
+      nodes: hydratedNodes,
+      selectedNodeIds: [],
+      workflowId: null,
+      workflowName: workflow.name
+    });
+    propagateExistingOutputs(hydratedNodes, get().propagateOutputsDownstream);
+    set({ isDirty: false });
+  },
+  loadWorkflowById: async () => {
+    throw new Error(
+      "loadWorkflowById not implemented - consuming app must provide API integration"
+    );
+  },
+  markCommentViewed: (nodeId) => {
+    set((state) => {
+      const newSet = new Set(state.viewedCommentIds);
+      newSet.add(nodeId);
+      return { viewedCommentIds: newSet };
+    });
+  },
+  // API operations - stubs that throw by default.
+  // Consuming apps override these via the store creator or by extending the slice.
+  saveWorkflow: async () => {
+    throw new Error(
+      "saveWorkflow not implemented - consuming app must provide API integration"
+    );
+  },
+  setDirty: (dirty) => {
+    set({ isDirty: dirty });
+  },
+  setNavigationTarget: (nodeId) => {
+    set({ navigationTargetId: nodeId });
+  },
+  setWorkflowName: (name) => {
+    set({ isDirty: true, workflowName: name });
+  },
   validateWorkflow: () => {
     const { nodes, edges } = get();
     const errors = [];
     const warnings = [];
     if (nodes.length === 0) {
       errors.push({
-        nodeId: "",
         message: "Workflow is empty - add some nodes first",
+        nodeId: "",
         severity: "error"
       });
-      return { isValid: false, errors, warnings };
+      return { errors, isValid: false, warnings };
     }
     if (edges.length === 0 && nodes.length > 1) {
       errors.push({
-        nodeId: "",
         message: "No connections - connect your nodes together",
+        nodeId: "",
         severity: "error"
       });
-      return { isValid: false, errors, warnings };
+      return { errors, isValid: false, warnings };
     }
     const hasNodeOutput = (node) => {
       const data = node.data;
@@ -841,19 +952,23 @@ var createPersistenceSlice = (set, get) => ({
       const incomingEdges = edges.filter((e) => e.target === node.id);
       for (const input of nodeDef.inputs) {
         if (input.required) {
-          const connectionEdge = incomingEdges.find((e) => e.targetHandle === input.id);
+          const connectionEdge = incomingEdges.find(
+            (e) => e.targetHandle === input.id
+          );
           if (!connectionEdge) {
             errors.push({
-              nodeId: node.id,
               message: `Missing required input: ${input.label}`,
+              nodeId: node.id,
               severity: "error"
             });
           } else {
-            const sourceNode = nodes.find((n) => n.id === connectionEdge.source);
+            const sourceNode = nodes.find(
+              (n) => n.id === connectionEdge.source
+            );
             if (sourceNode && !hasNodeOutput(sourceNode)) {
               errors.push({
-                nodeId: sourceNode.id,
                 message: `${sourceNode.data.label} is empty`,
+                nodeId: sourceNode.id,
                 severity: "error"
               });
             }
@@ -878,8 +993,8 @@ var createPersistenceSlice = (set, get) => ({
     for (const node of nodes) {
       if (hasCycle(node.id)) {
         errors.push({
-          nodeId: node.id,
           message: "Workflow contains a cycle",
+          nodeId: node.id,
           severity: "error"
         });
         break;
@@ -890,146 +1005,82 @@ var createPersistenceSlice = (set, get) => ({
         const refData = node.data;
         if (!refData.referencedWorkflowId) {
           errors.push({
-            nodeId: node.id,
             message: "Subworkflow node must reference a workflow",
+            nodeId: node.id,
             severity: "error"
           });
         } else if (!refData.cachedInterface) {
           warnings.push({
-            nodeId: node.id,
             message: "Subworkflow interface not loaded - refresh to update handles",
+            nodeId: node.id,
             severity: "warning"
           });
         }
       }
     }
     return {
-      isValid: errors.length === 0,
       errors,
+      isValid: errors.length === 0,
       warnings
     };
-  },
-  setDirty: (dirty) => {
-    set({ isDirty: dirty });
-  },
-  setWorkflowName: (name) => {
-    set({ workflowName: name, isDirty: true });
-  },
-  // API operations - stubs that throw by default.
-  // Consuming apps override these via the store creator or by extending the slice.
-  saveWorkflow: async () => {
-    throw new Error("saveWorkflow not implemented - consuming app must provide API integration");
-  },
-  loadWorkflowById: async () => {
-    throw new Error(
-      "loadWorkflowById not implemented - consuming app must provide API integration"
-    );
-  },
-  listWorkflows: async () => {
-    throw new Error("listWorkflows not implemented - consuming app must provide API integration");
-  },
-  deleteWorkflow: async () => {
-    throw new Error("deleteWorkflow not implemented - consuming app must provide API integration");
-  },
-  duplicateWorkflowApi: async () => {
-    throw new Error(
-      "duplicateWorkflowApi not implemented - consuming app must provide API integration"
-    );
-  },
-  createNewWorkflow: async () => {
-    throw new Error(
-      "createNewWorkflow not implemented - consuming app must provide API integration"
-    );
-  },
-  getNodesWithComments: () => {
-    const { nodes } = get();
-    return nodes.filter((node) => {
-      const data = node.data;
-      return data.comment?.trim();
-    }).sort((a, b) => {
-      if (Math.abs(a.position.y - b.position.y) < 50) {
-        return a.position.x - b.position.x;
-      }
-      return a.position.y - b.position.y;
-    });
-  },
-  markCommentViewed: (nodeId) => {
-    set((state) => {
-      const newSet = new Set(state.viewedCommentIds);
-      newSet.add(nodeId);
-      return { viewedCommentIds: newSet };
-    });
-  },
-  setNavigationTarget: (nodeId) => {
-    set({ navigationTargetId: nodeId });
-  },
-  getUnviewedCommentCount: () => {
-    const { nodes, viewedCommentIds } = get();
-    return nodes.filter((node) => {
-      const data = node.data;
-      return data.comment?.trim() && !viewedCommentIds.has(node.id);
-    }).length;
   }
 });
 
 // src/stores/workflow/slices/selectionSlice.ts
 var createSelectionSlice = (set) => ({
-  setSelectedNodeIds: (nodeIds) => {
-    set({ selectedNodeIds: nodeIds });
-  },
   addToSelection: (nodeId) => {
     set((state) => ({
       selectedNodeIds: state.selectedNodeIds.includes(nodeId) ? state.selectedNodeIds : [...state.selectedNodeIds, nodeId]
     }));
   },
+  clearSelection: () => {
+    set({ selectedNodeIds: [] });
+  },
   removeFromSelection: (nodeId) => {
     set((state) => ({
       selectedNodeIds: state.selectedNodeIds.filter((id) => id !== nodeId)
     }));
   },
-  clearSelection: () => {
-    set({ selectedNodeIds: [] });
+  setSelectedNodeIds: (nodeIds) => {
+    set({ selectedNodeIds: nodeIds });
   }
 });
 
 // src/stores/workflow/slices/snapshotSlice.ts
 function defaultApplyEditOperations(_operations, state) {
-  return { nodes: state.nodes, edges: state.edges, applied: 0, skipped: [] };
+  return { applied: 0, edges: state.edges, nodes: state.nodes, skipped: [] };
 }
 var createSnapshotSlice = (set, get) => ({
-  previousWorkflowSnapshot: null,
-  manualChangeCount: 0,
+  applyEditOperations: (operations) => {
+    const state = get();
+    const result = defaultApplyEditOperations(operations, {
+      edges: state.edges,
+      nodes: state.nodes
+    });
+    set({
+      edges: result.edges,
+      isDirty: true,
+      nodes: result.nodes
+    });
+    return { applied: result.applied, skipped: result.skipped };
+  },
   captureSnapshot: () => {
     const state = get();
     const snapshot = {
-      nodes: JSON.parse(JSON.stringify(state.nodes)),
+      edgeStyle: state.edgeStyle,
       edges: JSON.parse(JSON.stringify(state.edges)),
       groups: JSON.parse(JSON.stringify(state.groups)),
-      edgeStyle: state.edgeStyle
+      nodes: JSON.parse(JSON.stringify(state.nodes))
     };
     set({
-      previousWorkflowSnapshot: snapshot,
-      manualChangeCount: 0
+      manualChangeCount: 0,
+      previousWorkflowSnapshot: snapshot
     });
   },
-  revertToSnapshot: () => {
-    const state = get();
-    if (state.previousWorkflowSnapshot) {
-      set({
-        nodes: state.previousWorkflowSnapshot.nodes,
-        edges: state.previousWorkflowSnapshot.edges,
-        groups: state.previousWorkflowSnapshot.groups,
-        edgeStyle: state.previousWorkflowSnapshot.edgeStyle,
-        previousWorkflowSnapshot: null,
-        manualChangeCount: 0,
-        isDirty: true
-      });
-    }
-  },
   clearSnapshot: () => {
     set({
-      previousWorkflowSnapshot: null,
-      manualChangeCount: 0
+      manualChangeCount: 0,
+      previousWorkflowSnapshot: null
     });
   },
   incrementManualChangeCount: () => {
@@ -1037,44 +1088,47 @@ var createSnapshotSlice = (set, get) => ({
     const newCount = state.manualChangeCount + 1;
     if (newCount >= 3) {
       set({
-        previousWorkflowSnapshot: null,
-        manualChangeCount: 0
+        manualChangeCount: 0,
+        previousWorkflowSnapshot: null
       });
     } else {
       set({ manualChangeCount: newCount });
     }
   },
-  applyEditOperations: (operations) => {
+  manualChangeCount: 0,
+  previousWorkflowSnapshot: null,
+  revertToSnapshot: () => {
     const state = get();
-    const result = defaultApplyEditOperations(operations, {
-      nodes: state.nodes,
-      edges: state.edges
-    });
-    set({
-      nodes: result.nodes,
-      edges: result.edges,
-      isDirty: true
-    });
-    return { applied: result.applied, skipped: result.skipped };
+    if (state.previousWorkflowSnapshot) {
+      set({
+        edgeStyle: state.previousWorkflowSnapshot.edgeStyle,
+        edges: state.previousWorkflowSnapshot.edges,
+        groups: state.previousWorkflowSnapshot.groups,
+        isDirty: true,
+        manualChangeCount: 0,
+        nodes: state.previousWorkflowSnapshot.nodes,
+        previousWorkflowSnapshot: null
+      });
+    }
   }
 });
 
 // src/stores/workflow/workflowStore.ts
 var storeCreator = ((...args) => ({
-  // Initial state
-  nodes: [],
-  edges: [],
   edgeStyle: "default",
-  workflowName: "Untitled Workflow",
-  workflowId: null,
+  edges: [],
+  globalImageHistory: [],
+  groups: [],
   isDirty: false,
-  isSaving: false,
   isLoading: false,
-  groups: [],
+  isSaving: false,
+  navigationTargetId: null,
+  // Initial state
+  nodes: [],
   selectedNodeIds: [],
   viewedCommentIds: /* @__PURE__ */ new Set(),
-  navigationTargetId: null,
-  globalImageHistory: [],
+  workflowId: null,
+  workflowName: "Untitled Workflow",
   // Compose slices
   ...createNodeSlice(...args),
   ...createEdgeSlice(...args),
@@ -1087,16 +1141,16 @@ var storeCreator = ((...args) => ({
 }));
 var useWorkflowStore = create()(
   temporal(storeCreator, {
+    // Optimized equality check using shallow comparison instead of JSON.stringify
+    equality: temporalStateEquals,
+    // Limit history to prevent memory issues
+    limit: 50,
     // Only track meaningful state (not UI flags like isDirty, isSaving, etc.)
     partialize: (state) => ({
-      nodes: state.nodes,
       edges: state.edges,
-      groups: state.groups
-    }),
-    // Limit history to prevent memory issues
-    limit: 50,
-    // Optimized equality check using shallow comparison instead of JSON.stringify
-    equality: temporalStateEquals
+      groups: state.groups,
+      nodes: state.nodes
+    })
   })
 );