Merge branch 'master' into patch_hooks

.github/workflows/pullrequest-ci-run.yml

@@ -23,7 +23,7 @@ jobs:
             runner_label: [self-hosted, Linux]
             flags: ""
           - os: windows
-            runner_label: [self-hosted, win]
+            runner_label: [self-hosted, Windows]
             flags: ""
     runs-on: ${{ matrix.runner_label }}
     steps:

.github/workflows/stable-release.yml

@@ -17,12 +17,12 @@ on:
         description: 'Python minor version'
         required: true
         type: string
-        default: "11"
+        default: "12"
       python_patch:
         description: 'Python patch version'
         required: true
         type: string
-        default: "9"
+        default: "7"
 
 
 jobs:

.github/workflows/test-ci.yml

@@ -32,7 +32,7 @@ jobs:
             runner_label: [self-hosted, Linux]
             flags: ""
           - os: windows
-            runner_label: [self-hosted, win]
+            runner_label: [self-hosted, Windows]
             flags: ""
     runs-on: ${{ matrix.runner_label }}
     steps:
@@ -55,7 +55,7 @@ jobs:
         torch_version: ["nightly"]
         include:
           - os: windows
-            runner_label: [self-hosted, win]
+            runner_label: [self-hosted, Windows]
             flags: ""
     runs-on: ${{ matrix.runner_label }}
     steps:

.github/workflows/windows_release_dependencies.yml

@@ -12,7 +12,7 @@ on:
         description: 'extra dependencies'
         required: false
         type: string
-        default: "\"numpy<2\""
+        default: ""
       cu:
         description: 'cuda version'
         required: true
@@ -23,13 +23,13 @@ on:
         description: 'python minor version'
         required: true
         type: string
-        default: "11"
+        default: "12"
 
       python_patch:
         description: 'python patch version'
         required: true
         type: string
-        default: "9"
+        default: "7"
 #  push:
 #    branches:
 #      - master

.github/workflows/windows_release_package.yml

@@ -13,13 +13,13 @@ on:
         description: 'python minor version'
         required: true
         type: string
-        default: "11"
+        default: "12"
 
       python_patch:
         description: 'python patch version'
         required: true
         type: string
-        default: "9"
+        default: "7"
 #  push:
 #    branches:
 #      - master

README.md

@@ -127,6 +127,8 @@ To run it on services like paperspace, kaggle or colab you can use my [Jupyter N
 
 ## Manual Install (Windows, Linux)
 
+Note that some dependencies do not yet support python 3.13 so using 3.12 is recommended.
+
 Git clone this repo.
 
 Put your SD checkpoints (the huge ckpt/safetensors files) in: models/checkpoints

app/frontend_management.py

@@ -151,6 +151,15 @@ class FrontendManager:
             return cls.DEFAULT_FRONTEND_PATH
 
         repo_owner, repo_name, version = cls.parse_version_string(version_string)
+
+        if version.startswith("v"):
+            expected_path = str(Path(cls.CUSTOM_FRONTENDS_ROOT) / f"{repo_owner}_{repo_name}" / version.lstrip("v"))
+            if os.path.exists(expected_path):
+                logging.info(f"Using existing copy of specific frontend version tag: {repo_owner}/{repo_name}@{version}")
+                return expected_path
+
+        logging.info(f"Initializing frontend: {repo_owner}/{repo_name}@{version}, requesting version details from GitHub...")
+
         provider = provider or FrontEndProvider(repo_owner, repo_name)
         release = provider.get_release(version)
 
@@ -159,16 +168,20 @@ class FrontendManager:
             Path(cls.CUSTOM_FRONTENDS_ROOT) / provider.folder_name / semantic_version
         )
         if not os.path.exists(web_root):
+            # Use tmp path until complete to avoid path exists check passing from interrupted downloads
+            tmp_path = web_root + ".tmp"
             try:
-                os.makedirs(web_root, exist_ok=True)
+                os.makedirs(tmp_path, exist_ok=True)
                 logging.info(
                     "Downloading frontend(%s) version(%s) to (%s)",
                     provider.folder_name,
                     semantic_version,
-                    web_root,
+                    tmp_path,
                 )
                 logging.debug(release)
-                download_release_asset_zip(release, destination_path=web_root)
+                download_release_asset_zip(release, destination_path=tmp_path)
+                if os.listdir(tmp_path):
+                    os.rename(tmp_path, web_root)
             finally:
                 # Clean up the directory if it is empty, i.e. the download failed
                 if not os.listdir(web_root):

comfy/controlnet.py

@@ -60,7 +60,7 @@ class StrengthType(Enum):
     LINEAR_UP = 2
 
 class ControlBase:
-    def __init__(self, device=None):
+    def __init__(self):
         self.cond_hint_original = None
         self.cond_hint = None
         self.strength = 1.0
@@ -72,10 +72,6 @@ class ControlBase:
         self.compression_ratio = 8
         self.upscale_algorithm = 'nearest-exact'
         self.extra_args = {}
-
-        if device is None:
-            device = comfy.model_management.get_torch_device()
-        self.device = device
         self.previous_controlnet = None
         self.extra_conds = []
         self.strength_type = StrengthType.CONSTANT
@@ -185,8 +181,8 @@ class ControlBase:
 
 
 class ControlNet(ControlBase):
-    def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, latent_format=None, device=None, load_device=None, manual_cast_dtype=None, extra_conds=["y"], strength_type=StrengthType.CONSTANT, concat_mask=False):
+    def __init__(self, control_model=None, global_average_pooling=False, compression_ratio=8, latent_format=None, load_device=None, manual_cast_dtype=None, extra_conds=["y"], strength_type=StrengthType.CONSTANT, concat_mask=False):
-        super().__init__(device)
+        super().__init__()
         self.control_model = control_model
         self.load_device = load_device
         if control_model is not None:
@@ -237,11 +233,12 @@ class ControlNet(ControlBase):
             if len(self.extra_concat_orig) > 0:
                 to_concat = []
                 for c in self.extra_concat_orig:
+                    c = c.to(self.cond_hint.device)
                     c = comfy.utils.common_upscale(c, self.cond_hint.shape[3], self.cond_hint.shape[2], self.upscale_algorithm, "center")
                     to_concat.append(comfy.utils.repeat_to_batch_size(c, self.cond_hint.shape[0]))
                 self.cond_hint = torch.cat([self.cond_hint] + to_concat, dim=1)
 
-            self.cond_hint = self.cond_hint.to(device=self.device, dtype=dtype)
+            self.cond_hint = self.cond_hint.to(device=x_noisy.device, dtype=dtype)
         if x_noisy.shape[0] != self.cond_hint.shape[0]:
             self.cond_hint = broadcast_image_to(self.cond_hint, x_noisy.shape[0], batched_number)
 
@@ -340,8 +337,8 @@ class ControlLoraOps:
 
 
 class ControlLora(ControlNet):
-    def __init__(self, control_weights, global_average_pooling=False, device=None, model_options={}): #TODO? model_options
+    def __init__(self, control_weights, global_average_pooling=False, model_options={}): #TODO? model_options
-        ControlBase.__init__(self, device)
+        ControlBase.__init__(self)
         self.control_weights = control_weights
         self.global_average_pooling = global_average_pooling
         self.extra_conds += ["y"]
@@ -661,12 +658,15 @@ def load_controlnet(ckpt_path, model=None, model_options={}):
 
 class T2IAdapter(ControlBase):
     def __init__(self, t2i_model, channels_in, compression_ratio, upscale_algorithm, device=None):
-        super().__init__(device)
+        super().__init__()
         self.t2i_model = t2i_model
         self.channels_in = channels_in
         self.control_input = None
         self.compression_ratio = compression_ratio
         self.upscale_algorithm = upscale_algorithm
+        if device is None:
+            device = comfy.model_management.get_torch_device()
+        self.device = device
 
     def scale_image_to(self, width, height):
         unshuffle_amount = self.t2i_model.unshuffle_amount

comfy/float.py

@@ -41,6 +41,8 @@ def manual_stochastic_round_to_float8(x, dtype, generator=None):
         (2.0 ** (-EXPONENT_BIAS + 1)) * abs_x
     )
 
+    inf = torch.finfo(dtype)
+    torch.clamp(sign, min=inf.min, max=inf.max, out=sign)
     return sign
 
 

comfy/k_diffusion/sampling.py

@@ -1080,7 +1080,6 @@ def sample_euler_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disabl
         d = to_d(x, sigma_hat, temp[0])
         if callback is not None:
             callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigma_hat, 'denoised': denoised})
-        dt = sigmas[i + 1] - sigma_hat
         # Euler method
         x = denoised + d * sigmas[i + 1]
     return x
@@ -1107,7 +1106,6 @@ def sample_euler_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback=No
             callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
         d = to_d(x, sigmas[i], temp[0])
         # Euler method
-        dt = sigma_down - sigmas[i]
         x = denoised + d * sigma_down
         if sigmas[i + 1] > 0:
             x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
@@ -1138,7 +1136,6 @@ def sample_dpmpp_2s_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback
         if sigma_down == 0:
             # Euler method
             d = to_d(x, sigmas[i], temp[0])
-            dt = sigma_down - sigmas[i]
             x = denoised + d * sigma_down
         else:
             # DPM-Solver++(2S)
@@ -1186,4 +1183,4 @@ def sample_dpmpp_2m_cfg_pp(model, x, sigmas, extra_args=None, callback=None, dis
             denoised_mix = -torch.exp(-h) * uncond_denoised - torch.expm1(-h) * (1 / (2 * r)) * (denoised - old_uncond_denoised)
         x = denoised + denoised_mix + torch.exp(-h) * x
         old_uncond_denoised = uncond_denoised
-    return x
+    return x

comfy/latent_formats.py

@@ -115,23 +115,24 @@ class SD3(LatentFormat):
         self.scale_factor = 1.5305
         self.shift_factor = 0.0609
         self.latent_rgb_factors = [
-            [-0.0645,  0.0177,  0.1052],
+            [-0.0922, -0.0175,  0.0749],
-            [ 0.0028,  0.0312,  0.0650],
+            [ 0.0311,  0.0633,  0.0954],
-            [ 0.1848,  0.0762,  0.0360],
+            [ 0.1994,  0.0927,  0.0458],
-            [ 0.0944,  0.0360,  0.0889],
+            [ 0.0856,  0.0339,  0.0902],
-            [ 0.0897,  0.0506, -0.0364],
+            [ 0.0587,  0.0272, -0.0496],
-            [-0.0020,  0.1203,  0.0284],
+            [-0.0006,  0.1104,  0.0309],
-            [ 0.0855,  0.0118,  0.0283],
+            [ 0.0978,  0.0306,  0.0427],
-            [-0.0539,  0.0658,  0.1047],
+            [-0.0042,  0.1038,  0.1358],
-            [-0.0057,  0.0116,  0.0700],
+            [-0.0194,  0.0020,  0.0669],
-            [-0.0412,  0.0281, -0.0039],
+            [-0.0488,  0.0130, -0.0268],
-            [ 0.1106,  0.1171,  0.1220],
+            [ 0.0922,  0.0988,  0.0951],
-            [-0.0248,  0.0682, -0.0481],
+            [-0.0278,  0.0524, -0.0542],
-            [ 0.0815,  0.0846,  0.1207],
+            [ 0.0332,  0.0456,  0.0895],
-            [-0.0120, -0.0055, -0.0867],
+            [-0.0069, -0.0030, -0.0810],
-            [-0.0749, -0.0634, -0.0456],
+            [-0.0596, -0.0465, -0.0293],
-            [-0.1418, -0.1457, -0.1259]
+            [-0.1448, -0.1463, -0.1189]
         ]
+        self.latent_rgb_factors_bias = [0.2394, 0.2135, 0.1925]
         self.taesd_decoder_name = "taesd3_decoder"
 
     def process_in(self, latent):

comfy/ldm/modules/diffusionmodules/mmdit.py

@@ -5,7 +5,7 @@ from typing import Dict, Optional
 import numpy as np
 import torch
 import torch.nn as nn
-from .. import attention
+from ..attention import optimized_attention
 from einops import rearrange, repeat
 from .util import timestep_embedding
 import comfy.ops
@@ -266,8 +266,6 @@ def split_qkv(qkv, head_dim):
     qkv = qkv.reshape(qkv.shape[0], qkv.shape[1], 3, -1, head_dim).movedim(2, 0)
     return qkv[0], qkv[1], qkv[2]
 
-def optimized_attention(qkv, num_heads):
-    return attention.optimized_attention(qkv[0], qkv[1], qkv[2], num_heads)
 
 class SelfAttention(nn.Module):
     ATTENTION_MODES = ("xformers", "torch", "torch-hb", "math", "debug")
@@ -326,9 +324,9 @@ class SelfAttention(nn.Module):
         return x
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        qkv = self.pre_attention(x)
+        q, k, v = self.pre_attention(x)
         x = optimized_attention(
-            qkv, num_heads=self.num_heads
+            q, k, v, heads=self.num_heads
         )
         x = self.post_attention(x)
         return x
@@ -531,8 +529,8 @@ class DismantledBlock(nn.Module):
         assert not self.pre_only
         qkv, intermediates = self.pre_attention(x, c)
         attn = optimized_attention(
-            qkv,
+            qkv[0], qkv[1], qkv[2],
-            num_heads=self.attn.num_heads,
+            heads=self.attn.num_heads,
         )
         return self.post_attention(attn, *intermediates)
 
@@ -557,8 +555,8 @@ def _block_mixing(context, x, context_block, x_block, c):
     qkv = tuple(o)
 
     attn = optimized_attention(
-        qkv,
+        qkv[0], qkv[1], qkv[2],
-        num_heads=x_block.attn.num_heads,
+        heads=x_block.attn.num_heads,
     )
     context_attn, x_attn = (
         attn[:, : context_qkv[0].shape[1]],
@@ -642,7 +640,7 @@ class SelfAttentionContext(nn.Module):
     def forward(self, x):
         qkv = self.qkv(x)
         q, k, v = split_qkv(qkv, self.dim_head)
-        x = optimized_attention((q.reshape(q.shape[0], q.shape[1], -1), k, v), self.heads)
+        x = optimized_attention(q.reshape(q.shape[0], q.shape[1], -1), k, v, heads=self.heads)
         return self.proj(x)
 
 class ContextProcessorBlock(nn.Module):

comfy/lora.py

@@ -344,10 +344,10 @@ def model_lora_keys_unet(model, key_map={}):
     return key_map
 
 
-def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype):
+def weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function):
     dora_scale = comfy.model_management.cast_to_device(dora_scale, weight.device, intermediate_dtype)
     lora_diff *= alpha
-    weight_calc = weight + lora_diff.type(weight.dtype)
+    weight_calc = weight + function(lora_diff).type(weight.dtype)
     weight_norm = (
         weight_calc.transpose(0, 1)
         .reshape(weight_calc.shape[1], -1)
@@ -416,7 +416,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32, ori
             weight *= strength_model
 
         if isinstance(v, list):
-            v = (calculate_weight(v[1:], comfy.model_management.cast_to_device(v[0], weight.device, intermediate_dtype, copy=True), key, intermediate_dtype=intermediate_dtype), )
+            v = (calculate_weight(v[1:], v[0][1](comfy.model_management.cast_to_device(v[0][0], weight.device, intermediate_dtype, copy=True), inplace=True), key, intermediate_dtype=intermediate_dtype), )
 
         if len(v) == 1:
             patch_type = "diff"
@@ -459,7 +459,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32, ori
             try:
                 lora_diff = torch.mm(mat1.flatten(start_dim=1), mat2.flatten(start_dim=1)).reshape(weight.shape)
                 if dora_scale is not None:
-                    weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
+                    weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
                 else:
                     weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
             except Exception as e:
@@ -505,7 +505,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32, ori
             try:
                 lora_diff = torch.kron(w1, w2).reshape(weight.shape)
                 if dora_scale is not None:
-                    weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
+                    weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
                 else:
                     weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
             except Exception as e:
@@ -542,7 +542,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32, ori
             try:
                 lora_diff = (m1 * m2).reshape(weight.shape)
                 if dora_scale is not None:
-                    weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
+                    weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
                 else:
                     weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
             except Exception as e:
@@ -583,7 +583,7 @@ def calculate_weight(patches, weight, key, intermediate_dtype=torch.float32, ori
                     lora_diff += torch.mm(b1, b2).reshape(weight.shape)
 
                 if dora_scale is not None:
-                    weight = function(weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype))
+                    weight = weight_decompose(dora_scale, weight, lora_diff, alpha, strength, intermediate_dtype, function)
                 else:
                     weight += function(((strength * alpha) * lora_diff).type(weight.dtype))
             except Exception as e:

comfy/model_base.py

@@ -100,7 +100,8 @@ class BaseModel(torch.nn.Module):
 
         if not unet_config.get("disable_unet_model_creation", False):
             if model_config.custom_operations is None:
-                operations = comfy.ops.pick_operations(unet_config.get("dtype", None), self.manual_cast_dtype)
+                fp8 = model_config.optimizations.get("fp8", model_config.scaled_fp8 is not None)
+                operations = comfy.ops.pick_operations(unet_config.get("dtype", None), self.manual_cast_dtype, fp8_optimizations=fp8, scaled_fp8=model_config.scaled_fp8)
             else:
                 operations = model_config.custom_operations
             self.diffusion_model = unet_model(**unet_config, device=device, operations=operations)
@@ -248,6 +249,10 @@ class BaseModel(torch.nn.Module):
             extra_sds.append(self.model_config.process_clip_vision_state_dict_for_saving(clip_vision_state_dict))
 
         unet_state_dict = self.diffusion_model.state_dict()
+
+        if self.model_config.scaled_fp8 is not None:
+            unet_state_dict["scaled_fp8"] = torch.tensor([], dtype=self.model_config.scaled_fp8)
+
         unet_state_dict = self.model_config.process_unet_state_dict_for_saving(unet_state_dict)
 
         if self.model_type == ModelType.V_PREDICTION:

comfy/model_detection.py

@@ -286,9 +286,15 @@ def model_config_from_unet(state_dict, unet_key_prefix, use_base_if_no_match=Fal
         return None
     model_config = model_config_from_unet_config(unet_config, state_dict)
     if model_config is None and use_base_if_no_match:
-        return comfy.supported_models_base.BASE(unet_config)
+        model_config = comfy.supported_models_base.BASE(unet_config)
-    else:
+
-        return model_config
+    scaled_fp8_weight = state_dict.get("{}scaled_fp8".format(unet_key_prefix), None)
+    if scaled_fp8_weight is not None:
+        model_config.scaled_fp8 = scaled_fp8_weight.dtype
+        if model_config.scaled_fp8 == torch.float32:
+            model_config.scaled_fp8 = torch.float8_e4m3fn
+
+    return model_config
 
 def unet_prefix_from_state_dict(state_dict):
     candidates = ["model.diffusion_model.", #ldm/sgm models

comfy/model_management.py

@@ -145,7 +145,7 @@ total_ram = psutil.virtual_memory().total / (1024 * 1024)
 logging.info("Total VRAM {:0.0f} MB, total RAM {:0.0f} MB".format(total_vram, total_ram))
 
 try:
-    logging.info("pytorch version: {}".format(torch.version.__version__))
+    logging.info("pytorch version: {}".format(torch_version))
 except:
     pass
 
@@ -647,6 +647,9 @@ def unet_dtype(device=None, model_params=0, supported_dtypes=[torch.float16, tor
         pass
 
     if fp8_dtype is not None:
+        if supports_fp8_compute(device): #if fp8 compute is supported the casting is most likely not expensive
+            return fp8_dtype
+
         free_model_memory = maximum_vram_for_weights(device)
         if model_params * 2 > free_model_memory:
             return fp8_dtype
@@ -840,27 +843,21 @@ def force_channels_last():
     #TODO
     return False
 
+def cast_to(weight, dtype=None, device=None, non_blocking=False, copy=False):
+    if device is None or weight.device == device:
+        if not copy:
+            if dtype is None or weight.dtype == dtype:
+                return weight
+        return weight.to(dtype=dtype, copy=copy)
+
+    r = torch.empty_like(weight, dtype=dtype, device=device)
+    r.copy_(weight, non_blocking=non_blocking)
+    return r
+
 def cast_to_device(tensor, device, dtype, copy=False):
-    device_supports_cast = False
+    non_blocking = device_supports_non_blocking(device)
-    if tensor.dtype == torch.float32 or tensor.dtype == torch.float16:
+    return cast_to(tensor, dtype=dtype, device=device, non_blocking=non_blocking, copy=copy)
-        device_supports_cast = True
-    elif tensor.dtype == torch.bfloat16:
-        if hasattr(device, 'type') and device.type.startswith("cuda"):
-            device_supports_cast = True
-        elif is_intel_xpu():
-            device_supports_cast = True
 
-    non_blocking = device_should_use_non_blocking(device)
-
-    if device_supports_cast:
-        if copy:
-            if tensor.device == device:
-                return tensor.to(dtype, copy=copy, non_blocking=non_blocking)
-            return tensor.to(device, copy=copy, non_blocking=non_blocking).to(dtype, non_blocking=non_blocking)
-        else:
-            return tensor.to(device, non_blocking=non_blocking).to(dtype, non_blocking=non_blocking)
-    else:
-        return tensor.to(device, dtype, copy=copy, non_blocking=non_blocking)
 
 def xformers_enabled():
     global directml_enabled
@@ -899,7 +896,7 @@ def force_upcast_attention_dtype():
     upcast = args.force_upcast_attention
     try:
         macos_version = tuple(int(n) for n in platform.mac_ver()[0].split("."))
-        if (14, 5) <= macos_version < (14, 7):  # black image bug on recent versions of MacOS
+        if (14, 5) <= macos_version <= (15, 0, 1):  # black image bug on recent versions of macOS
             upcast = True
     except:
         pass
@@ -1065,6 +1062,9 @@ def should_use_bf16(device=None, model_params=0, prioritize_performance=True, ma
     return False
 
 def supports_fp8_compute(device=None):
+    if not is_nvidia():
+        return False
+
     props = torch.cuda.get_device_properties(device)
     if props.major >= 9:
         return True
@@ -1072,6 +1072,14 @@ def supports_fp8_compute(device=None):
         return False
     if props.minor < 9:
         return False
+
+    if int(torch_version[0]) < 2 or (int(torch_version[0]) == 2 and int(torch_version[2]) < 3):
+        return False
+
+    if WINDOWS:
+        if (int(torch_version[0]) == 2 and int(torch_version[2]) < 4):
+            return False
+
     return True
 
 def soft_empty_cache(force=False):

comfy/model_patcher.py

@@ -116,6 +116,31 @@ class LowVramPatch:
             return comfy.float.stochastic_rounding(comfy.lora.calculate_weight(self.patches[self.key], weight.to(intermediate_dtype), self.key, intermediate_dtype=intermediate_dtype), weight.dtype, seed=string_to_seed(self.key))
 
         return comfy.lora.calculate_weight(self.patches[self.key], weight, self.key, intermediate_dtype=intermediate_dtype)
+
+def get_key_weight(model, key):
+    set_func = None
+    convert_func = None
+    op_keys = key.rsplit('.', 1)
+    if len(op_keys) < 2:
+        weight = comfy.utils.get_attr(model, key)
+    else:
+        op = comfy.utils.get_attr(model, op_keys[0])
+        try:
+            set_func = getattr(op, "set_{}".format(op_keys[1]))
+        except AttributeError:
+            pass
+
+        try:
+            convert_func = getattr(op, "convert_{}".format(op_keys[1]))
+        except AttributeError:
+            pass
+
+        weight = getattr(op, op_keys[1])
+        if convert_func is not None:
+            weight = comfy.utils.get_attr(model, key)
+
+    return weight, set_func, convert_func
+
 class CallbacksMP:
     ON_CLONE = "on_clone"
     ON_LOAD = "on_load_after"
@@ -530,16 +555,18 @@ class ModelPatcher:
                     continue
             bk = self.backup.get(k, None)
             hbk = self.hook_backup.get(k, None)
+            weight, set_func, convert_func = get_key_weight(self.model, k)
             if bk is not None:
                 weight = bk.weight
             if hbk is not None:
                 weight = hbk[0]
-            else:
+            if convert_func is None:
-                weight = model_sd[k]
+                convert_func = lambda a, **kwargs: a
+
             if k in self.patches:
-                p[k] = [weight] + self.patches[k]
+                p[k] = [(weight, convert_func)] + self.patches[k]
             else:
-                p[k] = (weight,)
+                p[k] = [(weight, convert_func)]
         return p
 
     def model_state_dict(self, filter_prefix=None):
@@ -556,8 +583,7 @@ class ModelPatcher:
         if key not in self.patches:
             return
 
-        weight = comfy.utils.get_attr(self.model, key)
+        weight, set_func, convert_func = get_key_weight(self.model, key)
-
         inplace_update = self.weight_inplace_update or inplace_update
 
         if key not in self.backup:
@@ -567,12 +593,18 @@ class ModelPatcher:
             temp_weight = comfy.model_management.cast_to_device(weight, device_to, torch.float32, copy=True)
         else:
             temp_weight = weight.to(torch.float32, copy=True)
+        if convert_func is not None:
+            temp_weight = convert_func(temp_weight, inplace=True)
+
         out_weight = comfy.lora.calculate_weight(self.patches[key], temp_weight, key)
-        out_weight = comfy.float.stochastic_rounding(out_weight, weight.dtype, seed=string_to_seed(key))
+        if set_func is None:
-        if inplace_update:
+            out_weight = comfy.float.stochastic_rounding(out_weight, weight.dtype, seed=string_to_seed(key))
-            comfy.utils.copy_to_param(self.model, key, out_weight)
+            if inplace_update:
+                comfy.utils.copy_to_param(self.model, key, out_weight)
+            else:
+                comfy.utils.set_attr_param(self.model, key, out_weight)
         else:
-            comfy.utils.set_attr_param(self.model, key, out_weight)
+            set_func(out_weight, inplace_update=inplace_update, seed=string_to_seed(key))
 
     def load(self, device_to=None, lowvram_model_memory=0, force_patch_weights=False, full_load=False):
         with self.use_ejected():

comfy/ops.py

@@ -19,20 +19,12 @@
 import torch
 import comfy.model_management
 from comfy.cli_args import args
+import comfy.float
 
-def cast_to(weight, dtype=None, device=None, non_blocking=False, copy=False):
+cast_to = comfy.model_management.cast_to #TODO: remove once no more references
-    if device is None or weight.device == device:
-        if not copy:
-            if dtype is None or weight.dtype == dtype:
-                return weight
-        return weight.to(dtype=dtype, copy=copy)
-
-    r = torch.empty_like(weight, dtype=dtype, device=device)
-    r.copy_(weight, non_blocking=non_blocking)
-    return r
 
 def cast_to_input(weight, input, non_blocking=False, copy=True):
-    return cast_to(weight, input.dtype, input.device, non_blocking=non_blocking, copy=copy)
+    return comfy.model_management.cast_to(weight, input.dtype, input.device, non_blocking=non_blocking, copy=copy)
 
 def cast_bias_weight(s, input=None, dtype=None, device=None, bias_dtype=None):
     if input is not None:
@@ -47,12 +39,12 @@ def cast_bias_weight(s, input=None, dtype=None, device=None, bias_dtype=None):
     non_blocking = comfy.model_management.device_supports_non_blocking(device)
     if s.bias is not None:
         has_function = s.bias_function is not None
-        bias = cast_to(s.bias, bias_dtype, device, non_blocking=non_blocking, copy=has_function)
+        bias = comfy.model_management.cast_to(s.bias, bias_dtype, device, non_blocking=non_blocking, copy=has_function)
         if has_function:
             bias = s.bias_function(bias)
 
     has_function = s.weight_function is not None
-    weight = cast_to(s.weight, dtype, device, non_blocking=non_blocking, copy=has_function)
+    weight = comfy.model_management.cast_to(s.weight, dtype, device, non_blocking=non_blocking, copy=has_function)
     if has_function:
         weight = s.weight_function(weight)
     return weight, bias
@@ -258,19 +250,29 @@ def fp8_linear(self, input):
     if dtype not in [torch.float8_e4m3fn]:
         return None
 
+    tensor_2d = False
+    if len(input.shape) == 2:
+        tensor_2d = True
+        input = input.unsqueeze(1)
+
+
     if len(input.shape) == 3:
-        inn = input.reshape(-1, input.shape[2]).to(dtype)
         w, bias = cast_bias_weight(self, input, dtype=dtype, bias_dtype=input.dtype)
         w = w.t()
 
         scale_weight = self.scale_weight
         scale_input = self.scale_input
         if scale_weight is None:
-            scale_weight = torch.ones((1), device=input.device, dtype=torch.float32)
+            scale_weight = torch.ones((), device=input.device, dtype=torch.float32)
-            if scale_input is None:
+        else:
-                scale_input = scale_weight
+            scale_weight = scale_weight.to(input.device)
+
         if scale_input is None:
-            scale_input = torch.ones((1), device=input.device, dtype=torch.float32)
+            scale_input = torch.ones((), device=input.device, dtype=torch.float32)
+            inn = input.reshape(-1, input.shape[2]).to(dtype)
+        else:
+            scale_input = scale_input.to(input.device)
+            inn = (input * (1.0 / scale_input).to(input.dtype)).reshape(-1, input.shape[2]).to(dtype)
 
         if bias is not None:
             o = torch._scaled_mm(inn, w, out_dtype=input.dtype, bias=bias, scale_a=scale_input, scale_b=scale_weight)
@@ -280,7 +282,11 @@ def fp8_linear(self, input):
         if isinstance(o, tuple):
             o = o[0]
 
+        if tensor_2d:
+            return o.reshape(input.shape[0], -1)
+
         return o.reshape((-1, input.shape[1], self.weight.shape[0]))
+
     return None
 
 class fp8_ops(manual_cast):
@@ -298,11 +304,63 @@ class fp8_ops(manual_cast):
             weight, bias = cast_bias_weight(self, input)
             return torch.nn.functional.linear(input, weight, bias)
 
+def scaled_fp8_ops(fp8_matrix_mult=False, scale_input=False, override_dtype=None):
+    class scaled_fp8_op(manual_cast):
+        class Linear(manual_cast.Linear):
+            def __init__(self, *args, **kwargs):
+                if override_dtype is not None:
+                    kwargs['dtype'] = override_dtype
+                super().__init__(*args, **kwargs)
+
+            def reset_parameters(self):
+                if not hasattr(self, 'scale_weight'):
+                    self.scale_weight = torch.nn.parameter.Parameter(data=torch.ones((), device=self.weight.device, dtype=torch.float32), requires_grad=False)
+
+                if not scale_input:
+                    self.scale_input = None
+
+                if not hasattr(self, 'scale_input'):
+                    self.scale_input = torch.nn.parameter.Parameter(data=torch.ones((), device=self.weight.device, dtype=torch.float32), requires_grad=False)
+                return None
+
+            def forward_comfy_cast_weights(self, input):
+                if fp8_matrix_mult:
+                    out = fp8_linear(self, input)
+                    if out is not None:
+                        return out
+
+                weight, bias = cast_bias_weight(self, input)
+
+                if weight.numel() < input.numel(): #TODO: optimize
+                    return torch.nn.functional.linear(input, weight * self.scale_weight.to(device=weight.device, dtype=weight.dtype), bias)
+                else:
+                    return torch.nn.functional.linear(input * self.scale_weight.to(device=weight.device, dtype=weight.dtype), weight, bias)
+
+            def convert_weight(self, weight, inplace=False, **kwargs):
+                if inplace:
+                    weight *= self.scale_weight.to(device=weight.device, dtype=weight.dtype)
+                    return weight
+                else:
+                    return weight * self.scale_weight.to(device=weight.device, dtype=weight.dtype)
+
+            def set_weight(self, weight, inplace_update=False, seed=None, **kwargs):
+                weight = comfy.float.stochastic_rounding(weight / self.scale_weight.to(device=weight.device, dtype=weight.dtype), self.weight.dtype, seed=seed)
+                if inplace_update:
+                    self.weight.data.copy_(weight)
+                else:
+                    self.weight = torch.nn.Parameter(weight, requires_grad=False)
+
+    return scaled_fp8_op
+
+def pick_operations(weight_dtype, compute_dtype, load_device=None, disable_fast_fp8=False, fp8_optimizations=False, scaled_fp8=None):
+    fp8_compute = comfy.model_management.supports_fp8_compute(load_device)
+    if scaled_fp8 is not None:
+        return scaled_fp8_ops(fp8_matrix_mult=fp8_compute, scale_input=True, override_dtype=scaled_fp8)
+
+    if fp8_compute and (fp8_optimizations or args.fast) and not disable_fast_fp8:
+        return fp8_ops
 
-def pick_operations(weight_dtype, compute_dtype, load_device=None, disable_fast_fp8=False):
     if compute_dtype is None or weight_dtype == compute_dtype:
         return disable_weight_init
-    if args.fast and not disable_fast_fp8:
+
-        if comfy.model_management.supports_fp8_compute(load_device):
-            return fp8_ops
     return manual_cast

comfy/samplers.py

@@ -434,8 +434,11 @@ def beta_scheduler(model_sampling, steps, alpha=0.6, beta=0.6):
     ts = numpy.rint(scipy.stats.beta.ppf(ts, alpha, beta) * total_timesteps)
 
     sigs = []
+    last_t = -1
     for t in ts:
-        sigs += [float(model_sampling.sigmas[int(t)])]
+        if t != last_t:
+            sigs += [float(model_sampling.sigmas[int(t)])]
+        last_t = t
     sigs += [0.0]
     return torch.FloatTensor(sigs)
 

comfy/sd.py

@@ -347,7 +347,7 @@ class VAE:
             memory_used = self.memory_used_encode(pixel_samples.shape, self.vae_dtype)
             model_management.load_models_gpu([self.patcher], memory_required=memory_used)
             free_memory = model_management.get_free_memory(self.device)
-            batch_number = int(free_memory / memory_used)
+            batch_number = int(free_memory / max(1, memory_used))
             batch_number = max(1, batch_number)
             samples = torch.empty((pixel_samples.shape[0], self.latent_channels) + tuple(map(lambda a: a // self.downscale_ratio, pixel_samples.shape[2:])), device=self.output_device)
             for x in range(0, pixel_samples.shape[0], batch_number):
@@ -431,8 +431,21 @@ def detect_te_model(sd):
         return TEModel.T5_BASE
     return None
 
+
+def t5xxl_detect(clip_data):
+    weight_name = "encoder.block.23.layer.1.DenseReluDense.wi_1.weight"
+
+    dtype_t5 = None
+    for sd in clip_data:
+        if weight_name in sd:
+            return comfy.text_encoders.sd3_clip.t5_xxl_detect(sd)
+
+    return {}
+
+
 def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip_type=CLIPType.STABLE_DIFFUSION, model_options={}):
     clip_data = state_dicts
+
     class EmptyClass:
         pass
 
@@ -461,9 +474,7 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
             clip_target.clip = comfy.text_encoders.sd2_clip.SD2ClipModel
             clip_target.tokenizer = comfy.text_encoders.sd2_clip.SD2Tokenizer
         elif te_model == TEModel.T5_XXL:
-            weight = clip_data[0]["encoder.block.23.layer.1.DenseReluDense.wi_1.weight"]
+            clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, **t5xxl_detect(clip_data))
-            dtype_t5 = weight.dtype
-            clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=False, clip_g=False, t5=True, dtype_t5=dtype_t5)
             clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer
         elif te_model == TEModel.T5_XL:
             clip_target.clip = comfy.text_encoders.aura_t5.AuraT5Model
@@ -481,25 +492,19 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
     elif len(clip_data) == 2:
         if clip_type == CLIPType.SD3:
             te_models = [detect_te_model(clip_data[0]), detect_te_model(clip_data[1])]
-            clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=TEModel.CLIP_L in te_models, clip_g=TEModel.CLIP_G in te_models, t5=TEModel.T5_XXL in te_models)
+            clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=TEModel.CLIP_L in te_models, clip_g=TEModel.CLIP_G in te_models, t5=TEModel.T5_XXL in te_models, **t5xxl_detect(clip_data))
             clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer
         elif clip_type == CLIPType.HUNYUAN_DIT:
             clip_target.clip = comfy.text_encoders.hydit.HyditModel
             clip_target.tokenizer = comfy.text_encoders.hydit.HyditTokenizer
         elif clip_type == CLIPType.FLUX:
-            weight_name = "encoder.block.23.layer.1.DenseReluDense.wi_1.weight"
+            clip_target.clip = comfy.text_encoders.flux.flux_clip(**t5xxl_detect(clip_data))
-            weight = clip_data[0].get(weight_name, clip_data[1].get(weight_name, None))
-            dtype_t5 = None
-            if weight is not None:
-                dtype_t5 = weight.dtype
-
-            clip_target.clip = comfy.text_encoders.flux.flux_clip(dtype_t5=dtype_t5)
             clip_target.tokenizer = comfy.text_encoders.flux.FluxTokenizer
         else:
             clip_target.clip = sdxl_clip.SDXLClipModel
             clip_target.tokenizer = sdxl_clip.SDXLTokenizer
     elif len(clip_data) == 3:
-        clip_target.clip = comfy.text_encoders.sd3_clip.SD3ClipModel
+        clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(**t5xxl_detect(clip_data))
         clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer
 
     parameters = 0
@@ -574,11 +579,11 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c
         return None
 
     unet_weight_dtype = list(model_config.supported_inference_dtypes)
-    if weight_dtype is not None:
+    if weight_dtype is not None and model_config.scaled_fp8 is None:
         unet_weight_dtype.append(weight_dtype)
 
     model_config.custom_operations = model_options.get("custom_operations", None)
-    unet_dtype = model_options.get("weight_dtype", None)
+    unet_dtype = model_options.get("dtype", model_options.get("weight_dtype", None))
 
     if unet_dtype is None:
         unet_dtype = model_management.unet_dtype(model_params=parameters, supported_dtypes=unet_weight_dtype)
@@ -592,7 +597,6 @@ def load_state_dict_guess_config(sd, output_vae=True, output_clip=True, output_c
 
     if output_model:
         inital_load_device = model_management.unet_inital_load_device(parameters, unet_dtype)
-        offload_device = model_management.unet_offload_device()
         model = model_config.get_model(sd, diffusion_model_prefix, device=inital_load_device)
         model.load_model_weights(sd, diffusion_model_prefix)
 
@@ -644,6 +648,8 @@ def load_diffusion_model_state_dict(sd, model_options={}): #load unet in diffuse
         sd = temp_sd
 
     parameters = comfy.utils.calculate_parameters(sd)
+    weight_dtype = comfy.utils.weight_dtype(sd)
+
     load_device = model_management.get_torch_device()
     model_config = model_detection.model_config_from_unet(sd, "")
 
@@ -670,14 +676,21 @@ def load_diffusion_model_state_dict(sd, model_options={}): #load unet in diffuse
                     logging.warning("{} {}".format(diffusers_keys[k], k))
 
     offload_device = model_management.unet_offload_device()
+    unet_weight_dtype = list(model_config.supported_inference_dtypes)
+    if weight_dtype is not None and model_config.scaled_fp8 is None:
+        unet_weight_dtype.append(weight_dtype)
+
     if dtype is None:
-        unet_dtype = model_management.unet_dtype(model_params=parameters, supported_dtypes=model_config.supported_inference_dtypes)
+        unet_dtype = model_management.unet_dtype(model_params=parameters, supported_dtypes=unet_weight_dtype)
     else:
         unet_dtype = dtype
 
     manual_cast_dtype = model_management.unet_manual_cast(unet_dtype, load_device, model_config.supported_inference_dtypes)
     model_config.set_inference_dtype(unet_dtype, manual_cast_dtype)
     model_config.custom_operations = model_options.get("custom_operations", model_config.custom_operations)
+    if model_options.get("fp8_optimizations", False):
+        model_config.optimizations["fp8"] = True
+
     model = model_config.get_model(new_sd, "")
     model = model.to(offload_device)
     model.load_model_weights(new_sd, "")

comfy/sd1_clip.py

@@ -80,7 +80,7 @@ class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder):
         "pooled",
         "hidden"
     ]
-    def __init__(self, version="openai/clip-vit-large-patch14", device="cpu", max_length=77,
+    def __init__(self, device="cpu", max_length=77,
                  freeze=True, layer="last", layer_idx=None, textmodel_json_config=None, dtype=None, model_class=comfy.clip_model.CLIPTextModel,
                  special_tokens={"start": 49406, "end": 49407, "pad": 49407}, layer_norm_hidden_state=True, enable_attention_masks=False, zero_out_masked=False,
                  return_projected_pooled=True, return_attention_masks=False, model_options={}):  # clip-vit-base-patch32
@@ -94,11 +94,20 @@ class SDClipModel(torch.nn.Module, ClipTokenWeightEncoder):
             config = json.load(f)
 
         operations = model_options.get("custom_operations", None)
+        scaled_fp8 = None
+
         if operations is None:
-            operations = comfy.ops.manual_cast
+            scaled_fp8 = model_options.get("scaled_fp8", None)
+            if scaled_fp8 is not None:
+                operations = comfy.ops.scaled_fp8_ops(fp8_matrix_mult=False, override_dtype=scaled_fp8)
+            else:
+                operations = comfy.ops.manual_cast
 
         self.operations = operations
         self.transformer = model_class(config, dtype, device, self.operations)
+        if scaled_fp8 is not None:
+            self.transformer.scaled_fp8 = torch.nn.Parameter(torch.tensor([], dtype=scaled_fp8))
+
         self.num_layers = self.transformer.num_layers
 
         self.max_length = max_length

comfy/supported_models.py

@@ -529,12 +529,11 @@ class SD3(supported_models_base.BASE):
             clip_l = True
         if "{}clip_g.transformer.text_model.final_layer_norm.weight".format(pref) in state_dict:
             clip_g = True
-        t5_key = "{}t5xxl.transformer.encoder.final_layer_norm.weight".format(pref)
+        t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}t5xxl.transformer.".format(pref))
-        if t5_key in state_dict:
+        if "dtype_t5" in t5_detect:
             t5 = True
-            dtype_t5 = state_dict[t5_key].dtype
 
-        return supported_models_base.ClipTarget(comfy.text_encoders.sd3_clip.SD3Tokenizer, comfy.text_encoders.sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5))
+        return supported_models_base.ClipTarget(comfy.text_encoders.sd3_clip.SD3Tokenizer, comfy.text_encoders.sd3_clip.sd3_clip(clip_l=clip_l, clip_g=clip_g, t5=t5, **t5_detect))
 
 class StableAudio(supported_models_base.BASE):
     unet_config = {
@@ -653,11 +652,8 @@ class Flux(supported_models_base.BASE):
 
     def clip_target(self, state_dict={}):
         pref = self.text_encoder_key_prefix[0]
-        t5_key = "{}t5xxl.transformer.encoder.final_layer_norm.weight".format(pref)
+        t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}t5xxl.transformer.".format(pref))
-        dtype_t5 = None
+        return supported_models_base.ClipTarget(comfy.text_encoders.flux.FluxTokenizer, comfy.text_encoders.flux.flux_clip(**t5_detect))
-        if t5_key in state_dict:
-            dtype_t5 = state_dict[t5_key].dtype
-        return supported_models_base.ClipTarget(comfy.text_encoders.flux.FluxTokenizer, comfy.text_encoders.flux.flux_clip(dtype_t5=dtype_t5))
 
 class FluxSchnell(Flux):
     unet_config = {

comfy/supported_models_base.py

@@ -49,6 +49,8 @@ class BASE:
 
     manual_cast_dtype = None
     custom_operations = None
+    scaled_fp8 = None
+    optimizations = {"fp8": False}
 
     @classmethod
     def matches(s, unet_config, state_dict=None):
@@ -71,6 +73,7 @@ class BASE:
         self.unet_config = unet_config.copy()
         self.sampling_settings = self.sampling_settings.copy()
         self.latent_format = self.latent_format()
+        self.optimizations = self.optimizations.copy()
         for x in self.unet_extra_config:
             self.unet_config[x] = self.unet_extra_config[x]
 

comfy/text_encoders/flux.py

@@ -1,15 +1,11 @@
 from comfy import sd1_clip
 import comfy.text_encoders.t5
+import comfy.text_encoders.sd3_clip
 import comfy.model_management
 from transformers import T5TokenizerFast
 import torch
 import os
 
-class T5XXLModel(sd1_clip.SDClipModel):
-    def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}):
-        textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_xxl.json")
-        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, model_options=model_options)
-
 class T5XXLTokenizer(sd1_clip.SDTokenizer):
     def __init__(self, embedding_directory=None, tokenizer_data={}):
         tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_tokenizer")
@@ -41,7 +37,7 @@ class FluxClipModel(torch.nn.Module):
         dtype_t5 = comfy.model_management.pick_weight_dtype(dtype_t5, dtype, device)
         clip_l_class = model_options.get("clip_l_class", sd1_clip.SDClipModel)
         self.clip_l = clip_l_class(device=device, dtype=dtype, return_projected_pooled=False, model_options=model_options)
-        self.t5xxl = T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options)
+        self.t5xxl = comfy.text_encoders.sd3_clip.T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options)
         self.dtypes = set([dtype, dtype_t5])
 
     def set_clip_options(self, options):
@@ -66,8 +62,11 @@ class FluxClipModel(torch.nn.Module):
         else:
             return self.t5xxl.load_sd(sd)
 
-def flux_clip(dtype_t5=None):
+def flux_clip(dtype_t5=None, t5xxl_scaled_fp8=None):
     class FluxClipModel_(FluxClipModel):
         def __init__(self, device="cpu", dtype=None, model_options={}):
+            if t5xxl_scaled_fp8 is not None and "t5xxl_scaled_fp8" not in model_options:
+                model_options = model_options.copy()
+                model_options["t5xxl_scaled_fp8"] = t5xxl_scaled_fp8
             super().__init__(dtype_t5=dtype_t5, device=device, dtype=dtype, model_options=model_options)
     return FluxClipModel_

comfy/text_encoders/sd3_clip.py

@@ -8,9 +8,27 @@ import comfy.model_management
 import logging
 
 class T5XXLModel(sd1_clip.SDClipModel):
-    def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, model_options={}):
+    def __init__(self, device="cpu", layer="last", layer_idx=None, dtype=None, attention_mask=False, model_options={}):
         textmodel_json_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), "t5_config_xxl.json")
-        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, model_options=model_options)
+        t5xxl_scaled_fp8 = model_options.get("t5xxl_scaled_fp8", None)
+        if t5xxl_scaled_fp8 is not None:
+            model_options = model_options.copy()
+            model_options["scaled_fp8"] = t5xxl_scaled_fp8
+
+        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config=textmodel_json_config, dtype=dtype, special_tokens={"end": 1, "pad": 0}, model_class=comfy.text_encoders.t5.T5, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options)
+
+
+def t5_xxl_detect(state_dict, prefix=""):
+    out = {}
+    t5_key = "{}encoder.final_layer_norm.weight".format(prefix)
+    if t5_key in state_dict:
+        out["dtype_t5"] = state_dict[t5_key].dtype
+
+    scaled_fp8_key = "{}scaled_fp8".format(prefix)
+    if scaled_fp8_key in state_dict:
+        out["t5xxl_scaled_fp8"] = state_dict[scaled_fp8_key].dtype
+
+    return out
 
 class T5XXLTokenizer(sd1_clip.SDTokenizer):
     def __init__(self, embedding_directory=None, tokenizer_data={}):
@@ -39,7 +57,7 @@ class SD3Tokenizer:
         return {}
 
 class SD3ClipModel(torch.nn.Module):
-    def __init__(self, clip_l=True, clip_g=True, t5=True, dtype_t5=None, device="cpu", dtype=None, model_options={}):
+    def __init__(self, clip_l=True, clip_g=True, t5=True, dtype_t5=None, t5_attention_mask=False, device="cpu", dtype=None, model_options={}):
         super().__init__()
         self.dtypes = set()
         if clip_l:
@@ -57,7 +75,8 @@ class SD3ClipModel(torch.nn.Module):
 
         if t5:
             dtype_t5 = comfy.model_management.pick_weight_dtype(dtype_t5, dtype, device)
-            self.t5xxl = T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options)
+            self.t5_attention_mask = t5_attention_mask
+            self.t5xxl = T5XXLModel(device=device, dtype=dtype_t5, model_options=model_options, attention_mask=self.t5_attention_mask)
             self.dtypes.add(dtype_t5)
         else:
             self.t5xxl = None
@@ -87,6 +106,7 @@ class SD3ClipModel(torch.nn.Module):
         lg_out = None
         pooled = None
         out = None
+        extra = {}
 
         if len(token_weight_pairs_g) > 0 or len(token_weight_pairs_l) > 0:
             if self.clip_l is not None:
@@ -111,7 +131,11 @@ class SD3ClipModel(torch.nn.Module):
             pooled = torch.cat((l_pooled, g_pooled), dim=-1)
 
         if self.t5xxl is not None:
-            t5_out, t5_pooled = self.t5xxl.encode_token_weights(token_weight_pairs_t5)
+            t5_output = self.t5xxl.encode_token_weights(token_weight_pairs_t5)
+            t5_out, t5_pooled = t5_output[:2]
+            if self.t5_attention_mask:
+                extra["attention_mask"] = t5_output[2]["attention_mask"]
+
             if lg_out is not None:
                 out = torch.cat([lg_out, t5_out], dim=-2)
             else:
@@ -123,7 +147,7 @@ class SD3ClipModel(torch.nn.Module):
         if pooled is None:
             pooled = torch.zeros((1, 768 + 1280), device=comfy.model_management.intermediate_device())
 
-        return out, pooled
+        return out, pooled, extra
 
     def load_sd(self, sd):
         if "text_model.encoder.layers.30.mlp.fc1.weight" in sd:
@@ -133,8 +157,11 @@ class SD3ClipModel(torch.nn.Module):
         else:
             return self.t5xxl.load_sd(sd)
 
-def sd3_clip(clip_l=True, clip_g=True, t5=True, dtype_t5=None):
+def sd3_clip(clip_l=True, clip_g=True, t5=True, dtype_t5=None, t5xxl_scaled_fp8=None, t5_attention_mask=False):
     class SD3ClipModel_(SD3ClipModel):
         def __init__(self, device="cpu", dtype=None, model_options={}):
-            super().__init__(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5, device=device, dtype=dtype, model_options=model_options)
+            if t5xxl_scaled_fp8 is not None and "t5xxl_scaled_fp8" not in model_options:
+                model_options = model_options.copy()
+                model_options["t5xxl_scaled_fp8"] = t5xxl_scaled_fp8
+            super().__init__(clip_l=clip_l, clip_g=clip_g, t5=t5, dtype_t5=dtype_t5, t5_attention_mask=t5_attention_mask, device=device, dtype=dtype, model_options=model_options)
     return SD3ClipModel_

comfy/utils.py

@@ -68,7 +68,7 @@ def weight_dtype(sd, prefix=""):
     for k in sd.keys():
         if k.startswith(prefix):
             w = sd[k]
-            dtypes[w.dtype] = dtypes.get(w.dtype, 0) + 1
+            dtypes[w.dtype] = dtypes.get(w.dtype, 0) + w.numel()
 
     if len(dtypes) == 0:
         return None

comfy_extras/nodes_latent.py

@@ -1,4 +1,5 @@
 import comfy.utils
+import comfy_extras.nodes_post_processing
 import torch
 
 def reshape_latent_to(target_shape, latent):
@@ -145,6 +146,131 @@ class LatentBatchSeedBehavior:
 
         return (samples_out,)
 
+class LatentApplyOperation:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "samples": ("LATENT",),
+                             "operation": ("LATENT_OPERATION",),
+                             }}
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "op"
+
+    CATEGORY = "latent/advanced/operations"
+    EXPERIMENTAL = True
+
+    def op(self, samples, operation):
+        samples_out = samples.copy()
+
+        s1 = samples["samples"]
+        samples_out["samples"] = operation(latent=s1)
+        return (samples_out,)
+
+class LatentApplyOperationCFG:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "model": ("MODEL",),
+                             "operation": ("LATENT_OPERATION",),
+                              }}
+    RETURN_TYPES = ("MODEL",)
+    FUNCTION = "patch"
+
+    CATEGORY = "latent/advanced/operations"
+    EXPERIMENTAL = True
+
+    def patch(self, model, operation):
+        m = model.clone()
+
+        def pre_cfg_function(args):
+            conds_out = args["conds_out"]
+            if len(conds_out) == 2:
+                conds_out[0] = operation(latent=(conds_out[0] - conds_out[1])) + conds_out[1]
+            else:
+                conds_out[0] = operation(latent=conds_out[0])
+            return conds_out
+
+        m.set_model_sampler_pre_cfg_function(pre_cfg_function)
+        return (m, )
+
+class LatentOperationTonemapReinhard:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": { "multiplier": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 100.0, "step": 0.01}),
+                              }}
+
+    RETURN_TYPES = ("LATENT_OPERATION",)
+    FUNCTION = "op"
+
+    CATEGORY = "latent/advanced/operations"
+    EXPERIMENTAL = True
+
+    def op(self, multiplier):
+        def tonemap_reinhard(latent, **kwargs):
+            latent_vector_magnitude = (torch.linalg.vector_norm(latent, dim=(1)) + 0.0000000001)[:,None]
+            normalized_latent = latent / latent_vector_magnitude
+
+            mean = torch.mean(latent_vector_magnitude, dim=(1,2,3), keepdim=True)
+            std = torch.std(latent_vector_magnitude, dim=(1,2,3), keepdim=True)
+
+            top = (std * 5 + mean) * multiplier
+
+            #reinhard
+            latent_vector_magnitude *= (1.0 / top)
+            new_magnitude = latent_vector_magnitude / (latent_vector_magnitude + 1.0)
+            new_magnitude *= top
+
+            return normalized_latent * new_magnitude
+        return (tonemap_reinhard,)
+
+class LatentOperationSharpen:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                "sharpen_radius": ("INT", {
+                    "default": 9,
+                    "min": 1,
+                    "max": 31,
+                    "step": 1
+                }),
+                "sigma": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.1,
+                    "max": 10.0,
+                    "step": 0.1
+                }),
+                "alpha": ("FLOAT", {
+                    "default": 0.1,
+                    "min": 0.0,
+                    "max": 5.0,
+                    "step": 0.01
+                }),
+                              }}
+
+    RETURN_TYPES = ("LATENT_OPERATION",)
+    FUNCTION = "op"
+
+    CATEGORY = "latent/advanced/operations"
+    EXPERIMENTAL = True
+
+    def op(self, sharpen_radius, sigma, alpha):
+        def sharpen(latent, **kwargs):
+            luminance = (torch.linalg.vector_norm(latent, dim=(1)) + 1e-6)[:,None]
+            normalized_latent = latent / luminance
+            channels = latent.shape[1]
+
+            kernel_size = sharpen_radius * 2 + 1
+            kernel = comfy_extras.nodes_post_processing.gaussian_kernel(kernel_size, sigma, device=luminance.device)
+            center = kernel_size // 2
+
+            kernel *= alpha * -10
+            kernel[center, center] = kernel[center, center] - kernel.sum() + 1.0
+
+            padded_image = torch.nn.functional.pad(normalized_latent, (sharpen_radius,sharpen_radius,sharpen_radius,sharpen_radius), 'reflect')
+            sharpened = torch.nn.functional.conv2d(padded_image, kernel.repeat(channels, 1, 1).unsqueeze(1), padding=kernel_size // 2, groups=channels)[:,:,sharpen_radius:-sharpen_radius, sharpen_radius:-sharpen_radius]
+
+            return luminance * sharpened
+        return (sharpen,)
+
 NODE_CLASS_MAPPINGS = {
     "LatentAdd": LatentAdd,
     "LatentSubtract": LatentSubtract,
@@ -152,4 +278,8 @@ NODE_CLASS_MAPPINGS = {
     "LatentInterpolate": LatentInterpolate,
     "LatentBatch": LatentBatch,
     "LatentBatchSeedBehavior": LatentBatchSeedBehavior,
+    "LatentApplyOperation": LatentApplyOperation,
+    "LatentApplyOperationCFG": LatentApplyOperationCFG,
+    "LatentOperationTonemapReinhard": LatentOperationTonemapReinhard,
+    "LatentOperationSharpen": LatentOperationSharpen,
 }

comfy_extras/nodes_lora_extract.py

@@ -82,8 +82,8 @@ class LoraSave:
                               "lora_type": (tuple(LORA_TYPES.keys()),),
                               "bias_diff": ("BOOLEAN", {"default": True}),
                             },
-                "optional": {"model_diff": ("MODEL",),
+                "optional": {"model_diff": ("MODEL", {"tooltip": "The ModelSubtract output to be converted to a lora."}),
-                             "text_encoder_diff": ("CLIP",)},
+                             "text_encoder_diff": ("CLIP", {"tooltip": "The CLIPSubtract output to be converted to a lora."})},
     }
     RETURN_TYPES = ()
     FUNCTION = "save"
@@ -113,3 +113,7 @@ class LoraSave:
 NODE_CLASS_MAPPINGS = {
     "LoraSave": LoraSave
 }
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LoraSave": "Extract and Save Lora"
+}

folder_paths.py

@@ -234,8 +234,12 @@ def recursive_search(directory: str, excluded_dir_names: list[str] | None=None)
     for dirpath, subdirs, filenames in os.walk(directory, followlinks=True, topdown=True):
         subdirs[:] = [d for d in subdirs if d not in excluded_dir_names]
         for file_name in filenames:
-            relative_path = os.path.relpath(os.path.join(dirpath, file_name), directory)
+            try:
-            result.append(relative_path)
+                relative_path = os.path.relpath(os.path.join(dirpath, file_name), directory)
+                result.append(relative_path)
+            except:
+                logging.warning(f"Warning: Unable to access {file_name}. Skipping this file.")
+                continue
 
         for d in subdirs:
             path: str = os.path.join(dirpath, d)

nodes.py

@@ -861,7 +861,7 @@ class UNETLoader:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "unet_name": (folder_paths.get_filename_list("diffusion_models"), ),
-                              "weight_dtype": (["default", "fp8_e4m3fn", "fp8_e5m2"],)
+                              "weight_dtype": (["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],)
                              }}
     RETURN_TYPES = ("MODEL",)
     FUNCTION = "load_unet"
@@ -872,6 +872,9 @@ class UNETLoader:
         model_options = {}
         if weight_dtype == "fp8_e4m3fn":
             model_options["dtype"] = torch.float8_e4m3fn
+        elif weight_dtype == "fp8_e4m3fn_fast":
+            model_options["dtype"] = torch.float8_e4m3fn
+            model_options["fp8_optimizations"] = True
         elif weight_dtype == "fp8_e5m2":
             model_options["dtype"] = torch.float8_e5m2
 

server.py

@@ -40,7 +40,7 @@ class BinaryEventTypes:
 async def send_socket_catch_exception(function, message):
     try:
         await function(message)
-    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError) as err:
+    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError, BrokenPipeError, ConnectionError) as err:
         logging.warning("send error: {}".format(err))
 
 def get_comfyui_version():

web/assets/GraphView-BGt8GmeB.css

@@ -0,0 +1,792 @@
+
+.editable-text[data-v-54da6fc9] {
+  display: inline;
+}
+.editable-text input[data-v-54da6fc9] {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.group-title-editor.node-title-editor[data-v-fc3f26e3] {
+  z-index: 9999;
+  padding: 0.25rem;
+}
+[data-v-fc3f26e3] .editable-text {
+  width: 100%;
+  height: 100%;
+}
+[data-v-fc3f26e3] .editable-text input {
+  width: 100%;
+  height: 100%;
+  /* Override the default font size */
+  font-size: inherit;
+}
+
+.side-bar-button-icon {
+  font-size: var(--sidebar-icon-size) !important;
+}
+.side-bar-button-selected .side-bar-button-icon {
+  font-size: var(--sidebar-icon-size) !important;
+  font-weight: bold;
+}
+
+.side-bar-button[data-v-caa3ee9c] {
+  width: var(--sidebar-width);
+  height: var(--sidebar-width);
+  border-radius: 0;
+}
+.comfyui-body-left .side-bar-button.side-bar-button-selected[data-v-caa3ee9c],
+.comfyui-body-left .side-bar-button.side-bar-button-selected[data-v-caa3ee9c]:hover {
+  border-left: 4px solid var(--p-button-text-primary-color);
+}
+.comfyui-body-right .side-bar-button.side-bar-button-selected[data-v-caa3ee9c],
+.comfyui-body-right .side-bar-button.side-bar-button-selected[data-v-caa3ee9c]:hover {
+  border-right: 4px solid var(--p-button-text-primary-color);
+}
+
+:root {
+  --sidebar-width: 64px;
+  --sidebar-icon-size: 1.5rem;
+}
+:root .small-sidebar {
+  --sidebar-width: 40px;
+  --sidebar-icon-size: 1rem;
+}
+
+.side-tool-bar-container[data-v-4da64512] {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+
+  pointer-events: auto;
+
+  width: var(--sidebar-width);
+  height: 100%;
+
+  background-color: var(--comfy-menu-bg);
+  color: var(--fg-color);
+}
+.side-tool-bar-end[data-v-4da64512] {
+  align-self: flex-end;
+  margin-top: auto;
+}
+.sidebar-content-container[data-v-4da64512] {
+  height: 100%;
+  overflow-y: auto;
+}
+
+.p-splitter-gutter {
+  pointer-events: auto;
+}
+.gutter-hidden {
+  display: none !important;
+}
+
+.side-bar-panel[data-v-b9df3042] {
+  background-color: var(--bg-color);
+  pointer-events: auto;
+}
+.splitter-overlay[data-v-b9df3042] {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
+  background-color: transparent;
+  pointer-events: none;
+  /* Set it the same as the ComfyUI menu */
+  /* Note: Lite-graph DOM widgets have the same z-index as the node id, so
+  999 should be sufficient to make sure splitter overlays on node's DOM
+  widgets */
+  z-index: 999;
+  border: none;
+}
+
+._content[data-v-e7b35fd9] {
+
+    display: flex;
+
+    flex-direction: column
+}
+._content[data-v-e7b35fd9] > :not([hidden]) ~ :not([hidden]) {
+
+    --tw-space-y-reverse: 0;
+
+    margin-top: calc(0.5rem * calc(1 - var(--tw-space-y-reverse)));
+
+    margin-bottom: calc(0.5rem * var(--tw-space-y-reverse))
+}
+._footer[data-v-e7b35fd9] {
+
+    display: flex;
+
+    flex-direction: column;
+
+    align-items: flex-end;
+
+    padding-top: 1rem
+}
+
+[data-v-37f672ab] .highlight {
+  background-color: var(--p-primary-color);
+  color: var(--p-primary-contrast-color);
+  font-weight: bold;
+  border-radius: 0.25rem;
+  padding: 0rem 0.125rem;
+  margin: -0.125rem 0.125rem;
+}
+
+.slot_row[data-v-ff07c900] {
+  padding: 2px;
+}
+
+/* Original N-Sidebar styles */
+._sb_dot[data-v-ff07c900] {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background-color: grey;
+}
+.node_header[data-v-ff07c900] {
+  line-height: 1;
+  padding: 8px 13px 7px;
+  margin-bottom: 5px;
+  font-size: 15px;
+  text-wrap: nowrap;
+  overflow: hidden;
+  display: flex;
+  align-items: center;
+}
+.headdot[data-v-ff07c900] {
+  width: 10px;
+  height: 10px;
+  float: inline-start;
+  margin-right: 8px;
+}
+.IMAGE[data-v-ff07c900] {
+  background-color: #64b5f6;
+}
+.VAE[data-v-ff07c900] {
+  background-color: #ff6e6e;
+}
+.LATENT[data-v-ff07c900] {
+  background-color: #ff9cf9;
+}
+.MASK[data-v-ff07c900] {
+  background-color: #81c784;
+}
+.CONDITIONING[data-v-ff07c900] {
+  background-color: #ffa931;
+}
+.CLIP[data-v-ff07c900] {
+  background-color: #ffd500;
+}
+.MODEL[data-v-ff07c900] {
+  background-color: #b39ddb;
+}
+.CONTROL_NET[data-v-ff07c900] {
+  background-color: #a5d6a7;
+}
+._sb_node_preview[data-v-ff07c900] {
+  background-color: var(--comfy-menu-bg);
+  font-family: 'Open Sans', sans-serif;
+  font-size: small;
+  color: var(--descrip-text);
+  border: 1px solid var(--descrip-text);
+  min-width: 300px;
+  width: -moz-min-content;
+  width: min-content;
+  height: -moz-fit-content;
+  height: fit-content;
+  z-index: 9999;
+  border-radius: 12px;
+  overflow: hidden;
+  font-size: 12px;
+  padding-bottom: 10px;
+}
+._sb_node_preview ._sb_description[data-v-ff07c900] {
+  margin: 10px;
+  padding: 6px;
+  background: var(--border-color);
+  border-radius: 5px;
+  font-style: italic;
+  font-weight: 500;
+  font-size: 0.9rem;
+  word-break: break-word;
+}
+._sb_table[data-v-ff07c900] {
+  display: grid;
+
+  grid-column-gap: 10px;
+  /* Spazio tra le colonne */
+  width: 100%;
+  /* Imposta la larghezza della tabella al 100% del contenitore */
+}
+._sb_row[data-v-ff07c900] {
+  display: grid;
+  grid-template-columns: 10px 1fr 1fr 1fr 10px;
+  grid-column-gap: 10px;
+  align-items: center;
+  padding-left: 9px;
+  padding-right: 9px;
+}
+._sb_row_string[data-v-ff07c900] {
+  grid-template-columns: 10px 1fr 1fr 10fr 1fr;
+}
+._sb_col[data-v-ff07c900] {
+  border: 0px solid #000;
+  display: flex;
+  align-items: flex-end;
+  flex-direction: row-reverse;
+  flex-wrap: nowrap;
+  align-content: flex-start;
+  justify-content: flex-end;
+}
+._sb_inherit[data-v-ff07c900] {
+  display: inherit;
+}
+._long_field[data-v-ff07c900] {
+  background: var(--bg-color);
+  border: 2px solid var(--border-color);
+  margin: 5px 5px 0 5px;
+  border-radius: 10px;
+  line-height: 1.7;
+  text-wrap: nowrap;
+}
+._sb_arrow[data-v-ff07c900] {
+  color: var(--fg-color);
+}
+._sb_preview_badge[data-v-ff07c900] {
+  text-align: center;
+  background: var(--comfy-input-bg);
+  font-weight: bold;
+  color: var(--error-text);
+}
+
+.comfy-vue-node-search-container[data-v-2d409367] {
+  display: flex;
+  width: 100%;
+  min-width: 26rem;
+  align-items: center;
+  justify-content: center;
+}
+.comfy-vue-node-search-container[data-v-2d409367] * {
+  pointer-events: auto;
+}
+.comfy-vue-node-preview-container[data-v-2d409367] {
+  position: absolute;
+  left: -350px;
+  top: 50px;
+}
+.comfy-vue-node-search-box[data-v-2d409367] {
+  z-index: 10;
+  flex-grow: 1;
+}
+._filter-button[data-v-2d409367] {
+  z-index: 10;
+}
+._dialog[data-v-2d409367] {
+  min-width: 26rem;
+}
+
+.invisible-dialog-root {
+  width: 60%;
+  min-width: 24rem;
+  max-width: 48rem;
+  border: 0 !important;
+  background-color: transparent !important;
+  margin-top: 25vh;
+  margin-left: 400px;
+}
+@media all and (max-width: 768px) {
+.invisible-dialog-root {
+    margin-left: 0px;
+}
+}
+.node-search-box-dialog-mask {
+  align-items: flex-start !important;
+}
+
+.node-tooltip[data-v-0a4402f9] {
+  background: var(--comfy-input-bg);
+  border-radius: 5px;
+  box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
+  color: var(--input-text);
+  font-family: sans-serif;
+  left: 0;
+  max-width: 30vw;
+  padding: 4px 8px;
+  position: absolute;
+  top: 0;
+  transform: translate(5px, calc(-100% - 5px));
+  white-space: pre-wrap;
+  z-index: 99999;
+}
+
+.p-buttongroup-vertical[data-v-ce8bd6ac] {
+  display: flex;
+  flex-direction: column;
+  border-radius: var(--p-button-border-radius);
+  overflow: hidden;
+  border: 1px solid var(--p-panel-border-color);
+}
+.p-buttongroup-vertical .p-button[data-v-ce8bd6ac] {
+  margin: 0;
+  border-radius: 0;
+}
+
+.comfy-image-wrap[data-v-9bc23daf] {
+  display: contents;
+}
+.comfy-image-blur[data-v-9bc23daf] {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  -o-object-fit: cover;
+     object-fit: cover;
+}
+.comfy-image-main[data-v-9bc23daf] {
+  width: 100%;
+  height: 100%;
+  -o-object-fit: cover;
+     object-fit: cover;
+  -o-object-position: center;
+     object-position: center;
+  z-index: 1;
+}
+.contain .comfy-image-wrap[data-v-9bc23daf] {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}
+.contain .comfy-image-main[data-v-9bc23daf] {
+  -o-object-fit: contain;
+     object-fit: contain;
+  -webkit-backdrop-filter: blur(10px);
+          backdrop-filter: blur(10px);
+  position: absolute;
+}
+.broken-image-placeholder[data-v-9bc23daf] {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  margin: 2rem;
+}
+.broken-image-placeholder i[data-v-9bc23daf] {
+  font-size: 3rem;
+  margin-bottom: 0.5rem;
+}
+
+.result-container[data-v-d9c060ae] {
+  width: 100%;
+  height: 100%;
+  aspect-ratio: 1 / 1;
+  overflow: hidden;
+  position: relative;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.image-preview-mask[data-v-d9c060ae] {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  opacity: 0;
+  transition: opacity 0.3s ease;
+  z-index: 1;
+}
+.result-container:hover .image-preview-mask[data-v-d9c060ae] {
+  opacity: 1;
+}
+
+.task-result-preview[data-v-d4c8a1fe] {
+  aspect-ratio: 1 / 1;
+  overflow: hidden;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+  height: 100%;
+}
+.task-result-preview i[data-v-d4c8a1fe],
+.task-result-preview span[data-v-d4c8a1fe] {
+  font-size: 2rem;
+}
+.task-item[data-v-d4c8a1fe] {
+  display: flex;
+  flex-direction: column;
+  border-radius: 4px;
+  overflow: hidden;
+  position: relative;
+}
+.task-item-details[data-v-d4c8a1fe] {
+  position: absolute;
+  bottom: 0;
+  padding: 0.6rem;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  width: 100%;
+  z-index: 1;
+}
+.task-node-link[data-v-d4c8a1fe] {
+  padding: 2px;
+}
+
+/* In dark mode, transparent background color for tags is not ideal for tags that
+are floating on top of images. */
+.tag-wrapper[data-v-d4c8a1fe] {
+  background-color: var(--p-primary-contrast-color);
+  border-radius: 6px;
+  display: inline-flex;
+}
+.node-name-tag[data-v-d4c8a1fe] {
+  word-break: break-all;
+}
+.status-tag-group[data-v-d4c8a1fe] {
+  display: flex;
+  flex-direction: column;
+}
+.progress-preview-img[data-v-d4c8a1fe] {
+  width: 100%;
+  height: 100%;
+  -o-object-fit: cover;
+     object-fit: cover;
+  -o-object-position: center;
+     object-position: center;
+}
+
+/* PrimeVue's galleria teleports the fullscreen gallery out of subtree so we
+cannot use scoped style here. */
+img.galleria-image {
+  max-width: 100vw;
+  max-height: 100vh;
+  -o-object-fit: contain;
+     object-fit: contain;
+}
+.p-galleria-close-button {
+  /* Set z-index so the close button doesn't get hidden behind the image when image is large */
+  z-index: 1;
+}
+
+.comfy-vue-side-bar-container[data-v-1b0a8fe3] {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  overflow: hidden;
+}
+.comfy-vue-side-bar-header[data-v-1b0a8fe3] {
+  flex-shrink: 0;
+  border-left: none;
+  border-right: none;
+  border-top: none;
+  border-radius: 0;
+  padding: 0.25rem 1rem;
+  min-height: 2.5rem;
+}
+.comfy-vue-side-bar-header-span[data-v-1b0a8fe3] {
+  font-size: small;
+}
+.comfy-vue-side-bar-body[data-v-1b0a8fe3] {
+  flex-grow: 1;
+  overflow: auto;
+  scrollbar-width: thin;
+  scrollbar-color: transparent transparent;
+}
+.comfy-vue-side-bar-body[data-v-1b0a8fe3]::-webkit-scrollbar {
+  width: 1px;
+}
+.comfy-vue-side-bar-body[data-v-1b0a8fe3]::-webkit-scrollbar-thumb {
+  background-color: transparent;
+}
+
+.scroll-container[data-v-08fa89b1] {
+  height: 100%;
+  overflow-y: auto;
+}
+.queue-grid[data-v-08fa89b1] {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  padding: 0.5rem;
+  gap: 0.5rem;
+}
+
+.tree-node[data-v-633e27ab] {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.leaf-count-badge[data-v-633e27ab] {
+  margin-left: 0.5rem;
+}
+.node-content[data-v-633e27ab] {
+  display: flex;
+  align-items: center;
+  flex-grow: 1;
+}
+.leaf-label[data-v-633e27ab] {
+  margin-left: 0.5rem;
+}
+[data-v-633e27ab] .editable-text span {
+  word-break: break-all;
+}
+
+[data-v-bd7bae90] .tree-explorer-node-label {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  margin-left: var(--p-tree-node-gap);
+  flex-grow: 1;
+}
+
+/*
+ * The following styles are necessary to avoid layout shift when dragging nodes over folders.
+ * By setting the position to relative on the parent and using an absolutely positioned pseudo-element,
+ * we can create a visual indicator for the drop target without affecting the layout of other elements.
+ */
+[data-v-bd7bae90] .p-tree-node-content:has(.tree-folder) {
+  position: relative;
+}
+[data-v-bd7bae90] .p-tree-node-content:has(.tree-folder.can-drop)::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  border: 1px solid var(--p-content-color);
+  pointer-events: none;
+}
+
+.node-lib-node-container[data-v-90dfee08] {
+    height: 100%;
+    width: 100%
+}
+
+.p-selectbutton .p-button[data-v-91077f2a] {
+  padding: 0.5rem;
+}
+.p-selectbutton .p-button .pi[data-v-91077f2a] {
+  font-size: 1.5rem;
+}
+.field[data-v-91077f2a] {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+.color-picker-container[data-v-91077f2a] {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.node-lib-filter-popup {
+  margin-left: -13px;
+}
+
+[data-v-f6a7371a] .comfy-vue-side-bar-body {
+  background: var(--p-tree-background);
+}
+[data-v-f6a7371a] .node-lib-bookmark-tree-explorer {
+  padding-bottom: 2px;
+}
+[data-v-f6a7371a] .p-divider {
+  margin: var(--comfy-tree-explorer-item-padding) 0px;
+}
+
+.model_preview[data-v-32e6c4d9] {
+  background-color: var(--comfy-menu-bg);
+  font-family: 'Open Sans', sans-serif;
+  color: var(--descrip-text);
+  border: 1px solid var(--descrip-text);
+  min-width: 300px;
+  max-width: 500px;
+  width: -moz-fit-content;
+  width: fit-content;
+  height: -moz-fit-content;
+  height: fit-content;
+  z-index: 9999;
+  border-radius: 12px;
+  overflow: hidden;
+  font-size: 12px;
+  padding: 10px;
+}
+.model_preview_image[data-v-32e6c4d9] {
+  margin: auto;
+  width: -moz-fit-content;
+  width: fit-content;
+}
+.model_preview_image img[data-v-32e6c4d9] {
+  max-width: 100%;
+  max-height: 150px;
+  -o-object-fit: contain;
+     object-fit: contain;
+}
+.model_preview_title[data-v-32e6c4d9] {
+  font-weight: bold;
+  text-align: center;
+  font-size: 14px;
+}
+.model_preview_top_container[data-v-32e6c4d9] {
+  text-align: center;
+  line-height: 0.5;
+}
+.model_preview_filename[data-v-32e6c4d9],
+.model_preview_author[data-v-32e6c4d9],
+.model_preview_architecture[data-v-32e6c4d9] {
+  display: inline-block;
+  text-align: center;
+  margin: 5px;
+  font-size: 10px;
+}
+.model_preview_prefix[data-v-32e6c4d9] {
+  font-weight: bold;
+}
+
+.model-lib-model-icon-container[data-v-70b69131] {
+  display: inline-block;
+  position: relative;
+  left: 0;
+  height: 1.5rem;
+  vertical-align: top;
+  width: 0px;
+}
+.model-lib-model-icon[data-v-70b69131] {
+  background-size: cover;
+  background-position: center;
+  display: inline-block;
+  position: relative;
+  left: -2.5rem;
+  height: 2rem;
+  width: 2rem;
+  vertical-align: top;
+}
+
+.pi-fake-spacer {
+  height: 1px;
+  width: 16px;
+}
+
+[data-v-74b01bce] .comfy-vue-side-bar-body {
+  background: var(--p-tree-background);
+}
+
+[data-v-d2d58252] .comfy-vue-side-bar-body {
+  background: var(--p-tree-background);
+}
+
+[data-v-84e785b8] .p-togglebutton::before {
+  display: none
+}
+[data-v-84e785b8] .p-togglebutton {
+  position: relative;
+  flex-shrink: 0;
+  border-radius: 0px;
+  background-color: transparent;
+  padding-left: 0.5rem;
+  padding-right: 0.5rem
+}
+[data-v-84e785b8] .p-togglebutton.p-togglebutton-checked {
+  border-bottom-width: 2px;
+  border-bottom-color: var(--p-button-text-primary-color)
+}
+[data-v-84e785b8] .p-togglebutton-checked .close-button,[data-v-84e785b8] .p-togglebutton:hover .close-button {
+  visibility: visible
+}
+.status-indicator[data-v-84e785b8] {
+  position: absolute;
+  font-weight: 700;
+  font-size: 1.5rem;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%)
+}
+[data-v-84e785b8] .p-togglebutton:hover .status-indicator {
+  display: none
+}
+[data-v-84e785b8] .p-togglebutton .close-button {
+  visibility: hidden
+}
+
+.top-menubar[data-v-2ec1b620] .p-menubar-item-link svg {
+  display: none;
+}
+[data-v-2ec1b620] .p-menubar-submenu.dropdown-direction-up {
+  top: auto;
+  bottom: 100%;
+  flex-direction: column-reverse;
+}
+.keybinding-tag[data-v-2ec1b620] {
+  background: var(--p-content-hover-background);
+  border-color: var(--p-content-border-color);
+  border-style: solid;
+}
+
+[data-v-713442be] .p-inputtext {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+
+.comfyui-queue-button[data-v-fcd3efcd] .p-splitbutton-dropdown {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+.actionbar[data-v-bc6c78dd] {
+  pointer-events: all;
+  position: fixed;
+  z-index: 1000;
+}
+.actionbar.is-docked[data-v-bc6c78dd] {
+  position: static;
+  border-style: none;
+  background-color: transparent;
+  padding: 0px;
+}
+.actionbar.is-dragging[data-v-bc6c78dd] {
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+}
+[data-v-bc6c78dd] .p-panel-content {
+  padding: 0.25rem;
+}
+[data-v-bc6c78dd] .p-panel-header {
+  display: none;
+}
+
+.comfyui-menu[data-v-b13fdc92] {
+  width: 100vw;
+  background: var(--comfy-menu-bg);
+  color: var(--fg-color);
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: 0.8em;
+  box-sizing: border-box;
+  z-index: 1000;
+  order: 0;
+  grid-column: 1/-1;
+  max-height: 90vh;
+}
+.comfyui-menu.dropzone[data-v-b13fdc92] {
+  background: var(--p-highlight-background);
+}
+.comfyui-menu.dropzone-active[data-v-b13fdc92] {
+  background: var(--p-highlight-background-focus);
+}
+.comfyui-logo[data-v-b13fdc92] {
+  font-size: 1.2em;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+  cursor: default;
+}

web/assets/GraphView-DXU9yRen.css

@@ -1,158 +0,0 @@
-
-.group-title-editor.node-title-editor[data-v-fc3f26e3] {
-  z-index: 9999;
-  padding: 0.25rem;
-}
-[data-v-fc3f26e3] .editable-text {
-  width: 100%;
-  height: 100%;
-}
-[data-v-fc3f26e3] .editable-text input {
-  width: 100%;
-  height: 100%;
-  /* Override the default font size */
-  font-size: inherit;
-}
-
-.side-bar-button-icon {
-  font-size: var(--sidebar-icon-size) !important;
-}
-.side-bar-button-selected .side-bar-button-icon {
-  font-size: var(--sidebar-icon-size) !important;
-  font-weight: bold;
-}
-
-.side-bar-button[data-v-caa3ee9c] {
-  width: var(--sidebar-width);
-  height: var(--sidebar-width);
-  border-radius: 0;
-}
-.comfyui-body-left .side-bar-button.side-bar-button-selected[data-v-caa3ee9c],
-.comfyui-body-left .side-bar-button.side-bar-button-selected[data-v-caa3ee9c]:hover {
-  border-left: 4px solid var(--p-button-text-primary-color);
-}
-.comfyui-body-right .side-bar-button.side-bar-button-selected[data-v-caa3ee9c],
-.comfyui-body-right .side-bar-button.side-bar-button-selected[data-v-caa3ee9c]:hover {
-  border-right: 4px solid var(--p-button-text-primary-color);
-}
-
-:root {
-  --sidebar-width: 64px;
-  --sidebar-icon-size: 1.5rem;
-}
-:root .small-sidebar {
-  --sidebar-width: 40px;
-  --sidebar-icon-size: 1rem;
-}
-
-.side-tool-bar-container[data-v-ed7a1148] {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-
-  pointer-events: auto;
-
-  width: var(--sidebar-width);
-  height: 100%;
-
-  background-color: var(--comfy-menu-bg);
-  color: var(--fg-color);
-}
-.side-tool-bar-end[data-v-ed7a1148] {
-  align-self: flex-end;
-  margin-top: auto;
-}
-.sidebar-content-container[data-v-ed7a1148] {
-  height: 100%;
-  overflow-y: auto;
-}
-
-.p-splitter-gutter {
-  pointer-events: auto;
-}
-.gutter-hidden {
-  display: none !important;
-}
-
-.side-bar-panel[data-v-edca8328] {
-  background-color: var(--bg-color);
-  pointer-events: auto;
-}
-.splitter-overlay[data-v-edca8328] {
-  width: 100%;
-  height: 100%;
-  position: absolute;
-  top: 0;
-  left: 0;
-  background-color: transparent;
-  pointer-events: none;
-  /* Set it the same as the ComfyUI menu */
-  /* Note: Lite-graph DOM widgets have the same z-index as the node id, so
-  999 should be sufficient to make sure splitter overlays on node's DOM
-  widgets */
-  z-index: 999;
-  border: none;
-}
-
-[data-v-37f672ab] .highlight {
-  background-color: var(--p-primary-color);
-  color: var(--p-primary-contrast-color);
-  font-weight: bold;
-  border-radius: 0.25rem;
-  padding: 0rem 0.125rem;
-  margin: -0.125rem 0.125rem;
-}
-
-.comfy-vue-node-search-container[data-v-2d409367] {
-  display: flex;
-  width: 100%;
-  min-width: 26rem;
-  align-items: center;
-  justify-content: center;
-}
-.comfy-vue-node-search-container[data-v-2d409367] * {
-  pointer-events: auto;
-}
-.comfy-vue-node-preview-container[data-v-2d409367] {
-  position: absolute;
-  left: -350px;
-  top: 50px;
-}
-.comfy-vue-node-search-box[data-v-2d409367] {
-  z-index: 10;
-  flex-grow: 1;
-}
-._filter-button[data-v-2d409367] {
-  z-index: 10;
-}
-._dialog[data-v-2d409367] {
-  min-width: 26rem;
-}
-
-.invisible-dialog-root {
-  width: 30%;
-  min-width: 24rem;
-  max-width: 48rem;
-  border: 0 !important;
-  background-color: transparent !important;
-  margin-top: 25vh;
-}
-.node-search-box-dialog-mask {
-  align-items: flex-start !important;
-}
-
-.node-tooltip[data-v-e0597bf9] {
-  background: var(--comfy-input-bg);
-  border-radius: 5px;
-  box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
-  color: var(--input-text);
-  font-family: sans-serif;
-  left: 0;
-  max-width: 30vw;
-  padding: 4px 8px;
-  position: absolute;
-  top: 0;
-  transform: translate(5px, calc(-100% - 5px));
-  white-space: pre-wrap;
-  z-index: 99999;
-}

web/assets/colorPalette-D5oi2-2V.js

@@ -0,0 +1,865 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { k as app, aP as LGraphCanvas, bO as useToastStore, ca as $el, z as LiteGraph } from "./index-DGAbdBYF.js";
+const colorPalettes = {
+  dark: {
+    id: "dark",
+    name: "Dark (Default)",
+    colors: {
+      node_slot: {
+        CLIP: "#FFD500",
+        // bright yellow
+        CLIP_VISION: "#A8DADC",
+        // light blue-gray
+        CLIP_VISION_OUTPUT: "#ad7452",
+        // rusty brown-orange
+        CONDITIONING: "#FFA931",
+        // vibrant orange-yellow
+        CONTROL_NET: "#6EE7B7",
+        // soft mint green
+        IMAGE: "#64B5F6",
+        // bright sky blue
+        LATENT: "#FF9CF9",
+        // light pink-purple
+        MASK: "#81C784",
+        // muted green
+        MODEL: "#B39DDB",
+        // light lavender-purple
+        STYLE_MODEL: "#C2FFAE",
+        // light green-yellow
+        VAE: "#FF6E6E",
+        // bright red
+        NOISE: "#B0B0B0",
+        // gray
+        GUIDER: "#66FFFF",
+        // cyan
+        SAMPLER: "#ECB4B4",
+        // very soft red
+        SIGMAS: "#CDFFCD",
+        // soft lime green
+        TAESD: "#DCC274"
+        // cheesecake
+      },
+      litegraph_base: {
+        BACKGROUND_IMAGE: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAIAAAD/gAIDAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQBJREFUeNrs1rEKwjAUhlETUkj3vP9rdmr1Ysammk2w5wdxuLgcMHyptfawuZX4pJSWZTnfnu/lnIe/jNNxHHGNn//HNbbv+4dr6V+11uF527arU7+u63qfa/bnmh8sWLBgwYJlqRf8MEptXPBXJXa37BSl3ixYsGDBMliwFLyCV/DeLIMFCxYsWLBMwSt4Be/NggXLYMGCBUvBK3iNruC9WbBgwYJlsGApeAWv4L1ZBgsWLFiwYJmCV/AK3psFC5bBggULloJX8BpdwXuzYMGCBctgwVLwCl7Be7MMFixYsGDBsu8FH1FaSmExVfAxBa/gvVmwYMGCZbBg/W4vAQYA5tRF9QYlv/QAAAAASUVORK5CYII=",
+        CLEAR_BACKGROUND_COLOR: "#222",
+        NODE_TITLE_COLOR: "#999",
+        NODE_SELECTED_TITLE_COLOR: "#FFF",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#AAA",
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#333",
+        NODE_DEFAULT_BGCOLOR: "#353535",
+        NODE_DEFAULT_BOXCOLOR: "#666",
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#FFF",
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.5)",
+        DEFAULT_GROUP_FONT: 24,
+        WIDGET_BGCOLOR: "#222",
+        WIDGET_OUTLINE_COLOR: "#666",
+        WIDGET_TEXT_COLOR: "#DDD",
+        WIDGET_SECONDARY_TEXT_COLOR: "#999",
+        LINK_COLOR: "#9A9",
+        EVENT_LINK_COLOR: "#A86",
+        CONNECTING_LINK_COLOR: "#AFA",
+        BADGE_FG_COLOR: "#FFF",
+        BADGE_BG_COLOR: "#0F1F0F"
+      },
+      comfy_base: {
+        "fg-color": "#fff",
+        "bg-color": "#202020",
+        "comfy-menu-bg": "#353535",
+        "comfy-input-bg": "#222",
+        "input-text": "#ddd",
+        "descrip-text": "#999",
+        "drag-text": "#ccc",
+        "error-text": "#ff4444",
+        "border-color": "#4e4e4e",
+        "tr-even-bg-color": "#222",
+        "tr-odd-bg-color": "#353535",
+        "content-bg": "#4e4e4e",
+        "content-fg": "#fff",
+        "content-hover-bg": "#222",
+        "content-hover-fg": "#fff"
+      }
+    }
+  },
+  light: {
+    id: "light",
+    name: "Light",
+    colors: {
+      node_slot: {
+        CLIP: "#FFA726",
+        // orange
+        CLIP_VISION: "#5C6BC0",
+        // indigo
+        CLIP_VISION_OUTPUT: "#8D6E63",
+        // brown
+        CONDITIONING: "#EF5350",
+        // red
+        CONTROL_NET: "#66BB6A",
+        // green
+        IMAGE: "#42A5F5",
+        // blue
+        LATENT: "#AB47BC",
+        // purple
+        MASK: "#9CCC65",
+        // light green
+        MODEL: "#7E57C2",
+        // deep purple
+        STYLE_MODEL: "#D4E157",
+        // lime
+        VAE: "#FF7043"
+        // deep orange
+      },
+      litegraph_base: {
+        BACKGROUND_IMAGE: "data:image/gif;base64,R0lGODlhZABkALMAAAAAAP///+vr6+rq6ujo6Ofn5+bm5uXl5d3d3f///wAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAAkALAAAAABkAGQAAAT/UMhJq7046827HkcoHkYxjgZhnGG6si5LqnIM0/fL4qwwIMAg0CAsEovBIxKhRDaNy2GUOX0KfVFrssrNdpdaqTeKBX+dZ+jYvEaTf+y4W66mC8PUdrE879f9d2mBeoNLfH+IhYBbhIx2jkiHiomQlGKPl4uZe3CaeZifnnijgkESBqipqqusra6vsLGys62SlZO4t7qbuby7CLa+wqGWxL3Gv3jByMOkjc2lw8vOoNSi0czAncXW3Njdx9Pf48/Z4Kbbx+fQ5evZ4u3k1fKR6cn03vHlp7T9/v8A/8Gbp4+gwXoFryXMB2qgwoMMHyKEqA5fxX322FG8tzBcRnMW/zlulPbRncmQGidKjMjyYsOSKEF2FBlJQMCbOHP6c9iSZs+UnGYCdbnSo1CZI5F64kn0p1KnTH02nSoV3dGTV7FFHVqVq1dtWcMmVQZTbNGu72zqXMuW7danVL+6e4t1bEy6MeueBYLXrNO5Ze36jQtWsOG97wIj1vt3St/DjTEORss4nNq2mDP3e7w4r1bFkSET5hy6s2TRlD2/mSxXtSHQhCunXo26NevCpmvD/UU6tuullzULH76q92zdZG/Ltv1a+W+osI/nRmyc+fRi1Xdbh+68+0vv10dH3+77KD/i6IdnX669/frn5Zsjh4/2PXju8+8bzc9/6fj27LFnX11/+IUnXWl7BJfegm79FyB9JOl3oHgSklefgxAC+FmFGpqHIYcCfkhgfCohSKKJVo044YUMttggiBkmp6KFXw1oII24oYhjiDByaKOOHcp3Y5BD/njikSkO+eBREQAAOw==",
+        CLEAR_BACKGROUND_COLOR: "lightgray",
+        NODE_TITLE_COLOR: "#222",
+        NODE_SELECTED_TITLE_COLOR: "#000",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#444",
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#F7F7F7",
+        NODE_DEFAULT_BGCOLOR: "#F5F5F5",
+        NODE_DEFAULT_BOXCOLOR: "#CCC",
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#000",
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.1)",
+        DEFAULT_GROUP_FONT: 24,
+        WIDGET_BGCOLOR: "#D4D4D4",
+        WIDGET_OUTLINE_COLOR: "#999",
+        WIDGET_TEXT_COLOR: "#222",
+        WIDGET_SECONDARY_TEXT_COLOR: "#555",
+        LINK_COLOR: "#4CAF50",
+        EVENT_LINK_COLOR: "#FF9800",
+        CONNECTING_LINK_COLOR: "#2196F3",
+        BADGE_FG_COLOR: "#000",
+        BADGE_BG_COLOR: "#FFF"
+      },
+      comfy_base: {
+        "fg-color": "#222",
+        "bg-color": "#DDD",
+        "comfy-menu-bg": "#F5F5F5",
+        "comfy-input-bg": "#C9C9C9",
+        "input-text": "#222",
+        "descrip-text": "#444",
+        "drag-text": "#555",
+        "error-text": "#F44336",
+        "border-color": "#888",
+        "tr-even-bg-color": "#f9f9f9",
+        "tr-odd-bg-color": "#fff",
+        "content-bg": "#e0e0e0",
+        "content-fg": "#222",
+        "content-hover-bg": "#adadad",
+        "content-hover-fg": "#222"
+      }
+    }
+  },
+  solarized: {
+    id: "solarized",
+    name: "Solarized",
+    colors: {
+      node_slot: {
+        CLIP: "#2AB7CA",
+        // light blue
+        CLIP_VISION: "#6c71c4",
+        // blue violet
+        CLIP_VISION_OUTPUT: "#859900",
+        // olive green
+        CONDITIONING: "#d33682",
+        // magenta
+        CONTROL_NET: "#d1ffd7",
+        // light mint green
+        IMAGE: "#5940bb",
+        // deep blue violet
+        LATENT: "#268bd2",
+        // blue
+        MASK: "#CCC9E7",
+        // light purple-gray
+        MODEL: "#dc322f",
+        // red
+        STYLE_MODEL: "#1a998a",
+        // teal
+        UPSCALE_MODEL: "#054A29",
+        // dark green
+        VAE: "#facfad"
+        // light pink-orange
+      },
+      litegraph_base: {
+        NODE_TITLE_COLOR: "#fdf6e3",
+        // Base3
+        NODE_SELECTED_TITLE_COLOR: "#A9D400",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#657b83",
+        // Base00
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#094656",
+        NODE_DEFAULT_BGCOLOR: "#073642",
+        // Base02
+        NODE_DEFAULT_BOXCOLOR: "#839496",
+        // Base0
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#fdf6e3",
+        // Base3
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.5)",
+        DEFAULT_GROUP_FONT: 24,
+        WIDGET_BGCOLOR: "#002b36",
+        // Base03
+        WIDGET_OUTLINE_COLOR: "#839496",
+        // Base0
+        WIDGET_TEXT_COLOR: "#fdf6e3",
+        // Base3
+        WIDGET_SECONDARY_TEXT_COLOR: "#93a1a1",
+        // Base1
+        LINK_COLOR: "#2aa198",
+        // Solarized Cyan
+        EVENT_LINK_COLOR: "#268bd2",
+        // Solarized Blue
+        CONNECTING_LINK_COLOR: "#859900"
+        // Solarized Green
+      },
+      comfy_base: {
+        "fg-color": "#fdf6e3",
+        // Base3
+        "bg-color": "#002b36",
+        // Base03
+        "comfy-menu-bg": "#073642",
+        // Base02
+        "comfy-input-bg": "#002b36",
+        // Base03
+        "input-text": "#93a1a1",
+        // Base1
+        "descrip-text": "#586e75",
+        // Base01
+        "drag-text": "#839496",
+        // Base0
+        "error-text": "#dc322f",
+        // Solarized Red
+        "border-color": "#657b83",
+        // Base00
+        "tr-even-bg-color": "#002b36",
+        "tr-odd-bg-color": "#073642",
+        "content-bg": "#657b83",
+        "content-fg": "#fdf6e3",
+        "content-hover-bg": "#002b36",
+        "content-hover-fg": "#fdf6e3"
+      }
+    }
+  },
+  arc: {
+    id: "arc",
+    name: "Arc",
+    colors: {
+      node_slot: {
+        BOOLEAN: "",
+        CLIP: "#eacb8b",
+        CLIP_VISION: "#A8DADC",
+        CLIP_VISION_OUTPUT: "#ad7452",
+        CONDITIONING: "#cf876f",
+        CONTROL_NET: "#00d78d",
+        CONTROL_NET_WEIGHTS: "",
+        FLOAT: "",
+        GLIGEN: "",
+        IMAGE: "#80a1c0",
+        IMAGEUPLOAD: "",
+        INT: "",
+        LATENT: "#b38ead",
+        LATENT_KEYFRAME: "",
+        MASK: "#a3bd8d",
+        MODEL: "#8978a7",
+        SAMPLER: "",
+        SIGMAS: "",
+        STRING: "",
+        STYLE_MODEL: "#C2FFAE",
+        T2I_ADAPTER_WEIGHTS: "",
+        TAESD: "#DCC274",
+        TIMESTEP_KEYFRAME: "",
+        UPSCALE_MODEL: "",
+        VAE: "#be616b"
+      },
+      litegraph_base: {
+        BACKGROUND_IMAGE: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAACXBIWXMAAAsTAAALEwEAmpwYAAABcklEQVR4nO3YMUoDARgF4RfxBqZI6/0vZqFn0MYtrLIQMFN8U6V4LAtD+Jm9XG/v30OGl2e/AP7yevz4+vx45nvgF/+QGITEICQGITEIiUFIjNNC3q43u3/YnRJyPOzeQ+0e220nhRzReC8e7R7bbdvl+Jal1Bs46jEIiUFIDEJiEBKDkBhKPbZT6qHdptRTu02p53DUYxASg5AYhMQgJAYhMZR6bKfUQ7tNqad2m1LP4ajHICQGITEIiUFIDEJiKPXYTqmHdptST+02pZ7DUY9BSAxCYhASg5AYhMRQ6rGdUg/tNqWe2m1KPYejHoOQGITEICQGITEIiaHUYzulHtptSj2125R6Dkc9BiExCIlBSAxCYhASQ6nHdko9tNuUemq3KfUcjnoMQmIQEoOQGITEICSGUo/tlHpotyn11G5T6jkc9RiExCAkBiExCIlBSAylHtsp9dBuU+qp3abUczjqMQiJQUgMQmIQEoOQGITE+AHFISNQrFTGuwAAAABJRU5ErkJggg==",
+        CLEAR_BACKGROUND_COLOR: "#2b2f38",
+        NODE_TITLE_COLOR: "#b2b7bd",
+        NODE_SELECTED_TITLE_COLOR: "#FFF",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#AAA",
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#2b2f38",
+        NODE_DEFAULT_BGCOLOR: "#242730",
+        NODE_DEFAULT_BOXCOLOR: "#6e7581",
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#FFF",
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.5)",
+        DEFAULT_GROUP_FONT: 22,
+        WIDGET_BGCOLOR: "#2b2f38",
+        WIDGET_OUTLINE_COLOR: "#6e7581",
+        WIDGET_TEXT_COLOR: "#DDD",
+        WIDGET_SECONDARY_TEXT_COLOR: "#b2b7bd",
+        LINK_COLOR: "#9A9",
+        EVENT_LINK_COLOR: "#A86",
+        CONNECTING_LINK_COLOR: "#AFA"
+      },
+      comfy_base: {
+        "fg-color": "#fff",
+        "bg-color": "#2b2f38",
+        "comfy-menu-bg": "#242730",
+        "comfy-input-bg": "#2b2f38",
+        "input-text": "#ddd",
+        "descrip-text": "#b2b7bd",
+        "drag-text": "#ccc",
+        "error-text": "#ff4444",
+        "border-color": "#6e7581",
+        "tr-even-bg-color": "#2b2f38",
+        "tr-odd-bg-color": "#242730",
+        "content-bg": "#6e7581",
+        "content-fg": "#fff",
+        "content-hover-bg": "#2b2f38",
+        "content-hover-fg": "#fff"
+      }
+    }
+  },
+  nord: {
+    id: "nord",
+    name: "Nord",
+    colors: {
+      node_slot: {
+        BOOLEAN: "",
+        CLIP: "#eacb8b",
+        CLIP_VISION: "#A8DADC",
+        CLIP_VISION_OUTPUT: "#ad7452",
+        CONDITIONING: "#cf876f",
+        CONTROL_NET: "#00d78d",
+        CONTROL_NET_WEIGHTS: "",
+        FLOAT: "",
+        GLIGEN: "",
+        IMAGE: "#80a1c0",
+        IMAGEUPLOAD: "",
+        INT: "",
+        LATENT: "#b38ead",
+        LATENT_KEYFRAME: "",
+        MASK: "#a3bd8d",
+        MODEL: "#8978a7",
+        SAMPLER: "",
+        SIGMAS: "",
+        STRING: "",
+        STYLE_MODEL: "#C2FFAE",
+        T2I_ADAPTER_WEIGHTS: "",
+        TAESD: "#DCC274",
+        TIMESTEP_KEYFRAME: "",
+        UPSCALE_MODEL: "",
+        VAE: "#be616b"
+      },
+      litegraph_base: {
+        BACKGROUND_IMAGE: "data:image/png;base64,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",
+        CLEAR_BACKGROUND_COLOR: "#212732",
+        NODE_TITLE_COLOR: "#999",
+        NODE_SELECTED_TITLE_COLOR: "#e5eaf0",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#bcc2c8",
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#2e3440",
+        NODE_DEFAULT_BGCOLOR: "#161b22",
+        NODE_DEFAULT_BOXCOLOR: "#545d70",
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#e5eaf0",
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.5)",
+        DEFAULT_GROUP_FONT: 24,
+        WIDGET_BGCOLOR: "#2e3440",
+        WIDGET_OUTLINE_COLOR: "#545d70",
+        WIDGET_TEXT_COLOR: "#bcc2c8",
+        WIDGET_SECONDARY_TEXT_COLOR: "#999",
+        LINK_COLOR: "#9A9",
+        EVENT_LINK_COLOR: "#A86",
+        CONNECTING_LINK_COLOR: "#AFA"
+      },
+      comfy_base: {
+        "fg-color": "#e5eaf0",
+        "bg-color": "#2e3440",
+        "comfy-menu-bg": "#161b22",
+        "comfy-input-bg": "#2e3440",
+        "input-text": "#bcc2c8",
+        "descrip-text": "#999",
+        "drag-text": "#ccc",
+        "error-text": "#ff4444",
+        "border-color": "#545d70",
+        "tr-even-bg-color": "#2e3440",
+        "tr-odd-bg-color": "#161b22",
+        "content-bg": "#545d70",
+        "content-fg": "#e5eaf0",
+        "content-hover-bg": "#2e3440",
+        "content-hover-fg": "#e5eaf0"
+      }
+    }
+  },
+  github: {
+    id: "github",
+    name: "Github",
+    colors: {
+      node_slot: {
+        BOOLEAN: "",
+        CLIP: "#eacb8b",
+        CLIP_VISION: "#A8DADC",
+        CLIP_VISION_OUTPUT: "#ad7452",
+        CONDITIONING: "#cf876f",
+        CONTROL_NET: "#00d78d",
+        CONTROL_NET_WEIGHTS: "",
+        FLOAT: "",
+        GLIGEN: "",
+        IMAGE: "#80a1c0",
+        IMAGEUPLOAD: "",
+        INT: "",
+        LATENT: "#b38ead",
+        LATENT_KEYFRAME: "",
+        MASK: "#a3bd8d",
+        MODEL: "#8978a7",
+        SAMPLER: "",
+        SIGMAS: "",
+        STRING: "",
+        STYLE_MODEL: "#C2FFAE",
+        T2I_ADAPTER_WEIGHTS: "",
+        TAESD: "#DCC274",
+        TIMESTEP_KEYFRAME: "",
+        UPSCALE_MODEL: "",
+        VAE: "#be616b"
+      },
+      litegraph_base: {
+        BACKGROUND_IMAGE: "data:image/png;base64,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",
+        CLEAR_BACKGROUND_COLOR: "#040506",
+        NODE_TITLE_COLOR: "#999",
+        NODE_SELECTED_TITLE_COLOR: "#e5eaf0",
+        NODE_TEXT_SIZE: 14,
+        NODE_TEXT_COLOR: "#bcc2c8",
+        NODE_SUBTEXT_SIZE: 12,
+        NODE_DEFAULT_COLOR: "#161b22",
+        NODE_DEFAULT_BGCOLOR: "#13171d",
+        NODE_DEFAULT_BOXCOLOR: "#30363d",
+        NODE_DEFAULT_SHAPE: "box",
+        NODE_BOX_OUTLINE_COLOR: "#e5eaf0",
+        NODE_BYPASS_BGCOLOR: "#FF00FF",
+        DEFAULT_SHADOW_COLOR: "rgba(0,0,0,0.5)",
+        DEFAULT_GROUP_FONT: 24,
+        WIDGET_BGCOLOR: "#161b22",
+        WIDGET_OUTLINE_COLOR: "#30363d",
+        WIDGET_TEXT_COLOR: "#bcc2c8",
+        WIDGET_SECONDARY_TEXT_COLOR: "#999",
+        LINK_COLOR: "#9A9",
+        EVENT_LINK_COLOR: "#A86",
+        CONNECTING_LINK_COLOR: "#AFA"
+      },
+      comfy_base: {
+        "fg-color": "#e5eaf0",
+        "bg-color": "#161b22",
+        "comfy-menu-bg": "#13171d",
+        "comfy-input-bg": "#161b22",
+        "input-text": "#bcc2c8",
+        "descrip-text": "#999",
+        "drag-text": "#ccc",
+        "error-text": "#ff4444",
+        "border-color": "#30363d",
+        "tr-even-bg-color": "#161b22",
+        "tr-odd-bg-color": "#13171d",
+        "content-bg": "#30363d",
+        "content-fg": "#e5eaf0",
+        "content-hover-bg": "#161b22",
+        "content-hover-fg": "#e5eaf0"
+      }
+    }
+  }
+};
+const id = "Comfy.ColorPalette";
+const idCustomColorPalettes = "Comfy.CustomColorPalettes";
+const defaultColorPaletteId = "dark";
+const els = {
+  select: null
+};
+const getCustomColorPalettes = /* @__PURE__ */ __name(() => {
+  return app.ui.settings.getSettingValue(idCustomColorPalettes, {});
+}, "getCustomColorPalettes");
+const setCustomColorPalettes = /* @__PURE__ */ __name((customColorPalettes) => {
+  return app.ui.settings.setSettingValue(
+    idCustomColorPalettes,
+    customColorPalettes
+  );
+}, "setCustomColorPalettes");
+const defaultColorPalette = colorPalettes[defaultColorPaletteId];
+const getColorPalette = /* @__PURE__ */ __name((colorPaletteId) => {
+  if (!colorPaletteId) {
+    colorPaletteId = app.ui.settings.getSettingValue(id, defaultColorPaletteId);
+  }
+  if (colorPaletteId.startsWith("custom_")) {
+    colorPaletteId = colorPaletteId.substr(7);
+    let customColorPalettes = getCustomColorPalettes();
+    if (customColorPalettes[colorPaletteId]) {
+      return customColorPalettes[colorPaletteId];
+    }
+  }
+  return colorPalettes[colorPaletteId];
+}, "getColorPalette");
+const setColorPalette = /* @__PURE__ */ __name((colorPaletteId) => {
+  app.ui.settings.setSettingValue(id, colorPaletteId);
+}, "setColorPalette");
+app.registerExtension({
+  name: id,
+  init() {
+    LGraphCanvas.prototype.updateBackground = function(image, clearBackgroundColor) {
+      this._bg_img = new Image();
+      this._bg_img.name = image;
+      this._bg_img.src = image;
+      this._bg_img.onload = () => {
+        this.draw(true, true);
+      };
+      this.background_image = image;
+      this.clear_background = true;
+      this.clear_background_color = clearBackgroundColor;
+      this._pattern = null;
+    };
+  },
+  addCustomNodeDefs(node_defs) {
+    const sortObjectKeys = /* @__PURE__ */ __name((unordered) => {
+      return Object.keys(unordered).sort().reduce((obj, key) => {
+        obj[key] = unordered[key];
+        return obj;
+      }, {});
+    }, "sortObjectKeys");
+    function getSlotTypes() {
+      var types = [];
+      const defs = node_defs;
+      for (const nodeId in defs) {
+        const nodeData = defs[nodeId];
+        var inputs = nodeData["input"]["required"];
+        if (nodeData["input"]["optional"] !== void 0) {
+          inputs = Object.assign(
+            {},
+            nodeData["input"]["required"],
+            nodeData["input"]["optional"]
+          );
+        }
+        for (const inputName in inputs) {
+          const inputData = inputs[inputName];
+          const type = inputData[0];
+          if (!Array.isArray(type)) {
+            types.push(type);
+          }
+        }
+        for (const o in nodeData["output"]) {
+          const output = nodeData["output"][o];
+          types.push(output);
+        }
+      }
+      return types;
+    }
+    __name(getSlotTypes, "getSlotTypes");
+    function completeColorPalette(colorPalette) {
+      var types = getSlotTypes();
+      for (const type of types) {
+        if (!colorPalette.colors.node_slot[type]) {
+          colorPalette.colors.node_slot[type] = "";
+        }
+      }
+      colorPalette.colors.node_slot = sortObjectKeys(
+        colorPalette.colors.node_slot
+      );
+      return colorPalette;
+    }
+    __name(completeColorPalette, "completeColorPalette");
+    const getColorPaletteTemplate = /* @__PURE__ */ __name(async () => {
+      let colorPalette = {
+        id: "my_color_palette_unique_id",
+        name: "My Color Palette",
+        colors: {
+          node_slot: {},
+          litegraph_base: {},
+          comfy_base: {}
+        }
+      };
+      const defaultColorPalette2 = colorPalettes[defaultColorPaletteId];
+      for (const key in defaultColorPalette2.colors.litegraph_base) {
+        if (!colorPalette.colors.litegraph_base[key]) {
+          colorPalette.colors.litegraph_base[key] = "";
+        }
+      }
+      for (const key in defaultColorPalette2.colors.comfy_base) {
+        if (!colorPalette.colors.comfy_base[key]) {
+          colorPalette.colors.comfy_base[key] = "";
+        }
+      }
+      return completeColorPalette(colorPalette);
+    }, "getColorPaletteTemplate");
+    const addCustomColorPalette = /* @__PURE__ */ __name(async (colorPalette) => {
+      if (typeof colorPalette !== "object") {
+        useToastStore().addAlert("Invalid color palette.");
+        return;
+      }
+      if (!colorPalette.id) {
+        useToastStore().addAlert("Color palette missing id.");
+        return;
+      }
+      if (!colorPalette.name) {
+        useToastStore().addAlert("Color palette missing name.");
+        return;
+      }
+      if (!colorPalette.colors) {
+        useToastStore().addAlert("Color palette missing colors.");
+        return;
+      }
+      if (colorPalette.colors.node_slot && typeof colorPalette.colors.node_slot !== "object") {
+        useToastStore().addAlert("Invalid color palette colors.node_slot.");
+        return;
+      }
+      const customColorPalettes = getCustomColorPalettes();
+      customColorPalettes[colorPalette.id] = colorPalette;
+      setCustomColorPalettes(customColorPalettes);
+      for (const option of els.select.childNodes) {
+        if (option.value === "custom_" + colorPalette.id) {
+          els.select.removeChild(option);
+        }
+      }
+      els.select.append(
+        $el("option", {
+          textContent: colorPalette.name + " (custom)",
+          value: "custom_" + colorPalette.id,
+          selected: true
+        })
+      );
+      setColorPalette("custom_" + colorPalette.id);
+      await loadColorPalette(colorPalette);
+    }, "addCustomColorPalette");
+    const deleteCustomColorPalette = /* @__PURE__ */ __name(async (colorPaletteId) => {
+      const customColorPalettes = getCustomColorPalettes();
+      delete customColorPalettes[colorPaletteId];
+      setCustomColorPalettes(customColorPalettes);
+      for (const opt of els.select.childNodes) {
+        const option = opt;
+        if (option.value === defaultColorPaletteId) {
+          option.selected = true;
+        }
+        if (option.value === "custom_" + colorPaletteId) {
+          els.select.removeChild(option);
+        }
+      }
+      setColorPalette(defaultColorPaletteId);
+      await loadColorPalette(getColorPalette());
+    }, "deleteCustomColorPalette");
+    const loadColorPalette = /* @__PURE__ */ __name(async (colorPalette) => {
+      colorPalette = await completeColorPalette(colorPalette);
+      if (colorPalette.colors) {
+        if (colorPalette.colors.node_slot) {
+          Object.assign(
+            app.canvas.default_connection_color_byType,
+            colorPalette.colors.node_slot
+          );
+          Object.assign(
+            LGraphCanvas.link_type_colors,
+            colorPalette.colors.node_slot
+          );
+        }
+        if (colorPalette.colors.litegraph_base) {
+          app.canvas.node_title_color = colorPalette.colors.litegraph_base.NODE_TITLE_COLOR;
+          app.canvas.default_link_color = colorPalette.colors.litegraph_base.LINK_COLOR;
+          for (const key in colorPalette.colors.litegraph_base) {
+            if (colorPalette.colors.litegraph_base.hasOwnProperty(key) && LiteGraph.hasOwnProperty(key)) {
+              LiteGraph[key] = colorPalette.colors.litegraph_base[key];
+            }
+          }
+        }
+        if (colorPalette.colors.comfy_base) {
+          const rootStyle = document.documentElement.style;
+          for (const key in colorPalette.colors.comfy_base) {
+            rootStyle.setProperty(
+              "--" + key,
+              colorPalette.colors.comfy_base[key]
+            );
+          }
+        }
+        if (colorPalette.colors.litegraph_base.NODE_BYPASS_BGCOLOR) {
+          app.bypassBgColor = colorPalette.colors.litegraph_base.NODE_BYPASS_BGCOLOR;
+        }
+        app.canvas.draw(true, true);
+      }
+    }, "loadColorPalette");
+    const fileInput = $el("input", {
+      type: "file",
+      accept: ".json",
+      style: { display: "none" },
+      parent: document.body,
+      onchange: /* @__PURE__ */ __name(() => {
+        const file = fileInput.files[0];
+        if (file.type === "application/json" || file.name.endsWith(".json")) {
+          const reader = new FileReader();
+          reader.onload = async () => {
+            await addCustomColorPalette(JSON.parse(reader.result));
+          };
+          reader.readAsText(file);
+        }
+      }, "onchange")
+    });
+    app.ui.settings.addSetting({
+      id,
+      category: ["Comfy", "ColorPalette"],
+      name: "Color Palette",
+      type: /* @__PURE__ */ __name((name, setter, value) => {
+        const options = [
+          ...Object.values(colorPalettes).map(
+            (c) => $el("option", {
+              textContent: c.name,
+              value: c.id,
+              selected: c.id === value
+            })
+          ),
+          ...Object.values(getCustomColorPalettes()).map(
+            (c) => $el("option", {
+              textContent: `${c.name} (custom)`,
+              value: `custom_${c.id}`,
+              selected: `custom_${c.id}` === value
+            })
+          )
+        ];
+        els.select = $el(
+          "select",
+          {
+            style: {
+              marginBottom: "0.15rem",
+              width: "100%"
+            },
+            onchange: /* @__PURE__ */ __name((e) => {
+              setter(e.target.value);
+            }, "onchange")
+          },
+          options
+        );
+        return $el("tr", [
+          $el("td", [
+            els.select,
+            $el(
+              "div",
+              {
+                style: {
+                  display: "grid",
+                  gap: "4px",
+                  gridAutoFlow: "column"
+                }
+              },
+              [
+                $el("input", {
+                  type: "button",
+                  value: "Export",
+                  onclick: /* @__PURE__ */ __name(async () => {
+                    const colorPaletteId = app.ui.settings.getSettingValue(
+                      id,
+                      defaultColorPaletteId
+                    );
+                    const colorPalette = await completeColorPalette(
+                      getColorPalette(colorPaletteId)
+                    );
+                    const json = JSON.stringify(colorPalette, null, 2);
+                    const blob = new Blob([json], { type: "application/json" });
+                    const url = URL.createObjectURL(blob);
+                    const a = $el("a", {
+                      href: url,
+                      download: colorPaletteId + ".json",
+                      style: { display: "none" },
+                      parent: document.body
+                    });
+                    a.click();
+                    setTimeout(function() {
+                      a.remove();
+                      window.URL.revokeObjectURL(url);
+                    }, 0);
+                  }, "onclick")
+                }),
+                $el("input", {
+                  type: "button",
+                  value: "Import",
+                  onclick: /* @__PURE__ */ __name(() => {
+                    fileInput.click();
+                  }, "onclick")
+                }),
+                $el("input", {
+                  type: "button",
+                  value: "Template",
+                  onclick: /* @__PURE__ */ __name(async () => {
+                    const colorPalette = await getColorPaletteTemplate();
+                    const json = JSON.stringify(colorPalette, null, 2);
+                    const blob = new Blob([json], { type: "application/json" });
+                    const url = URL.createObjectURL(blob);
+                    const a = $el("a", {
+                      href: url,
+                      download: "color_palette.json",
+                      style: { display: "none" },
+                      parent: document.body
+                    });
+                    a.click();
+                    setTimeout(function() {
+                      a.remove();
+                      window.URL.revokeObjectURL(url);
+                    }, 0);
+                  }, "onclick")
+                }),
+                $el("input", {
+                  type: "button",
+                  value: "Delete",
+                  onclick: /* @__PURE__ */ __name(async () => {
+                    let colorPaletteId = app.ui.settings.getSettingValue(
+                      id,
+                      defaultColorPaletteId
+                    );
+                    if (colorPalettes[colorPaletteId]) {
+                      useToastStore().addAlert(
+                        "You cannot delete a built-in color palette."
+                      );
+                      return;
+                    }
+                    if (colorPaletteId.startsWith("custom_")) {
+                      colorPaletteId = colorPaletteId.substr(7);
+                    }
+                    await deleteCustomColorPalette(colorPaletteId);
+                  }, "onclick")
+                })
+              ]
+            )
+          ])
+        ]);
+      }, "type"),
+      defaultValue: defaultColorPaletteId,
+      async onChange(value) {
+        if (!value) {
+          return;
+        }
+        let palette = colorPalettes[value];
+        if (palette) {
+          await loadColorPalette(palette);
+        } else if (value.startsWith("custom_")) {
+          value = value.substr(7);
+          let customColorPalettes = getCustomColorPalettes();
+          if (customColorPalettes[value]) {
+            palette = customColorPalettes[value];
+            await loadColorPalette(customColorPalettes[value]);
+          }
+        }
+        let { BACKGROUND_IMAGE, CLEAR_BACKGROUND_COLOR } = palette.colors.litegraph_base;
+        if (BACKGROUND_IMAGE === void 0 || CLEAR_BACKGROUND_COLOR === void 0) {
+          const base = colorPalettes["dark"].colors.litegraph_base;
+          BACKGROUND_IMAGE = base.BACKGROUND_IMAGE;
+          CLEAR_BACKGROUND_COLOR = base.CLEAR_BACKGROUND_COLOR;
+        }
+        app.canvas.updateBackground(BACKGROUND_IMAGE, CLEAR_BACKGROUND_COLOR);
+      }
+    });
+  }
+});
+window.comfyAPI = window.comfyAPI || {};
+window.comfyAPI.colorPalette = window.comfyAPI.colorPalette || {};
+window.comfyAPI.colorPalette.defaultColorPalette = defaultColorPalette;
+window.comfyAPI.colorPalette.getColorPalette = getColorPalette;
+export {
+  defaultColorPalette as d,
+  getColorPalette as g
+};
+//# sourceMappingURL=colorPalette-D5oi2-2V.js.map

web/assets/userSelection-CmI-fOSC.css

@@ -1,3 +1,37 @@
+.lds-ring {
+  display: inline-block;
+  position: relative;
+  width: 1em;
+  height: 1em;
+}
+.lds-ring div {
+  box-sizing: border-box;
+  display: block;
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  border: 0.15em solid #fff;
+  border-radius: 50%;
+  animation: lds-ring 1.2s cubic-bezier(0.5, 0, 0.5, 1) infinite;
+  border-color: #fff transparent transparent transparent;
+}
+.lds-ring div:nth-child(1) {
+  animation-delay: -0.45s;
+}
+.lds-ring div:nth-child(2) {
+  animation-delay: -0.3s;
+}
+.lds-ring div:nth-child(3) {
+  animation-delay: -0.15s;
+}
+@keyframes lds-ring {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
 .comfy-user-selection {
     width: 100vw;
     height: 100vh;

web/assets/userSelection-Duxc-t_S.js

@@ -1,6 +1,15 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { aY as createSpinner, aT as api, aN as $el } from "./index-Drc_oD2f.js";
+import { b4 as api, ca as $el } from "./index-DGAbdBYF.js";
+function createSpinner() {
+  const div = document.createElement("div");
+  div.innerHTML = `<div class="lds-ring"><div></div><div></div><div></div><div></div></div>`;
+  return div.firstElementChild;
+}
+__name(createSpinner, "createSpinner");
+window.comfyAPI = window.comfyAPI || {};
+window.comfyAPI.spinner = window.comfyAPI.spinner || {};
+window.comfyAPI.spinner.createSpinner = createSpinner;
 class UserSelectionScreen {
   static {
     __name(this, "UserSelectionScreen");
@@ -117,4 +126,4 @@ window.comfyAPI.userSelection.UserSelectionScreen = UserSelectionScreen;
 export {
   UserSelectionScreen
 };
-//# sourceMappingURL=userSelection-BM5u5JIA.js.map
+//# sourceMappingURL=userSelection-Duxc-t_S.js.map

web/assets/widgetInputs-DdoWwzg5.js

@@ -0,0 +1,756 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { l as LGraphNode, k as app, cf as applyTextReplacements, ce as ComfyWidgets, ci as addValueControlWidgets, z as LiteGraph } from "./index-DGAbdBYF.js";
+const CONVERTED_TYPE = "converted-widget";
+const VALID_TYPES = [
+  "STRING",
+  "combo",
+  "number",
+  "toggle",
+  "BOOLEAN",
+  "text",
+  "string"
+];
+const CONFIG = Symbol();
+const GET_CONFIG = Symbol();
+const TARGET = Symbol();
+const replacePropertyName = "Run widget replace on values";
+class PrimitiveNode extends LGraphNode {
+  static {
+    __name(this, "PrimitiveNode");
+  }
+  controlValues;
+  lastType;
+  static category;
+  constructor(title) {
+    super(title);
+    this.addOutput("connect to widget input", "*");
+    this.serialize_widgets = true;
+    this.isVirtualNode = true;
+    if (!this.properties || !(replacePropertyName in this.properties)) {
+      this.addProperty(replacePropertyName, false, "boolean");
+    }
+  }
+  applyToGraph(extraLinks = []) {
+    if (!this.outputs[0].links?.length) return;
+    function get_links(node) {
+      let links2 = [];
+      for (const l of node.outputs[0].links) {
+        const linkInfo = app.graph.links[l];
+        const n = node.graph.getNodeById(linkInfo.target_id);
+        if (n.type == "Reroute") {
+          links2 = links2.concat(get_links(n));
+        } else {
+          links2.push(l);
+        }
+      }
+      return links2;
+    }
+    __name(get_links, "get_links");
+    let links = [
+      ...get_links(this).map((l) => app.graph.links[l]),
+      ...extraLinks
+    ];
+    let v = this.widgets?.[0].value;
+    if (v && this.properties[replacePropertyName]) {
+      v = applyTextReplacements(app, v);
+    }
+    for (const linkInfo of links) {
+      const node = this.graph.getNodeById(linkInfo.target_id);
+      const input = node.inputs[linkInfo.target_slot];
+      let widget;
+      if (input.widget[TARGET]) {
+        widget = input.widget[TARGET];
+      } else {
+        const widgetName = input.widget.name;
+        if (widgetName) {
+          widget = node.widgets.find((w) => w.name === widgetName);
+        }
+      }
+      if (widget) {
+        widget.value = v;
+        if (widget.callback) {
+          widget.callback(
+            widget.value,
+            app.canvas,
+            node,
+            app.canvas.graph_mouse,
+            {}
+          );
+        }
+      }
+    }
+  }
+  refreshComboInNode() {
+    const widget = this.widgets?.[0];
+    if (widget?.type === "combo") {
+      widget.options.values = this.outputs[0].widget[GET_CONFIG]()[0];
+      if (!widget.options.values.includes(widget.value)) {
+        widget.value = widget.options.values[0];
+        widget.callback(widget.value);
+      }
+    }
+  }
+  onAfterGraphConfigured() {
+    if (this.outputs[0].links?.length && !this.widgets?.length) {
+      if (!this.#onFirstConnection()) return;
+      if (this.widgets) {
+        for (let i = 0; i < this.widgets_values.length; i++) {
+          const w = this.widgets[i];
+          if (w) {
+            w.value = this.widgets_values[i];
+          }
+        }
+      }
+      this.#mergeWidgetConfig();
+    }
+  }
+  onConnectionsChange(_, index, connected) {
+    if (app.configuringGraph) {
+      return;
+    }
+    const links = this.outputs[0].links;
+    if (connected) {
+      if (links?.length && !this.widgets?.length) {
+        this.#onFirstConnection();
+      }
+    } else {
+      this.#mergeWidgetConfig();
+      if (!links?.length) {
+        this.onLastDisconnect();
+      }
+    }
+  }
+  onConnectOutput(slot, type, input, target_node, target_slot) {
+    if (!input.widget) {
+      if (!(input.type in ComfyWidgets)) return false;
+    }
+    if (this.outputs[slot].links?.length) {
+      const valid = this.#isValidConnection(input);
+      if (valid) {
+        this.applyToGraph([{ target_id: target_node.id, target_slot }]);
+      }
+      return valid;
+    }
+  }
+  #onFirstConnection(recreating) {
+    if (!this.outputs[0].links) {
+      this.onLastDisconnect();
+      return;
+    }
+    const linkId = this.outputs[0].links[0];
+    const link = this.graph.links[linkId];
+    if (!link) return;
+    const theirNode = this.graph.getNodeById(link.target_id);
+    if (!theirNode || !theirNode.inputs) return;
+    const input = theirNode.inputs[link.target_slot];
+    if (!input) return;
+    let widget;
+    if (!input.widget) {
+      if (!(input.type in ComfyWidgets)) return;
+      widget = { name: input.name, [GET_CONFIG]: () => [input.type, {}] };
+    } else {
+      widget = input.widget;
+    }
+    const config = widget[GET_CONFIG]?.();
+    if (!config) return;
+    const { type } = getWidgetType(config);
+    this.outputs[0].type = type;
+    this.outputs[0].name = type;
+    this.outputs[0].widget = widget;
+    this.#createWidget(
+      widget[CONFIG] ?? config,
+      theirNode,
+      widget.name,
+      recreating,
+      widget[TARGET]
+    );
+  }
+  #createWidget(inputData, node, widgetName, recreating, targetWidget) {
+    let type = inputData[0];
+    if (type instanceof Array) {
+      type = "COMBO";
+    }
+    const size = this.size;
+    let widget;
+    if (type in ComfyWidgets) {
+      widget = (ComfyWidgets[type](this, "value", inputData, app) || {}).widget;
+    } else {
+      widget = this.addWidget(type, "value", null, () => {
+      }, {});
+    }
+    if (targetWidget) {
+      widget.value = targetWidget.value;
+    } else if (node?.widgets && widget) {
+      const theirWidget = node.widgets.find((w) => w.name === widgetName);
+      if (theirWidget) {
+        widget.value = theirWidget.value;
+      }
+    }
+    if (!inputData?.[1]?.control_after_generate && (widget.type === "number" || widget.type === "combo")) {
+      let control_value = this.widgets_values?.[1];
+      if (!control_value) {
+        control_value = "fixed";
+      }
+      addValueControlWidgets(
+        this,
+        widget,
+        control_value,
+        void 0,
+        inputData
+      );
+      let filter = this.widgets_values?.[2];
+      if (filter && this.widgets.length === 3) {
+        this.widgets[2].value = filter;
+      }
+    }
+    const controlValues = this.controlValues;
+    if (this.lastType === this.widgets[0].type && controlValues?.length === this.widgets.length - 1) {
+      for (let i = 0; i < controlValues.length; i++) {
+        this.widgets[i + 1].value = controlValues[i];
+      }
+    }
+    const callback = widget.callback;
+    const self = this;
+    widget.callback = function() {
+      const r = callback ? callback.apply(this, arguments) : void 0;
+      self.applyToGraph();
+      return r;
+    };
+    this.size = [
+      Math.max(this.size[0], size[0]),
+      Math.max(this.size[1], size[1])
+    ];
+    if (!recreating) {
+      const sz = this.computeSize();
+      if (this.size[0] < sz[0]) {
+        this.size[0] = sz[0];
+      }
+      if (this.size[1] < sz[1]) {
+        this.size[1] = sz[1];
+      }
+      requestAnimationFrame(() => {
+        if (this.onResize) {
+          this.onResize(this.size);
+        }
+      });
+    }
+  }
+  recreateWidget() {
+    const values = this.widgets?.map((w) => w.value);
+    this.#removeWidgets();
+    this.#onFirstConnection(true);
+    if (values?.length) {
+      for (let i = 0; i < this.widgets?.length; i++)
+        this.widgets[i].value = values[i];
+    }
+    return this.widgets?.[0];
+  }
+  #mergeWidgetConfig() {
+    const output = this.outputs[0];
+    const links = output.links;
+    const hasConfig = !!output.widget[CONFIG];
+    if (hasConfig) {
+      delete output.widget[CONFIG];
+    }
+    if (links?.length < 2 && hasConfig) {
+      if (links.length) {
+        this.recreateWidget();
+      }
+      return;
+    }
+    const config1 = output.widget[GET_CONFIG]();
+    const isNumber = config1[0] === "INT" || config1[0] === "FLOAT";
+    if (!isNumber) return;
+    for (const linkId of links) {
+      const link = app.graph.links[linkId];
+      if (!link) continue;
+      const theirNode = app.graph.getNodeById(link.target_id);
+      const theirInput = theirNode.inputs[link.target_slot];
+      this.#isValidConnection(theirInput, hasConfig);
+    }
+  }
+  isValidWidgetLink(originSlot, targetNode, targetWidget) {
+    const config2 = getConfig.call(targetNode, targetWidget.name) ?? [
+      targetWidget.type,
+      targetWidget.options || {}
+    ];
+    if (!isConvertibleWidget(targetWidget, config2)) return false;
+    const output = this.outputs[originSlot];
+    if (!(output.widget?.[CONFIG] ?? output.widget?.[GET_CONFIG]())) {
+      return true;
+    }
+    return !!mergeIfValid.call(this, output, config2);
+  }
+  #isValidConnection(input, forceUpdate) {
+    const output = this.outputs[0];
+    const config2 = input.widget[GET_CONFIG]();
+    return !!mergeIfValid.call(
+      this,
+      output,
+      config2,
+      forceUpdate,
+      this.recreateWidget
+    );
+  }
+  #removeWidgets() {
+    if (this.widgets) {
+      for (const w of this.widgets) {
+        if (w.onRemove) {
+          w.onRemove();
+        }
+      }
+      this.controlValues = [];
+      this.lastType = this.widgets[0]?.type;
+      for (let i = 1; i < this.widgets.length; i++) {
+        this.controlValues.push(this.widgets[i].value);
+      }
+      setTimeout(() => {
+        delete this.lastType;
+        delete this.controlValues;
+      }, 15);
+      this.widgets.length = 0;
+    }
+  }
+  onLastDisconnect() {
+    this.outputs[0].type = "*";
+    this.outputs[0].name = "connect to widget input";
+    delete this.outputs[0].widget;
+    this.#removeWidgets();
+  }
+}
+function getWidgetConfig(slot) {
+  return slot.widget[CONFIG] ?? slot.widget[GET_CONFIG]();
+}
+__name(getWidgetConfig, "getWidgetConfig");
+function getConfig(widgetName) {
+  const { nodeData } = this.constructor;
+  return nodeData?.input?.required?.[widgetName] ?? nodeData?.input?.optional?.[widgetName];
+}
+__name(getConfig, "getConfig");
+function isConvertibleWidget(widget, config) {
+  return (VALID_TYPES.includes(widget.type) || VALID_TYPES.includes(config[0])) && !widget.options?.forceInput;
+}
+__name(isConvertibleWidget, "isConvertibleWidget");
+function hideWidget(node, widget, suffix = "") {
+  if (widget.type?.startsWith(CONVERTED_TYPE)) return;
+  widget.origType = widget.type;
+  widget.origComputeSize = widget.computeSize;
+  widget.origSerializeValue = widget.serializeValue;
+  widget.computeSize = () => [0, -4];
+  widget.type = CONVERTED_TYPE + suffix;
+  widget.serializeValue = () => {
+    if (!node.inputs) {
+      return void 0;
+    }
+    let node_input = node.inputs.find((i) => i.widget?.name === widget.name);
+    if (!node_input || !node_input.link) {
+      return void 0;
+    }
+    return widget.origSerializeValue ? widget.origSerializeValue() : widget.value;
+  };
+  if (widget.linkedWidgets) {
+    for (const w of widget.linkedWidgets) {
+      hideWidget(node, w, ":" + widget.name);
+    }
+  }
+}
+__name(hideWidget, "hideWidget");
+function showWidget(widget) {
+  widget.type = widget.origType;
+  widget.computeSize = widget.origComputeSize;
+  widget.serializeValue = widget.origSerializeValue;
+  delete widget.origType;
+  delete widget.origComputeSize;
+  delete widget.origSerializeValue;
+  if (widget.linkedWidgets) {
+    for (const w of widget.linkedWidgets) {
+      showWidget(w);
+    }
+  }
+}
+__name(showWidget, "showWidget");
+function convertToInput(node, widget, config) {
+  hideWidget(node, widget);
+  const { type } = getWidgetType(config);
+  const sz = node.size;
+  const inputIsOptional = !!widget.options?.inputIsOptional;
+  const input = node.addInput(widget.name, type, {
+    widget: { name: widget.name, [GET_CONFIG]: () => config },
+    ...inputIsOptional ? { shape: LiteGraph.SlotShape.HollowCircle } : {}
+  });
+  for (const widget2 of node.widgets) {
+    widget2.last_y += LiteGraph.NODE_SLOT_HEIGHT;
+  }
+  node.setSize([Math.max(sz[0], node.size[0]), Math.max(sz[1], node.size[1])]);
+  return input;
+}
+__name(convertToInput, "convertToInput");
+function convertToWidget(node, widget) {
+  showWidget(widget);
+  const sz = node.size;
+  node.removeInput(node.inputs.findIndex((i) => i.widget?.name === widget.name));
+  for (const widget2 of node.widgets) {
+    widget2.last_y -= LiteGraph.NODE_SLOT_HEIGHT;
+  }
+  node.setSize([Math.max(sz[0], node.size[0]), Math.max(sz[1], node.size[1])]);
+}
+__name(convertToWidget, "convertToWidget");
+function getWidgetType(config) {
+  let type = config[0];
+  if (type instanceof Array) {
+    type = "COMBO";
+  }
+  return { type };
+}
+__name(getWidgetType, "getWidgetType");
+function isValidCombo(combo, obj) {
+  if (!(obj instanceof Array)) {
+    console.log(`connection rejected: tried to connect combo to ${obj}`);
+    return false;
+  }
+  if (combo.length !== obj.length) {
+    console.log(`connection rejected: combo lists dont match`);
+    return false;
+  }
+  if (combo.find((v, i) => obj[i] !== v)) {
+    console.log(`connection rejected: combo lists dont match`);
+    return false;
+  }
+  return true;
+}
+__name(isValidCombo, "isValidCombo");
+function isPrimitiveNode(node) {
+  return node.type === "PrimitiveNode";
+}
+__name(isPrimitiveNode, "isPrimitiveNode");
+function setWidgetConfig(slot, config, target) {
+  if (!slot.widget) return;
+  if (config) {
+    slot.widget[GET_CONFIG] = () => config;
+    slot.widget[TARGET] = target;
+  } else {
+    delete slot.widget;
+  }
+  if (slot.link) {
+    const link = app.graph.links[slot.link];
+    if (link) {
+      const originNode = app.graph.getNodeById(link.origin_id);
+      if (isPrimitiveNode(originNode)) {
+        if (config) {
+          originNode.recreateWidget();
+        } else if (!app.configuringGraph) {
+          originNode.disconnectOutput(0);
+          originNode.onLastDisconnect();
+        }
+      }
+    }
+  }
+}
+__name(setWidgetConfig, "setWidgetConfig");
+function mergeIfValid(output, config2, forceUpdate, recreateWidget, config1) {
+  if (!config1) {
+    config1 = output.widget[CONFIG] ?? output.widget[GET_CONFIG]();
+  }
+  if (config1[0] instanceof Array) {
+    if (!isValidCombo(config1[0], config2[0])) return;
+  } else if (config1[0] !== config2[0]) {
+    console.log(`connection rejected: types dont match`, config1[0], config2[0]);
+    return;
+  }
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(config1[1] ?? {}),
+    ...Object.keys(config2[1] ?? {})
+  ]);
+  let customConfig;
+  const getCustomConfig = /* @__PURE__ */ __name(() => {
+    if (!customConfig) {
+      if (typeof structuredClone === "undefined") {
+        customConfig = JSON.parse(JSON.stringify(config1[1] ?? {}));
+      } else {
+        customConfig = structuredClone(config1[1] ?? {});
+      }
+    }
+    return customConfig;
+  }, "getCustomConfig");
+  const isNumber = config1[0] === "INT" || config1[0] === "FLOAT";
+  for (const k of keys.values()) {
+    if (k !== "default" && k !== "forceInput" && k !== "defaultInput" && k !== "control_after_generate" && k !== "multiline" && k !== "tooltip") {
+      let v1 = config1[1][k];
+      let v2 = config2[1]?.[k];
+      if (v1 === v2 || !v1 && !v2) continue;
+      if (isNumber) {
+        if (k === "min") {
+          const theirMax = config2[1]?.["max"];
+          if (theirMax != null && v1 > theirMax) {
+            console.log("connection rejected: min > max", v1, theirMax);
+            return;
+          }
+          getCustomConfig()[k] = v1 == null ? v2 : v2 == null ? v1 : Math.max(v1, v2);
+          continue;
+        } else if (k === "max") {
+          const theirMin = config2[1]?.["min"];
+          if (theirMin != null && v1 < theirMin) {
+            console.log("connection rejected: max < min", v1, theirMin);
+            return;
+          }
+          getCustomConfig()[k] = v1 == null ? v2 : v2 == null ? v1 : Math.min(v1, v2);
+          continue;
+        } else if (k === "step") {
+          let step;
+          if (v1 == null) {
+            step = v2;
+          } else if (v2 == null) {
+            step = v1;
+          } else {
+            if (v1 < v2) {
+              const a = v2;
+              v2 = v1;
+              v1 = a;
+            }
+            if (v1 % v2) {
+              console.log(
+                "connection rejected: steps not divisible",
+                "current:",
+                v1,
+                "new:",
+                v2
+              );
+              return;
+            }
+            step = v1;
+          }
+          getCustomConfig()[k] = step;
+          continue;
+        }
+      }
+      console.log(`connection rejected: config ${k} values dont match`, v1, v2);
+      return;
+    }
+  }
+  if (customConfig || forceUpdate) {
+    if (customConfig) {
+      output.widget[CONFIG] = [config1[0], customConfig];
+    }
+    const widget = recreateWidget?.call(this);
+    if (widget) {
+      const min = widget.options.min;
+      const max = widget.options.max;
+      if (min != null && widget.value < min) widget.value = min;
+      if (max != null && widget.value > max) widget.value = max;
+      widget.callback(widget.value);
+    }
+  }
+  return { customConfig };
+}
+__name(mergeIfValid, "mergeIfValid");
+let useConversionSubmenusSetting;
+app.registerExtension({
+  name: "Comfy.WidgetInputs",
+  init() {
+    useConversionSubmenusSetting = app.ui.settings.addSetting({
+      id: "Comfy.NodeInputConversionSubmenus",
+      name: "In the node context menu, place the entries that convert between input/widget in sub-menus.",
+      type: "boolean",
+      defaultValue: true
+    });
+  },
+  async beforeRegisterNodeDef(nodeType, nodeData, app2) {
+    const origGetExtraMenuOptions = nodeType.prototype.getExtraMenuOptions;
+    nodeType.prototype.convertWidgetToInput = function(widget) {
+      const config = getConfig.call(this, widget.name) ?? [
+        widget.type,
+        widget.options || {}
+      ];
+      if (!isConvertibleWidget(widget, config)) return false;
+      if (widget.type?.startsWith(CONVERTED_TYPE)) return false;
+      convertToInput(this, widget, config);
+      return true;
+    };
+    nodeType.prototype.getExtraMenuOptions = function(_, options) {
+      const r = origGetExtraMenuOptions ? origGetExtraMenuOptions.apply(this, arguments) : void 0;
+      if (this.widgets) {
+        let toInput = [];
+        let toWidget = [];
+        for (const w of this.widgets) {
+          if (w.options?.forceInput) {
+            continue;
+          }
+          if (w.type === CONVERTED_TYPE) {
+            toWidget.push({
+              content: `Convert ${w.name} to widget`,
+              callback: /* @__PURE__ */ __name(() => convertToWidget(this, w), "callback")
+            });
+          } else {
+            const config = getConfig.call(this, w.name) ?? [
+              w.type,
+              w.options || {}
+            ];
+            if (isConvertibleWidget(w, config)) {
+              toInput.push({
+                content: `Convert ${w.name} to input`,
+                callback: /* @__PURE__ */ __name(() => convertToInput(this, w, config), "callback")
+              });
+            }
+          }
+        }
+        if (toInput.length) {
+          if (useConversionSubmenusSetting.value) {
+            options.push({
+              content: "Convert Widget to Input",
+              submenu: {
+                options: toInput
+              }
+            });
+          } else {
+            options.push(...toInput, null);
+          }
+        }
+        if (toWidget.length) {
+          if (useConversionSubmenusSetting.value) {
+            options.push({
+              content: "Convert Input to Widget",
+              submenu: {
+                options: toWidget
+              }
+            });
+          } else {
+            options.push(...toWidget, null);
+          }
+        }
+      }
+      return r;
+    };
+    nodeType.prototype.onGraphConfigured = function() {
+      if (!this.inputs) return;
+      this.widgets ??= [];
+      for (const input of this.inputs) {
+        if (input.widget) {
+          if (!input.widget[GET_CONFIG]) {
+            input.widget[GET_CONFIG] = () => getConfig.call(this, input.widget.name);
+          }
+          if (input.widget.config) {
+            if (input.widget.config[0] instanceof Array) {
+              input.type = "COMBO";
+              const link = app2.graph.links[input.link];
+              if (link) {
+                link.type = input.type;
+              }
+            }
+            delete input.widget.config;
+          }
+          const w = this.widgets.find((w2) => w2.name === input.widget.name);
+          if (w) {
+            hideWidget(this, w);
+          } else {
+            convertToWidget(this, input);
+          }
+        }
+      }
+    };
+    const origOnNodeCreated = nodeType.prototype.onNodeCreated;
+    nodeType.prototype.onNodeCreated = function() {
+      const r = origOnNodeCreated ? origOnNodeCreated.apply(this) : void 0;
+      if (!app2.configuringGraph && this.widgets) {
+        for (const w of this.widgets) {
+          if (w?.options?.forceInput || w?.options?.defaultInput) {
+            const config = getConfig.call(this, w.name) ?? [
+              w.type,
+              w.options || {}
+            ];
+            convertToInput(this, w, config);
+          }
+        }
+      }
+      return r;
+    };
+    const origOnConfigure = nodeType.prototype.onConfigure;
+    nodeType.prototype.onConfigure = function() {
+      const r = origOnConfigure ? origOnConfigure.apply(this, arguments) : void 0;
+      if (!app2.configuringGraph && this.inputs) {
+        for (const input of this.inputs) {
+          if (input.widget && !input.widget[GET_CONFIG]) {
+            input.widget[GET_CONFIG] = () => getConfig.call(this, input.widget.name);
+            const w = this.widgets.find((w2) => w2.name === input.widget.name);
+            if (w) {
+              hideWidget(this, w);
+            }
+          }
+        }
+      }
+      return r;
+    };
+    function isNodeAtPos(pos) {
+      for (const n of app2.graph.nodes) {
+        if (n.pos[0] === pos[0] && n.pos[1] === pos[1]) {
+          return true;
+        }
+      }
+      return false;
+    }
+    __name(isNodeAtPos, "isNodeAtPos");
+    const origOnInputDblClick = nodeType.prototype.onInputDblClick;
+    const ignoreDblClick = Symbol();
+    nodeType.prototype.onInputDblClick = function(slot) {
+      const r = origOnInputDblClick ? origOnInputDblClick.apply(this, arguments) : void 0;
+      const input = this.inputs[slot];
+      if (!input.widget || !input[ignoreDblClick]) {
+        if (!(input.type in ComfyWidgets) && !(input.widget[GET_CONFIG]?.()?.[0] instanceof Array)) {
+          return r;
+        }
+      }
+      const node = LiteGraph.createNode("PrimitiveNode");
+      app2.graph.add(node);
+      const pos = [
+        this.pos[0] - node.size[0] - 30,
+        this.pos[1]
+      ];
+      while (isNodeAtPos(pos)) {
+        pos[1] += LiteGraph.NODE_TITLE_HEIGHT;
+      }
+      node.pos = pos;
+      node.connect(0, this, slot);
+      node.title = input.name;
+      input[ignoreDblClick] = true;
+      setTimeout(() => {
+        delete input[ignoreDblClick];
+      }, 300);
+      return r;
+    };
+    const onConnectInput = nodeType.prototype.onConnectInput;
+    nodeType.prototype.onConnectInput = function(targetSlot, type, output, originNode, originSlot) {
+      const v = onConnectInput?.(this, arguments);
+      if (type !== "COMBO") return v;
+      if (originNode.outputs[originSlot].widget) return v;
+      const targetCombo = this.inputs[targetSlot].widget?.[GET_CONFIG]?.()?.[0];
+      if (!targetCombo || !(targetCombo instanceof Array)) return v;
+      const originConfig = originNode.constructor?.nodeData?.output?.[originSlot];
+      if (!originConfig || !isValidCombo(targetCombo, originConfig)) {
+        return false;
+      }
+      return v;
+    };
+  },
+  registerCustomNodes() {
+    LiteGraph.registerNodeType(
+      "PrimitiveNode",
+      Object.assign(PrimitiveNode, {
+        title: "Primitive"
+      })
+    );
+    PrimitiveNode.category = "utils";
+  }
+});
+window.comfyAPI = window.comfyAPI || {};
+window.comfyAPI.widgetInputs = window.comfyAPI.widgetInputs || {};
+window.comfyAPI.widgetInputs.getWidgetConfig = getWidgetConfig;
+window.comfyAPI.widgetInputs.convertToInput = convertToInput;
+window.comfyAPI.widgetInputs.setWidgetConfig = setWidgetConfig;
+window.comfyAPI.widgetInputs.mergeIfValid = mergeIfValid;
+export {
+  convertToInput,
+  getWidgetConfig,
+  mergeIfValid,
+  setWidgetConfig
+};
+//# sourceMappingURL=widgetInputs-DdoWwzg5.js.map

web/extensions/core/widgetInputs.js

@@ -1,4 +1,5 @@
 // Shim for extensions/core/widgetInputs.ts
 export const getWidgetConfig = window.comfyAPI.widgetInputs.getWidgetConfig;
+export const convertToInput = window.comfyAPI.widgetInputs.convertToInput;
 export const setWidgetConfig = window.comfyAPI.widgetInputs.setWidgetConfig;
 export const mergeIfValid = window.comfyAPI.widgetInputs.mergeIfValid;

web/index.html

@@ -4,20 +4,12 @@
     <meta charset="UTF-8">
     <title>ComfyUI</title>
     <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-    <!-- Browser Test Fonts -->
-    <!-- <link href="https://fonts.googleapis.com/css2?family=Roboto+Mono:ital,wght@0,100..700;1,100..700&family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap" rel="stylesheet">
-    <link href="https://fonts.googleapis.com/css2?family=Noto+Color+Emoji&family=Roboto+Mono:ital,wght@0,100..700;1,100..700&family=Roboto:ital,wght@0,100;0,300;0,400;0,500;0,700;0,900;1,100;1,300;1,400;1,500;1,700;1,900&display=swap" rel="stylesheet">
-    <style>
-      * {
-        font-family: 'Roboto Mono', 'Noto Color Emoji';
-      }
-    </style> -->
     <link rel="stylesheet" type="text/css" href="user.css" />
     <link rel="stylesheet" type="text/css" href="materialdesignicons.min.css" />
-    <script type="module" crossorigin src="./assets/index-Drc_oD2f.js"></script>
+    <script type="module" crossorigin src="./assets/index-DGAbdBYF.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-8NH3XvqK.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-BHJGjcJh.css">
   </head>
-  <body class="litegraph">
+  <body class="litegraph grid">
     <div id="vue-app"></div>
     <div id="comfy-user-selection" class="comfy-user-selection" style="display: none;">
       <main class="comfy-user-selection-inner">

web/scripts/changeTracker.js

@@ -1,2 +1,3 @@
 // Shim for scripts/changeTracker.ts
 export const ChangeTracker = window.comfyAPI.changeTracker.ChangeTracker;
+export const globalTracker = window.comfyAPI.changeTracker.globalTracker;

web/scripts/ui/menu/interruptButton.js

@@ -1,2 +0,0 @@
-// Shim for scripts/ui/menu/interruptButton.ts
-export const getInterruptButton = window.comfyAPI.interruptButton.getInterruptButton;

web/scripts/ui/menu/queueButton.js

@@ -1,2 +0,0 @@
-// Shim for scripts/ui/menu/queueButton.ts
-export const ComfyQueueButton = window.comfyAPI.queueButton.ComfyQueueButton;

web/scripts/ui/menu/queueOptions.js

@@ -1,2 +0,0 @@
-// Shim for scripts/ui/menu/queueOptions.ts
-export const ComfyQueueOptions = window.comfyAPI.queueOptions.ComfyQueueOptions;

web/scripts/ui/menu/workflows.js

@@ -1,3 +0,0 @@
-// Shim for scripts/ui/menu/workflows.ts
-export const ComfyWorkflowsMenu = window.comfyAPI.workflows.ComfyWorkflowsMenu;
-export const ComfyWorkflowsContent = window.comfyAPI.workflows.ComfyWorkflowsContent;

web/templates/default.json

@@ -0,0 +1,356 @@
+{
+  "last_node_id": 9,
+  "last_link_id": 9,
+  "nodes": [
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        413,
+        389
+      ],
+      "size": [
+        425.27801513671875,
+        180.6060791015625
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        "text, watermark"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        415,
+        186
+      ],
+      "size": [
+        422.84503173828125,
+        164.31304931640625
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        "beautiful scenery nature glass bottle landscape, , purple galaxy bottle,"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "EmptyLatentImage",
+      "pos": [
+        473,
+        609
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            2
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        512,
+        512,
+        1
+      ]
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        863,
+        186
+      ],
+      "size": [
+        315,
+        262
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 1
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 4
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        156680208700286,
+        true,
+        20,
+        8,
+        "euler",
+        "normal",
+        1
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1209,
+        188
+      ],
+      "size": [
+        210,
+        46
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {}
+    },
+    {
+      "id": 9,
+      "type": "SaveImage",
+      "pos": [
+        1451,
+        189
+      ],
+      "size": [
+        210,
+        26
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        }
+      ],
+      "properties": {}
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        26,
+        474
+      ],
+      "size": [
+        315,
+        98
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            1
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            3,
+            5
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            8
+          ],
+          "slot_index": 2
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        "v1-5-pruned-emaonly.safetensors"
+      ]
+    }
+  ],
+  "links": [
+    [
+      1,
+      4,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      2,
+      5,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      3,
+      4,
+      1,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      4,
+      6,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      5,
+      4,
+      1,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      6,
+      7,
+      0,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      8,
+      4,
+      2,
+      8,
+      1,
+      "VAE"
+    ],
+    [
+      9,
+      8,
+      0,
+      9,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "models": [{
+    "name": "v1-5-pruned-emaonly.safetensors",
+    "url": "https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/resolve/main/v1-5-pruned-emaonly.safetensors?download=true",
+    "directory": "checkpoints"
+  }]
+}

web/templates/flux_schnell.json

@@ -0,0 +1,420 @@
+{
+    "last_node_id": 36,
+    "last_link_id": 58,
+    "nodes": [
+      {
+        "id": 33,
+        "type": "CLIPTextEncode",
+        "pos": [
+          390,
+          400
+        ],
+        "size": {
+          "0": 422.84503173828125,
+          "1": 164.31304931640625
+        },
+        "flags": {
+          "collapsed": true
+        },
+        "order": 4,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "clip",
+            "type": "CLIP",
+            "link": 54,
+            "slot_index": 0
+          }
+        ],
+        "outputs": [
+          {
+            "name": "CONDITIONING",
+            "type": "CONDITIONING",
+            "links": [
+              55
+            ],
+            "slot_index": 0
+          }
+        ],
+        "title": "CLIP Text Encode (Negative Prompt)",
+        "properties": {
+          "Node name for S&R": "CLIPTextEncode"
+        },
+        "widgets_values": [
+          ""
+        ],
+        "color": "#322",
+        "bgcolor": "#533"
+      },
+      {
+        "id": 27,
+        "type": "EmptySD3LatentImage",
+        "pos": [
+          471,
+          455
+        ],
+        "size": {
+          "0": 315,
+          "1": 106
+        },
+        "flags": {},
+        "order": 0,
+        "mode": 0,
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              51
+            ],
+            "shape": 3,
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "EmptySD3LatentImage"
+        },
+        "widgets_values": [
+          1024,
+          1024,
+          1
+        ],
+        "color": "#323",
+        "bgcolor": "#535"
+      },
+      {
+        "id": 8,
+        "type": "VAEDecode",
+        "pos": [
+          1151,
+          195
+        ],
+        "size": {
+          "0": 210,
+          "1": 46
+        },
+        "flags": {},
+        "order": 6,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "samples",
+            "type": "LATENT",
+            "link": 52
+          },
+          {
+            "name": "vae",
+            "type": "VAE",
+            "link": 46
+          }
+        ],
+        "outputs": [
+          {
+            "name": "IMAGE",
+            "type": "IMAGE",
+            "links": [
+              9
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "VAEDecode"
+        }
+      },
+      {
+        "id": 9,
+        "type": "SaveImage",
+        "pos": [
+          1375,
+          194
+        ],
+        "size": {
+          "0": 985.3012084960938,
+          "1": 1060.3828125
+        },
+        "flags": {},
+        "order": 7,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "images",
+            "type": "IMAGE",
+            "link": 9
+          }
+        ],
+        "properties": {},
+        "widgets_values": [
+          "ComfyUI"
+        ]
+      },
+      {
+        "id": 31,
+        "type": "KSampler",
+        "pos": [
+          816,
+          192
+        ],
+        "size": {
+          "0": 315,
+          "1": 262
+        },
+        "flags": {},
+        "order": 5,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "model",
+            "type": "MODEL",
+            "link": 47
+          },
+          {
+            "name": "positive",
+            "type": "CONDITIONING",
+            "link": 58
+          },
+          {
+            "name": "negative",
+            "type": "CONDITIONING",
+            "link": 55
+          },
+          {
+            "name": "latent_image",
+            "type": "LATENT",
+            "link": 51
+          }
+        ],
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              52
+            ],
+            "shape": 3,
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "KSampler"
+        },
+        "widgets_values": [
+          173805153958730,
+          "randomize",
+          4,
+          1,
+          "euler",
+          "simple",
+          1
+        ]
+      },
+      {
+        "id": 30,
+        "type": "CheckpointLoaderSimple",
+        "pos": [
+          48,
+          192
+        ],
+        "size": {
+          "0": 315,
+          "1": 98
+        },
+        "flags": {},
+        "order": 1,
+        "mode": 0,
+        "outputs": [
+          {
+            "name": "MODEL",
+            "type": "MODEL",
+            "links": [
+              47
+            ],
+            "shape": 3,
+            "slot_index": 0
+          },
+          {
+            "name": "CLIP",
+            "type": "CLIP",
+            "links": [
+              45,
+              54
+            ],
+            "shape": 3,
+            "slot_index": 1
+          },
+          {
+            "name": "VAE",
+            "type": "VAE",
+            "links": [
+              46
+            ],
+            "shape": 3,
+            "slot_index": 2
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "CheckpointLoaderSimple"
+        },
+        "widgets_values": [
+          "flux1-schnell-fp8.safetensors"
+        ]
+      },
+      {
+        "id": 6,
+        "type": "CLIPTextEncode",
+        "pos": [
+          384,
+          192
+        ],
+        "size": {
+          "0": 422.84503173828125,
+          "1": 164.31304931640625
+        },
+        "flags": {},
+        "order": 3,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "clip",
+            "type": "CLIP",
+            "link": 45
+          }
+        ],
+        "outputs": [
+          {
+            "name": "CONDITIONING",
+            "type": "CONDITIONING",
+            "links": [
+              58
+            ],
+            "slot_index": 0
+          }
+        ],
+        "title": "CLIP Text Encode (Positive Prompt)",
+        "properties": {
+          "Node name for S&R": "CLIPTextEncode"
+        },
+        "widgets_values": [
+          "a bottle with a beautiful rainbow galaxy inside it on top of a wooden table in the middle of a modern kitchen beside a plate of vegetables and mushrooms and a wine glasse that contains a planet earth with a plate with a half eaten apple pie on it"
+        ],
+        "color": "#232",
+        "bgcolor": "#353"
+      },
+      {
+        "id": 34,
+        "type": "Note",
+        "pos": [
+          831,
+          501
+        ],
+        "size": {
+          "0": 282.8617858886719,
+          "1": 164.08004760742188
+        },
+        "flags": {},
+        "order": 2,
+        "mode": 0,
+        "properties": {
+          "text": ""
+        },
+        "widgets_values": [
+          "Note that Flux dev and schnell do not have any negative prompt so CFG should be set to 1.0. Setting CFG to 1.0 means the negative prompt is ignored.\n\nThe schnell model is a distilled model that can generate a good image with only 4 steps."
+        ],
+        "color": "#432",
+        "bgcolor": "#653"
+      }
+    ],
+    "links": [
+      [
+        9,
+        8,
+        0,
+        9,
+        0,
+        "IMAGE"
+      ],
+      [
+        45,
+        30,
+        1,
+        6,
+        0,
+        "CLIP"
+      ],
+      [
+        46,
+        30,
+        2,
+        8,
+        1,
+        "VAE"
+      ],
+      [
+        47,
+        30,
+        0,
+        31,
+        0,
+        "MODEL"
+      ],
+      [
+        51,
+        27,
+        0,
+        31,
+        3,
+        "LATENT"
+      ],
+      [
+        52,
+        31,
+        0,
+        8,
+        0,
+        "LATENT"
+      ],
+      [
+        54,
+        30,
+        1,
+        33,
+        0,
+        "CLIP"
+      ],
+      [
+        55,
+        33,
+        0,
+        31,
+        2,
+        "CONDITIONING"
+      ],
+      [
+        58,
+        6,
+        0,
+        31,
+        1,
+        "CONDITIONING"
+      ]
+    ],
+    "groups": [],
+    "config": {},
+    "extra": {
+      "ds": {
+        "scale": 1.1,
+        "offset": [
+          0.6836674124529055,
+          1.8290357611967831
+        ]
+      }
+    },
+    "models": [
+      {
+        "name": "flux1-schnell-fp8.safetensors",
+        "url": "https://huggingface.co/Comfy-Org/flux1-schnell/resolve/main/flux1-schnell-fp8.safetensors?download=true",
+        "directory": "checkpoints"
+      }
+    ],
+    "version": 0.4
+  }

web/templates/image2image.json

@@ -0,0 +1,447 @@
+{
+  "last_node_id": 14,
+  "last_link_id": 17,
+  "nodes": [
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        413,
+        389
+      ],
+      "size": {
+        "0": 425.27801513671875,
+        "1": 180.6060791015625
+      },
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 15
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "watermark, text\n"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        415,
+        186
+      ],
+      "size": {
+        "0": 422.84503173828125,
+        "1": 164.31304931640625
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 14
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            4
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "photograph of victorian woman with wings, sky clouds, meadow grass\n"
+      ]
+    },
+    {
+      "id": 8,
+      "type": "VAEDecode",
+      "pos": [
+        1209,
+        188
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 17
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            9
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEDecode"
+      }
+    },
+    {
+      "id": 9,
+      "type": "SaveImage",
+      "pos": [
+        1451,
+        189
+      ],
+      "size": {
+        "0": 210,
+        "1": 58
+      },
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 9
+        }
+      ],
+      "properties": {},
+      "widgets_values": [
+        "ComfyUI"
+      ]
+    },
+    {
+      "id": 10,
+      "type": "LoadImage",
+      "pos": [
+        215.9799597167969,
+        703.6800268554688
+      ],
+      "size": [
+        315,
+        314.00002670288086
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            10
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 12,
+      "type": "VAEEncode",
+      "pos": [
+        614.979959716797,
+        707.6800268554688
+      ],
+      "size": {
+        "0": 210,
+        "1": 46
+      },
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "pixels",
+          "type": "IMAGE",
+          "link": 10
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 16
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            11
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAEEncode"
+      }
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        863,
+        186
+      ],
+      "size": {
+        "0": 315,
+        "1": 262
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 13
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 4
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 11
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            7
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        280823642470253,
+        "randomize",
+        20,
+        8,
+        "dpmpp_2m",
+        "normal",
+        0.8700000000000001
+      ]
+    },
+    {
+      "id": 14,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        19,
+        433
+      ],
+      "size": {
+        "0": 315,
+        "1": 98
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            13
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            14,
+            15
+          ],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            16,
+            17
+          ],
+          "shape": 3,
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "v1-5-pruned-emaonly.safetensors"
+      ]
+    }
+  ],
+  "links": [
+    [
+      4,
+      6,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      6,
+      7,
+      0,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      7,
+      3,
+      0,
+      8,
+      0,
+      "LATENT"
+    ],
+    [
+      9,
+      8,
+      0,
+      9,
+      0,
+      "IMAGE"
+    ],
+    [
+      10,
+      10,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      11,
+      12,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      13,
+      14,
+      0,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      14,
+      14,
+      1,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      15,
+      14,
+      1,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      16,
+      14,
+      2,
+      12,
+      1,
+      "VAE"
+    ],
+    [
+      17,
+      14,
+      2,
+      8,
+      1,
+      "VAE"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Loading images",
+      "bounding": [
+        150,
+        630,
+        726,
+        171
+      ],
+      "color": "#3f789e"
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "models": [{
+    "name": "v1-5-pruned-emaonly.safetensors",
+    "url": "https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/resolve/main/v1-5-pruned-emaonly.safetensors?download=true",
+    "directory": "checkpoints"
+  }]
+}

web/templates/upscale.json

@@ -0,0 +1,652 @@
+{
+    "last_node_id": 16,
+    "last_link_id": 23,
+    "nodes": [
+      {
+        "id": 8,
+        "type": "VAEDecode",
+        "pos": [
+          1235.7215957031258,
+          577.1878720703122
+        ],
+        "size": {
+          "0": 210,
+          "1": 46
+        },
+        "flags": {},
+        "order": 5,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "samples",
+            "type": "LATENT",
+            "link": 7
+          },
+          {
+            "name": "vae",
+            "type": "VAE",
+            "link": 21
+          }
+        ],
+        "outputs": [
+          {
+            "name": "IMAGE",
+            "type": "IMAGE",
+            "links": [
+              9
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "VAEDecode"
+        }
+      },
+      {
+        "id": 10,
+        "type": "LatentUpscale",
+        "pos": [
+          1238,
+          170
+        ],
+        "size": {
+          "0": 315,
+          "1": 130
+        },
+        "flags": {},
+        "order": 6,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "samples",
+            "type": "LATENT",
+            "link": 10
+          }
+        ],
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              14
+            ]
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "LatentUpscale"
+        },
+        "widgets_values": [
+          "nearest-exact",
+          1152,
+          1152,
+          "disabled"
+        ]
+      },
+      {
+        "id": 13,
+        "type": "VAEDecode",
+        "pos": [
+          1961,
+          125
+        ],
+        "size": {
+          "0": 210,
+          "1": 46
+        },
+        "flags": {},
+        "order": 9,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "samples",
+            "type": "LATENT",
+            "link": 15
+          },
+          {
+            "name": "vae",
+            "type": "VAE",
+            "link": 22
+          }
+        ],
+        "outputs": [
+          {
+            "name": "IMAGE",
+            "type": "IMAGE",
+            "links": [
+              17
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "VAEDecode"
+        }
+      },
+      {
+        "id": 6,
+        "type": "CLIPTextEncode",
+        "pos": [
+          374,
+          171
+        ],
+        "size": {
+          "0": 422.84503173828125,
+          "1": 164.31304931640625
+        },
+        "flags": {},
+        "order": 2,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "clip",
+            "type": "CLIP",
+            "link": 19
+          }
+        ],
+        "outputs": [
+          {
+            "name": "CONDITIONING",
+            "type": "CONDITIONING",
+            "links": [
+              4,
+              12
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "CLIPTextEncode"
+        },
+        "widgets_values": [
+          "masterpiece HDR victorian portrait painting of woman, blonde hair, mountain nature, blue sky\n"
+        ]
+      },
+      {
+        "id": 7,
+        "type": "CLIPTextEncode",
+        "pos": [
+          377,
+          381
+        ],
+        "size": {
+          "0": 425.27801513671875,
+          "1": 180.6060791015625
+        },
+        "flags": {},
+        "order": 3,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "clip",
+            "type": "CLIP",
+            "link": 20
+          }
+        ],
+        "outputs": [
+          {
+            "name": "CONDITIONING",
+            "type": "CONDITIONING",
+            "links": [
+              6,
+              13
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "CLIPTextEncode"
+        },
+        "widgets_values": [
+          "bad hands, text, watermark\n"
+        ]
+      },
+      {
+        "id": 5,
+        "type": "EmptyLatentImage",
+        "pos": [
+          435,
+          600
+        ],
+        "size": {
+          "0": 315,
+          "1": 106
+        },
+        "flags": {},
+        "order": 0,
+        "mode": 0,
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              2
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "EmptyLatentImage"
+        },
+        "widgets_values": [
+          768,
+          768,
+          1
+        ]
+      },
+      {
+        "id": 11,
+        "type": "KSampler",
+        "pos": [
+          1585,
+          114
+        ],
+        "size": {
+          "0": 315,
+          "1": 262
+        },
+        "flags": {},
+        "order": 8,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "model",
+            "type": "MODEL",
+            "link": 23,
+            "slot_index": 0
+          },
+          {
+            "name": "positive",
+            "type": "CONDITIONING",
+            "link": 12,
+            "slot_index": 1
+          },
+          {
+            "name": "negative",
+            "type": "CONDITIONING",
+            "link": 13,
+            "slot_index": 2
+          },
+          {
+            "name": "latent_image",
+            "type": "LATENT",
+            "link": 14,
+            "slot_index": 3
+          }
+        ],
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              15
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "KSampler"
+        },
+        "widgets_values": [
+          469771404043268,
+          "randomize",
+          14,
+          8,
+          "dpmpp_2m",
+          "simple",
+          0.5
+        ]
+      },
+      {
+        "id": 12,
+        "type": "SaveImage",
+        "pos": [
+          2203,
+          123
+        ],
+        "size": {
+          "0": 407.53717041015625,
+          "1": 468.13226318359375
+        },
+        "flags": {},
+        "order": 10,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "images",
+            "type": "IMAGE",
+            "link": 17
+          }
+        ],
+        "properties": {},
+        "widgets_values": [
+          "ComfyUI"
+        ]
+      },
+      {
+        "id": 3,
+        "type": "KSampler",
+        "pos": [
+          845,
+          172
+        ],
+        "size": {
+          "0": 315,
+          "1": 262
+        },
+        "flags": {},
+        "order": 4,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "model",
+            "type": "MODEL",
+            "link": 18
+          },
+          {
+            "name": "positive",
+            "type": "CONDITIONING",
+            "link": 4
+          },
+          {
+            "name": "negative",
+            "type": "CONDITIONING",
+            "link": 6
+          },
+          {
+            "name": "latent_image",
+            "type": "LATENT",
+            "link": 2
+          }
+        ],
+        "outputs": [
+          {
+            "name": "LATENT",
+            "type": "LATENT",
+            "links": [
+              7,
+              10
+            ],
+            "slot_index": 0
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "KSampler"
+        },
+        "widgets_values": [
+          89848141647836,
+          "randomize",
+          12,
+          8,
+          "dpmpp_sde",
+          "normal",
+          1
+        ]
+      },
+      {
+        "id": 16,
+        "type": "CheckpointLoaderSimple",
+        "pos": [
+          24,
+          315
+        ],
+        "size": {
+          "0": 315,
+          "1": 98
+        },
+        "flags": {},
+        "order": 1,
+        "mode": 0,
+        "outputs": [
+          {
+            "name": "MODEL",
+            "type": "MODEL",
+            "links": [
+              18,
+              23
+            ],
+            "slot_index": 0
+          },
+          {
+            "name": "CLIP",
+            "type": "CLIP",
+            "links": [
+              19,
+              20
+            ],
+            "slot_index": 1
+          },
+          {
+            "name": "VAE",
+            "type": "VAE",
+            "links": [
+              21,
+              22
+            ],
+            "slot_index": 2
+          }
+        ],
+        "properties": {
+          "Node name for S&R": "CheckpointLoaderSimple"
+        },
+        "widgets_values": [
+          "v2-1_768-ema-pruned.safetensors"
+        ]
+      },
+      {
+        "id": 9,
+        "type": "SaveImage",
+        "pos": [
+          1495.7215957031258,
+          576.1878720703122
+        ],
+        "size": [
+          232.9403301043692,
+          282.4336258387117
+        ],
+        "flags": {},
+        "order": 7,
+        "mode": 0,
+        "inputs": [
+          {
+            "name": "images",
+            "type": "IMAGE",
+            "link": 9
+          }
+        ],
+        "properties": {},
+        "widgets_values": [
+          "ComfyUI"
+        ]
+      }
+    ],
+    "links": [
+      [
+        2,
+        5,
+        0,
+        3,
+        3,
+        "LATENT"
+      ],
+      [
+        4,
+        6,
+        0,
+        3,
+        1,
+        "CONDITIONING"
+      ],
+      [
+        6,
+        7,
+        0,
+        3,
+        2,
+        "CONDITIONING"
+      ],
+      [
+        7,
+        3,
+        0,
+        8,
+        0,
+        "LATENT"
+      ],
+      [
+        9,
+        8,
+        0,
+        9,
+        0,
+        "IMAGE"
+      ],
+      [
+        10,
+        3,
+        0,
+        10,
+        0,
+        "LATENT"
+      ],
+      [
+        12,
+        6,
+        0,
+        11,
+        1,
+        "CONDITIONING"
+      ],
+      [
+        13,
+        7,
+        0,
+        11,
+        2,
+        "CONDITIONING"
+      ],
+      [
+        14,
+        10,
+        0,
+        11,
+        3,
+        "LATENT"
+      ],
+      [
+        15,
+        11,
+        0,
+        13,
+        0,
+        "LATENT"
+      ],
+      [
+        17,
+        13,
+        0,
+        12,
+        0,
+        "IMAGE"
+      ],
+      [
+        18,
+        16,
+        0,
+        3,
+        0,
+        "MODEL"
+      ],
+      [
+        19,
+        16,
+        1,
+        6,
+        0,
+        "CLIP"
+      ],
+      [
+        20,
+        16,
+        1,
+        7,
+        0,
+        "CLIP"
+      ],
+      [
+        21,
+        16,
+        2,
+        8,
+        1,
+        "VAE"
+      ],
+      [
+        22,
+        16,
+        2,
+        13,
+        1,
+        "VAE"
+      ],
+      [
+        23,
+        16,
+        0,
+        11,
+        0,
+        "MODEL"
+      ]
+    ],
+    "groups": [
+      {
+        "title": "Txt2Img",
+        "bounding": [
+          -1,
+          30,
+          1211,
+          708
+        ],
+        "color": "#a1309b"
+      },
+      {
+        "title": "Save Intermediate Image",
+        "bounding": [
+          1225,
+          500,
+          516,
+          196
+        ],
+        "color": "#3f789e"
+      },
+      {
+        "title": "Hires Fix",
+        "bounding": [
+          1224,
+          29,
+          710,
+          464
+        ],
+        "color": "#b58b2a"
+      },
+      {
+        "title": "Save Final Image",
+        "bounding": [
+          1949,
+          31,
+          483,
+          199
+        ],
+        "color": "#3f789e"
+      }
+    ],
+    "config": {},
+    "extra": {},
+    "version": 0.4,
+    "models": [
+      {
+        "name": "v2-1_768-ema-pruned.safetensors",
+        "url": "https://huggingface.co/stabilityai/stable-diffusion-2-1/resolve/main/v2-1_768-ema-pruned.safetensors?download=true",
+        "directory": "checkpoints"
+      }
+    ]
+  }