@genfeedai/workflow-ui 0.1.0 → 0.1.2

package/dist/chunk-NSDLGLAQ.js

@@ -1,2166 +0,0 @@
-'use strict';
-
-var chunkZ7PWFZG5_js = require('./chunk-Z7PWFZG5.js');
-var zundo = require('zundo');
-var zustand = require('zustand');
-var react = require('@xyflow/react');
-var nanoid = require('nanoid');
-
-// ../types/dist/chunk-P7K5LM6V.js
-var require_chunk_P7K5LM6V = chunkZ7PWFZG5_js.__commonJS({
-  "../types/dist/chunk-P7K5LM6V.js"(exports$1) {
-    var HandleTypeEnum = /* @__PURE__ */ ((HandleTypeEnum2) => {
-      HandleTypeEnum2["IMAGE"] = "image";
-      HandleTypeEnum2["TEXT"] = "text";
-      HandleTypeEnum2["VIDEO"] = "video";
-      HandleTypeEnum2["NUMBER"] = "number";
-      HandleTypeEnum2["AUDIO"] = "audio";
-      return HandleTypeEnum2;
-    })(HandleTypeEnum || {});
-    var CONNECTION_RULES2 = {
-      image: ["image"],
-      text: ["text"],
-      video: ["video"],
-      number: ["number"],
-      audio: ["audio"]
-    };
-    var ProviderTypeEnum = /* @__PURE__ */ ((ProviderTypeEnum2) => {
-      ProviderTypeEnum2["REPLICATE"] = "replicate";
-      ProviderTypeEnum2["FAL"] = "fal";
-      ProviderTypeEnum2["HUGGINGFACE"] = "huggingface";
-      ProviderTypeEnum2["GENFEED_AI"] = "genfeed-ai";
-      return ProviderTypeEnum2;
-    })(ProviderTypeEnum || {});
-    var ModelCapabilityEnum = /* @__PURE__ */ ((ModelCapabilityEnum2) => {
-      ModelCapabilityEnum2["TEXT_TO_IMAGE"] = "text-to-image";
-      ModelCapabilityEnum2["IMAGE_TO_IMAGE"] = "image-to-image";
-      ModelCapabilityEnum2["TEXT_TO_VIDEO"] = "text-to-video";
-      ModelCapabilityEnum2["IMAGE_TO_VIDEO"] = "image-to-video";
-      ModelCapabilityEnum2["TEXT_GENERATION"] = "text-generation";
-      return ModelCapabilityEnum2;
-    })(ModelCapabilityEnum || {});
-    var ModelUseCaseEnum = /* @__PURE__ */ ((ModelUseCaseEnum2) => {
-      ModelUseCaseEnum2["STYLE_TRANSFER"] = "style-transfer";
-      ModelUseCaseEnum2["CHARACTER_CONSISTENT"] = "character-consistent";
-      ModelUseCaseEnum2["IMAGE_VARIATION"] = "image-variation";
-      ModelUseCaseEnum2["INPAINTING"] = "inpainting";
-      ModelUseCaseEnum2["UPSCALE"] = "upscale";
-      ModelUseCaseEnum2["GENERAL"] = "general";
-      return ModelUseCaseEnum2;
-    })(ModelUseCaseEnum || {});
-    var NodeTypeEnum = /* @__PURE__ */ ((NodeTypeEnum2) => {
-      NodeTypeEnum2["IMAGE_INPUT"] = "imageInput";
-      NodeTypeEnum2["AUDIO_INPUT"] = "audioInput";
-      NodeTypeEnum2["VIDEO_INPUT"] = "videoInput";
-      NodeTypeEnum2["PROMPT"] = "prompt";
-      NodeTypeEnum2["PROMPT_CONSTRUCTOR"] = "promptConstructor";
-      NodeTypeEnum2["IMAGE_GEN"] = "imageGen";
-      NodeTypeEnum2["VIDEO_GEN"] = "videoGen";
-      NodeTypeEnum2["LLM"] = "llm";
-      NodeTypeEnum2["LIP_SYNC"] = "lipSync";
-      NodeTypeEnum2["VOICE_CHANGE"] = "voiceChange";
-      NodeTypeEnum2["TEXT_TO_SPEECH"] = "textToSpeech";
-      NodeTypeEnum2["TRANSCRIBE"] = "transcribe";
-      NodeTypeEnum2["MOTION_CONTROL"] = "motionControl";
-      NodeTypeEnum2["RESIZE"] = "resize";
-      NodeTypeEnum2["ANIMATION"] = "animation";
-      NodeTypeEnum2["VIDEO_STITCH"] = "videoStitch";
-      NodeTypeEnum2["VIDEO_TRIM"] = "videoTrim";
-      NodeTypeEnum2["VIDEO_FRAME_EXTRACT"] = "videoFrameExtract";
-      NodeTypeEnum2["REFRAME"] = "reframe";
-      NodeTypeEnum2["UPSCALE"] = "upscale";
-      NodeTypeEnum2["IMAGE_GRID_SPLIT"] = "imageGridSplit";
-      NodeTypeEnum2["ANNOTATION"] = "annotation";
-      NodeTypeEnum2["SUBTITLE"] = "subtitle";
-      NodeTypeEnum2["OUTPUT_GALLERY"] = "outputGallery";
-      NodeTypeEnum2["IMAGE_COMPARE"] = "imageCompare";
-      NodeTypeEnum2["DOWNLOAD"] = "download";
-      NodeTypeEnum2["WORKFLOW_INPUT"] = "workflowInput";
-      NodeTypeEnum2["WORKFLOW_OUTPUT"] = "workflowOutput";
-      NodeTypeEnum2["WORKFLOW_REF"] = "workflowRef";
-      return NodeTypeEnum2;
-    })(NodeTypeEnum || {});
-    var NodeCategoryEnum = /* @__PURE__ */ ((NodeCategoryEnum2) => {
-      NodeCategoryEnum2["INPUT"] = "input";
-      NodeCategoryEnum2["AI"] = "ai";
-      NodeCategoryEnum2["PROCESSING"] = "processing";
-      NodeCategoryEnum2["OUTPUT"] = "output";
-      NodeCategoryEnum2["COMPOSITION"] = "composition";
-      return NodeCategoryEnum2;
-    })(NodeCategoryEnum || {});
-    var NodeStatusEnum = /* @__PURE__ */ ((NodeStatusEnum2) => {
-      NodeStatusEnum2["IDLE"] = "idle";
-      NodeStatusEnum2["PENDING"] = "pending";
-      NodeStatusEnum2["PROCESSING"] = "processing";
-      NodeStatusEnum2["COMPLETE"] = "complete";
-      NodeStatusEnum2["ERROR"] = "error";
-      return NodeStatusEnum2;
-    })(NodeStatusEnum || {});
-    var TemplateCategory = /* @__PURE__ */ ((TemplateCategory2) => {
-      TemplateCategory2["IMAGE"] = "image";
-      TemplateCategory2["VIDEO"] = "video";
-      TemplateCategory2["AUDIO"] = "audio";
-      TemplateCategory2["FULL_PIPELINE"] = "full-pipeline";
-      return TemplateCategory2;
-    })(TemplateCategory || {});
-    var ReframeNodeType = /* @__PURE__ */ ((ReframeNodeType2) => {
-      ReframeNodeType2["REFRAME"] = "reframe";
-      ReframeNodeType2["LUMA_REFRAME_IMAGE"] = "lumaReframeImage";
-      ReframeNodeType2["LUMA_REFRAME_VIDEO"] = "lumaReframeVideo";
-      return ReframeNodeType2;
-    })(ReframeNodeType || {});
-    var UpscaleNodeType = /* @__PURE__ */ ((UpscaleNodeType2) => {
-      UpscaleNodeType2["UPSCALE"] = "upscale";
-      UpscaleNodeType2["TOPAZ_IMAGE_UPSCALE"] = "topazImageUpscale";
-      UpscaleNodeType2["TOPAZ_VIDEO_UPSCALE"] = "topazVideoUpscale";
-      return UpscaleNodeType2;
-    })(UpscaleNodeType || {});
-    var KlingQuality = /* @__PURE__ */ ((KlingQuality2) => {
-      KlingQuality2["STANDARD"] = "std";
-      KlingQuality2["PRO"] = "pro";
-      return KlingQuality2;
-    })(KlingQuality || {});
-    var ProcessingNodeType = /* @__PURE__ */ ((ProcessingNodeType2) => {
-      ProcessingNodeType2["REFRAME"] = "reframe";
-      ProcessingNodeType2["LUMA_REFRAME_IMAGE"] = "lumaReframeImage";
-      ProcessingNodeType2["LUMA_REFRAME_VIDEO"] = "lumaReframeVideo";
-      ProcessingNodeType2["UPSCALE"] = "upscale";
-      ProcessingNodeType2["TOPAZ_IMAGE_UPSCALE"] = "topazImageUpscale";
-      ProcessingNodeType2["TOPAZ_VIDEO_UPSCALE"] = "topazVideoUpscale";
-      ProcessingNodeType2["VIDEO_FRAME_EXTRACT"] = "videoFrameExtract";
-      ProcessingNodeType2["LIP_SYNC"] = "lipSync";
-      ProcessingNodeType2["TEXT_TO_SPEECH"] = "textToSpeech";
-      ProcessingNodeType2["VOICE_CHANGE"] = "voiceChange";
-      ProcessingNodeType2["SUBTITLE"] = "subtitle";
-      ProcessingNodeType2["VIDEO_STITCH"] = "videoStitch";
-      ProcessingNodeType2["WORKFLOW_REF"] = "workflowRef";
-      return ProcessingNodeType2;
-    })(ProcessingNodeType || {});
-    var NODE_DEFINITIONS5 = {
-      // Input nodes
-      imageInput: {
-        type: "imageInput",
-        label: "Image",
-        description: "Upload or reference an image",
-        category: "input",
-        icon: "Image",
-        inputs: [],
-        outputs: [{ id: "image", type: "image", label: "Image" }],
-        defaultData: {
-          label: "Image",
-          status: "idle",
-          image: null,
-          filename: null,
-          dimensions: null,
-          source: "upload"
-        }
-      },
-      prompt: {
-        type: "prompt",
-        label: "Prompt",
-        description: "Text prompt for AI generation",
-        category: "input",
-        icon: "MessageSquare",
-        inputs: [],
-        outputs: [{ id: "text", type: "text", label: "Prompt" }],
-        defaultData: {
-          label: "Prompt",
-          status: "idle",
-          prompt: "",
-          variables: {}
-        }
-      },
-      audioInput: {
-        type: "audioInput",
-        label: "Audio",
-        description: "Upload an audio file (MP3, WAV)",
-        category: "input",
-        icon: "Volume2",
-        inputs: [],
-        outputs: [{ id: "audio", type: "audio", label: "Audio" }],
-        defaultData: {
-          label: "Audio",
-          status: "idle",
-          audio: null,
-          filename: null,
-          duration: null,
-          source: "upload"
-        }
-      },
-      videoInput: {
-        type: "videoInput",
-        label: "Video",
-        description: "Upload or reference a video file",
-        category: "input",
-        icon: "FileVideo",
-        inputs: [],
-        outputs: [{ id: "video", type: "video", label: "Video" }],
-        defaultData: {
-          label: "Video",
-          status: "idle",
-          video: null,
-          filename: null,
-          duration: null,
-          dimensions: null,
-          source: "upload"
-        }
-      },
-      promptConstructor: {
-        type: "promptConstructor",
-        label: "Prompt Constructor",
-        description: "Template-based prompt with @variable interpolation from connected Prompt nodes",
-        category: "input",
-        icon: "Puzzle",
-        inputs: [{ id: "text", type: "text", label: "Variables", multiple: true }],
-        outputs: [{ id: "text", type: "text", label: "Prompt" }],
-        defaultData: {
-          label: "Prompt Constructor",
-          status: "idle",
-          template: "",
-          outputText: null,
-          unresolvedVars: []
-        }
-      },
-      // AI nodes
-      imageGen: {
-        type: "imageGen",
-        label: "Image Generator",
-        description: "Generate images with nano-banana models",
-        category: "ai",
-        icon: "Sparkles",
-        inputs: [
-          { id: "prompt", type: "text", label: "Prompt", required: true },
-          { id: "images", type: "image", label: "Reference Images", multiple: true }
-        ],
-        outputs: [{ id: "image", type: "image", label: "Generated Image" }],
-        defaultData: {
-          label: "Image Generator",
-          status: "idle",
-          inputImages: [],
-          inputPrompt: null,
-          outputImage: null,
-          outputImages: [],
-          model: "nano-banana-pro",
-          aspectRatio: "1:1",
-          resolution: "2K",
-          outputFormat: "jpg",
-          jobId: null
-        }
-      },
-      videoGen: {
-        type: "videoGen",
-        label: "Video Generator",
-        description: "Generate videos with veo-3.1 models",
-        category: "ai",
-        icon: "Video",
-        inputs: [
-          { id: "prompt", type: "text", label: "Prompt", required: true },
-          { id: "image", type: "image", label: "Starting Frame" },
-          { id: "lastFrame", type: "image", label: "Last Frame (interpolation)" }
-        ],
-        outputs: [{ id: "video", type: "video", label: "Generated Video" }],
-        defaultData: {
-          label: "Video Generator",
-          status: "idle",
-          inputImage: null,
-          lastFrame: null,
-          referenceImages: [],
-          inputPrompt: null,
-          negativePrompt: "",
-          outputVideo: null,
-          model: "veo-3.1-fast",
-          duration: 8,
-          aspectRatio: "16:9",
-          resolution: "1080p",
-          generateAudio: true,
-          jobId: null
-        }
-      },
-      llm: {
-        type: "llm",
-        label: "LLM",
-        description: "Generate text with meta-llama",
-        category: "ai",
-        icon: "Brain",
-        inputs: [{ id: "prompt", type: "text", label: "Prompt", required: true }],
-        outputs: [{ id: "text", type: "text", label: "Generated Text" }],
-        defaultData: {
-          label: "LLM",
-          status: "idle",
-          inputPrompt: null,
-          outputText: null,
-          model: "meta-llama-3.1-405b-instruct",
-          systemPrompt: "You are a creative assistant helping generate content prompts.",
-          temperature: 0.7,
-          maxTokens: 1024,
-          topP: 0.9,
-          jobId: null
-        }
-      },
-      lipSync: {
-        type: "lipSync",
-        label: "Lip Sync",
-        description: "Generate talking-head video from image/video and audio using Replicate",
-        category: "ai",
-        icon: "Mic",
-        inputs: [
-          { id: "image", type: "image", label: "Face Image" },
-          { id: "video", type: "video", label: "Source Video" },
-          { id: "audio", type: "audio", label: "Audio", required: true }
-        ],
-        outputs: [{ id: "video", type: "video", label: "Generated Video" }],
-        defaultData: {
-          label: "Lip Sync",
-          status: "idle",
-          inputImage: null,
-          inputVideo: null,
-          inputAudio: null,
-          outputVideo: null,
-          model: "sync/lipsync-2",
-          syncMode: "loop",
-          temperature: 0.5,
-          activeSpeaker: false,
-          jobId: null
-        }
-      },
-      voiceChange: {
-        type: "voiceChange",
-        label: "Voice Change",
-        description: "Replace or mix audio track in a video",
-        category: "ai",
-        icon: "AudioLines",
-        inputs: [
-          { id: "video", type: "video", label: "Video", required: true },
-          { id: "audio", type: "audio", label: "New Audio", required: true }
-        ],
-        outputs: [{ id: "video", type: "video", label: "Output Video" }],
-        defaultData: {
-          label: "Voice Change",
-          status: "idle",
-          inputVideo: null,
-          inputAudio: null,
-          outputVideo: null,
-          preserveOriginalAudio: false,
-          audioMixLevel: 0.5,
-          jobId: null
-        }
-      },
-      textToSpeech: {
-        type: "textToSpeech",
-        label: "Text to Speech",
-        description: "Convert text to natural-sounding speech using ElevenLabs",
-        category: "ai",
-        icon: "AudioLines",
-        inputs: [{ id: "text", type: "text", label: "Text", required: true }],
-        outputs: [{ id: "audio", type: "audio", label: "Audio" }],
-        defaultData: {
-          label: "Text to Speech",
-          status: "idle",
-          inputText: null,
-          outputAudio: null,
-          provider: "elevenlabs",
-          voice: "rachel",
-          stability: 0.5,
-          similarityBoost: 0.75,
-          speed: 1,
-          jobId: null
-        }
-      },
-      transcribe: {
-        type: "transcribe",
-        label: "Transcribe",
-        description: "Convert video or audio to text transcript",
-        category: "ai",
-        icon: "FileText",
-        inputs: [
-          { id: "video", type: "video", label: "Video" },
-          { id: "audio", type: "audio", label: "Audio" }
-        ],
-        outputs: [{ id: "text", type: "text", label: "Transcript" }],
-        defaultData: {
-          label: "Transcribe",
-          status: "idle",
-          inputVideo: null,
-          inputAudio: null,
-          outputText: null,
-          language: "auto",
-          timestamps: false,
-          jobId: null
-        }
-      },
-      motionControl: {
-        type: "motionControl",
-        label: "Motion Control",
-        description: "Generate video with precise motion control using Kling AI",
-        category: "ai",
-        icon: "Navigation",
-        inputs: [
-          { id: "image", type: "image", label: "Image", required: true },
-          { id: "video", type: "video", label: "Motion Video" },
-          { id: "prompt", type: "text", label: "Prompt" }
-        ],
-        outputs: [{ id: "video", type: "video", label: "Video" }],
-        defaultData: {
-          label: "Motion Control",
-          status: "idle",
-          inputImage: null,
-          inputVideo: null,
-          inputPrompt: null,
-          outputVideo: null,
-          mode: "video_transfer",
-          duration: 5,
-          aspectRatio: "16:9",
-          trajectoryPoints: [],
-          cameraMovement: "static",
-          cameraIntensity: 50,
-          qualityMode: "pro",
-          characterOrientation: "image",
-          keepOriginalSound: true,
-          motionStrength: 50,
-          negativePrompt: "",
-          seed: null,
-          jobId: null
-        }
-      },
-      // Processing nodes
-      resize: {
-        type: "resize",
-        label: "Resize",
-        description: "Resize images or videos to different aspect ratios using Luma AI",
-        category: "processing",
-        icon: "Maximize2",
-        inputs: [{ id: "media", type: "image", label: "Media", required: true }],
-        outputs: [{ id: "media", type: "image", label: "Resized Media" }],
-        defaultData: {
-          label: "Resize",
-          status: "idle",
-          inputMedia: null,
-          inputType: null,
-          outputMedia: null,
-          targetAspectRatio: "16:9",
-          prompt: "",
-          gridPosition: { x: 0.5, y: 0.5 },
-          jobId: null
-        }
-      },
-      animation: {
-        type: "animation",
-        label: "Animation",
-        description: "Apply easing curve to video",
-        category: "processing",
-        icon: "Wand2",
-        inputs: [{ id: "video", type: "video", label: "Video", required: true }],
-        outputs: [{ id: "video", type: "video", label: "Animated Video" }],
-        defaultData: {
-          label: "Animation",
-          status: "idle",
-          inputVideo: null,
-          outputVideo: null,
-          curveType: "preset",
-          preset: "easeInOutCubic",
-          customCurve: [0.645, 0.045, 0.355, 1],
-          speedMultiplier: 1
-        }
-      },
-      videoStitch: {
-        type: "videoStitch",
-        label: "Video Stitch",
-        description: "Concatenate multiple videos",
-        category: "processing",
-        icon: "Layers",
-        inputs: [{ id: "videos", type: "video", label: "Videos", multiple: true, required: true }],
-        outputs: [{ id: "video", type: "video", label: "Stitched Video" }],
-        defaultData: {
-          label: "Video Stitch",
-          status: "idle",
-          inputVideos: [],
-          outputVideo: null,
-          transitionType: "crossfade",
-          transitionDuration: 0.5,
-          seamlessLoop: false
-        }
-      },
-      videoTrim: {
-        type: "videoTrim",
-        label: "Video Trim",
-        description: "Trim video to a specific time range",
-        category: "processing",
-        icon: "Scissors",
-        inputs: [{ id: "video", type: "video", label: "Video", required: true }],
-        outputs: [{ id: "video", type: "video", label: "Trimmed Video" }],
-        defaultData: {
-          label: "Video Trim",
-          status: "idle",
-          inputVideo: null,
-          outputVideo: null,
-          startTime: 0,
-          endTime: 60,
-          duration: null,
-          jobId: null
-        }
-      },
-      videoFrameExtract: {
-        type: "videoFrameExtract",
-        label: "Frame Extract",
-        description: "Extract a specific frame from video as image",
-        category: "processing",
-        icon: "Film",
-        inputs: [{ id: "video", type: "video", label: "Video", required: true }],
-        outputs: [{ id: "image", type: "image", label: "Extracted Frame" }],
-        defaultData: {
-          label: "Frame Extract",
-          status: "idle",
-          inputVideo: null,
-          outputImage: null,
-          selectionMode: "last",
-          timestampSeconds: 0,
-          percentagePosition: 100,
-          videoDuration: null,
-          jobId: null
-        }
-      },
-      reframe: {
-        type: "reframe",
-        label: "Reframe",
-        description: "Reframe images or videos to different aspect ratios with AI outpainting",
-        category: "processing",
-        icon: "Crop",
-        inputs: [
-          { id: "image", type: "image", label: "Image" },
-          { id: "video", type: "video", label: "Video" }
-        ],
-        outputs: [
-          { id: "image", type: "image", label: "Reframed Image" },
-          { id: "video", type: "video", label: "Reframed Video" }
-        ],
-        defaultData: {
-          label: "Reframe",
-          status: "idle",
-          inputImage: null,
-          inputVideo: null,
-          inputType: null,
-          outputImage: null,
-          outputVideo: null,
-          model: "photon-flash-1",
-          aspectRatio: "16:9",
-          prompt: "",
-          gridPosition: { x: 0.5, y: 0.5 },
-          jobId: null
-        }
-      },
-      upscale: {
-        type: "upscale",
-        label: "Upscale",
-        description: "AI-powered upscaling for images and videos",
-        category: "processing",
-        icon: "Maximize",
-        inputs: [
-          { id: "image", type: "image", label: "Image" },
-          { id: "video", type: "video", label: "Video" }
-        ],
-        outputs: [
-          { id: "image", type: "image", label: "Upscaled Image" },
-          { id: "video", type: "video", label: "Upscaled Video" }
-        ],
-        defaultData: {
-          label: "Upscale",
-          status: "idle",
-          inputImage: null,
-          inputVideo: null,
-          inputType: null,
-          outputImage: null,
-          outputVideo: null,
-          originalPreview: null,
-          outputPreview: null,
-          model: "topaz-standard-v2",
-          upscaleFactor: "2x",
-          outputFormat: "png",
-          faceEnhancement: false,
-          faceEnhancementStrength: 80,
-          faceEnhancementCreativity: 0,
-          targetResolution: "1080p",
-          targetFps: 30,
-          showComparison: true,
-          comparisonPosition: 50,
-          jobId: null
-        }
-      },
-      imageGridSplit: {
-        type: "imageGridSplit",
-        label: "Grid Split",
-        description: "Split image into grid cells",
-        category: "processing",
-        icon: "Grid3X3",
-        inputs: [{ id: "image", type: "image", label: "Image", required: true }],
-        outputs: [{ id: "images", type: "image", label: "Split Images", multiple: true }],
-        defaultData: {
-          label: "Grid Split",
-          status: "idle",
-          inputImage: null,
-          outputImages: [],
-          gridRows: 2,
-          gridCols: 3,
-          borderInset: 10,
-          outputFormat: "jpg",
-          quality: 95
-        }
-      },
-      annotation: {
-        type: "annotation",
-        label: "Annotation",
-        description: "Add shapes, arrows, and text to images",
-        category: "processing",
-        icon: "Pencil",
-        inputs: [{ id: "image", type: "image", label: "Image", required: true }],
-        outputs: [{ id: "image", type: "image", label: "Annotated Image" }],
-        defaultData: {
-          label: "Annotation",
-          status: "idle",
-          inputImage: null,
-          outputImage: null,
-          annotations: [],
-          hasAnnotations: false
-        }
-      },
-      subtitle: {
-        type: "subtitle",
-        label: "Subtitle",
-        description: "Burn subtitles into video using FFmpeg",
-        category: "processing",
-        icon: "Subtitles",
-        inputs: [
-          { id: "video", type: "video", label: "Video", required: true },
-          { id: "text", type: "text", label: "Subtitle Text", required: true }
-        ],
-        outputs: [{ id: "video", type: "video", label: "Video with Subtitles" }],
-        defaultData: {
-          label: "Subtitle",
-          status: "idle",
-          inputVideo: null,
-          inputText: null,
-          outputVideo: null,
-          style: "modern",
-          position: "bottom",
-          fontSize: 24,
-          fontColor: "#FFFFFF",
-          backgroundColor: "rgba(0,0,0,0.7)",
-          fontFamily: "Arial",
-          jobId: null
-        }
-      },
-      outputGallery: {
-        type: "outputGallery",
-        label: "Output Gallery",
-        description: "Thumbnail grid with lightbox for multi-image outputs",
-        category: "output",
-        icon: "LayoutGrid",
-        inputs: [{ id: "image", type: "image", label: "Images", multiple: true }],
-        outputs: [],
-        defaultData: {
-          label: "Output Gallery",
-          status: "idle",
-          images: []
-        }
-      },
-      imageCompare: {
-        type: "imageCompare",
-        label: "Image Compare",
-        description: "Side-by-side A/B comparison with draggable slider",
-        category: "output",
-        icon: "Columns2",
-        inputs: [
-          { id: "image", type: "image", label: "Image A" },
-          { id: "image-1", type: "image", label: "Image B" }
-        ],
-        outputs: [],
-        defaultData: {
-          label: "Image Compare",
-          status: "idle",
-          imageA: null,
-          imageB: null
-        }
-      },
-      // Output nodes
-      download: {
-        type: "download",
-        label: "Download",
-        description: "Download workflow output with custom filename",
-        category: "output",
-        icon: "Download",
-        inputs: [
-          { id: "image", type: "image", label: "Image" },
-          { id: "video", type: "video", label: "Video" }
-        ],
-        outputs: [],
-        defaultData: {
-          label: "Download",
-          status: "idle",
-          inputImage: null,
-          inputVideo: null,
-          inputType: null,
-          outputName: "output"
-        }
-      },
-      // Composition nodes (workflow-as-node)
-      workflowInput: {
-        type: "workflowInput",
-        label: "Workflow Input",
-        description: "Define an input port for when this workflow is used as a subworkflow",
-        category: "composition",
-        icon: "ArrowRightToLine",
-        inputs: [],
-        outputs: [{ id: "value", type: "image", label: "Value" }],
-        // Type is dynamic based on inputType
-        defaultData: {
-          label: "Workflow Input",
-          status: "idle",
-          inputName: "input",
-          inputType: "image",
-          required: true,
-          description: ""
-        }
-      },
-      workflowOutput: {
-        type: "workflowOutput",
-        label: "Workflow Output",
-        description: "Define an output port for when this workflow is used as a subworkflow",
-        category: "composition",
-        icon: "ArrowLeftFromLine",
-        inputs: [{ id: "value", type: "image", label: "Value", required: true }],
-        // Type is dynamic based on outputType
-        outputs: [],
-        defaultData: {
-          label: "Workflow Output",
-          status: "idle",
-          outputName: "output",
-          outputType: "image",
-          description: "",
-          inputValue: null
-        }
-      },
-      workflowRef: {
-        type: "workflowRef",
-        label: "Subworkflow",
-        description: "Reference another workflow as a subworkflow",
-        category: "composition",
-        icon: "GitBranch",
-        inputs: [],
-        // Dynamic based on referenced workflow interface
-        outputs: [],
-        // Dynamic based on referenced workflow interface
-        defaultData: {
-          label: "Subworkflow",
-          status: "idle",
-          referencedWorkflowId: null,
-          referencedWorkflowName: null,
-          cachedInterface: null,
-          inputMappings: {},
-          outputMappings: {},
-          childExecutionId: null
-        }
-      }
-      // Multi-format nodes removed - format conversion now handled by schema-driven engine
-    };
-    var NODE_ORDER = {
-      input: ["imageInput", "videoInput", "audioInput", "prompt", "promptConstructor"],
-      ai: [
-        "imageGen",
-        "videoGen",
-        "llm",
-        "lipSync",
-        "textToSpeech",
-        "transcribe",
-        "voiceChange",
-        "motionControl"
-      ],
-      processing: [
-        "reframe",
-        "upscale",
-        "resize",
-        "videoStitch",
-        "videoTrim",
-        "videoFrameExtract",
-        "imageGridSplit",
-        "annotation",
-        "subtitle",
-        "animation"
-      ],
-      output: ["download", "outputGallery", "imageCompare"],
-      composition: ["workflowRef", "workflowInput", "workflowOutput"]
-    };
-    function getNodesByCategory() {
-      const categories = {
-        input: [],
-        ai: [],
-        processing: [],
-        output: [],
-        composition: []
-      };
-      for (const category of Object.keys(NODE_ORDER)) {
-        for (const nodeType of NODE_ORDER[category]) {
-          const def = NODE_DEFINITIONS5[nodeType];
-          if (def) {
-            categories[category].push(def);
-          }
-        }
-      }
-      return categories;
-    }
-    exports$1.CONNECTION_RULES = CONNECTION_RULES2;
-    exports$1.HandleTypeEnum = HandleTypeEnum;
-    exports$1.KlingQuality = KlingQuality;
-    exports$1.ModelCapabilityEnum = ModelCapabilityEnum;
-    exports$1.ModelUseCaseEnum = ModelUseCaseEnum;
-    exports$1.NODE_DEFINITIONS = NODE_DEFINITIONS5;
-    exports$1.NODE_ORDER = NODE_ORDER;
-    exports$1.NodeCategoryEnum = NodeCategoryEnum;
-    exports$1.NodeStatusEnum = NodeStatusEnum;
-    exports$1.NodeTypeEnum = NodeTypeEnum;
-    exports$1.ProcessingNodeType = ProcessingNodeType;
-    exports$1.ProviderTypeEnum = ProviderTypeEnum;
-    exports$1.ReframeNodeType = ReframeNodeType;
-    exports$1.TemplateCategory = TemplateCategory;
-    exports$1.UpscaleNodeType = UpscaleNodeType;
-    exports$1.getNodesByCategory = getNodesByCategory;
-  }
-});
-
-// ../types/dist/chunk-KXAKQO3U.js
-var require_chunk_KXAKQO3U = chunkZ7PWFZG5_js.__commonJS({
-  "../types/dist/chunk-KXAKQO3U.js"(exports$1) {
-    var EdgeStyleEnum = /* @__PURE__ */ ((EdgeStyleEnum2) => {
-      EdgeStyleEnum2["DEFAULT"] = "default";
-      EdgeStyleEnum2["SMOOTHSTEP"] = "smoothstep";
-      EdgeStyleEnum2["STRAIGHT"] = "straight";
-      return EdgeStyleEnum2;
-    })(EdgeStyleEnum || {});
-    exports$1.EdgeStyleEnum = EdgeStyleEnum;
-  }
-});
-
-// ../types/dist/chunk-RNGYPX4W.js
-var require_chunk_RNGYPX4W = chunkZ7PWFZG5_js.__commonJS({
-  "../types/dist/chunk-RNGYPX4W.js"() {
-  }
-});
-
-// ../types/dist/index.js
-var require_dist = chunkZ7PWFZG5_js.__commonJS({
-  "../types/dist/index.js"(exports$1) {
-    var chunkP7K5LM6V_js = require_chunk_P7K5LM6V();
-    var chunkKXAKQO3U_js = require_chunk_KXAKQO3U();
-    require_chunk_RNGYPX4W();
-    var PROMPT_CATEGORIES = [
-      "ads",
-      "anime",
-      "product",
-      "portrait",
-      "landscape",
-      "abstract",
-      "fashion",
-      "food",
-      "architecture",
-      "custom"
-    ];
-    var MOOD_PRESETS = [
-      "cinematic",
-      "dreamy",
-      "gritty",
-      "ethereal",
-      "nostalgic",
-      "futuristic",
-      "mysterious",
-      "peaceful",
-      "energetic",
-      "moody",
-      "dramatic",
-      "whimsical"
-    ];
-    var STYLE_PRESETS = [
-      "photorealistic",
-      "anime",
-      "3d-render",
-      "oil-painting",
-      "watercolor",
-      "digital-art",
-      "comic-book",
-      "sketch",
-      "pixel-art",
-      "minimalist",
-      "cyberpunk",
-      "fantasy",
-      "retro",
-      "vintage"
-    ];
-    var CAMERA_PRESETS = [
-      "wide-angle",
-      "macro",
-      "telephoto",
-      "drone",
-      "portrait",
-      "fisheye",
-      "tilt-shift",
-      "gopro",
-      "close-up",
-      "establishing",
-      "eye-level",
-      "low-angle",
-      "high-angle",
-      "dutch-angle"
-    ];
-    var LIGHTING_PRESETS = [
-      "golden-hour",
-      "studio",
-      "neon",
-      "natural",
-      "dramatic",
-      "soft",
-      "backlit",
-      "rim-light",
-      "high-key",
-      "low-key",
-      "candlelight",
-      "moonlight",
-      "fluorescent",
-      "cinematic"
-    ];
-    var SCENE_PRESETS = [
-      "indoor",
-      "outdoor",
-      "urban",
-      "nature",
-      "studio",
-      "underwater",
-      "space",
-      "abstract",
-      "industrial",
-      "domestic",
-      "beach",
-      "forest",
-      "city-skyline",
-      "desert"
-    ];
-    var CATEGORY_LABELS = {
-      ads: "Ads & Marketing",
-      anime: "Anime & Manga",
-      product: "Product Photography",
-      portrait: "Portraits",
-      landscape: "Landscapes",
-      abstract: "Abstract Art",
-      fashion: "Fashion",
-      food: "Food & Culinary",
-      architecture: "Architecture",
-      custom: "Custom"
-    };
-    Object.defineProperty(exports$1, "CONNECTION_RULES", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.CONNECTION_RULES;
-      }
-    });
-    Object.defineProperty(exports$1, "HandleTypeEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.HandleTypeEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "KlingQuality", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.KlingQuality;
-      }
-    });
-    Object.defineProperty(exports$1, "ModelCapabilityEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.ModelCapabilityEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "ModelUseCaseEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.ModelUseCaseEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "NODE_DEFINITIONS", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.NODE_DEFINITIONS;
-      }
-    });
-    Object.defineProperty(exports$1, "NODE_ORDER", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.NODE_ORDER;
-      }
-    });
-    Object.defineProperty(exports$1, "NodeCategoryEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.NodeCategoryEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "NodeStatusEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.NodeStatusEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "NodeTypeEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.NodeTypeEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "ProcessingNodeType", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.ProcessingNodeType;
-      }
-    });
-    Object.defineProperty(exports$1, "ProviderTypeEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.ProviderTypeEnum;
-      }
-    });
-    Object.defineProperty(exports$1, "ReframeNodeType", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.ReframeNodeType;
-      }
-    });
-    Object.defineProperty(exports$1, "TemplateCategory", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.TemplateCategory;
-      }
-    });
-    Object.defineProperty(exports$1, "UpscaleNodeType", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.UpscaleNodeType;
-      }
-    });
-    Object.defineProperty(exports$1, "getNodesByCategory", {
-      enumerable: true,
-      get: function() {
-        return chunkP7K5LM6V_js.getNodesByCategory;
-      }
-    });
-    Object.defineProperty(exports$1, "EdgeStyleEnum", {
-      enumerable: true,
-      get: function() {
-        return chunkKXAKQO3U_js.EdgeStyleEnum;
-      }
-    });
-    exports$1.CAMERA_PRESETS = CAMERA_PRESETS;
-    exports$1.CATEGORY_LABELS = CATEGORY_LABELS;
-    exports$1.LIGHTING_PRESETS = LIGHTING_PRESETS;
-    exports$1.MOOD_PRESETS = MOOD_PRESETS;
-    exports$1.PROMPT_CATEGORIES = PROMPT_CATEGORIES;
-    exports$1.SCENE_PRESETS = SCENE_PRESETS;
-    exports$1.STYLE_PRESETS = STYLE_PRESETS;
-  }
-});
-
-// src/stores/workflow/helpers/equality.ts
-function temporalStateEquals(a, b) {
-  if (a === b) return true;
-  if (!arraysShallowEqual(a.nodes, b.nodes, nodeEquals)) return false;
-  if (!arraysShallowEqual(a.edges, b.edges, edgeEquals)) return false;
-  if (!arraysShallowEqual(a.groups, b.groups, groupEquals)) return false;
-  return true;
-}
-function arraysShallowEqual(a, b, itemEquals) {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (!itemEquals(a[i], b[i])) return false;
-  }
-  return true;
-}
-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.width !== b.width || a.height !== b.height) return false;
-  const aData = a.data;
-  const bData = b.data;
-  if (aData.status !== bData.status) return false;
-  if (aData.outputImage !== bData.outputImage) return false;
-  if (aData.outputVideo !== bData.outputVideo) return false;
-  if (aData.outputText !== bData.outputText) return false;
-  if (aData.outputAudio !== bData.outputAudio) return false;
-  if (aData.prompt !== bData.prompt) return false;
-  if (aData.image !== bData.image) return false;
-  if (aData.video !== bData.video) return false;
-  if (aData.audio !== bData.audio) return false;
-  if (aData.inputPrompt !== bData.inputPrompt) return false;
-  if (aData.inputImage !== bData.inputImage) return false;
-  if (aData.inputVideo !== bData.inputVideo) return false;
-  if (aData.inputAudio !== bData.inputAudio) return false;
-  if (aData.inputText !== bData.inputText) return false;
-  if (aData.model !== bData.model) return false;
-  if (aData.schemaParams !== bData.schemaParams) {
-    if (JSON.stringify(aData.schemaParams) !== JSON.stringify(bData.schemaParams)) {
-      return false;
-    }
-  }
-  return true;
-}
-function edgeEquals(a, b) {
-  if (a === b) return true;
-  return a.id === b.id && a.source === b.source && a.target === b.target && a.sourceHandle === b.sourceHandle && a.targetHandle === b.targetHandle;
-}
-function groupEquals(a, b) {
-  if (a === b) return true;
-  if (a.id !== b.id) return false;
-  if (a.name !== b.name) return false;
-  if (a.color !== b.color) return false;
-  if (a.nodeIds.length !== b.nodeIds.length) return false;
-  for (let i = 0; i < a.nodeIds.length; i++) {
-    if (a.nodeIds[i] !== b.nodeIds[i]) return false;
-  }
-  return true;
-}
-
-// src/stores/workflow/slices/chatSlice.ts
-var createChatSlice = (set, get) => ({
-  chatMessages: [],
-  isChatOpen: false,
-  addChatMessage: (role, content) => {
-    set((state) => ({
-      chatMessages: [
-        ...state.chatMessages,
-        {
-          id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-          role,
-          content,
-          timestamp: Date.now()
-        }
-      ]
-    }));
-  },
-  clearChatMessages: () => {
-    set({ chatMessages: [] });
-  },
-  toggleChat: () => {
-    set((state) => ({ isChatOpen: !state.isChatOpen }));
-  },
-  setChatOpen: (open) => {
-    set({ isChatOpen: open });
-  },
-  applyChatEditOperations: (operations) => {
-    const state = get();
-    state.captureSnapshot();
-    return state.applyEditOperations(operations);
-  }
-});
-
-// src/stores/workflow/slices/edgeSlice.ts
-var import_types2 = chunkZ7PWFZG5_js.__toESM(require_dist());
-
-// src/stores/workflow/helpers/nodeHelpers.ts
-var import_types = chunkZ7PWFZG5_js.__toESM(require_dist());
-function generateId() {
-  return nanoid.nanoid(8);
-}
-function getHandleType(nodeType, handleId, direction) {
-  const nodeDef = import_types.NODE_DEFINITIONS[nodeType];
-  if (!nodeDef) return null;
-  const handles = direction === "source" ? nodeDef.outputs : nodeDef.inputs;
-  const handle = handles.find((h) => h.id === handleId);
-  return handle?.type ?? null;
-}
-
-// 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"
-    );
-    set((state) => ({
-      nodes: react.applyNodeChanges(changes, state.nodes),
-      ...hasMeaningfulChange && { isDirty: true }
-    }));
-  },
-  onEdgesChange: (changes) => {
-    const hasMeaningfulChange = changes.some(
-      (change) => change.type === "add" || change.type === "remove" || change.type === "replace"
-    );
-    set((state) => ({
-      edges: react.applyEdgeChanges(changes, state.edges),
-      ...hasMeaningfulChange && { isDirty: true }
-    }));
-  },
-  onConnect: (connection) => {
-    const { isValidConnection, propagateOutputsDownstream } = get();
-    if (!isValidConnection(connection)) return;
-    set((state) => ({
-      edges: react.addEdge(
-        {
-          ...connection,
-          id: generateId(),
-          type: state.edgeStyle
-        },
-        state.edges
-      ),
-      isDirty: true
-    }));
-    if (connection.source) {
-      propagateOutputsDownstream(connection.source);
-    }
-  },
-  removeEdge: (edgeId) => {
-    set((state) => ({
-      edges: state.edges.filter((edge) => edge.id !== edgeId),
-      isDirty: true
-    }));
-  },
-  setEdgeStyle: (style) => {
-    set((state) => ({
-      edgeStyle: style,
-      edges: state.edges.map((edge) => ({ ...edge, type: style })),
-      isDirty: true
-    }));
-  },
-  toggleEdgePause: (edgeId) => {
-    set((state) => ({
-      edges: state.edges.map(
-        (edge) => edge.id === edgeId ? {
-          ...edge,
-          data: {
-            ...edge.data,
-            hasPause: !edge.data?.hasPause
-          }
-        } : edge
-      ),
-      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 import_types2.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 = import_types2.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 (import_types2.CONNECTION_RULES[sourceType]?.includes(input.type)) {
-        return input.id;
-      }
-    }
-    return null;
-  }
-});
-
-// src/stores/workflow/slices/groupSlice.ts
-var DEFAULT_GROUP_COLORS = [
-  "purple",
-  "blue",
-  "green",
-  "yellow",
-  "orange",
-  "red",
-  "pink",
-  "gray"
-];
-var createGroupSlice = (set, get) => ({
-  createGroup: (nodeIds, name) => {
-    if (nodeIds.length === 0) return "";
-    const groupId = generateId();
-    const { groups } = get();
-    const colorIndex = groups.length % DEFAULT_GROUP_COLORS.length;
-    const newGroup = {
-      id: groupId,
-      name: name ?? `Group ${groups.length + 1}`,
-      nodeIds,
-      isLocked: false,
-      color: DEFAULT_GROUP_COLORS[colorIndex]
-    };
-    set((state) => ({
-      groups: [...state.groups, newGroup],
-      isDirty: true
-    }));
-    return groupId;
-  },
-  deleteGroup: (groupId) => {
-    set((state) => ({
-      groups: state.groups.filter((g) => g.id !== groupId),
-      isDirty: true
-    }));
-  },
-  addToGroup: (groupId, nodeIds) => {
-    set((state) => ({
-      groups: state.groups.map(
-        (g) => g.id === groupId ? { ...g, nodeIds: [.../* @__PURE__ */ new Set([...g.nodeIds, ...nodeIds])] } : g
-      ),
-      isDirty: true
-    }));
-  },
-  removeFromGroup: (groupId, nodeIds) => {
-    set((state) => ({
-      groups: state.groups.map(
-        (g) => g.id === groupId ? { ...g, nodeIds: g.nodeIds.filter((id) => !nodeIds.includes(id)) } : g
-      ),
-      isDirty: true
-    }));
-  },
-  toggleGroupLock: (groupId) => {
-    const { groups, lockMultipleNodes, unlockMultipleNodes } = 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),
-      isDirty: true
-    }));
-    if (!group.isLocked) {
-      lockMultipleNodes(group.nodeIds);
-    } 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);
-  }
-});
-
-// src/stores/workflow/helpers/propagation.ts
-function getNodeOutput(node) {
-  const data = node.data;
-  const outputImages = data.outputImages;
-  if (outputImages?.length) return outputImages[0];
-  const output = data.outputImage ?? data.outputVideo ?? data.outputText ?? data.outputAudio ?? data.prompt ?? data.extractedTweet ?? data.image ?? data.video ?? data.audio ?? null;
-  if (output === null) return null;
-  if (typeof output === "string") return output;
-  if (Array.isArray(output) && output.length > 0) return String(output[0]);
-  return null;
-}
-function getOutputType(sourceType) {
-  if (["prompt", "llm", "tweetParser", "transcribe"].includes(sourceType)) {
-    return "text";
-  }
-  if (["imageGen", "image", "imageInput", "upscale", "resize", "reframe", "imageGridSplit"].includes(
-    sourceType
-  )) {
-    return "image";
-  }
-  if ([
-    "videoGen",
-    "video",
-    "videoInput",
-    "animation",
-    "videoStitch",
-    "lipSync",
-    "voiceChange",
-    "motionControl",
-    "videoTrim",
-    "videoFrameExtract",
-    "subtitle"
-  ].includes(sourceType)) {
-    return "video";
-  }
-  if (["textToSpeech", "audio", "audioInput"].includes(sourceType)) {
-    return "audio";
-  }
-  return null;
-}
-function mapOutputToInput(output, sourceType, targetType) {
-  const outputType = getOutputType(sourceType);
-  if (targetType === "download") {
-    if (outputType === "video") {
-      return { inputVideo: output, inputImage: null, inputType: "video" };
-    }
-    if (outputType === "image") {
-      return { inputImage: output, inputVideo: null, inputType: "image" };
-    }
-    return null;
-  }
-  if (outputType === "text") {
-    if (["textToSpeech", "subtitle"].includes(targetType)) {
-      return { inputText: output };
-    }
-    if (["imageGen", "videoGen", "llm", "motionControl"].includes(targetType)) {
-      return { inputPrompt: output };
-    }
-  }
-  if (outputType === "image") {
-    if (["upscale", "reframe"].includes(targetType)) {
-      return { inputImage: output, inputVideo: null, inputType: "image" };
-    }
-    if (["videoGen", "lipSync", "voiceChange", "motionControl", "resize", "animation"].includes(
-      targetType
-    )) {
-      return { inputImage: output };
-    }
-    if (targetType === "imageGen") {
-      return { inputImages: [output] };
-    }
-  }
-  if (outputType === "video") {
-    if (["upscale", "reframe"].includes(targetType)) {
-      return { inputVideo: output, inputImage: null, inputType: "video" };
-    }
-    if ([
-      "lipSync",
-      "voiceChange",
-      "resize",
-      "videoStitch",
-      "videoTrim",
-      "videoFrameExtract",
-      "subtitle",
-      "transcribe"
-    ].includes(targetType)) {
-      return { inputVideo: output };
-    }
-  }
-  if (outputType === "audio") {
-    if (["lipSync", "voiceChange", "transcribe"].includes(targetType)) {
-      return { inputAudio: output };
-    }
-  }
-  return null;
-}
-function collectGalleryUpdate(sourceData, currentOutput, existingGalleryImages, pendingUpdateImages) {
-  const allImages = [];
-  const outputImagesArr = sourceData.outputImages;
-  if (outputImagesArr?.length) {
-    allImages.push(...outputImagesArr);
-  } else if (typeof currentOutput === "string") {
-    allImages.push(currentOutput);
-  }
-  if (allImages.length === 0) return null;
-  return {
-    images: [.../* @__PURE__ */ new Set([...existingGalleryImages, ...pendingUpdateImages, ...allImages])]
-  };
-}
-function computeDownstreamUpdates(sourceNodeId, initialOutput, nodes, edges) {
-  const updates = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [
-    { nodeId: sourceNodeId, output: initialOutput }
-  ];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (visited.has(current.nodeId)) continue;
-    visited.add(current.nodeId);
-    const currentNode = nodes.find((n) => n.id === current.nodeId);
-    if (!currentNode) continue;
-    const downstreamEdges = edges.filter((e) => e.source === current.nodeId);
-    for (const edge of downstreamEdges) {
-      const targetNode = nodes.find((n) => n.id === edge.target);
-      if (!targetNode) continue;
-      if (targetNode.type === "outputGallery") {
-        const sourceData = currentNode.data;
-        const existing = updates.get(edge.target) ?? {};
-        const pendingImages = existing.images ?? [];
-        const targetData = targetNode.data;
-        const galleryExisting = targetData.images ?? [];
-        const galleryUpdate = collectGalleryUpdate(
-          sourceData,
-          current.output,
-          galleryExisting,
-          pendingImages
-        );
-        if (galleryUpdate) {
-          updates.set(edge.target, { ...existing, ...galleryUpdate });
-        }
-        continue;
-      }
-      const inputUpdate = mapOutputToInput(current.output, currentNode.type, targetNode.type);
-      if (inputUpdate) {
-        const existing = updates.get(edge.target) ?? {};
-        updates.set(edge.target, { ...existing, ...inputUpdate });
-        const targetOutput = getNodeOutput(targetNode);
-        if (targetOutput && !visited.has(edge.target)) {
-          queue.push({ nodeId: edge.target, output: targetOutput });
-        }
-      }
-    }
-  }
-  return updates;
-}
-function hasStateChanged(updates, nodes) {
-  for (const [nodeId, update] of updates) {
-    const existingNode = nodes.find((n) => n.id === nodeId);
-    if (!existingNode) continue;
-    const existingData = existingNode.data;
-    for (const [key, value] of Object.entries(update)) {
-      const prev = existingData[key];
-      if (Array.isArray(prev) && Array.isArray(value)) {
-        if (prev.length !== value.length || prev.some((v, i) => v !== value[i])) {
-          return true;
-        }
-      } else if (prev !== value) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function applyNodeUpdates(nodes, updates) {
-  return nodes.map((n) => {
-    const update = updates.get(n.id);
-    if (update) {
-      return { ...n, data: { ...n.data, ...update } };
-    }
-    return n;
-  });
-}
-function propagateExistingOutputs(nodes, propagateFn) {
-  for (const node of nodes) {
-    if (getNodeOutput(node) !== null) {
-      propagateFn(node.id);
-    }
-  }
-}
-
-// src/stores/workflow/slices/lockingSlice.ts
-var createLockingSlice = (set, get) => ({
-  _setNodeLockState: (predicate, lock) => {
-    set((state) => ({
-      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) }
-          }
-        } : 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);
-  },
-  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);
-  },
-  lockMultipleNodes: (nodeIds) => {
-    get()._setNodeLockState((id) => nodeIds.includes(id), true);
-  },
-  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));
-  }
-});
-
-// src/stores/workflow/slices/nodeSlice.ts
-var import_types3 = chunkZ7PWFZG5_js.__toESM(require_dist());
-var createNodeSlice = (set, get) => ({
-  addNode: (type, position) => {
-    const nodeDef = import_types3.NODE_DEFINITIONS[type];
-    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 }
-    };
-    set((state) => ({
-      nodes: [...state.nodes, newNode],
-      isDirty: true
-    }));
-    return id;
-  },
-  addNodesAndEdges: (newNodes, newEdges) => {
-    if (newNodes.length === 0) return;
-    set((state) => ({
-      nodes: [...state.nodes, ...newNodes],
-      edges: [...state.edges, ...newEdges],
-      isDirty: true
-    }));
-    const { propagateOutputsDownstream } = get();
-    const sourceNodeIds = new Set(newEdges.map((e) => e.source));
-    for (const sourceId of sourceNodeIds) {
-      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));
-    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);
-      }
-    }
-  },
-  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
-    }));
-  },
-  duplicateNode: (nodeId) => {
-    const { nodes, edges, edgeStyle, propagateOutputsDownstream } = get();
-    const node = nodes.find((n) => n.id === nodeId);
-    if (!node) return null;
-    const newId = generateId();
-    const newNode = {
-      ...node,
-      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 clonedEdges = incomingEdges.map((edge) => ({
-      ...edge,
-      id: generateId(),
-      target: newId,
-      type: edgeStyle
-    }));
-    set((state) => ({
-      nodes: [...state.nodes, newNode],
-      edges: [...state.edges, ...clonedEdges],
-      isDirty: true
-    }));
-    const sourcesNotified = /* @__PURE__ */ new Set();
-    for (const edge of incomingEdges) {
-      if (!sourcesNotified.has(edge.source)) {
-        sourcesNotified.add(edge.source);
-        propagateOutputsDownstream(edge.source);
-      }
-    }
-    return newId;
-  },
-  propagateOutputsDownstream: (sourceNodeId, outputValue) => {
-    const { nodes, edges } = get();
-    const sourceNode = nodes.find((n) => n.id === sourceNodeId);
-    if (!sourceNode) return;
-    const output = outputValue ?? getNodeOutput(sourceNode);
-    if (!output) return;
-    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
-    }));
-  }
-});
-
-// src/stores/workflow/slices/persistenceSlice.ts
-var import_types4 = chunkZ7PWFZG5_js.__toESM(require_dist());
-function normalizeEdgeTypes(edges) {
-  return edges.map((edge) => ({
-    ...edge,
-    type: edge.type === "bezier" ? "default" : edge.type
-  }));
-}
-function hydrateWorkflowNodes(nodes) {
-  return nodes.map((node) => {
-    const nodeDef = import_types4.NODE_DEFINITIONS[node.type];
-    if (!nodeDef) return node;
-    return {
-      ...node,
-      data: {
-        ...nodeDef.defaultData,
-        ...node.data
-      }
-    };
-  });
-}
-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: []
-    });
-  },
-  exportWorkflow: () => {
-    const { nodes, edges, edgeStyle, workflowName, groups } = get();
-    return {
-      version: 1,
-      name: workflowName,
-      description: "",
-      nodes,
-      edges,
-      edgeStyle,
-      groups,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  },
-  getNodeById: (id) => {
-    return get().nodes.find((node) => node.id === id);
-  },
-  getConnectedInputs: (nodeId) => {
-    const { nodes, edges } = get();
-    const inputs = /* @__PURE__ */ new Map();
-    const incomingEdges = edges.filter((edge) => edge.target === nodeId);
-    for (const edge of incomingEdges) {
-      const sourceNode = nodes.find((n) => n.id === edge.source);
-      if (!sourceNode) continue;
-      const handleId = edge.targetHandle;
-      if (!handleId) continue;
-      const sourceData = sourceNode.data;
-      let value = null;
-      if (edge.sourceHandle === "image") {
-        value = sourceData.outputImage ?? sourceData.image ?? null;
-      } else if (edge.sourceHandle === "video") {
-        value = sourceData.outputVideo ?? sourceData.video ?? null;
-      } else if (edge.sourceHandle === "text") {
-        value = sourceData.outputText ?? sourceData.prompt ?? null;
-      } else if (edge.sourceHandle === "audio") {
-        value = sourceData.outputAudio ?? sourceData.audio ?? null;
-      }
-      if (value) {
-        const existing = inputs.get(handleId);
-        if (existing) {
-          if (Array.isArray(existing)) {
-            inputs.set(handleId, [...existing, value]);
-          } else {
-            inputs.set(handleId, [existing, value]);
-          }
-        } else {
-          inputs.set(handleId, value);
-        }
-      }
-    }
-    return inputs;
-  },
-  getConnectedNodeIds: (nodeIds) => {
-    const { edges } = get();
-    const connected = new Set(nodeIds);
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [...nodeIds];
-    while (queue.length > 0) {
-      const currentId = queue.shift();
-      if (visited.has(currentId)) continue;
-      visited.add(currentId);
-      const upstreamEdges = edges.filter((e) => e.target === currentId);
-      for (const edge of upstreamEdges) {
-        if (!connected.has(edge.source)) {
-          connected.add(edge.source);
-          queue.push(edge.source);
-        }
-      }
-    }
-    return Array.from(connected);
-  },
-  validateWorkflow: () => {
-    const { nodes, edges } = get();
-    const errors = [];
-    const warnings = [];
-    if (nodes.length === 0) {
-      errors.push({
-        nodeId: "",
-        message: "Workflow is empty - add some nodes first",
-        severity: "error"
-      });
-      return { isValid: false, errors, warnings };
-    }
-    if (edges.length === 0 && nodes.length > 1) {
-      errors.push({
-        nodeId: "",
-        message: "No connections - connect your nodes together",
-        severity: "error"
-      });
-      return { isValid: false, errors, warnings };
-    }
-    const hasNodeOutput = (node) => {
-      const data = node.data;
-      switch (node.type) {
-        case "prompt":
-          return Boolean(data.prompt?.trim());
-        case "imageInput":
-          return Boolean(data.image);
-        case "videoInput":
-          return Boolean(data.video);
-        case "audioInput":
-          return Boolean(data.audio);
-        default:
-          return true;
-      }
-    };
-    for (const node of nodes) {
-      const nodeDef = import_types4.NODE_DEFINITIONS[node.type];
-      if (!nodeDef) continue;
-      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);
-          if (!connectionEdge) {
-            errors.push({
-              nodeId: node.id,
-              message: `Missing required input: ${input.label}`,
-              severity: "error"
-            });
-          } else {
-            const sourceNode = nodes.find((n) => n.id === connectionEdge.source);
-            if (sourceNode && !hasNodeOutput(sourceNode)) {
-              errors.push({
-                nodeId: sourceNode.id,
-                message: `${sourceNode.data.label} is empty`,
-                severity: "error"
-              });
-            }
-          }
-        }
-      }
-    }
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    function hasCycle(nodeId) {
-      if (recStack.has(nodeId)) return true;
-      if (visited.has(nodeId)) return false;
-      visited.add(nodeId);
-      recStack.add(nodeId);
-      const outgoing = edges.filter((e) => e.source === nodeId);
-      for (const edge of outgoing) {
-        if (hasCycle(edge.target)) return true;
-      }
-      recStack.delete(nodeId);
-      return false;
-    }
-    for (const node of nodes) {
-      if (hasCycle(node.id)) {
-        errors.push({
-          nodeId: node.id,
-          message: "Workflow contains a cycle",
-          severity: "error"
-        });
-        break;
-      }
-    }
-    for (const node of nodes) {
-      if (node.type === "workflowRef") {
-        const refData = node.data;
-        if (!refData.referencedWorkflowId) {
-          errors.push({
-            nodeId: node.id,
-            message: "Subworkflow node must reference a workflow",
-            severity: "error"
-          });
-        } else if (!refData.cachedInterface) {
-          warnings.push({
-            nodeId: node.id,
-            message: "Subworkflow interface not loaded - refresh to update handles",
-            severity: "warning"
-          });
-        }
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors,
-      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]
-    }));
-  },
-  removeFromSelection: (nodeId) => {
-    set((state) => ({
-      selectedNodeIds: state.selectedNodeIds.filter((id) => id !== nodeId)
-    }));
-  },
-  clearSelection: () => {
-    set({ selectedNodeIds: [] });
-  }
-});
-
-// src/stores/workflow/slices/snapshotSlice.ts
-function defaultApplyEditOperations(_operations, state) {
-  return { nodes: state.nodes, edges: state.edges, applied: 0, skipped: [] };
-}
-var createSnapshotSlice = (set, get) => ({
-  previousWorkflowSnapshot: null,
-  manualChangeCount: 0,
-  captureSnapshot: () => {
-    const state = get();
-    const snapshot = {
-      nodes: JSON.parse(JSON.stringify(state.nodes)),
-      edges: JSON.parse(JSON.stringify(state.edges)),
-      groups: JSON.parse(JSON.stringify(state.groups)),
-      edgeStyle: state.edgeStyle
-    };
-    set({
-      previousWorkflowSnapshot: snapshot,
-      manualChangeCount: 0
-    });
-  },
-  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
-    });
-  },
-  incrementManualChangeCount: () => {
-    const state = get();
-    const newCount = state.manualChangeCount + 1;
-    if (newCount >= 3) {
-      set({
-        previousWorkflowSnapshot: null,
-        manualChangeCount: 0
-      });
-    } else {
-      set({ manualChangeCount: newCount });
-    }
-  },
-  applyEditOperations: (operations) => {
-    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 };
-  }
-});
-
-// src/stores/workflow/workflowStore.ts
-var storeCreator = ((...args) => ({
-  // Initial state
-  nodes: [],
-  edges: [],
-  edgeStyle: "default",
-  workflowName: "Untitled Workflow",
-  workflowId: null,
-  isDirty: false,
-  isSaving: false,
-  isLoading: false,
-  groups: [],
-  selectedNodeIds: [],
-  viewedCommentIds: /* @__PURE__ */ new Set(),
-  navigationTargetId: null,
-  // Compose slices
-  ...createNodeSlice(...args),
-  ...createEdgeSlice(...args),
-  ...createLockingSlice(...args),
-  ...createGroupSlice(...args),
-  ...createSelectionSlice(...args),
-  ...createPersistenceSlice(...args),
-  ...createSnapshotSlice(...args),
-  ...createChatSlice(...args)
-}));
-var useWorkflowStore = zustand.create()(
-  zundo.temporal(storeCreator, {
-    // 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
-  })
-);
-
-exports.require_dist = require_dist;
-exports.useWorkflowStore = useWorkflowStore;