Bump ComfyUI version to v0.3.14

Co-authored-by: huchenlei <20929282+huchenlei@users.noreply.github.com>

.github/workflows/stable-release.yml

@@ -12,7 +12,7 @@ on:
         description: 'CUDA version'
         required: true
         type: string
-        default: "124"
+        default: "126"
       python_minor:
         description: 'Python minor version'
         required: true

.github/workflows/test-build.yml

@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}

.github/workflows/test-unit.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Set up Python      
       uses: actions/setup-python@v4
       with:
-        python-version: '3.10'
+        python-version: '3.12'
     - name: Install requirements
       run: |
         python -m pip install --upgrade pip

.github/workflows/windows_release_dependencies.yml

@@ -17,7 +17,7 @@ on:
         description: 'cuda version'
         required: true
         type: string
-        default: "124"
+        default: "126"
 
       python_minor:
         description: 'python minor version'

.github/workflows/windows_release_package.yml

@@ -7,7 +7,7 @@ on:
         description: 'cuda version'
         required: true
         type: string
-        default: "124"
+        default: "126"
 
       python_minor:
         description: 'python minor version'

README.md

@@ -47,6 +47,7 @@ This ui will let you design and execute advanced stable diffusion pipelines usin
    - [AuraFlow](https://comfyanonymous.github.io/ComfyUI_examples/aura_flow/)
    - [HunyuanDiT](https://comfyanonymous.github.io/ComfyUI_examples/hunyuan_dit/)
    - [Flux](https://comfyanonymous.github.io/ComfyUI_examples/flux/)
+   - [Lumina Image 2.0](https://comfyanonymous.github.io/ComfyUI_examples/lumina2/)
 - Video Models
    - [Stable Video Diffusion](https://comfyanonymous.github.io/ComfyUI_examples/video/)
    - [Mochi](https://comfyanonymous.github.io/ComfyUI_examples/mochi/)
@@ -130,6 +131,8 @@ Simply download, extract with [7-Zip](https://7-zip.org) and run. Make sure you
 
 If you have trouble extracting it, right click the file -> properties -> unblock
 
+If you have a 50 series Blackwell card like a 5090 or 5080 see [this discussion thread](https://github.com/comfyanonymous/ComfyUI/discussions/6643)
+
 #### How do I share models between another UI and ComfyUI?
 
 See the [Config file](extra_model_paths.yaml.example) to set the search paths for models. In the standalone windows build you can find this file in the ComfyUI directory. Rename this file to extra_model_paths.yaml and edit it with your favorite text editor.
@@ -140,7 +143,7 @@ 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.
+python 3.13 is supported but using 3.12 is recommended because some custom nodes and their dependencies might not support it yet.
 
 Git clone this repo.
 
@@ -152,11 +155,11 @@ Put your VAE in: models/vae
 ### AMD GPUs (Linux only)
 AMD users can install rocm and pytorch with pip if you don't have it already installed, this is the command to install the stable version:
 
-```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.2```
+```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.2.4```
 
-This is the command to install the nightly with ROCm 6.2 which might have some performance improvements:
+This is the command to install the nightly with ROCm 6.3 which might have some performance improvements:
 
-```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.2.4```
+```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.3```
 
 ### Intel GPUs (Windows and Linux)
 
@@ -186,7 +189,7 @@ Additional discussion and help can be found [here](https://github.com/comfyanony
 
 Nvidia users should install stable pytorch using this command:
 
-```pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124```
+```pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu126```
 
 This is the command to install pytorch nightly instead which might have performance improvements:
 

comfy/cli_args.py

@@ -43,10 +43,11 @@ parser.add_argument("--tls-certfile", type=str, help="Path to TLS (SSL) certific
 parser.add_argument("--enable-cors-header", type=str, default=None, metavar="ORIGIN", nargs="?", const="*", help="Enable CORS (Cross-Origin Resource Sharing) with optional origin or allow all with default '*'.")
 parser.add_argument("--max-upload-size", type=float, default=100, help="Set the maximum upload size in MB.")
 
+parser.add_argument("--base-directory", type=str, default=None, help="Set the ComfyUI base directory for models, custom_nodes, input, output, temp, and user directories.")
 parser.add_argument("--extra-model-paths-config", type=str, default=None, metavar="PATH", nargs='+', action='append', help="Load one or more extra_model_paths.yaml files.")
-parser.add_argument("--output-directory", type=str, default=None, help="Set the ComfyUI output directory.")
-parser.add_argument("--temp-directory", type=str, default=None, help="Set the ComfyUI temp directory (default is in the ComfyUI directory).")
-parser.add_argument("--input-directory", type=str, default=None, help="Set the ComfyUI input directory.")
+parser.add_argument("--output-directory", type=str, default=None, help="Set the ComfyUI output directory. Overrides --base-directory.")
+parser.add_argument("--temp-directory", type=str, default=None, help="Set the ComfyUI temp directory (default is in the ComfyUI directory). Overrides --base-directory.")
+parser.add_argument("--input-directory", type=str, default=None, help="Set the ComfyUI input directory. Overrides --base-directory.")
 parser.add_argument("--auto-launch", action="store_true", help="Automatically launch ComfyUI in the default browser.")
 parser.add_argument("--disable-auto-launch", action="store_true", help="Disable auto launching the browser.")
 parser.add_argument("--cuda-device", type=int, default=None, metavar="DEVICE_ID", help="Set the id of the cuda device this instance will use.")
@@ -176,7 +177,9 @@ parser.add_argument(
     help="The local filesystem path to the directory where the frontend is located. Overrides --front-end-version.",
 )
 
-parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path.")
+parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path. Overrides --base-directory.")
+
+parser.add_argument("--disable-compres-response-body", action="store_true", help="Disable compressing response body.")
 
 if comfy.options.args_parsing:
     args = parser.parse_args()

comfy/clip_model.py

@@ -102,9 +102,9 @@ class CLIPTextModel_(torch.nn.Module):
         mask = None
         if attention_mask is not None:
             mask = 1.0 - attention_mask.to(x.dtype).reshape((attention_mask.shape[0], 1, -1, attention_mask.shape[-1])).expand(attention_mask.shape[0], 1, attention_mask.shape[-1], attention_mask.shape[-1])
-            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
+            mask = mask.masked_fill(mask.to(torch.bool), -torch.finfo(x.dtype).max)
 
-        causal_mask = torch.empty(x.shape[1], x.shape[1], dtype=x.dtype, device=x.device).fill_(float("-inf")).triu_(1)
+        causal_mask = torch.empty(x.shape[1], x.shape[1], dtype=x.dtype, device=x.device).fill_(-torch.finfo(x.dtype).max).triu_(1)
         if mask is not None:
             mask += causal_mask
         else:

comfy/conds.py

@@ -3,9 +3,6 @@ import math
 import comfy.utils
 
 
-def lcm(a, b): #TODO: eventually replace by math.lcm (added in python3.9)
-    return abs(a*b) // math.gcd(a, b)
-
 class CONDRegular:
     def __init__(self, cond):
         self.cond = cond

comfy/diffusers_convert.py

@@ -4,105 +4,6 @@ import logging
 
 # conversion code from https://github.com/huggingface/diffusers/blob/main/scripts/convert_diffusers_to_original_stable_diffusion.py
 
-# =================#
-# UNet Conversion #
-# =================#
-
-unet_conversion_map = [
-    # (stable-diffusion, HF Diffusers)
-    ("time_embed.0.weight", "time_embedding.linear_1.weight"),
-    ("time_embed.0.bias", "time_embedding.linear_1.bias"),
-    ("time_embed.2.weight", "time_embedding.linear_2.weight"),
-    ("time_embed.2.bias", "time_embedding.linear_2.bias"),
-    ("input_blocks.0.0.weight", "conv_in.weight"),
-    ("input_blocks.0.0.bias", "conv_in.bias"),
-    ("out.0.weight", "conv_norm_out.weight"),
-    ("out.0.bias", "conv_norm_out.bias"),
-    ("out.2.weight", "conv_out.weight"),
-    ("out.2.bias", "conv_out.bias"),
-]
-
-unet_conversion_map_resnet = [
-    # (stable-diffusion, HF Diffusers)
-    ("in_layers.0", "norm1"),
-    ("in_layers.2", "conv1"),
-    ("out_layers.0", "norm2"),
-    ("out_layers.3", "conv2"),
-    ("emb_layers.1", "time_emb_proj"),
-    ("skip_connection", "conv_shortcut"),
-]
-
-unet_conversion_map_layer = []
-# hardcoded number of downblocks and resnets/attentions...
-# would need smarter logic for other networks.
-for i in range(4):
-    # loop over downblocks/upblocks
-
-    for j in range(2):
-        # loop over resnets/attentions for downblocks
-        hf_down_res_prefix = f"down_blocks.{i}.resnets.{j}."
-        sd_down_res_prefix = f"input_blocks.{3 * i + j + 1}.0."
-        unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix))
-
-        if i < 3:
-            # no attention layers in down_blocks.3
-            hf_down_atn_prefix = f"down_blocks.{i}.attentions.{j}."
-            sd_down_atn_prefix = f"input_blocks.{3 * i + j + 1}.1."
-            unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix))
-
-    for j in range(3):
-        # loop over resnets/attentions for upblocks
-        hf_up_res_prefix = f"up_blocks.{i}.resnets.{j}."
-        sd_up_res_prefix = f"output_blocks.{3 * i + j}.0."
-        unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix))
-
-        if i > 0:
-            # no attention layers in up_blocks.0
-            hf_up_atn_prefix = f"up_blocks.{i}.attentions.{j}."
-            sd_up_atn_prefix = f"output_blocks.{3 * i + j}.1."
-            unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix))
-
-    if i < 3:
-        # no downsample in down_blocks.3
-        hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0.conv."
-        sd_downsample_prefix = f"input_blocks.{3 * (i + 1)}.0.op."
-        unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix))
-
-        # no upsample in up_blocks.3
-        hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0."
-        sd_upsample_prefix = f"output_blocks.{3 * i + 2}.{1 if i == 0 else 2}."
-        unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix))
-
-hf_mid_atn_prefix = "mid_block.attentions.0."
-sd_mid_atn_prefix = "middle_block.1."
-unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix))
-
-for j in range(2):
-    hf_mid_res_prefix = f"mid_block.resnets.{j}."
-    sd_mid_res_prefix = f"middle_block.{2 * j}."
-    unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix))
-
-
-def convert_unet_state_dict(unet_state_dict):
-    # buyer beware: this is a *brittle* function,
-    # and correct output requires that all of these pieces interact in
-    # the exact order in which I have arranged them.
-    mapping = {k: k for k in unet_state_dict.keys()}
-    for sd_name, hf_name in unet_conversion_map:
-        mapping[hf_name] = sd_name
-    for k, v in mapping.items():
-        if "resnets" in k:
-            for sd_part, hf_part in unet_conversion_map_resnet:
-                v = v.replace(hf_part, sd_part)
-            mapping[k] = v
-    for k, v in mapping.items():
-        for sd_part, hf_part in unet_conversion_map_layer:
-            v = v.replace(hf_part, sd_part)
-        mapping[k] = v
-    new_state_dict = {v: unet_state_dict[k] for k, v in mapping.items()}
-    return new_state_dict
-
-
 # ================#
 # VAE Conversion #
 # ================#
@@ -213,6 +114,7 @@ textenc_pattern = re.compile("|".join(protected.keys()))
 # Ordering is from https://github.com/pytorch/pytorch/blob/master/test/cpp/api/modules.cpp
 code2idx = {"q": 0, "k": 1, "v": 2}
 
+
 # This function exists because at the time of writing torch.cat can't do fp8 with cuda
 def cat_tensors(tensors):
     x = 0
@@ -229,6 +131,7 @@ def cat_tensors(tensors):
 
     return out
 
+
 def convert_text_enc_state_dict_v20(text_enc_dict, prefix=""):
     new_state_dict = {}
     capture_qkv_weight = {}
@@ -284,5 +187,3 @@ def convert_text_enc_state_dict_v20(text_enc_dict, prefix=""):
 
 def convert_text_enc_state_dict(text_enc_dict):
     return text_enc_dict
-
-

comfy/ldm/lumina/model.py

@@ -0,0 +1,674 @@
+# Code from: https://github.com/Alpha-VLLM/Lumina-Image-2.0/blob/main/models/model.py
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from comfy.ldm.modules.diffusionmodules.mmdit import TimestepEmbedder, RMSNorm
+from comfy.ldm.modules.attention import optimized_attention_masked
+from comfy.ldm.flux.layers import EmbedND
+
+
+def modulate(x, scale):
+    return x * (1 + scale.unsqueeze(1))
+
+#############################################################################
+#                               Core NextDiT Model                              #
+#############################################################################
+
+
+class JointAttention(nn.Module):
+    """Multi-head attention module."""
+
+    def __init__(
+        self,
+        dim: int,
+        n_heads: int,
+        n_kv_heads: Optional[int],
+        qk_norm: bool,
+        operation_settings={},
+    ):
+        """
+        Initialize the Attention module.
+
+        Args:
+            dim (int): Number of input dimensions.
+            n_heads (int): Number of heads.
+            n_kv_heads (Optional[int]): Number of kv heads, if using GQA.
+
+        """
+        super().__init__()
+        self.n_kv_heads = n_heads if n_kv_heads is None else n_kv_heads
+        self.n_local_heads = n_heads
+        self.n_local_kv_heads = self.n_kv_heads
+        self.n_rep = self.n_local_heads // self.n_local_kv_heads
+        self.head_dim = dim // n_heads
+
+        self.qkv = operation_settings.get("operations").Linear(
+            dim,
+            (n_heads + self.n_kv_heads + self.n_kv_heads) * self.head_dim,
+            bias=False,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+        self.out = operation_settings.get("operations").Linear(
+            n_heads * self.head_dim,
+            dim,
+            bias=False,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+
+        if qk_norm:
+            self.q_norm = RMSNorm(self.head_dim, elementwise_affine=True, **operation_settings)
+            self.k_norm = RMSNorm(self.head_dim, elementwise_affine=True, **operation_settings)
+        else:
+            self.q_norm = self.k_norm = nn.Identity()
+
+    @staticmethod
+    def apply_rotary_emb(
+        x_in: torch.Tensor,
+        freqs_cis: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Apply rotary embeddings to input tensors using the given frequency
+        tensor.
+
+        This function applies rotary embeddings to the given query 'xq' and
+        key 'xk' tensors using the provided frequency tensor 'freqs_cis'. The
+        input tensors are reshaped as complex numbers, and the frequency tensor
+        is reshaped for broadcasting compatibility. The resulting tensors
+        contain rotary embeddings and are returned as real tensors.
+
+        Args:
+            x_in (torch.Tensor): Query or Key tensor to apply rotary embeddings.
+            freqs_cis (torch.Tensor): Precomputed frequency tensor for complex
+                exponentials.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor
+                and key tensor with rotary embeddings.
+        """
+
+        t_ = x_in.reshape(*x_in.shape[:-1], -1, 1, 2)
+        t_out = freqs_cis[..., 0] * t_[..., 0] + freqs_cis[..., 1] * t_[..., 1]
+        return t_out.reshape(*x_in.shape)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        x_mask: torch.Tensor,
+        freqs_cis: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+
+        Args:
+            x:
+            x_mask:
+            freqs_cis:
+
+        Returns:
+
+        """
+        bsz, seqlen, _ = x.shape
+
+        xq, xk, xv = torch.split(
+            self.qkv(x),
+            [
+                self.n_local_heads * self.head_dim,
+                self.n_local_kv_heads * self.head_dim,
+                self.n_local_kv_heads * self.head_dim,
+            ],
+            dim=-1,
+        )
+        xq = xq.view(bsz, seqlen, self.n_local_heads, self.head_dim)
+        xk = xk.view(bsz, seqlen, self.n_local_kv_heads, self.head_dim)
+        xv = xv.view(bsz, seqlen, self.n_local_kv_heads, self.head_dim)
+
+        xq = self.q_norm(xq)
+        xk = self.k_norm(xk)
+
+        xq = JointAttention.apply_rotary_emb(xq, freqs_cis=freqs_cis)
+        xk = JointAttention.apply_rotary_emb(xk, freqs_cis=freqs_cis)
+
+        n_rep = self.n_local_heads // self.n_local_kv_heads
+        if n_rep >= 1:
+            xk = xk.unsqueeze(3).repeat(1, 1, 1, n_rep, 1).flatten(2, 3)
+            xv = xv.unsqueeze(3).repeat(1, 1, 1, n_rep, 1).flatten(2, 3)
+        output = optimized_attention_masked(xq.movedim(1, 2), xk.movedim(1, 2), xv.movedim(1, 2), self.n_local_heads, x_mask, skip_reshape=True)
+
+        return self.out(output)
+
+
+class FeedForward(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        hidden_dim: int,
+        multiple_of: int,
+        ffn_dim_multiplier: Optional[float],
+        operation_settings={},
+    ):
+        """
+        Initialize the FeedForward module.
+
+        Args:
+            dim (int): Input dimension.
+            hidden_dim (int): Hidden dimension of the feedforward layer.
+            multiple_of (int): Value to ensure hidden dimension is a multiple
+                of this value.
+            ffn_dim_multiplier (float, optional): Custom multiplier for hidden
+                dimension. Defaults to None.
+
+        """
+        super().__init__()
+        # custom dim factor multiplier
+        if ffn_dim_multiplier is not None:
+            hidden_dim = int(ffn_dim_multiplier * hidden_dim)
+        hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
+
+        self.w1 = operation_settings.get("operations").Linear(
+            dim,
+            hidden_dim,
+            bias=False,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+        self.w2 = operation_settings.get("operations").Linear(
+            hidden_dim,
+            dim,
+            bias=False,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+        self.w3 = operation_settings.get("operations").Linear(
+            dim,
+            hidden_dim,
+            bias=False,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+
+    # @torch.compile
+    def _forward_silu_gating(self, x1, x3):
+        return F.silu(x1) * x3
+
+    def forward(self, x):
+        return self.w2(self._forward_silu_gating(self.w1(x), self.w3(x)))
+
+
+class JointTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        layer_id: int,
+        dim: int,
+        n_heads: int,
+        n_kv_heads: int,
+        multiple_of: int,
+        ffn_dim_multiplier: float,
+        norm_eps: float,
+        qk_norm: bool,
+        modulation=True,
+        operation_settings={},
+    ) -> None:
+        """
+        Initialize a TransformerBlock.
+
+        Args:
+            layer_id (int): Identifier for the layer.
+            dim (int): Embedding dimension of the input features.
+            n_heads (int): Number of attention heads.
+            n_kv_heads (Optional[int]): Number of attention heads in key and
+                value features (if using GQA), or set to None for the same as
+                query.
+            multiple_of (int):
+            ffn_dim_multiplier (float):
+            norm_eps (float):
+
+        """
+        super().__init__()
+        self.dim = dim
+        self.head_dim = dim // n_heads
+        self.attention = JointAttention(dim, n_heads, n_kv_heads, qk_norm, operation_settings=operation_settings)
+        self.feed_forward = FeedForward(
+            dim=dim,
+            hidden_dim=4 * dim,
+            multiple_of=multiple_of,
+            ffn_dim_multiplier=ffn_dim_multiplier,
+            operation_settings=operation_settings,
+        )
+        self.layer_id = layer_id
+        self.attention_norm1 = RMSNorm(dim, eps=norm_eps, elementwise_affine=True, **operation_settings)
+        self.ffn_norm1 = RMSNorm(dim, eps=norm_eps, elementwise_affine=True, **operation_settings)
+
+        self.attention_norm2 = RMSNorm(dim, eps=norm_eps, elementwise_affine=True, **operation_settings)
+        self.ffn_norm2 = RMSNorm(dim, eps=norm_eps, elementwise_affine=True, **operation_settings)
+
+        self.modulation = modulation
+        if modulation:
+            self.adaLN_modulation = nn.Sequential(
+                nn.SiLU(),
+                operation_settings.get("operations").Linear(
+                    min(dim, 1024),
+                    4 * dim,
+                    bias=True,
+                    device=operation_settings.get("device"),
+                    dtype=operation_settings.get("dtype"),
+                ),
+            )
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        x_mask: torch.Tensor,
+        freqs_cis: torch.Tensor,
+        adaln_input: Optional[torch.Tensor]=None,
+    ):
+        """
+        Perform a forward pass through the TransformerBlock.
+
+        Args:
+            x (torch.Tensor): Input tensor.
+            freqs_cis (torch.Tensor): Precomputed cosine and sine frequencies.
+
+        Returns:
+            torch.Tensor: Output tensor after applying attention and
+                feedforward layers.
+
+        """
+        if self.modulation:
+            assert adaln_input is not None
+            scale_msa, gate_msa, scale_mlp, gate_mlp = self.adaLN_modulation(adaln_input).chunk(4, dim=1)
+
+            x = x + gate_msa.unsqueeze(1).tanh() * self.attention_norm2(
+                self.attention(
+                    modulate(self.attention_norm1(x), scale_msa),
+                    x_mask,
+                    freqs_cis,
+                )
+            )
+            x = x + gate_mlp.unsqueeze(1).tanh() * self.ffn_norm2(
+                self.feed_forward(
+                    modulate(self.ffn_norm1(x), scale_mlp),
+                )
+            )
+        else:
+            assert adaln_input is None
+            x = x + self.attention_norm2(
+                self.attention(
+                    self.attention_norm1(x),
+                    x_mask,
+                    freqs_cis,
+                )
+            )
+            x = x + self.ffn_norm2(
+                self.feed_forward(
+                    self.ffn_norm1(x),
+                )
+            )
+        return x
+
+
+class FinalLayer(nn.Module):
+    """
+    The final layer of NextDiT.
+    """
+
+    def __init__(self, hidden_size, patch_size, out_channels, operation_settings={}):
+        super().__init__()
+        self.norm_final = operation_settings.get("operations").LayerNorm(
+            hidden_size,
+            elementwise_affine=False,
+            eps=1e-6,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+        self.linear = operation_settings.get("operations").Linear(
+            hidden_size,
+            patch_size * patch_size * out_channels,
+            bias=True,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            operation_settings.get("operations").Linear(
+                min(hidden_size, 1024),
+                hidden_size,
+                bias=True,
+                device=operation_settings.get("device"),
+                dtype=operation_settings.get("dtype"),
+            ),
+        )
+
+    def forward(self, x, c):
+        scale = self.adaLN_modulation(c)
+        x = modulate(self.norm_final(x), scale)
+        x = self.linear(x)
+        return x
+
+
+class RopeEmbedder:
+    def __init__(
+        self, theta: float = 10000.0, axes_dims: List[int] = (16, 56, 56), axes_lens: List[int] = (1, 512, 512)
+    ):
+        super().__init__()
+        self.theta = theta
+        self.axes_dims = axes_dims
+        self.axes_lens = axes_lens
+        self.freqs_cis = NextDiT.precompute_freqs_cis(self.axes_dims, self.axes_lens, theta=self.theta)
+
+    def __call__(self, ids: torch.Tensor):
+        self.freqs_cis = [freqs_cis.to(ids.device) for freqs_cis in self.freqs_cis]
+        result = []
+        for i in range(len(self.axes_dims)):
+            index = ids[:, :, i:i+1].repeat(1, 1, self.freqs_cis[i].shape[-1]).to(torch.int64)
+            result.append(torch.gather(self.freqs_cis[i].unsqueeze(0).repeat(index.shape[0], 1, 1), dim=1, index=index))
+        return torch.cat(result, dim=-1)
+
+
+class NextDiT(nn.Module):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+
+    def __init__(
+        self,
+        patch_size: int = 2,
+        in_channels: int = 4,
+        dim: int = 4096,
+        n_layers: int = 32,
+        n_refiner_layers: int = 2,
+        n_heads: int = 32,
+        n_kv_heads: Optional[int] = None,
+        multiple_of: int = 256,
+        ffn_dim_multiplier: Optional[float] = None,
+        norm_eps: float = 1e-5,
+        qk_norm: bool = False,
+        cap_feat_dim: int = 5120,
+        axes_dims: List[int] = (16, 56, 56),
+        axes_lens: List[int] = (1, 512, 512),
+        image_model=None,
+        device=None,
+        dtype=None,
+        operations=None,
+    ) -> None:
+        super().__init__()
+        self.dtype = dtype
+        operation_settings = {"operations": operations, "device": device, "dtype": dtype}
+        self.in_channels = in_channels
+        self.out_channels = in_channels
+        self.patch_size = patch_size
+
+        self.x_embedder = operation_settings.get("operations").Linear(
+            in_features=patch_size * patch_size * in_channels,
+            out_features=dim,
+            bias=True,
+            device=operation_settings.get("device"),
+            dtype=operation_settings.get("dtype"),
+        )
+
+        self.noise_refiner = nn.ModuleList(
+            [
+                JointTransformerBlock(
+                    layer_id,
+                    dim,
+                    n_heads,
+                    n_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    qk_norm,
+                    modulation=True,
+                    operation_settings=operation_settings,
+                )
+                for layer_id in range(n_refiner_layers)
+            ]
+        )
+        self.context_refiner = nn.ModuleList(
+            [
+                JointTransformerBlock(
+                    layer_id,
+                    dim,
+                    n_heads,
+                    n_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    qk_norm,
+                    modulation=False,
+                    operation_settings=operation_settings,
+                )
+                for layer_id in range(n_refiner_layers)
+            ]
+        )
+
+        self.t_embedder = TimestepEmbedder(min(dim, 1024), **operation_settings)
+        self.cap_embedder = nn.Sequential(
+            RMSNorm(cap_feat_dim, eps=norm_eps, elementwise_affine=True, **operation_settings),
+            operation_settings.get("operations").Linear(
+                cap_feat_dim,
+                dim,
+                bias=True,
+                device=operation_settings.get("device"),
+                dtype=operation_settings.get("dtype"),
+            ),
+        )
+
+        self.layers = nn.ModuleList(
+            [
+                JointTransformerBlock(
+                    layer_id,
+                    dim,
+                    n_heads,
+                    n_kv_heads,
+                    multiple_of,
+                    ffn_dim_multiplier,
+                    norm_eps,
+                    qk_norm,
+                    operation_settings=operation_settings,
+                )
+                for layer_id in range(n_layers)
+            ]
+        )
+        self.norm_final = RMSNorm(dim, eps=norm_eps, elementwise_affine=True, **operation_settings)
+        self.final_layer = FinalLayer(dim, patch_size, self.out_channels, operation_settings=operation_settings)
+
+        assert (dim // n_heads) == sum(axes_dims)
+        self.axes_dims = axes_dims
+        self.axes_lens = axes_lens
+        # self.rope_embedder = RopeEmbedder(axes_dims=axes_dims, axes_lens=axes_lens)
+        self.rope_embedder = EmbedND(dim=dim // n_heads, theta=10000.0, axes_dim=axes_dims)
+        self.dim = dim
+        self.n_heads = n_heads
+
+    def unpatchify(
+        self, x: torch.Tensor, img_size: List[Tuple[int, int]], cap_size: List[int], return_tensor=False
+    ) -> List[torch.Tensor]:
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        pH = pW = self.patch_size
+        imgs = []
+        for i in range(x.size(0)):
+            H, W = img_size[i]
+            begin = cap_size[i]
+            end = begin + (H // pH) * (W // pW)
+            imgs.append(
+                x[i][begin:end]
+                .view(H // pH, W // pW, pH, pW, self.out_channels)
+                .permute(4, 0, 2, 1, 3)
+                .flatten(3, 4)
+                .flatten(1, 2)
+            )
+
+        if return_tensor:
+            imgs = torch.stack(imgs, dim=0)
+        return imgs
+
+    def patchify_and_embed(
+        self, x: List[torch.Tensor] | torch.Tensor, cap_feats: torch.Tensor, cap_mask: torch.Tensor, t: torch.Tensor, num_tokens
+    ) -> Tuple[torch.Tensor, torch.Tensor, List[Tuple[int, int]], List[int], torch.Tensor]:
+        bsz = len(x)
+        pH = pW = self.patch_size
+        device = x[0].device
+        dtype = x[0].dtype
+
+        if cap_mask is not None:
+            l_effective_cap_len = cap_mask.sum(dim=1).tolist()
+        else:
+            l_effective_cap_len = [num_tokens] * bsz
+
+        if cap_mask is not None and not torch.is_floating_point(cap_mask):
+            cap_mask = (cap_mask - 1).to(dtype) * torch.finfo(dtype).max
+
+        img_sizes = [(img.size(1), img.size(2)) for img in x]
+        l_effective_img_len = [(H // pH) * (W // pW) for (H, W) in img_sizes]
+
+        max_seq_len = max(
+            (cap_len+img_len for cap_len, img_len in zip(l_effective_cap_len, l_effective_img_len))
+        )
+        max_cap_len = max(l_effective_cap_len)
+        max_img_len = max(l_effective_img_len)
+
+        position_ids = torch.zeros(bsz, max_seq_len, 3, dtype=torch.int32, device=device)
+
+        for i in range(bsz):
+            cap_len = l_effective_cap_len[i]
+            img_len = l_effective_img_len[i]
+            H, W = img_sizes[i]
+            H_tokens, W_tokens = H // pH, W // pW
+            assert H_tokens * W_tokens == img_len
+
+            position_ids[i, :cap_len, 0] = torch.arange(cap_len, dtype=torch.int32, device=device)
+            position_ids[i, cap_len:cap_len+img_len, 0] = cap_len
+            row_ids = torch.arange(H_tokens, dtype=torch.int32, device=device).view(-1, 1).repeat(1, W_tokens).flatten()
+            col_ids = torch.arange(W_tokens, dtype=torch.int32, device=device).view(1, -1).repeat(H_tokens, 1).flatten()
+            position_ids[i, cap_len:cap_len+img_len, 1] = row_ids
+            position_ids[i, cap_len:cap_len+img_len, 2] = col_ids
+
+        freqs_cis = self.rope_embedder(position_ids).movedim(1, 2).to(dtype)
+
+        # build freqs_cis for cap and image individually
+        cap_freqs_cis_shape = list(freqs_cis.shape)
+        # cap_freqs_cis_shape[1] = max_cap_len
+        cap_freqs_cis_shape[1] = cap_feats.shape[1]
+        cap_freqs_cis = torch.zeros(*cap_freqs_cis_shape, device=device, dtype=freqs_cis.dtype)
+
+        img_freqs_cis_shape = list(freqs_cis.shape)
+        img_freqs_cis_shape[1] = max_img_len
+        img_freqs_cis = torch.zeros(*img_freqs_cis_shape, device=device, dtype=freqs_cis.dtype)
+
+        for i in range(bsz):
+            cap_len = l_effective_cap_len[i]
+            img_len = l_effective_img_len[i]
+            cap_freqs_cis[i, :cap_len] = freqs_cis[i, :cap_len]
+            img_freqs_cis[i, :img_len] = freqs_cis[i, cap_len:cap_len+img_len]
+
+        # refine context
+        for layer in self.context_refiner:
+            cap_feats = layer(cap_feats, cap_mask, cap_freqs_cis)
+
+        # refine image
+        flat_x = []
+        for i in range(bsz):
+            img = x[i]
+            C, H, W = img.size()
+            img = img.view(C, H // pH, pH, W // pW, pW).permute(1, 3, 2, 4, 0).flatten(2).flatten(0, 1)
+            flat_x.append(img)
+        x = flat_x
+        padded_img_embed = torch.zeros(bsz, max_img_len, x[0].shape[-1], device=device, dtype=x[0].dtype)
+        padded_img_mask = torch.zeros(bsz, max_img_len, dtype=dtype, device=device)
+        for i in range(bsz):
+            padded_img_embed[i, :l_effective_img_len[i]] = x[i]
+            padded_img_mask[i, l_effective_img_len[i]:] = -torch.finfo(dtype).max
+
+        padded_img_embed = self.x_embedder(padded_img_embed)
+        padded_img_mask = padded_img_mask.unsqueeze(1)
+        for layer in self.noise_refiner:
+            padded_img_embed = layer(padded_img_embed, padded_img_mask, img_freqs_cis, t)
+
+        if cap_mask is not None:
+            mask = torch.zeros(bsz, max_seq_len, dtype=dtype, device=device)
+            mask[:, :max_cap_len] = cap_mask[:, :max_cap_len]
+        else:
+            mask = None
+
+        padded_full_embed = torch.zeros(bsz, max_seq_len, self.dim, device=device, dtype=x[0].dtype)
+        for i in range(bsz):
+            cap_len = l_effective_cap_len[i]
+            img_len = l_effective_img_len[i]
+
+            padded_full_embed[i, :cap_len] = cap_feats[i, :cap_len]
+            padded_full_embed[i, cap_len:cap_len+img_len] = padded_img_embed[i, :img_len]
+
+        return padded_full_embed, mask, img_sizes, l_effective_cap_len, freqs_cis
+
+
+    # def forward(self, x, t, cap_feats, cap_mask):
+    def forward(self, x, timesteps, context, num_tokens, attention_mask=None, **kwargs):
+        t = 1.0 - timesteps
+        cap_feats = context
+        cap_mask = attention_mask
+        """
+        Forward pass of NextDiT.
+        t: (N,) tensor of diffusion timesteps
+        y: (N,) tensor of text tokens/features
+        """
+
+        t = self.t_embedder(t, dtype=x.dtype)  # (N, D)
+        adaln_input = t
+
+        cap_feats = self.cap_embedder(cap_feats)  # (N, L, D)  # todo check if able to batchify w.o. redundant compute
+
+        x_is_tensor = isinstance(x, torch.Tensor)
+        x, mask, img_size, cap_size, freqs_cis = self.patchify_and_embed(x, cap_feats, cap_mask, t, num_tokens)
+        freqs_cis = freqs_cis.to(x.device)
+
+        for layer in self.layers:
+            x = layer(x, mask, freqs_cis, adaln_input)
+
+        x = self.final_layer(x, adaln_input)
+        x = self.unpatchify(x, img_size, cap_size, return_tensor=x_is_tensor)
+
+        return -x
+
+    @staticmethod
+    def precompute_freqs_cis(
+        dim: List[int],
+        end: List[int],
+        theta: float = 10000.0,
+    ):
+        """
+        Precompute the frequency tensor for complex exponentials (cis) with
+        given dimensions.
+
+        This function calculates a frequency tensor with complex exponentials
+        using the given dimension 'dim' and the end index 'end'. The 'theta'
+        parameter scales the frequencies. The returned tensor contains complex
+        values in complex64 data type.
+
+        Args:
+            dim (list): Dimension of the frequency tensor.
+            end (list): End index for precomputing frequencies.
+            theta (float, optional): Scaling factor for frequency computation.
+                Defaults to 10000.0.
+
+        Returns:
+            torch.Tensor: Precomputed frequency tensor with complex
+                exponentials.
+        """
+        freqs_cis = []
+        for i, (d, e) in enumerate(zip(dim, end)):
+            freqs = 1.0 / (theta ** (torch.arange(0, d, 2, dtype=torch.float64, device="cpu") / d))
+            timestep = torch.arange(e, device=freqs.device, dtype=torch.float64)
+            freqs = torch.outer(timestep, freqs).float()
+            freqs_cis_i = torch.polar(torch.ones_like(freqs), freqs).to(torch.complex64)  # complex64
+            freqs_cis.append(freqs_cis_i)
+
+        return freqs_cis

comfy/ldm/modules/attention.py

@@ -1,4 +1,6 @@
 import math
+import sys
+
 import torch
 import torch.nn.functional as F
 from torch import nn, einsum
@@ -16,7 +18,11 @@ if model_management.xformers_enabled():
     import xformers.ops
 
 if model_management.sage_attention_enabled():
-    from sageattention import sageattn
+    try:
+        from sageattention import sageattn
+    except ModuleNotFoundError:
+        logging.error(f"\n\nTo use the `--use-sage-attention` feature, the `sageattention` package must be installed first.\ncommand:\n\t{sys.executable} -m pip install sageattention")
+        exit(-1)
 
 from comfy.cli_args import args
 import comfy.ops

comfy/ldm/modules/diffusionmodules/mmdit.py

@@ -321,7 +321,7 @@ class SelfAttention(nn.Module):
 
 class RMSNorm(torch.nn.Module):
     def __init__(
-        self, dim: int, elementwise_affine: bool = False, eps: float = 1e-6, device=None, dtype=None
+        self, dim: int, elementwise_affine: bool = False, eps: float = 1e-6, device=None, dtype=None, **kwargs
     ):
         """
         Initialize the RMSNorm normalization layer.

comfy/ldm/modules/diffusionmodules/model.py

@@ -702,9 +702,6 @@ class Decoder(nn.Module):
                                         padding=1)
 
     def forward(self, z, **kwargs):
-        #assert z.shape[1:] == self.z_shape[1:]
-        self.last_z_shape = z.shape
-
         # timestep embedding
         temb = None
 

comfy/lora.py

@@ -307,7 +307,6 @@ def model_lora_keys_unet(model, key_map={}):
             if k.endswith(".weight"):
                 key_lora = k[len("diffusion_model."):-len(".weight")].replace(".", "_")
                 key_map["lora_unet_{}".format(key_lora)] = k
-                key_map["lora_prior_unet_{}".format(key_lora)] = k #cascade lora: TODO put lora key prefix in the model config
                 key_map["{}".format(k[:-len(".weight")])] = k #generic lora format without any weird key names
             else:
                 key_map["{}".format(k)] = k #generic lora format for not .weight without any weird key names
@@ -327,6 +326,13 @@ def model_lora_keys_unet(model, key_map={}):
                     diffusers_lora_key = diffusers_lora_key[:-2]
                 key_map[diffusers_lora_key] = unet_key
 
+    if isinstance(model, comfy.model_base.StableCascade_C):
+        for k in sdk:
+            if k.startswith("diffusion_model."):
+                if k.endswith(".weight"):
+                    key_lora = k[len("diffusion_model."):-len(".weight")].replace(".", "_")
+                    key_map["lora_prior_unet_{}".format(key_lora)] = k
+
     if isinstance(model, comfy.model_base.SD3): #Diffusers lora SD3
         diffusers_keys = comfy.utils.mmdit_to_diffusers(model.model_config.unet_config, output_prefix="diffusion_model.")
         for k in diffusers_keys:

comfy/model_base.py

@@ -34,6 +34,7 @@ import comfy.ldm.flux.model
 import comfy.ldm.lightricks.model
 import comfy.ldm.hunyuan_video.model
 import comfy.ldm.cosmos.model
+import comfy.ldm.lumina.model
 
 import comfy.model_management
 import comfy.patcher_extension
@@ -904,3 +905,19 @@ class CosmosVideo(BaseModel):
             latent_image = latent_image + noise
         latent_image = self.model_sampling.calculate_input(torch.tensor([sigma_noise_augmentation], device=latent_image.device, dtype=latent_image.dtype), latent_image)
         return latent_image * ((sigma ** 2 + self.model_sampling.sigma_data ** 2) ** 0.5)
+
+class Lumina2(BaseModel):
+    def __init__(self, model_config, model_type=ModelType.FLOW, device=None):
+        super().__init__(model_config, model_type, device=device, unet_model=comfy.ldm.lumina.model.NextDiT)
+
+    def extra_conds(self, **kwargs):
+        out = super().extra_conds(**kwargs)
+        attention_mask = kwargs.get("attention_mask", None)
+        if attention_mask is not None:
+            if torch.numel(attention_mask) != attention_mask.sum():
+                out['attention_mask'] = comfy.conds.CONDRegular(attention_mask)
+            out['num_tokens'] = comfy.conds.CONDConstant(max(1, torch.sum(attention_mask).item()))
+        cross_attn = kwargs.get("cross_attn", None)
+        if cross_attn is not None:
+            out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn)
+        return out

comfy/model_detection.py

@@ -239,7 +239,7 @@ def detect_unet_config(state_dict, key_prefix):
             dit_config["micro_condition"] = False
         return dit_config
 
-    if '{}blocks.block0.blocks.0.block.attn.to_q.0.weight'.format(key_prefix) in state_dict_keys:
+    if '{}blocks.block0.blocks.0.block.attn.to_q.0.weight'.format(key_prefix) in state_dict_keys:  # Cosmos
         dit_config = {}
         dit_config["image_model"] = "cosmos"
         dit_config["max_img_h"] = 240
@@ -284,6 +284,21 @@ def detect_unet_config(state_dict, key_prefix):
             dit_config["extra_per_block_abs_pos_emb_type"] = "learnable"
         return dit_config
 
+    if '{}cap_embedder.1.weight'.format(key_prefix) in state_dict_keys:  # Lumina 2
+        dit_config = {}
+        dit_config["image_model"] = "lumina2"
+        dit_config["patch_size"] = 2
+        dit_config["in_channels"] = 16
+        dit_config["dim"] = 2304
+        dit_config["cap_feat_dim"] = 2304
+        dit_config["n_layers"] = 26
+        dit_config["n_heads"] = 24
+        dit_config["n_kv_heads"] = 8
+        dit_config["qk_norm"] = True
+        dit_config["axes_dims"] = [32, 32, 32]
+        dit_config["axes_lens"] = [300, 512, 512]
+        return dit_config
+
     if '{}input_blocks.0.0.weight'.format(key_prefix) not in state_dict_keys:
         return None
 

comfy/model_management.py

@@ -218,7 +218,7 @@ def is_amd():
 
 MIN_WEIGHT_MEMORY_RATIO = 0.4
 if is_nvidia():
-    MIN_WEIGHT_MEMORY_RATIO = 0.2
+    MIN_WEIGHT_MEMORY_RATIO = 0.1
 
 ENABLE_PYTORCH_ATTENTION = False
 if args.use_pytorch_cross_attention:
@@ -535,14 +535,11 @@ def load_models_gpu(models, memory_required=0, force_patch_weights=False, minimu
             vram_set_state = vram_state
         lowvram_model_memory = 0
         if lowvram_available and (vram_set_state == VRAMState.LOW_VRAM or vram_set_state == VRAMState.NORMAL_VRAM) and not force_full_load:
-            model_size = loaded_model.model_memory_required(torch_dev)
             loaded_memory = loaded_model.model_loaded_memory()
             current_free_mem = get_free_memory(torch_dev) + loaded_memory
 
             lowvram_model_memory = max(64 * 1024 * 1024, (current_free_mem - minimum_memory_required), min(current_free_mem * MIN_WEIGHT_MEMORY_RATIO, current_free_mem - minimum_inference_memory()))
             lowvram_model_memory = max(0.1, lowvram_model_memory - loaded_memory)
-            if model_size <= lowvram_model_memory: #only switch to lowvram if really necessary
-                lowvram_model_memory = 0
 
         if vram_set_state == VRAMState.NO_VRAM:
             lowvram_model_memory = 0.1

comfy/model_sampling.py

@@ -31,6 +31,7 @@ class EPS:
         return model_input - model_output * sigma
 
     def noise_scaling(self, sigma, noise, latent_image, max_denoise=False):
+        sigma = sigma.view(sigma.shape[:1] + (1,) * (noise.ndim - 1))
         if max_denoise:
             noise = noise * torch.sqrt(1.0 + sigma ** 2.0)
         else:
@@ -61,9 +62,11 @@ class CONST:
         return model_input - model_output * sigma
 
     def noise_scaling(self, sigma, noise, latent_image, max_denoise=False):
+        sigma = sigma.view(sigma.shape[:1] + (1,) * (noise.ndim - 1))
         return sigma * noise + (1.0 - sigma) * latent_image
 
     def inverse_noise_scaling(self, sigma, latent):
+        sigma = sigma.view(sigma.shape[:1] + (1,) * (latent.ndim - 1))
         return latent / (1.0 - sigma)
 
 class ModelSamplingDiscrete(torch.nn.Module):

comfy/sd.py

@@ -36,6 +36,7 @@ import comfy.text_encoders.genmo
 import comfy.text_encoders.lt
 import comfy.text_encoders.hunyuan_video
 import comfy.text_encoders.cosmos
+import comfy.text_encoders.lumina2
 
 import comfy.model_patcher
 import comfy.lora
@@ -657,6 +658,7 @@ class CLIPType(Enum):
     HUNYUAN_VIDEO = 9
     PIXART = 10
     COSMOS = 11
+    LUMINA2 = 12
 
 
 def load_clip(ckpt_paths, embedding_directory=None, clip_type=CLIPType.STABLE_DIFFUSION, model_options={}):
@@ -675,6 +677,7 @@ class TEModel(Enum):
     T5_BASE = 6
     LLAMA3_8 = 7
     T5_XXL_OLD = 8
+    GEMMA_2_2B = 9
 
 def detect_te_model(sd):
     if "text_model.encoder.layers.30.mlp.fc1.weight" in sd:
@@ -693,6 +696,8 @@ def detect_te_model(sd):
         return TEModel.T5_XXL_OLD
     if "encoder.block.0.layer.0.SelfAttention.k.weight" in sd:
         return TEModel.T5_BASE
+    if 'model.layers.0.post_feedforward_layernorm.weight' in sd:
+        return TEModel.GEMMA_2_2B
     if "model.layers.0.post_attention_layernorm.weight" in sd:
         return TEModel.LLAMA3_8
     return None
@@ -730,6 +735,7 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
             if "text_projection" in clip_data[i]:
                 clip_data[i]["text_projection.weight"] = clip_data[i]["text_projection"].transpose(0, 1) #old models saved with the CLIPSave node
 
+    tokenizer_data = {}
     clip_target = EmptyClass()
     clip_target.params = {}
     if len(clip_data) == 1:
@@ -769,6 +775,10 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
         elif te_model == TEModel.T5_BASE:
             clip_target.clip = comfy.text_encoders.sa_t5.SAT5Model
             clip_target.tokenizer = comfy.text_encoders.sa_t5.SAT5Tokenizer
+        elif te_model == TEModel.GEMMA_2_2B:
+            clip_target.clip = comfy.text_encoders.lumina2.te(**llama_detect(clip_data))
+            clip_target.tokenizer = comfy.text_encoders.lumina2.LuminaTokenizer
+            tokenizer_data["spiece_model"] = clip_data[0].get("spiece_model", None)
         else:
             if clip_type == CLIPType.SD3:
                 clip_target.clip = comfy.text_encoders.sd3_clip.sd3_clip(clip_l=True, clip_g=False, t5=False)
@@ -798,7 +808,6 @@ def load_text_encoder_state_dicts(state_dicts=[], embedding_directory=None, clip
         clip_target.tokenizer = comfy.text_encoders.sd3_clip.SD3Tokenizer
 
     parameters = 0
-    tokenizer_data = {}
     for c in clip_data:
         parameters += comfy.utils.calculate_parameters(c)
         tokenizer_data, model_options = comfy.text_encoders.long_clipl.model_options_long_clip(c, tokenizer_data, model_options)

comfy/sd1_clip.py

@@ -421,10 +421,10 @@ def load_embed(embedding_name, embedding_directory, embedding_size, embed_key=No
     return embed_out
 
 class SDTokenizer:
-    def __init__(self, tokenizer_path=None, max_length=77, pad_with_end=True, embedding_directory=None, embedding_size=768, embedding_key='clip_l', tokenizer_class=CLIPTokenizer, has_start_token=True, has_end_token=True, pad_to_max_length=True, min_length=None, pad_token=None, end_token=None, tokenizer_data={}):
+    def __init__(self, tokenizer_path=None, max_length=77, pad_with_end=True, embedding_directory=None, embedding_size=768, embedding_key='clip_l', tokenizer_class=CLIPTokenizer, has_start_token=True, has_end_token=True, pad_to_max_length=True, min_length=None, pad_token=None, end_token=None, tokenizer_data={}, tokenizer_args={}):
         if tokenizer_path is None:
             tokenizer_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "sd1_tokenizer")
-        self.tokenizer = tokenizer_class.from_pretrained(tokenizer_path)
+        self.tokenizer = tokenizer_class.from_pretrained(tokenizer_path, **tokenizer_args)
         self.max_length = max_length
         self.min_length = min_length
         self.end_token = None
@@ -585,9 +585,14 @@ class SDTokenizer:
         return {}
 
 class SD1Tokenizer:
-    def __init__(self, embedding_directory=None, tokenizer_data={}, clip_name="l", tokenizer=SDTokenizer):
-        self.clip_name = clip_name
-        self.clip = "clip_{}".format(self.clip_name)
+    def __init__(self, embedding_directory=None, tokenizer_data={}, clip_name="l", tokenizer=SDTokenizer, name=None):
+        if name is not None:
+            self.clip_name = name
+            self.clip = "{}".format(self.clip_name)
+        else:
+            self.clip_name = clip_name
+            self.clip = "clip_{}".format(self.clip_name)
+
         tokenizer = tokenizer_data.get("{}_tokenizer_class".format(self.clip), tokenizer)
         setattr(self, self.clip, tokenizer(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data))
 
@@ -600,7 +605,7 @@ class SD1Tokenizer:
         return getattr(self, self.clip).untokenize(token_weight_pair)
 
     def state_dict(self):
-        return {}
+        return getattr(self, self.clip).state_dict()
 
 class SD1CheckpointClipModel(SDClipModel):
     def __init__(self, device="cpu", dtype=None, model_options={}):

comfy/supported_models.py

@@ -15,6 +15,7 @@ import comfy.text_encoders.genmo
 import comfy.text_encoders.lt
 import comfy.text_encoders.hunyuan_video
 import comfy.text_encoders.cosmos
+import comfy.text_encoders.lumina2
 
 from . import supported_models_base
 from . import latent_formats
@@ -865,6 +866,35 @@ class CosmosI2V(CosmosT2V):
         out = model_base.CosmosVideo(self, image_to_video=True, device=device)
         return out
 
-models = [Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, HunyuanVideo, CosmosT2V, CosmosI2V]
+class Lumina2(supported_models_base.BASE):
+    unet_config = {
+        "image_model": "lumina2",
+    }
+
+    sampling_settings = {
+        "multiplier": 1.0,
+        "shift": 6.0,
+    }
+
+    memory_usage_factor = 1.2
+
+    unet_extra_config = {}
+    latent_format = latent_formats.Flux
+
+    supported_inference_dtypes = [torch.bfloat16, torch.float32]
+
+    vae_key_prefix = ["vae."]
+    text_encoder_key_prefix = ["text_encoders."]
+
+    def get_model(self, state_dict, prefix="", device=None):
+        out = model_base.Lumina2(self, device=device)
+        return out
+
+    def clip_target(self, state_dict={}):
+        pref = self.text_encoder_key_prefix[0]
+        hunyuan_detect = comfy.text_encoders.hunyuan_video.llama_detect(state_dict, "{}gemma2_2b.transformer.".format(pref))
+        return supported_models_base.ClipTarget(comfy.text_encoders.lumina2.LuminaTokenizer, comfy.text_encoders.lumina2.te(**hunyuan_detect))
+
+models = [Stable_Zero123, SD15_instructpix2pix, SD15, SD20, SD21UnclipL, SD21UnclipH, SDXL_instructpix2pix, SDXLRefiner, SDXL, SSD1B, KOALA_700M, KOALA_1B, Segmind_Vega, SD_X4Upscaler, Stable_Cascade_C, Stable_Cascade_B, SV3D_u, SV3D_p, SD3, StableAudio, AuraFlow, PixArtAlpha, PixArtSigma, HunyuanDiT, HunyuanDiT1, FluxInpaint, Flux, FluxSchnell, GenmoMochi, LTXV, HunyuanVideo, CosmosT2V, CosmosI2V, Lumina2]
 
 models += [SVD_img2vid]

comfy/text_encoders/bert.py

@@ -118,7 +118,7 @@ class BertModel_(torch.nn.Module):
         mask = None
         if attention_mask is not None:
             mask = 1.0 - attention_mask.to(x.dtype).reshape((attention_mask.shape[0], 1, -1, attention_mask.shape[-1])).expand(attention_mask.shape[0], 1, attention_mask.shape[-1], attention_mask.shape[-1])
-            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
+            mask = mask.masked_fill(mask.to(torch.bool), -torch.finfo(x.dtype).max)
 
         x, i = self.encoder(x, mask, intermediate_output)
         return x, i

comfy/text_encoders/llama.py

@@ -1,6 +1,5 @@
 import torch
 import torch.nn as nn
-import torch.nn.functional as F
 from dataclasses import dataclass
 from typing import Optional, Any
 
@@ -21,15 +20,41 @@ class Llama2Config:
     max_position_embeddings: int = 8192
     rms_norm_eps: float = 1e-5
     rope_theta: float = 500000.0
+    transformer_type: str = "llama"
+    head_dim = 128
+    rms_norm_add = False
+    mlp_activation = "silu"
+
+@dataclass
+class Gemma2_2B_Config:
+    vocab_size: int = 256000
+    hidden_size: int = 2304
+    intermediate_size: int = 9216
+    num_hidden_layers: int = 26
+    num_attention_heads: int = 8
+    num_key_value_heads: int = 4
+    max_position_embeddings: int = 8192
+    rms_norm_eps: float = 1e-6
+    rope_theta: float = 10000.0
+    transformer_type: str = "gemma2"
+    head_dim = 256
+    rms_norm_add = True
+    mlp_activation = "gelu_pytorch_tanh"
 
 class RMSNorm(nn.Module):
-    def __init__(self, dim: int, eps: float = 1e-5, device=None, dtype=None):
+    def __init__(self, dim: int, eps: float = 1e-5, add=False, device=None, dtype=None):
         super().__init__()
         self.eps = eps
         self.weight = nn.Parameter(torch.empty(dim, device=device, dtype=dtype))
+        self.add = add
 
     def forward(self, x: torch.Tensor):
-        return comfy.ldm.common_dit.rms_norm(x, self.weight, self.eps)
+        w = self.weight
+        if self.add:
+            w = w + 1.0
+
+        return comfy.ldm.common_dit.rms_norm(x, w, self.eps)
+
 
 
 def rotate_half(x):
@@ -68,13 +93,15 @@ class Attention(nn.Module):
         self.num_heads = config.num_attention_heads
         self.num_kv_heads = config.num_key_value_heads
         self.hidden_size = config.hidden_size
-        self.head_dim = self.hidden_size // self.num_heads
+
+        self.head_dim = config.head_dim
+        self.inner_size = self.num_heads * self.head_dim
 
         ops = ops or nn
-        self.q_proj = ops.Linear(config.hidden_size, config.hidden_size, bias=False, device=device, dtype=dtype)
+        self.q_proj = ops.Linear(config.hidden_size, self.inner_size, bias=False, device=device, dtype=dtype)
         self.k_proj = ops.Linear(config.hidden_size, self.num_kv_heads * self.head_dim, bias=False, device=device, dtype=dtype)
         self.v_proj = ops.Linear(config.hidden_size, self.num_kv_heads * self.head_dim, bias=False, device=device, dtype=dtype)
-        self.o_proj = ops.Linear(config.hidden_size, config.hidden_size, bias=False, device=device, dtype=dtype)
+        self.o_proj = ops.Linear(self.inner_size, config.hidden_size, bias=False, device=device, dtype=dtype)
 
     def forward(
         self,
@@ -84,7 +111,6 @@ class Attention(nn.Module):
         optimized_attention=None,
     ):
         batch_size, seq_length, _ = hidden_states.shape
-
         xq = self.q_proj(hidden_states)
         xk = self.k_proj(hidden_states)
         xv = self.v_proj(hidden_states)
@@ -108,9 +134,13 @@ class MLP(nn.Module):
         self.gate_proj = ops.Linear(config.hidden_size, config.intermediate_size, bias=False, device=device, dtype=dtype)
         self.up_proj = ops.Linear(config.hidden_size, config.intermediate_size, bias=False, device=device, dtype=dtype)
         self.down_proj = ops.Linear(config.intermediate_size, config.hidden_size, bias=False, device=device, dtype=dtype)
+        if config.mlp_activation == "silu":
+            self.activation = torch.nn.functional.silu
+        elif config.mlp_activation == "gelu_pytorch_tanh":
+            self.activation = lambda a: torch.nn.functional.gelu(a, approximate="tanh")
 
     def forward(self, x):
-        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+        return self.down_proj(self.activation(self.gate_proj(x)) * self.up_proj(x))
 
 class TransformerBlock(nn.Module):
     def __init__(self, config: Llama2Config, device=None, dtype=None, ops: Any = None):
@@ -146,6 +176,45 @@ class TransformerBlock(nn.Module):
 
         return x
 
+class TransformerBlockGemma2(nn.Module):
+    def __init__(self, config: Llama2Config, device=None, dtype=None, ops: Any = None):
+        super().__init__()
+        self.self_attn = Attention(config, device=device, dtype=dtype, ops=ops)
+        self.mlp = MLP(config, device=device, dtype=dtype, ops=ops)
+        self.input_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, add=config.rms_norm_add, device=device, dtype=dtype)
+        self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, add=config.rms_norm_add, device=device, dtype=dtype)
+        self.pre_feedforward_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, add=config.rms_norm_add, device=device, dtype=dtype)
+        self.post_feedforward_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, add=config.rms_norm_add, device=device, dtype=dtype)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        freqs_cis: Optional[torch.Tensor] = None,
+        optimized_attention=None,
+    ):
+        # Self Attention
+        residual = x
+        x = self.input_layernorm(x)
+        x = self.self_attn(
+            hidden_states=x,
+            attention_mask=attention_mask,
+            freqs_cis=freqs_cis,
+            optimized_attention=optimized_attention,
+        )
+
+        x = self.post_attention_layernorm(x)
+        x = residual + x
+
+        # MLP
+        residual = x
+        x = self.pre_feedforward_layernorm(x)
+        x = self.mlp(x)
+        x = self.post_feedforward_layernorm(x)
+        x = residual + x
+
+        return x
+
 class Llama2_(nn.Module):
     def __init__(self, config, device=None, dtype=None, ops=None):
         super().__init__()
@@ -158,17 +227,27 @@ class Llama2_(nn.Module):
             device=device,
             dtype=dtype
         )
+        if self.config.transformer_type == "gemma2":
+            transformer = TransformerBlockGemma2
+            self.normalize_in = True
+        else:
+            transformer = TransformerBlock
+            self.normalize_in = False
+
         self.layers = nn.ModuleList([
-            TransformerBlock(config, device=device, dtype=dtype, ops=ops)
+            transformer(config, device=device, dtype=dtype, ops=ops)
             for _ in range(config.num_hidden_layers)
         ])
-        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, device=device, dtype=dtype)
+        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, add=config.rms_norm_add, device=device, dtype=dtype)
         # self.lm_head = ops.Linear(config.hidden_size, config.vocab_size, bias=False, device=device, dtype=dtype)
 
     def forward(self, x, attention_mask=None, intermediate_output=None, final_layer_norm_intermediate=True, dtype=None):
         x = self.embed_tokens(x, out_dtype=dtype)
 
-        freqs_cis = precompute_freqs_cis(self.config.hidden_size // self.config.num_attention_heads,
+        if self.normalize_in:
+            x *= self.config.hidden_size ** 0.5
+
+        freqs_cis = precompute_freqs_cis(self.config.head_dim,
                                          x.shape[1],
                                          self.config.rope_theta,
                                          device=x.device)
@@ -206,16 +285,7 @@ class Llama2_(nn.Module):
 
         return x, intermediate
 
-
-class Llama2(torch.nn.Module):
-    def __init__(self, config_dict, dtype, device, operations):
-        super().__init__()
-        config = Llama2Config(**config_dict)
-        self.num_layers = config.num_hidden_layers
-
-        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
-        self.dtype = dtype
-
+class BaseLlama:
     def get_input_embeddings(self):
         return self.model.embed_tokens
 
@@ -224,3 +294,23 @@ class Llama2(torch.nn.Module):
 
     def forward(self, input_ids, *args, **kwargs):
         return self.model(input_ids, *args, **kwargs)
+
+
+class Llama2(BaseLlama, torch.nn.Module):
+    def __init__(self, config_dict, dtype, device, operations):
+        super().__init__()
+        config = Llama2Config(**config_dict)
+        self.num_layers = config.num_hidden_layers
+
+        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
+        self.dtype = dtype
+
+
+class Gemma2_2B(BaseLlama, torch.nn.Module):
+    def __init__(self, config_dict, dtype, device, operations):
+        super().__init__()
+        config = Gemma2_2B_Config(**config_dict)
+        self.num_layers = config.num_hidden_layers
+
+        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
+        self.dtype = dtype

comfy/text_encoders/lumina2.py

@@ -0,0 +1,44 @@
+from comfy import sd1_clip
+from .spiece_tokenizer import SPieceTokenizer
+import comfy.text_encoders.llama
+
+
+class Gemma2BTokenizer(sd1_clip.SDTokenizer):
+    def __init__(self, embedding_directory=None, tokenizer_data={}):
+        tokenizer = tokenizer_data.get("spiece_model", None)
+        super().__init__(tokenizer, pad_with_end=False, embedding_size=2304, embedding_key='gemma2_2b', tokenizer_class=SPieceTokenizer, has_end_token=False, pad_to_max_length=False, max_length=99999999, min_length=1, tokenizer_args={"add_bos": True, "add_eos": False})
+
+    def state_dict(self):
+        return {"spiece_model": self.tokenizer.serialize_model()}
+
+
+class LuminaTokenizer(sd1_clip.SD1Tokenizer):
+    def __init__(self, embedding_directory=None, tokenizer_data={}):
+        super().__init__(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data, name="gemma2_2b", tokenizer=Gemma2BTokenizer)
+
+
+class Gemma2_2BModel(sd1_clip.SDClipModel):
+    def __init__(self, device="cpu", layer="hidden", layer_idx=-2, dtype=None, attention_mask=True, model_options={}):
+        llama_scaled_fp8 = model_options.get("llama_scaled_fp8", None)
+        if llama_scaled_fp8 is not None:
+            model_options = model_options.copy()
+            model_options["scaled_fp8"] = llama_scaled_fp8
+
+        super().__init__(device=device, layer=layer, layer_idx=layer_idx, textmodel_json_config={}, dtype=dtype, special_tokens={"start": 2, "pad": 0}, layer_norm_hidden_state=False, model_class=comfy.text_encoders.llama.Gemma2_2B, enable_attention_masks=attention_mask, return_attention_masks=attention_mask, model_options=model_options)
+
+
+class LuminaModel(sd1_clip.SD1ClipModel):
+    def __init__(self, device="cpu", dtype=None, model_options={}):
+        super().__init__(device=device, dtype=dtype, name="gemma2_2b", clip_model=Gemma2_2BModel, model_options=model_options)
+
+
+def te(dtype_llama=None, llama_scaled_fp8=None):
+    class LuminaTEModel_(LuminaModel):
+        def __init__(self, device="cpu", dtype=None, model_options={}):
+            if llama_scaled_fp8 is not None and "llama_scaled_fp8" not in model_options:
+                model_options = model_options.copy()
+                model_options["llama_scaled_fp8"] = llama_scaled_fp8
+                if dtype_llama is not None:
+                    dtype = dtype_llama
+            super().__init__(device=device, dtype=dtype, model_options=model_options)
+    return LuminaTEModel_

comfy/text_encoders/spiece_tokenizer.py

@@ -1,21 +1,21 @@
 import torch
 
 class SPieceTokenizer:
-    add_eos = True
-
     @staticmethod
-    def from_pretrained(path):
-        return SPieceTokenizer(path)
+    def from_pretrained(path, **kwargs):
+        return SPieceTokenizer(path, **kwargs)
 
-    def __init__(self, tokenizer_path):
+    def __init__(self, tokenizer_path, add_bos=False, add_eos=True):
+        self.add_bos = add_bos
+        self.add_eos = add_eos
         import sentencepiece
         if torch.is_tensor(tokenizer_path):
             tokenizer_path = tokenizer_path.numpy().tobytes()
 
         if isinstance(tokenizer_path, bytes):
-            self.tokenizer = sentencepiece.SentencePieceProcessor(model_proto=tokenizer_path, add_eos=self.add_eos)
+            self.tokenizer = sentencepiece.SentencePieceProcessor(model_proto=tokenizer_path, add_bos=self.add_bos, add_eos=self.add_eos)
         else:
-            self.tokenizer = sentencepiece.SentencePieceProcessor(model_file=tokenizer_path, add_eos=self.add_eos)
+            self.tokenizer = sentencepiece.SentencePieceProcessor(model_file=tokenizer_path, add_bos=self.add_bos, add_eos=self.add_eos)
 
     def get_vocab(self):
         out = {}

comfy/text_encoders/t5.py

@@ -203,7 +203,7 @@ class T5Stack(torch.nn.Module):
         mask = None
         if attention_mask is not None:
             mask = 1.0 - attention_mask.to(x.dtype).reshape((attention_mask.shape[0], 1, -1, attention_mask.shape[-1])).expand(attention_mask.shape[0], 1, attention_mask.shape[-1], attention_mask.shape[-1])
-            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
+            mask = mask.masked_fill(mask.to(torch.bool), -torch.finfo(x.dtype).max)
 
         intermediate = None
         optimized_attention = optimized_attention_for_device(x.device, mask=attention_mask is not None, small_input=True)

comfy/utils.py

@@ -50,7 +50,16 @@ def load_torch_file(ckpt, safe_load=False, device=None):
     if device is None:
         device = torch.device("cpu")
     if ckpt.lower().endswith(".safetensors") or ckpt.lower().endswith(".sft"):
-        sd = safetensors.torch.load_file(ckpt, device=device.type)
+        try:
+            sd = safetensors.torch.load_file(ckpt, device=device.type)
+        except Exception as e:
+            if len(e.args) > 0:
+                message = e.args[0]
+                if "HeaderTooLarge" in message:
+                    raise ValueError("{}\n\nFile path: {}\n\nThe safetensors file is corrupt or invalid. Make sure this is actually a safetensors file and not a ckpt or pt or other filetype.".format(message, ckpt))
+                if "MetadataIncompleteBuffer" in message:
+                    raise ValueError("{}\n\nFile path: {}\n\nThe safetensors file is incomplete. Check the file size and make sure you have copied/downloaded it correctly.".format(message, ckpt))
+            raise e
     else:
         if safe_load or ALWAYS_SAFE_LOAD:
             pl_sd = torch.load(ckpt, map_location=device, weights_only=True)

comfy_extras/nodes_load_3d.py

@@ -20,7 +20,6 @@ class Load3D():
             "width": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "height": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "material": (["original", "normal", "wireframe", "depth"],),
-            "bg_color": ("STRING", {"default": "#000000", "multiline": False}),
             "light_intensity": ("INT", {"default": 10, "min": 1, "max": 20, "step": 1}),
             "up_direction": (["original", "-x", "+x", "-y", "+y", "-z", "+z"],),
             "fov": ("INT", {"default": 75, "min": 10, "max": 150, "step": 1}),
@@ -67,10 +66,8 @@ class Load3DAnimation():
             "width": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "height": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "material": (["original", "normal", "wireframe", "depth"],),
-            "bg_color": ("STRING", {"default": "#000000", "multiline": False}),
             "light_intensity": ("INT", {"default": 10, "min": 1, "max": 20, "step": 1}),
             "up_direction": (["original", "-x", "+x", "-y", "+y", "-z", "+z"],),
-            "animation_speed": (["0.1", "0.5", "1", "1.5", "2"], {"default": "1"}),
             "fov": ("INT", {"default": 75, "min": 10, "max": 150, "step": 1}),
         }}
 
@@ -104,7 +101,28 @@ class Preview3D():
         return {"required": {
             "model_file": ("STRING", {"default": "", "multiline": False}),
             "material": (["original", "normal", "wireframe", "depth"],),
-            "bg_color": ("STRING", {"default": "#000000", "multiline": False}),
+            "light_intensity": ("INT", {"default": 10, "min": 1, "max": 20, "step": 1}),
+            "up_direction": (["original", "-x", "+x", "-y", "+y", "-z", "+z"],),
+            "fov": ("INT", {"default": 75, "min": 10, "max": 150, "step": 1}),
+        }}
+
+    OUTPUT_NODE = True
+    RETURN_TYPES = ()
+
+    CATEGORY = "3d"
+
+    FUNCTION = "process"
+    EXPERIMENTAL = True
+
+    def process(self, model_file, **kwargs):
+        return {"ui": {"model_file": [model_file]}, "result": ()}
+
+class Preview3DAnimation():
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "model_file": ("STRING", {"default": "", "multiline": False}),
+            "material": (["original", "normal", "wireframe", "depth"],),
             "light_intensity": ("INT", {"default": 10, "min": 1, "max": 20, "step": 1}),
             "up_direction": (["original", "-x", "+x", "-y", "+y", "-z", "+z"],),
             "fov": ("INT", {"default": 75, "min": 10, "max": 150, "step": 1}),
@@ -124,11 +142,13 @@ class Preview3D():
 NODE_CLASS_MAPPINGS = {
     "Load3D": Load3D,
     "Load3DAnimation": Load3DAnimation,
-    "Preview3D": Preview3D
+    "Preview3D": Preview3D,
+    "Preview3DAnimation": Preview3DAnimation
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
     "Load3D": "Load 3D",
     "Load3DAnimation": "Load 3D - Animation",
-    "Preview3D": "Preview 3D"
+    "Preview3D": "Preview 3D",
+    "Preview3DAnimation": "Preview 3D - Animation"
 }

comfy_extras/nodes_model_merging_model_specific.py

@@ -196,6 +196,54 @@ class ModelMergeLTXV(comfy_extras.nodes_model_merging.ModelMergeBlocks):
 
         return {"required": arg_dict}
 
+class ModelMergeCosmos7B(comfy_extras.nodes_model_merging.ModelMergeBlocks):
+    CATEGORY = "advanced/model_merging/model_specific"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        arg_dict = { "model1": ("MODEL",),
+                              "model2": ("MODEL",)}
+
+        argument = ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01})
+
+        arg_dict["pos_embedder."] = argument
+        arg_dict["extra_pos_embedder."] = argument
+        arg_dict["x_embedder."] = argument
+        arg_dict["t_embedder."] = argument
+        arg_dict["affline_norm."] = argument
+
+
+        for i in range(28):
+            arg_dict["blocks.block{}.".format(i)] = argument
+
+        arg_dict["final_layer."] = argument
+
+        return {"required": arg_dict}
+
+class ModelMergeCosmos14B(comfy_extras.nodes_model_merging.ModelMergeBlocks):
+    CATEGORY = "advanced/model_merging/model_specific"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        arg_dict = { "model1": ("MODEL",),
+                              "model2": ("MODEL",)}
+
+        argument = ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01})
+
+        arg_dict["pos_embedder."] = argument
+        arg_dict["extra_pos_embedder."] = argument
+        arg_dict["x_embedder."] = argument
+        arg_dict["t_embedder."] = argument
+        arg_dict["affline_norm."] = argument
+
+
+        for i in range(36):
+            arg_dict["blocks.block{}.".format(i)] = argument
+
+        arg_dict["final_layer."] = argument
+
+        return {"required": arg_dict}
+
 NODE_CLASS_MAPPINGS = {
     "ModelMergeSD1": ModelMergeSD1,
     "ModelMergeSD2": ModelMergeSD1, #SD1 and SD2 have the same blocks
@@ -206,4 +254,6 @@ NODE_CLASS_MAPPINGS = {
     "ModelMergeSD35_Large": ModelMergeSD35_Large,
     "ModelMergeMochiPreview": ModelMergeMochiPreview,
     "ModelMergeLTXV": ModelMergeLTXV,
+    "ModelMergeCosmos7B": ModelMergeCosmos7B,
+    "ModelMergeCosmos14B": ModelMergeCosmos14B,
 }

comfyui_version.py

@@ -1,3 +1,3 @@
 # This file is automatically generated by the build process when version is
 # updated in pyproject.toml.
-__version__ = "0.3.12"
+__version__ = "0.3.14"

folder_paths.py

@@ -7,11 +7,18 @@ import logging
 from typing import Literal
 from collections.abc import Collection
 
-supported_pt_extensions: set[str] = {'.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl', '.sft'}
+from comfy.cli_args import args
+
+supported_pt_extensions: set[str] = {'.ckpt', '.pt', '.pt2', '.bin', '.pth', '.safetensors', '.pkl', '.sft'}
 
 folder_names_and_paths: dict[str, tuple[list[str], set[str]]] = {}
 
-base_path = os.path.dirname(os.path.realpath(__file__))
+# --base-directory - Resets all default paths configured in folder_paths with a new base path
+if args.base_directory:
+    base_path = os.path.abspath(args.base_directory)
+else:
+    base_path = os.path.dirname(os.path.realpath(__file__))
+
 models_dir = os.path.join(base_path, "models")
 folder_names_and_paths["checkpoints"] = ([os.path.join(models_dir, "checkpoints")], supported_pt_extensions)
 folder_names_and_paths["configs"] = ([os.path.join(models_dir, "configs")], [".yaml"])
@@ -39,10 +46,10 @@ folder_names_and_paths["photomaker"] = ([os.path.join(models_dir, "photomaker")]
 
 folder_names_and_paths["classifiers"] = ([os.path.join(models_dir, "classifiers")], {""})
 
-output_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "output")
-temp_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "temp")
-input_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "input")
-user_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), "user")
+output_directory = os.path.join(base_path, "output")
+temp_directory = os.path.join(base_path, "temp")
+input_directory = os.path.join(base_path, "input")
+user_directory = os.path.join(base_path, "user")
 
 filename_list_cache: dict[str, tuple[list[str], dict[str, float], float]] = {}
 

latent_preview.py

@@ -12,7 +12,10 @@ MAX_PREVIEW_RESOLUTION = args.preview_size
 def preview_to_image(latent_image):
         latents_ubyte = (((latent_image + 1.0) / 2.0).clamp(0, 1)  # change scale from -1..1 to 0..1
                             .mul(0xFF)  # to 0..255
-                            ).to(device="cpu", dtype=torch.uint8, non_blocking=comfy.model_management.device_supports_non_blocking(latent_image.device))
+                            )
+        if comfy.model_management.directml_enabled:
+                latents_ubyte = latents_ubyte.to(dtype=torch.uint8)
+        latents_ubyte = latents_ubyte.to(device="cpu", dtype=torch.uint8, non_blocking=comfy.model_management.device_supports_non_blocking(latent_image.device))
 
         return Image.fromarray(latents_ubyte.numpy())
 

main.py

@@ -138,6 +138,8 @@ import server
 from server import BinaryEventTypes
 import nodes
 import comfy.model_management
+import comfyui_version
+
 
 def cuda_malloc_warning():
     device = comfy.model_management.get_torch_device()
@@ -292,6 +294,7 @@ def start_comfyui(asyncio_loop=None):
 
 if __name__ == "__main__":
     # Running directly, just start ComfyUI.
+    logging.info("ComfyUI version: {}".format(comfyui_version.__version__))
     event_loop, _, start_all_func = start_comfyui()
     try:
         event_loop.run_until_complete(start_all_func())

nodes.py

@@ -63,6 +63,8 @@ class CLIPTextEncode(ComfyNodeABC):
     DESCRIPTION = "Encodes a text prompt using a CLIP model into an embedding that can be used to guide the diffusion model towards generating specific images."
 
     def encode(self, clip, text):
+        if clip is None:
+            raise RuntimeError("ERROR: clip input is invalid: None\n\nIf the clip is from a checkpoint loader node your checkpoint does not contain a valid clip or text encoder model.")
         tokens = clip.tokenize(text)
         return (clip.encode_from_tokens_scheduled(tokens), )
 
@@ -912,7 +914,7 @@ class CLIPLoader:
     @classmethod
     def INPUT_TYPES(s):
         return {"required": { "clip_name": (folder_paths.get_filename_list("text_encoders"), ),
-                              "type": (["stable_diffusion", "stable_cascade", "sd3", "stable_audio", "mochi", "ltxv", "pixart", "cosmos"], ),
+                              "type": (["stable_diffusion", "stable_cascade", "sd3", "stable_audio", "mochi", "ltxv", "pixart", "cosmos", "lumina2"], ),
                               },
                 "optional": {
                               "device": (["default", "cpu"], {"advanced": True}),
@@ -939,6 +941,8 @@ class CLIPLoader:
             clip_type = comfy.sd.CLIPType.PIXART
         elif type == "cosmos":
             clip_type = comfy.sd.CLIPType.COSMOS
+        elif type == "lumina2":
+            clip_type = comfy.sd.CLIPType.LUMINA2
         else:
             clip_type = comfy.sd.CLIPType.STABLE_DIFFUSION
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ComfyUI"
-version = "0.3.12"
+version = "0.3.14"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"

server.py

@@ -52,6 +52,22 @@ async def cache_control(request: web.Request, handler):
         response.headers.setdefault('Cache-Control', 'no-cache')
     return response
 
+
+@web.middleware
+async def compress_body(request: web.Request, handler):
+    accept_encoding = request.headers.get("Accept-Encoding", "")
+    response: web.Response = await handler(request)
+    if args.disable_compres_response_body:
+        return response
+    if not isinstance(response, web.Response):
+        return response
+    if response.content_type not in ["application/json", "text/plain"]:
+        return response
+    if response.body and "gzip" in accept_encoding:
+        response.enable_compression()
+    return response
+
+
 def create_cors_middleware(allowed_origin: str):
     @web.middleware
     async def cors_middleware(request: web.Request, handler):
@@ -149,7 +165,7 @@ class PromptServer():
         self.client_session:Optional[aiohttp.ClientSession] = None
         self.number = 0
 
-        middlewares = [cache_control]
+        middlewares = [cache_control, compress_body]
         if args.enable_cors_header:
             middlewares.append(create_cors_middleware(args.enable_cors_header))
         else:

tests-unit/comfy_test/folder_path_test.py

@@ -1,19 +1,23 @@
 ### 🗻 This file is created through the spirit of Mount Fuji at its peak
 # TODO(yoland): clean up this after I get back down
+import sys
 import pytest
 import os
 import tempfile
 from unittest.mock import patch
+from importlib import reload
 
 import folder_paths
+import comfy.cli_args
+from comfy.options import enable_args_parsing
+enable_args_parsing()
+
 
 @pytest.fixture()
 def clear_folder_paths():
-    # Clear the global dictionary before each test to ensure isolation
-    original = folder_paths.folder_names_and_paths.copy()
-    folder_paths.folder_names_and_paths.clear()
+    # Reload the module after each test to ensure isolation
     yield
-    folder_paths.folder_names_and_paths = original
+    reload(folder_paths)
 
 @pytest.fixture
 def temp_dir():
@@ -21,7 +25,21 @@ def temp_dir():
         yield tmpdirname
 
 
-def test_get_directory_by_type():
+@pytest.fixture
+def set_base_dir():
+    def _set_base_dir(base_dir):
+        # Mock CLI args
+        with patch.object(sys, 'argv', ["main.py", "--base-directory", base_dir]):
+            reload(comfy.cli_args)
+            reload(folder_paths)
+    yield _set_base_dir
+    # Reload the modules after each test to ensure isolation
+    with patch.object(sys, 'argv', ["main.py"]):
+        reload(comfy.cli_args)
+        reload(folder_paths)
+
+
+def test_get_directory_by_type(clear_folder_paths):
     test_dir = "/test/dir"
     folder_paths.set_output_directory(test_dir)
     assert folder_paths.get_directory_by_type("output") == test_dir
@@ -96,3 +114,49 @@ def test_get_save_image_path(temp_dir):
         assert counter == 1
         assert subfolder == ""
         assert filename_prefix == "test"
+
+
+def test_base_path_changes(set_base_dir):
+    test_dir = os.path.abspath("/test/dir")
+    set_base_dir(test_dir)
+
+    assert folder_paths.base_path == test_dir
+    assert folder_paths.models_dir == os.path.join(test_dir, "models")
+    assert folder_paths.input_directory == os.path.join(test_dir, "input")
+    assert folder_paths.output_directory == os.path.join(test_dir, "output")
+    assert folder_paths.temp_directory == os.path.join(test_dir, "temp")
+    assert folder_paths.user_directory == os.path.join(test_dir, "user")
+
+    assert os.path.join(test_dir, "custom_nodes") in folder_paths.get_folder_paths("custom_nodes")
+
+    for name in ["checkpoints", "loras", "vae", "configs", "embeddings", "controlnet", "classifiers"]:
+        assert folder_paths.get_folder_paths(name)[0] == os.path.join(test_dir, "models", name)
+
+
+def test_base_path_change_clears_old(set_base_dir):
+    test_dir = os.path.abspath("/test/dir")
+    set_base_dir(test_dir)
+
+    assert len(folder_paths.get_folder_paths("custom_nodes")) == 1
+
+    single_model_paths = [
+        "checkpoints",
+        "loras",
+        "vae",
+        "configs",
+        "clip_vision",
+        "style_models",
+        "diffusers",
+        "vae_approx",
+        "gligen",
+        "upscale_models",
+        "embeddings",
+        "hypernetworks",
+        "photomaker",
+        "classifiers",
+    ]
+    for name in single_model_paths:
+        assert len(folder_paths.get_folder_paths(name)) == 1
+
+    for name in ["controlnet", "diffusion_models", "text_encoders"]:
+        assert len(folder_paths.get_folder_paths(name)) == 2

web/assets/BaseViewTemplate-v6omkdXg.js

@@ -1,4 +1,4 @@
-import { d as defineComponent, ad as ref, t as onMounted, bT as isElectron, bV as electronAPI, af as nextTick, o as openBlock, f as createElementBlock, i as withDirectives, v as vShow, m as createBaseVNode, M as renderSlot, V as normalizeClass } from "./index-QvfM__ze.js";
+import { d as defineComponent, U as ref, p as onMounted, b4 as isElectron, W as nextTick, b5 as electronAPI, o as openBlock, f as createElementBlock, i as withDirectives, v as vShow, j as unref, b6 as isNativeWindow, m as createBaseVNode, A as renderSlot, ai as normalizeClass } from "./index-4Hb32CNk.js";
 const _hoisted_1 = { class: "flex-grow w-full flex items-center justify-center overflow-auto" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "BaseViewTemplate",
@@ -16,11 +16,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       symbolColor: "#171717"
     };
     const topMenuRef = ref(null);
-    const isNativeWindow = ref(false);
     onMounted(async () => {
       if (isElectron()) {
-        const windowStyle = await electronAPI().Config.getWindowStyle();
-        isNativeWindow.value = windowStyle === "custom";
         await nextTick();
         electronAPI().changeTheme({
           ...props.dark ? darkTheme : lightTheme,
@@ -39,7 +36,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           ref: topMenuRef,
           class: "app-drag w-full h-[var(--comfy-topbar-height)]"
         }, null, 512), [
-          [vShow, isNativeWindow.value]
+          [vShow, unref(isNativeWindow)()]
         ]),
         createBaseVNode("div", _hoisted_1, [
           renderSlot(_ctx.$slots, "default")
@@ -51,4 +48,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as _
 };
-//# sourceMappingURL=BaseViewTemplate-BhQMaVFP.js.map
+//# sourceMappingURL=BaseViewTemplate-v6omkdXg.js.map

web/assets/DesktopStartView-coDnSXEF.js

@@ -1,5 +1,5 @@
-import { d as defineComponent, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, k as createVNode, j as unref, ch as script } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
+import { d as defineComponent, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, k as createVNode, j as unref, bz as script } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = { class: "max-w-screen-sm w-screen p-8" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "DesktopStartView",
@@ -19,4 +19,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=DesktopStartView-le6AjGZr.js.map
+//# sourceMappingURL=DesktopStartView-coDnSXEF.js.map

web/assets/DownloadGitView-3STu4yxt.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, k as createVNode, j as unref, l as script, c2 as useRouter } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
+import { d as defineComponent, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, k as createVNode, j as unref, l as script, be as useRouter } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = { class: "max-w-screen-sm flex flex-col gap-8 p-8 bg-[url('/assets/images/Git-Logo-White.svg')] bg-no-repeat bg-right-top bg-origin-padding" };
 const _hoisted_2 = { class: "mt-24 text-4xl font-bold text-red-500" };
 const _hoisted_3 = { class: "space-y-4" };
@@ -55,4 +55,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=DownloadGitView-rPK_vYgU.js.map
+//# sourceMappingURL=DownloadGitView-3STu4yxt.js.map

web/assets/ExtensionPanel-GE0aOkbr.js

@@ -1,8 +1,8 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, ad as ref, cu as FilterMatchMode, cz as useExtensionStore, a as useSettingStore, t as onMounted, c as computed, o as openBlock, J as createBlock, P as withCtx, k as createVNode, cv as SearchBox, j as unref, c6 as script, m as createBaseVNode, f as createElementBlock, I as renderList, Z as toDisplayString, aG as createTextVNode, H as Fragment, l as script$1, L as createCommentVNode, aK as script$3, b8 as script$4, cc as script$5, cw as _sfc_main$1 } from "./index-QvfM__ze.js";
-import { s as script$2, a as script$6 } from "./index-DpF-ptbJ.js";
-import "./index-Q1cQr26V.js";
+import { d as defineComponent, U as ref, dl as FilterMatchMode, dr as useExtensionStore, a as useSettingStore, p as onMounted, c as computed, o as openBlock, y as createBlock, z as withCtx, k as createVNode, dm as SearchBox, j as unref, bj as script, m as createBaseVNode, f as createElementBlock, D as renderList, E as toDisplayString, a7 as createTextVNode, F as Fragment, l as script$1, B as createCommentVNode, a4 as script$3, ax as script$4, bn as script$5, dn as _sfc_main$1 } from "./index-4Hb32CNk.js";
+import { g as script$2, h as script$6 } from "./index-nJubvliG.js";
+import "./index-D6zf5KAf.js";
 const _hoisted_1 = { class: "flex justify-end" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "ExtensionPanel",
@@ -179,4 +179,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=ExtensionPanel-3jWrm6Zi.js.map
+//# sourceMappingURL=ExtensionPanel-GE0aOkbr.js.map

web/assets/GraphView-CVCdiww1.css

@@ -230,7 +230,7 @@
   border-bottom-left-radius: 0;
 }
 
-.comfyui-queue-button[data-v-e9044686] .p-splitbutton-dropdown {
+.comfyui-queue-button[data-v-91a628af] .p-splitbutton-dropdown {
   border-top-right-radius: 0;
   border-bottom-right-radius: 0;
 }
@@ -275,7 +275,7 @@
   border-style: solid;
 }
 
-.comfyui-menu[data-v-6e35440f] {
+.comfyui-menu[data-v-929e7543] {
   width: 100vw;
   height: var(--comfy-topbar-height);
   background: var(--comfy-menu-bg);
@@ -288,16 +288,16 @@
   order: 0;
   grid-column: 1/-1;
 }
-.comfyui-menu.dropzone[data-v-6e35440f] {
+.comfyui-menu.dropzone[data-v-929e7543] {
   background: var(--p-highlight-background);
 }
-.comfyui-menu.dropzone-active[data-v-6e35440f] {
+.comfyui-menu.dropzone-active[data-v-929e7543] {
   background: var(--p-highlight-background-focus);
 }
-[data-v-6e35440f] .p-menubar-item-label {
+[data-v-929e7543] .p-menubar-item-label {
   line-height: revert;
 }
-.comfyui-logo[data-v-6e35440f] {
+.comfyui-logo[data-v-929e7543] {
   font-size: 1.2em;
   -webkit-user-select: none;
      -moz-user-select: none;

web/assets/InstallView-DTDlVr0Z.js

@@ -0,0 +1,945 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { d as defineComponent, U as ref, bm as useModel, o as openBlock, f as createElementBlock, m as createBaseVNode, E as toDisplayString, k as createVNode, j as unref, bn as script, bh as script$1, ar as withModifiers, z as withCtx, ab as script$2, K as useI18n, c as computed, ai as normalizeClass, B as createCommentVNode, a4 as script$3, a7 as createTextVNode, b5 as electronAPI, _ as _export_sfc, p as onMounted, r as resolveDirective, bg as script$4, i as withDirectives, bo as script$5, bp as script$6, l as script$7, y as createBlock, bj as script$8, bq as MigrationItems, w as watchEffect, F as Fragment, D as renderList, br as script$9, bs as mergeModels, bt as ValidationState, Y as normalizeI18nKey, O as watch, bu as checkMirrorReachable, bv as _sfc_main$7, bw as mergeValidationStates, bc as t, a$ as script$a, bx as CUDA_TORCH_URL, by as NIGHTLY_CPU_TORCH_URL, be as useRouter, ag as toRaw } from "./index-4Hb32CNk.js";
+import { s as script$b, a as script$c, b as script$d, c as script$e, d as script$f } from "./index-hkkV7N7e.js";
+import { P as PYTHON_MIRROR, a as PYPI_MIRROR } from "./uvMirrors-B-HKMf6X.js";
+import { _ as _sfc_main$8 } from "./BaseViewTemplate-v6omkdXg.js";
+const _hoisted_1$5 = { class: "flex flex-col gap-6 w-[600px]" };
+const _hoisted_2$5 = { class: "flex flex-col gap-4" };
+const _hoisted_3$5 = { class: "text-2xl font-semibold text-neutral-100" };
+const _hoisted_4$5 = { class: "text-neutral-400 my-0" };
+const _hoisted_5$3 = { class: "flex flex-col bg-neutral-800 p-4 rounded-lg" };
+const _hoisted_6$3 = { class: "flex items-center gap-4" };
+const _hoisted_7$3 = { class: "flex-1" };
+const _hoisted_8$3 = { class: "text-lg font-medium text-neutral-100" };
+const _hoisted_9$3 = { class: "text-sm text-neutral-400 mt-1" };
+const _hoisted_10$3 = { class: "flex items-center gap-4" };
+const _hoisted_11$3 = { class: "flex-1" };
+const _hoisted_12$3 = { class: "text-lg font-medium text-neutral-100" };
+const _hoisted_13$1 = { class: "text-sm text-neutral-400 mt-1" };
+const _hoisted_14$1 = { class: "text-neutral-300" };
+const _hoisted_15 = { class: "font-medium mb-2" };
+const _hoisted_16 = { class: "list-disc pl-6 space-y-1" };
+const _hoisted_17 = { class: "font-medium mt-4 mb-2" };
+const _hoisted_18 = { class: "list-disc pl-6 space-y-1" };
+const _hoisted_19 = { class: "mt-4" };
+const _hoisted_20 = {
+  href: "https://comfy.org/privacy",
+  target: "_blank",
+  class: "text-blue-400 hover:text-blue-300 underline"
+};
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "DesktopSettingsConfiguration",
+  props: {
+    "autoUpdate": { type: Boolean, ...{ required: true } },
+    "autoUpdateModifiers": {},
+    "allowMetrics": { type: Boolean, ...{ required: true } },
+    "allowMetricsModifiers": {}
+  },
+  emits: ["update:autoUpdate", "update:allowMetrics"],
+  setup(__props) {
+    const showDialog = ref(false);
+    const autoUpdate = useModel(__props, "autoUpdate");
+    const allowMetrics = useModel(__props, "allowMetrics");
+    const showMetricsInfo = /* @__PURE__ */ __name(() => {
+      showDialog.value = true;
+    }, "showMetricsInfo");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$5, [
+        createBaseVNode("div", _hoisted_2$5, [
+          createBaseVNode("h2", _hoisted_3$5, toDisplayString(_ctx.$t("install.desktopAppSettings")), 1),
+          createBaseVNode("p", _hoisted_4$5, toDisplayString(_ctx.$t("install.desktopAppSettingsDescription")), 1)
+        ]),
+        createBaseVNode("div", _hoisted_5$3, [
+          createBaseVNode("div", _hoisted_6$3, [
+            createBaseVNode("div", _hoisted_7$3, [
+              createBaseVNode("h3", _hoisted_8$3, toDisplayString(_ctx.$t("install.settings.autoUpdate")), 1),
+              createBaseVNode("p", _hoisted_9$3, toDisplayString(_ctx.$t("install.settings.autoUpdateDescription")), 1)
+            ]),
+            createVNode(unref(script), {
+              modelValue: autoUpdate.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => autoUpdate.value = $event)
+            }, null, 8, ["modelValue"])
+          ]),
+          createVNode(unref(script$1)),
+          createBaseVNode("div", _hoisted_10$3, [
+            createBaseVNode("div", _hoisted_11$3, [
+              createBaseVNode("h3", _hoisted_12$3, toDisplayString(_ctx.$t("install.settings.allowMetrics")), 1),
+              createBaseVNode("p", _hoisted_13$1, toDisplayString(_ctx.$t("install.settings.allowMetricsDescription")), 1),
+              createBaseVNode("a", {
+                href: "#",
+                class: "text-sm text-blue-400 hover:text-blue-300 mt-1 inline-block",
+                onClick: withModifiers(showMetricsInfo, ["prevent"])
+              }, toDisplayString(_ctx.$t("install.settings.learnMoreAboutData")), 1)
+            ]),
+            createVNode(unref(script), {
+              modelValue: allowMetrics.value,
+              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => allowMetrics.value = $event)
+            }, null, 8, ["modelValue"])
+          ])
+        ]),
+        createVNode(unref(script$2), {
+          visible: showDialog.value,
+          "onUpdate:visible": _cache[2] || (_cache[2] = ($event) => showDialog.value = $event),
+          modal: "",
+          header: _ctx.$t("install.settings.dataCollectionDialog.title")
+        }, {
+          default: withCtx(() => [
+            createBaseVNode("div", _hoisted_14$1, [
+              createBaseVNode("h4", _hoisted_15, toDisplayString(_ctx.$t("install.settings.dataCollectionDialog.whatWeCollect")), 1),
+              createBaseVNode("ul", _hoisted_16, [
+                createBaseVNode("li", null, toDisplayString(_ctx.$t("install.settings.dataCollectionDialog.collect.errorReports")), 1),
+                createBaseVNode("li", null, toDisplayString(_ctx.$t("install.settings.dataCollectionDialog.collect.systemInfo")), 1),
+                createBaseVNode("li", null, toDisplayString(_ctx.$t(
+                  "install.settings.dataCollectionDialog.collect.userJourneyEvents"
+                )), 1)
+              ]),
+              createBaseVNode("h4", _hoisted_17, toDisplayString(_ctx.$t("install.settings.dataCollectionDialog.whatWeDoNotCollect")), 1),
+              createBaseVNode("ul", _hoisted_18, [
+                createBaseVNode("li", null, toDisplayString(_ctx.$t(
+                  "install.settings.dataCollectionDialog.doNotCollect.personalInformation"
+                )), 1),
+                createBaseVNode("li", null, toDisplayString(_ctx.$t(
+                  "install.settings.dataCollectionDialog.doNotCollect.workflowContents"
+                )), 1),
+                createBaseVNode("li", null, toDisplayString(_ctx.$t(
+                  "install.settings.dataCollectionDialog.doNotCollect.fileSystemInformation"
+                )), 1),
+                createBaseVNode("li", null, toDisplayString(_ctx.$t(
+                  "install.settings.dataCollectionDialog.doNotCollect.customNodeConfigurations"
+                )), 1)
+              ]),
+              createBaseVNode("div", _hoisted_19, [
+                createBaseVNode("a", _hoisted_20, toDisplayString(_ctx.$t("install.settings.dataCollectionDialog.viewFullPolicy")), 1)
+              ])
+            ])
+          ]),
+          _: 1
+        }, 8, ["visible", "header"])
+      ]);
+    };
+  }
+});
+const _imports_0 = "" + new URL("images/nvidia-logo.svg", import.meta.url).href;
+const _imports_1 = "" + new URL("images/apple-mps-logo.png", import.meta.url).href;
+const _imports_2 = "" + new URL("images/manual-configuration.svg", import.meta.url).href;
+const _hoisted_1$4 = { class: "flex flex-col gap-6 w-[600px] h-[30rem] select-none" };
+const _hoisted_2$4 = { class: "grow flex flex-col gap-4 text-neutral-300" };
+const _hoisted_3$4 = { class: "text-2xl font-semibold text-neutral-100" };
+const _hoisted_4$4 = { class: "m-1 text-neutral-400" };
+const _hoisted_5$2 = {
+  key: 0,
+  class: "m-1"
+};
+const _hoisted_6$2 = {
+  key: 1,
+  class: "m-1"
+};
+const _hoisted_7$2 = {
+  key: 2,
+  class: "text-neutral-300"
+};
+const _hoisted_8$2 = { class: "m-1" };
+const _hoisted_9$2 = { key: 3 };
+const _hoisted_10$2 = { class: "m-1" };
+const _hoisted_11$2 = { class: "m-1" };
+const _hoisted_12$2 = {
+  for: "cpu-mode",
+  class: "select-none"
+};
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "GpuPicker",
+  props: {
+    "device": {
+      required: true
+    },
+    "deviceModifiers": {}
+  },
+  emits: ["update:device"],
+  setup(__props) {
+    const { t: t2 } = useI18n();
+    const cpuMode = computed({
+      get: /* @__PURE__ */ __name(() => selected.value === "cpu", "get"),
+      set: /* @__PURE__ */ __name((value) => {
+        selected.value = value ? "cpu" : null;
+      }, "set")
+    });
+    const selected = useModel(__props, "device");
+    const electron = electronAPI();
+    const platform = electron.getPlatform();
+    const pickGpu = /* @__PURE__ */ __name((value) => {
+      const newValue = selected.value === value ? null : value;
+      selected.value = newValue;
+    }, "pickGpu");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$4, [
+        createBaseVNode("div", _hoisted_2$4, [
+          createBaseVNode("h2", _hoisted_3$4, toDisplayString(_ctx.$t("install.gpuSelection.selectGpu")), 1),
+          createBaseVNode("p", _hoisted_4$4, toDisplayString(_ctx.$t("install.gpuSelection.selectGpuDescription")) + ": ", 1),
+          createBaseVNode("div", {
+            class: normalizeClass(["flex gap-2 text-center transition-opacity", { selected: selected.value }])
+          }, [
+            unref(platform) !== "darwin" ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: normalizeClass(["gpu-button", { selected: selected.value === "nvidia" }]),
+              role: "button",
+              onClick: _cache[0] || (_cache[0] = ($event) => pickGpu("nvidia"))
+            }, _cache[4] || (_cache[4] = [
+              createBaseVNode("img", {
+                class: "m-12",
+                alt: "NVIDIA logo",
+                width: "196",
+                height: "32",
+                src: _imports_0
+              }, null, -1)
+            ]), 2)) : createCommentVNode("", true),
+            unref(platform) === "darwin" ? (openBlock(), createElementBlock("div", {
+              key: 1,
+              class: normalizeClass(["gpu-button", { selected: selected.value === "mps" }]),
+              role: "button",
+              onClick: _cache[1] || (_cache[1] = ($event) => pickGpu("mps"))
+            }, _cache[5] || (_cache[5] = [
+              createBaseVNode("img", {
+                class: "rounded-lg hover-brighten",
+                alt: "Apple Metal Performance Shaders Logo",
+                width: "292",
+                ratio: "",
+                src: _imports_1
+              }, null, -1)
+            ]), 2)) : createCommentVNode("", true),
+            createBaseVNode("div", {
+              class: normalizeClass(["gpu-button", { selected: selected.value === "unsupported" }]),
+              role: "button",
+              onClick: _cache[2] || (_cache[2] = ($event) => pickGpu("unsupported"))
+            }, _cache[6] || (_cache[6] = [
+              createBaseVNode("img", {
+                class: "m-12",
+                alt: "Manual configuration",
+                width: "196",
+                src: _imports_2
+              }, null, -1)
+            ]), 2)
+          ], 2),
+          selected.value === "nvidia" ? (openBlock(), createElementBlock("p", _hoisted_5$2, [
+            createVNode(unref(script$3), {
+              icon: "pi pi-check",
+              severity: "success",
+              value: "CUDA"
+            }),
+            createTextVNode(" " + toDisplayString(_ctx.$t("install.gpuSelection.nvidiaDescription")), 1)
+          ])) : createCommentVNode("", true),
+          selected.value === "mps" ? (openBlock(), createElementBlock("p", _hoisted_6$2, [
+            createVNode(unref(script$3), {
+              icon: "pi pi-check",
+              severity: "success",
+              value: "MPS"
+            }),
+            createTextVNode(" " + toDisplayString(_ctx.$t("install.gpuSelection.mpsDescription")), 1)
+          ])) : createCommentVNode("", true),
+          selected.value === "unsupported" ? (openBlock(), createElementBlock("div", _hoisted_7$2, [
+            createBaseVNode("p", _hoisted_8$2, [
+              createVNode(unref(script$3), {
+                icon: "pi pi-exclamation-triangle",
+                severity: "warn",
+                value: unref(t2)("icon.exclamation-triangle")
+              }, null, 8, ["value"]),
+              createTextVNode(" " + toDisplayString(_ctx.$t("install.gpuSelection.customSkipsPython")), 1)
+            ]),
+            createBaseVNode("ul", null, [
+              createBaseVNode("li", null, [
+                createBaseVNode("strong", null, toDisplayString(_ctx.$t("install.gpuSelection.customComfyNeedsPython")), 1)
+              ]),
+              createBaseVNode("li", null, toDisplayString(_ctx.$t("install.gpuSelection.customManualVenv")), 1),
+              createBaseVNode("li", null, toDisplayString(_ctx.$t("install.gpuSelection.customInstallRequirements")), 1),
+              createBaseVNode("li", null, toDisplayString(_ctx.$t("install.gpuSelection.customMayNotWork")), 1)
+            ])
+          ])) : createCommentVNode("", true),
+          selected.value === "cpu" ? (openBlock(), createElementBlock("div", _hoisted_9$2, [
+            createBaseVNode("p", _hoisted_10$2, [
+              createVNode(unref(script$3), {
+                icon: "pi pi-exclamation-triangle",
+                severity: "warn",
+                value: unref(t2)("icon.exclamation-triangle")
+              }, null, 8, ["value"]),
+              createTextVNode(" " + toDisplayString(_ctx.$t("install.gpuSelection.cpuModeDescription")), 1)
+            ]),
+            createBaseVNode("p", _hoisted_11$2, toDisplayString(_ctx.$t("install.gpuSelection.cpuModeDescription2")), 1)
+          ])) : createCommentVNode("", true)
+        ]),
+        createBaseVNode("div", {
+          class: normalizeClass(["transition-opacity flex gap-3 h-0", {
+            "opacity-40": selected.value && selected.value !== "cpu"
+          }])
+        }, [
+          createVNode(unref(script), {
+            modelValue: cpuMode.value,
+            "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => cpuMode.value = $event),
+            inputId: "cpu-mode",
+            class: "-translate-y-40"
+          }, null, 8, ["modelValue"]),
+          createBaseVNode("label", _hoisted_12$2, toDisplayString(_ctx.$t("install.gpuSelection.enableCpuMode")), 1)
+        ], 2)
+      ]);
+    };
+  }
+});
+const GpuPicker = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-79125ff6"]]);
+const _hoisted_1$3 = { class: "flex flex-col gap-6 w-[600px]" };
+const _hoisted_2$3 = { class: "flex flex-col gap-4" };
+const _hoisted_3$3 = { class: "text-2xl font-semibold text-neutral-100" };
+const _hoisted_4$3 = { class: "text-neutral-400 my-0" };
+const _hoisted_5$1 = { class: "flex gap-2" };
+const _hoisted_6$1 = { class: "bg-neutral-800 p-4 rounded-lg" };
+const _hoisted_7$1 = { class: "text-lg font-medium mt-0 mb-3 text-neutral-100" };
+const _hoisted_8$1 = { class: "flex flex-col gap-2" };
+const _hoisted_9$1 = { class: "flex items-center gap-2" };
+const _hoisted_10$1 = { class: "text-neutral-200" };
+const _hoisted_11$1 = { class: "pi pi-info-circle" };
+const _hoisted_12$1 = { class: "flex items-center gap-2" };
+const _hoisted_13 = { class: "text-neutral-200" };
+const _hoisted_14 = { class: "pi pi-info-circle" };
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "InstallLocationPicker",
+  props: {
+    "installPath": { required: true },
+    "installPathModifiers": {},
+    "pathError": { required: true },
+    "pathErrorModifiers": {}
+  },
+  emits: ["update:installPath", "update:pathError"],
+  setup(__props) {
+    const { t: t2 } = useI18n();
+    const installPath = useModel(__props, "installPath");
+    const pathError = useModel(__props, "pathError");
+    const pathExists = ref(false);
+    const appData = ref("");
+    const appPath = ref("");
+    const electron = electronAPI();
+    onMounted(async () => {
+      const paths = await electron.getSystemPaths();
+      appData.value = paths.appData;
+      appPath.value = paths.appPath;
+      installPath.value = paths.defaultInstallPath;
+      await validatePath(paths.defaultInstallPath);
+    });
+    const validatePath = /* @__PURE__ */ __name(async (path) => {
+      try {
+        pathError.value = "";
+        pathExists.value = false;
+        const validation = await electron.validateInstallPath(path);
+        if (!validation.isValid) {
+          const errors = [];
+          if (validation.cannotWrite) errors.push(t2("install.cannotWrite"));
+          if (validation.freeSpace < validation.requiredSpace) {
+            const requiredGB = validation.requiredSpace / 1024 / 1024 / 1024;
+            errors.push(`${t2("install.insufficientFreeSpace")}: ${requiredGB} GB`);
+          }
+          if (validation.parentMissing) errors.push(t2("install.parentMissing"));
+          if (validation.error)
+            errors.push(`${t2("install.unhandledError")}: ${validation.error}`);
+          pathError.value = errors.join("\n");
+        }
+        if (validation.exists) pathExists.value = true;
+      } catch (error) {
+        pathError.value = t2("install.pathValidationFailed");
+      }
+    }, "validatePath");
+    const browsePath = /* @__PURE__ */ __name(async () => {
+      try {
+        const result = await electron.showDirectoryPicker();
+        if (result) {
+          installPath.value = result;
+          await validatePath(result);
+        }
+      } catch (error) {
+        pathError.value = t2("install.failedToSelectDirectory");
+      }
+    }, "browsePath");
+    return (_ctx, _cache) => {
+      const _directive_tooltip = resolveDirective("tooltip");
+      return openBlock(), createElementBlock("div", _hoisted_1$3, [
+        createBaseVNode("div", _hoisted_2$3, [
+          createBaseVNode("h2", _hoisted_3$3, toDisplayString(_ctx.$t("install.chooseInstallationLocation")), 1),
+          createBaseVNode("p", _hoisted_4$3, toDisplayString(_ctx.$t("install.installLocationDescription")), 1),
+          createBaseVNode("div", _hoisted_5$1, [
+            createVNode(unref(script$6), { class: "flex-1" }, {
+              default: withCtx(() => [
+                createVNode(unref(script$4), {
+                  modelValue: installPath.value,
+                  "onUpdate:modelValue": [
+                    _cache[0] || (_cache[0] = ($event) => installPath.value = $event),
+                    validatePath
+                  ],
+                  class: normalizeClass(["w-full", { "p-invalid": pathError.value }])
+                }, null, 8, ["modelValue", "class"]),
+                withDirectives(createVNode(unref(script$5), { class: "pi pi-info-circle" }, null, 512), [
+                  [_directive_tooltip, _ctx.$t("install.installLocationTooltip")]
+                ])
+              ]),
+              _: 1
+            }),
+            createVNode(unref(script$7), {
+              icon: "pi pi-folder",
+              onClick: browsePath,
+              class: "w-12"
+            })
+          ]),
+          pathError.value ? (openBlock(), createBlock(unref(script$8), {
+            key: 0,
+            severity: "error",
+            class: "whitespace-pre-line"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(pathError.value), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true),
+          pathExists.value ? (openBlock(), createBlock(unref(script$8), {
+            key: 1,
+            severity: "warn"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.$t("install.pathExists")), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        createBaseVNode("div", _hoisted_6$1, [
+          createBaseVNode("h3", _hoisted_7$1, toDisplayString(_ctx.$t("install.systemLocations")), 1),
+          createBaseVNode("div", _hoisted_8$1, [
+            createBaseVNode("div", _hoisted_9$1, [
+              _cache[1] || (_cache[1] = createBaseVNode("i", { class: "pi pi-folder text-neutral-400" }, null, -1)),
+              _cache[2] || (_cache[2] = createBaseVNode("span", { class: "text-neutral-400" }, "App Data:", -1)),
+              createBaseVNode("span", _hoisted_10$1, toDisplayString(appData.value), 1),
+              withDirectives(createBaseVNode("span", _hoisted_11$1, null, 512), [
+                [_directive_tooltip, _ctx.$t("install.appDataLocationTooltip")]
+              ])
+            ]),
+            createBaseVNode("div", _hoisted_12$1, [
+              _cache[3] || (_cache[3] = createBaseVNode("i", { class: "pi pi-desktop text-neutral-400" }, null, -1)),
+              _cache[4] || (_cache[4] = createBaseVNode("span", { class: "text-neutral-400" }, "App Path:", -1)),
+              createBaseVNode("span", _hoisted_13, toDisplayString(appPath.value), 1),
+              withDirectives(createBaseVNode("span", _hoisted_14, null, 512), [
+                [_directive_tooltip, _ctx.$t("install.appPathLocationTooltip")]
+              ])
+            ])
+          ])
+        ])
+      ]);
+    };
+  }
+});
+const _hoisted_1$2 = { class: "flex flex-col gap-6 w-[600px]" };
+const _hoisted_2$2 = { class: "flex flex-col gap-4" };
+const _hoisted_3$2 = { class: "text-2xl font-semibold text-neutral-100" };
+const _hoisted_4$2 = { class: "text-neutral-400 my-0" };
+const _hoisted_5 = { class: "flex gap-2" };
+const _hoisted_6 = {
+  key: 0,
+  class: "flex flex-col gap-4 bg-neutral-800 p-4 rounded-lg"
+};
+const _hoisted_7 = { class: "text-lg mt-0 font-medium text-neutral-100" };
+const _hoisted_8 = { class: "flex flex-col gap-3" };
+const _hoisted_9 = ["onClick"];
+const _hoisted_10 = ["for"];
+const _hoisted_11 = { class: "text-sm text-neutral-400 my-1" };
+const _hoisted_12 = {
+  key: 1,
+  class: "text-neutral-400 italic"
+};
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "MigrationPicker",
+  props: {
+    "sourcePath": { required: false },
+    "sourcePathModifiers": {},
+    "migrationItemIds": {
+      required: false
+    },
+    "migrationItemIdsModifiers": {}
+  },
+  emits: ["update:sourcePath", "update:migrationItemIds"],
+  setup(__props) {
+    const { t: t2 } = useI18n();
+    const electron = electronAPI();
+    const sourcePath = useModel(__props, "sourcePath");
+    const migrationItemIds = useModel(__props, "migrationItemIds");
+    const migrationItems = ref(
+      MigrationItems.map((item) => ({
+        ...item,
+        selected: true
+      }))
+    );
+    const pathError = ref("");
+    const isValidSource = computed(
+      () => sourcePath.value !== "" && pathError.value === ""
+    );
+    const validateSource = /* @__PURE__ */ __name(async (sourcePath2) => {
+      if (!sourcePath2) {
+        pathError.value = "";
+        return;
+      }
+      try {
+        pathError.value = "";
+        const validation = await electron.validateComfyUISource(sourcePath2);
+        if (!validation.isValid) pathError.value = validation.error;
+      } catch (error) {
+        console.error(error);
+        pathError.value = t2("install.pathValidationFailed");
+      }
+    }, "validateSource");
+    const browsePath = /* @__PURE__ */ __name(async () => {
+      try {
+        const result = await electron.showDirectoryPicker();
+        if (result) {
+          sourcePath.value = result;
+          await validateSource(result);
+        }
+      } catch (error) {
+        console.error(error);
+        pathError.value = t2("install.failedToSelectDirectory");
+      }
+    }, "browsePath");
+    watchEffect(() => {
+      migrationItemIds.value = migrationItems.value.filter((item) => item.selected).map((item) => item.id);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$2, [
+        createBaseVNode("div", _hoisted_2$2, [
+          createBaseVNode("h2", _hoisted_3$2, toDisplayString(_ctx.$t("install.migrateFromExistingInstallation")), 1),
+          createBaseVNode("p", _hoisted_4$2, toDisplayString(_ctx.$t("install.migrationSourcePathDescription")), 1),
+          createBaseVNode("div", _hoisted_5, [
+            createVNode(unref(script$4), {
+              modelValue: sourcePath.value,
+              "onUpdate:modelValue": [
+                _cache[0] || (_cache[0] = ($event) => sourcePath.value = $event),
+                validateSource
+              ],
+              placeholder: "Select existing ComfyUI installation (optional)",
+              class: normalizeClass(["flex-1", { "p-invalid": pathError.value }])
+            }, null, 8, ["modelValue", "class"]),
+            createVNode(unref(script$7), {
+              icon: "pi pi-folder",
+              onClick: browsePath,
+              class: "w-12"
+            })
+          ]),
+          pathError.value ? (openBlock(), createBlock(unref(script$8), {
+            key: 0,
+            severity: "error"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(pathError.value), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        isValidSource.value ? (openBlock(), createElementBlock("div", _hoisted_6, [
+          createBaseVNode("h3", _hoisted_7, toDisplayString(_ctx.$t("install.selectItemsToMigrate")), 1),
+          createBaseVNode("div", _hoisted_8, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(migrationItems.value, (item) => {
+              return openBlock(), createElementBlock("div", {
+                key: item.id,
+                class: "flex items-center gap-3 p-2 hover:bg-neutral-700 rounded",
+                onClick: /* @__PURE__ */ __name(($event) => item.selected = !item.selected, "onClick")
+              }, [
+                createVNode(unref(script$9), {
+                  modelValue: item.selected,
+                  "onUpdate:modelValue": /* @__PURE__ */ __name(($event) => item.selected = $event, "onUpdate:modelValue"),
+                  inputId: item.id,
+                  binary: true,
+                  onClick: _cache[1] || (_cache[1] = withModifiers(() => {
+                  }, ["stop"]))
+                }, null, 8, ["modelValue", "onUpdate:modelValue", "inputId"]),
+                createBaseVNode("div", null, [
+                  createBaseVNode("label", {
+                    for: item.id,
+                    class: "text-neutral-200 font-medium"
+                  }, toDisplayString(item.label), 9, _hoisted_10),
+                  createBaseVNode("p", _hoisted_11, toDisplayString(item.description), 1)
+                ])
+              ], 8, _hoisted_9);
+            }), 128))
+          ])
+        ])) : (openBlock(), createElementBlock("div", _hoisted_12, toDisplayString(_ctx.$t("install.migrationOptional")), 1))
+      ]);
+    };
+  }
+});
+const _hoisted_1$1 = { class: "flex flex-col items-center gap-4" };
+const _hoisted_2$1 = { class: "w-full" };
+const _hoisted_3$1 = { class: "text-lg font-medium text-neutral-100" };
+const _hoisted_4$1 = { class: "text-sm text-neutral-400 mt-1" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "MirrorItem",
+  props: /* @__PURE__ */ mergeModels({
+    item: {}
+  }, {
+    "modelValue": { required: true },
+    "modelModifiers": {}
+  }),
+  emits: /* @__PURE__ */ mergeModels(["state-change"], ["update:modelValue"]),
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const modelValue = useModel(__props, "modelValue");
+    const validationState = ref(ValidationState.IDLE);
+    const normalizedSettingId = computed(() => {
+      return normalizeI18nKey(__props.item.settingId);
+    });
+    onMounted(() => {
+      modelValue.value = __props.item.mirror;
+    });
+    watch(validationState, (newState) => {
+      emit("state-change", newState);
+      if (newState === ValidationState.INVALID && modelValue.value === __props.item.mirror) {
+        modelValue.value = __props.item.fallbackMirror;
+      }
+    });
+    return (_ctx, _cache) => {
+      const _component_UrlInput = _sfc_main$7;
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        createBaseVNode("div", _hoisted_2$1, [
+          createBaseVNode("h3", _hoisted_3$1, toDisplayString(_ctx.$t(`settings.${normalizedSettingId.value}.name`)), 1),
+          createBaseVNode("p", _hoisted_4$1, toDisplayString(_ctx.$t(`settings.${normalizedSettingId.value}.tooltip`)), 1)
+        ]),
+        createVNode(_component_UrlInput, {
+          modelValue: modelValue.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event),
+          "validate-url-fn": /* @__PURE__ */ __name((mirror) => unref(checkMirrorReachable)(mirror + (_ctx.item.validationPathSuffix ?? "")), "validate-url-fn"),
+          onStateChange: _cache[1] || (_cache[1] = ($event) => validationState.value = $event)
+        }, null, 8, ["modelValue", "validate-url-fn"])
+      ]);
+    };
+  }
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "MirrorsConfiguration",
+  props: /* @__PURE__ */ mergeModels({
+    device: {}
+  }, {
+    "pythonMirror": { required: true },
+    "pythonMirrorModifiers": {},
+    "pypiMirror": { required: true },
+    "pypiMirrorModifiers": {},
+    "torchMirror": { required: true },
+    "torchMirrorModifiers": {}
+  }),
+  emits: ["update:pythonMirror", "update:pypiMirror", "update:torchMirror"],
+  setup(__props) {
+    const showMirrorInputs = ref(false);
+    const pythonMirror = useModel(__props, "pythonMirror");
+    const pypiMirror = useModel(__props, "pypiMirror");
+    const torchMirror = useModel(__props, "torchMirror");
+    const getTorchMirrorItem = /* @__PURE__ */ __name((device) => {
+      const settingId = "Comfy-Desktop.UV.TorchInstallMirror";
+      switch (device) {
+        case "mps":
+          return {
+            settingId,
+            mirror: NIGHTLY_CPU_TORCH_URL,
+            fallbackMirror: NIGHTLY_CPU_TORCH_URL
+          };
+        case "nvidia":
+          return {
+            settingId,
+            mirror: CUDA_TORCH_URL,
+            fallbackMirror: CUDA_TORCH_URL
+          };
+        case "cpu":
+        default:
+          return {
+            settingId,
+            mirror: PYPI_MIRROR.mirror,
+            fallbackMirror: PYPI_MIRROR.fallbackMirror
+          };
+      }
+    }, "getTorchMirrorItem");
+    const mirrors = computed(() => [
+      [PYTHON_MIRROR, pythonMirror],
+      [PYPI_MIRROR, pypiMirror],
+      [getTorchMirrorItem(__props.device), torchMirror]
+    ]);
+    const validationStates = ref(
+      mirrors.value.map(() => ValidationState.IDLE)
+    );
+    const validationState = computed(() => {
+      return mergeValidationStates(validationStates.value);
+    });
+    const validationStateTooltip = computed(() => {
+      switch (validationState.value) {
+        case ValidationState.INVALID:
+          return t("install.settings.mirrorsUnreachable");
+        case ValidationState.VALID:
+          return t("install.settings.mirrorsReachable");
+        default:
+          return t("install.settings.checkingMirrors");
+      }
+    });
+    return (_ctx, _cache) => {
+      const _directive_tooltip = resolveDirective("tooltip");
+      return openBlock(), createBlock(unref(script$a), {
+        header: _ctx.$t("install.settings.mirrorSettings"),
+        toggleable: "",
+        collapsed: !showMirrorInputs.value,
+        "pt:root": "bg-neutral-800 border-none w-[600px]"
+      }, {
+        icons: withCtx(() => [
+          withDirectives(createBaseVNode("i", {
+            class: normalizeClass({
+              "pi pi-spin pi-spinner text-neutral-400": validationState.value === unref(ValidationState).LOADING,
+              "pi pi-check text-green-500": validationState.value === unref(ValidationState).VALID,
+              "pi pi-times text-red-500": validationState.value === unref(ValidationState).INVALID
+            })
+          }, null, 2), [
+            [_directive_tooltip, validationStateTooltip.value]
+          ])
+        ]),
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(mirrors.value, ([item, modelValue], index) => {
+            return openBlock(), createElementBlock(Fragment, {
+              key: item.settingId + item.mirror
+            }, [
+              index > 0 ? (openBlock(), createBlock(unref(script$1), { key: 0 })) : createCommentVNode("", true),
+              createVNode(_sfc_main$2, {
+                item,
+                modelValue: modelValue.value,
+                "onUpdate:modelValue": /* @__PURE__ */ __name(($event) => modelValue.value = $event, "onUpdate:modelValue"),
+                onStateChange: /* @__PURE__ */ __name(($event) => validationStates.value[index] = $event, "onStateChange")
+              }, null, 8, ["item", "modelValue", "onUpdate:modelValue", "onStateChange"])
+            ], 64);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["header", "collapsed"]);
+    };
+  }
+});
+const _hoisted_1 = { class: "flex pt-6 justify-end" };
+const _hoisted_2 = { class: "flex pt-6 justify-between" };
+const _hoisted_3 = { class: "flex pt-6 justify-between" };
+const _hoisted_4 = { class: "flex mt-6 justify-between" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "InstallView",
+  setup(__props) {
+    const device = ref(null);
+    const installPath = ref("");
+    const pathError = ref("");
+    const migrationSourcePath = ref("");
+    const migrationItemIds = ref([]);
+    const autoUpdate = ref(true);
+    const allowMetrics = ref(true);
+    const pythonMirror = ref("");
+    const pypiMirror = ref("");
+    const torchMirror = ref("");
+    const highestStep = ref(0);
+    const handleStepChange = /* @__PURE__ */ __name((value) => {
+      setHighestStep(value);
+      electronAPI().Events.trackEvent("install_stepper_change", {
+        step: value
+      });
+    }, "handleStepChange");
+    const setHighestStep = /* @__PURE__ */ __name((value) => {
+      const int = typeof value === "number" ? value : parseInt(value, 10);
+      if (!isNaN(int) && int > highestStep.value) highestStep.value = int;
+    }, "setHighestStep");
+    const hasError = computed(() => pathError.value !== "");
+    const noGpu = computed(() => typeof device.value !== "string");
+    const electron = electronAPI();
+    const router = useRouter();
+    const install = /* @__PURE__ */ __name(() => {
+      const options = {
+        installPath: installPath.value,
+        autoUpdate: autoUpdate.value,
+        allowMetrics: allowMetrics.value,
+        migrationSourcePath: migrationSourcePath.value,
+        migrationItemIds: toRaw(migrationItemIds.value),
+        pythonMirror: pythonMirror.value,
+        pypiMirror: pypiMirror.value,
+        torchMirror: torchMirror.value,
+        device: device.value
+      };
+      electron.installComfyUI(options);
+      const nextPage = options.device === "unsupported" ? "/manual-configuration" : "/server-start";
+      router.push(nextPage);
+    }, "install");
+    onMounted(async () => {
+      if (!electron) return;
+      const detectedGpu = await electron.Config.getDetectedGpu();
+      if (detectedGpu === "mps" || detectedGpu === "nvidia") {
+        device.value = detectedGpu;
+      }
+      electronAPI().Events.trackEvent("install_stepper_change", {
+        step: "0",
+        gpu: detectedGpu
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$8, { dark: "" }, {
+        default: withCtx(() => [
+          createVNode(unref(script$f), {
+            class: "h-full p-8 2xl:p-16",
+            value: "0",
+            "onUpdate:value": handleStepChange
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(script$b), { class: "select-none" }, {
+                default: withCtx(() => [
+                  createVNode(unref(script$c), { value: "0" }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("install.gpu")), 1)
+                    ]),
+                    _: 1
+                  }),
+                  createVNode(unref(script$c), {
+                    value: "1",
+                    disabled: noGpu.value
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("install.installLocation")), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["disabled"]),
+                  createVNode(unref(script$c), {
+                    value: "2",
+                    disabled: noGpu.value || hasError.value || highestStep.value < 1
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("install.migration")), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["disabled"]),
+                  createVNode(unref(script$c), {
+                    value: "3",
+                    disabled: noGpu.value || hasError.value || highestStep.value < 2
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(toDisplayString(_ctx.$t("install.desktopSettings")), 1)
+                    ]),
+                    _: 1
+                  }, 8, ["disabled"])
+                ]),
+                _: 1
+              }),
+              createVNode(unref(script$d), null, {
+                default: withCtx(() => [
+                  createVNode(unref(script$e), { value: "0" }, {
+                    default: withCtx(({ activateCallback }) => [
+                      createVNode(GpuPicker, {
+                        device: device.value,
+                        "onUpdate:device": _cache[0] || (_cache[0] = ($event) => device.value = $event)
+                      }, null, 8, ["device"]),
+                      createBaseVNode("div", _hoisted_1, [
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.next"),
+                          icon: "pi pi-arrow-right",
+                          iconPos: "right",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("1"), "onClick"),
+                          disabled: typeof device.value !== "string"
+                        }, null, 8, ["label", "onClick", "disabled"])
+                      ])
+                    ]),
+                    _: 1
+                  }),
+                  createVNode(unref(script$e), { value: "1" }, {
+                    default: withCtx(({ activateCallback }) => [
+                      createVNode(_sfc_main$4, {
+                        installPath: installPath.value,
+                        "onUpdate:installPath": _cache[1] || (_cache[1] = ($event) => installPath.value = $event),
+                        pathError: pathError.value,
+                        "onUpdate:pathError": _cache[2] || (_cache[2] = ($event) => pathError.value = $event)
+                      }, null, 8, ["installPath", "pathError"]),
+                      createBaseVNode("div", _hoisted_2, [
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.back"),
+                          severity: "secondary",
+                          icon: "pi pi-arrow-left",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("0"), "onClick")
+                        }, null, 8, ["label", "onClick"]),
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.next"),
+                          icon: "pi pi-arrow-right",
+                          iconPos: "right",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("2"), "onClick"),
+                          disabled: pathError.value !== ""
+                        }, null, 8, ["label", "onClick", "disabled"])
+                      ])
+                    ]),
+                    _: 1
+                  }),
+                  createVNode(unref(script$e), { value: "2" }, {
+                    default: withCtx(({ activateCallback }) => [
+                      createVNode(_sfc_main$3, {
+                        sourcePath: migrationSourcePath.value,
+                        "onUpdate:sourcePath": _cache[3] || (_cache[3] = ($event) => migrationSourcePath.value = $event),
+                        migrationItemIds: migrationItemIds.value,
+                        "onUpdate:migrationItemIds": _cache[4] || (_cache[4] = ($event) => migrationItemIds.value = $event)
+                      }, null, 8, ["sourcePath", "migrationItemIds"]),
+                      createBaseVNode("div", _hoisted_3, [
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.back"),
+                          severity: "secondary",
+                          icon: "pi pi-arrow-left",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("1"), "onClick")
+                        }, null, 8, ["label", "onClick"]),
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.next"),
+                          icon: "pi pi-arrow-right",
+                          iconPos: "right",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("3"), "onClick")
+                        }, null, 8, ["label", "onClick"])
+                      ])
+                    ]),
+                    _: 1
+                  }),
+                  createVNode(unref(script$e), { value: "3" }, {
+                    default: withCtx(({ activateCallback }) => [
+                      createVNode(_sfc_main$6, {
+                        autoUpdate: autoUpdate.value,
+                        "onUpdate:autoUpdate": _cache[5] || (_cache[5] = ($event) => autoUpdate.value = $event),
+                        allowMetrics: allowMetrics.value,
+                        "onUpdate:allowMetrics": _cache[6] || (_cache[6] = ($event) => allowMetrics.value = $event)
+                      }, null, 8, ["autoUpdate", "allowMetrics"]),
+                      createVNode(_sfc_main$1, {
+                        device: device.value,
+                        pythonMirror: pythonMirror.value,
+                        "onUpdate:pythonMirror": _cache[7] || (_cache[7] = ($event) => pythonMirror.value = $event),
+                        pypiMirror: pypiMirror.value,
+                        "onUpdate:pypiMirror": _cache[8] || (_cache[8] = ($event) => pypiMirror.value = $event),
+                        torchMirror: torchMirror.value,
+                        "onUpdate:torchMirror": _cache[9] || (_cache[9] = ($event) => torchMirror.value = $event),
+                        class: "mt-6"
+                      }, null, 8, ["device", "pythonMirror", "pypiMirror", "torchMirror"]),
+                      createBaseVNode("div", _hoisted_4, [
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.back"),
+                          severity: "secondary",
+                          icon: "pi pi-arrow-left",
+                          onClick: /* @__PURE__ */ __name(($event) => activateCallback("2"), "onClick")
+                        }, null, 8, ["label", "onClick"]),
+                        createVNode(unref(script$7), {
+                          label: _ctx.$t("g.install"),
+                          icon: "pi pi-check",
+                          iconPos: "right",
+                          disabled: hasError.value,
+                          onClick: _cache[10] || (_cache[10] = ($event) => install())
+                        }, null, 8, ["label", "disabled"])
+                      ])
+                    ]),
+                    _: 1
+                  })
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const InstallView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-cd6731d2"]]);
+export {
+  InstallView as default
+};
+//# sourceMappingURL=InstallView-DTDlVr0Z.js.map

web/assets/InstallView-DbJ2cGfL.css

@@ -2,11 +2,13 @@
 .p-tag[data-v-79125ff6] {
   --p-tag-gap: 0.5rem;
 }
-.hover-brighten[data-v-79125ff6] {
+.hover-brighten {
+&[data-v-79125ff6] {
   transition-property: color, background-color, border-color, text-decoration-color, fill, stroke;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
   transition-duration: 150ms;
   transition-property: filter, box-shadow;
+  }
 &[data-v-79125ff6]:hover {
     filter: brightness(107%) contrast(105%);
     box-shadow: 0 0 0.25rem #ffffff79;
@@ -20,7 +22,7 @@
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
   transition-duration: 150ms;
 }
-div.selected[data-v-79125ff6] {
+div.selected {
 .gpu-button[data-v-79125ff6]:not(.selected) {
     opacity: 0.5;
 }
@@ -46,7 +48,7 @@ div.selected[data-v-79125ff6] {
 .gpu-button[data-v-79125ff6]:hover {
   --tw-bg-opacity: 0.75;
 }
-.gpu-button[data-v-79125ff6] {
+.gpu-button {
 &.selected[data-v-79125ff6] {
     --tw-bg-opacity: 1;
     background-color: rgb(64 64 64 / var(--tw-bg-opacity));
@@ -74,6 +76,6 @@ div.selected[data-v-79125ff6] {
   text-align: center;
 }
 
-[data-v-0a97b0ae] .p-steppanel {
+[data-v-cd6731d2] .p-steppanel {
     background-color: transparent
 }

web/assets/KeybindingPanel-C0Nt6GXU.js

@@ -1,9 +1,9 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, c as computed, o as openBlock, f as createElementBlock, H as Fragment, I as renderList, k as createVNode, P as withCtx, aG as createTextVNode, Z as toDisplayString, j as unref, aK as script, L as createCommentVNode, ad as ref, cu as FilterMatchMode, a$ as useKeybindingStore, a4 as useCommandStore, a3 as useI18n, ah as normalizeI18nKey, w as watchEffect, bz as useToast, r as resolveDirective, J as createBlock, cv as SearchBox, m as createBaseVNode, l as script$2, ax as script$4, b3 as withModifiers, c6 as script$5, aP as script$6, i as withDirectives, cw as _sfc_main$2, p as pushScopeId, q as popScopeId, cx as KeyComboImpl, cy as KeybindingImpl, _ as _export_sfc } from "./index-QvfM__ze.js";
-import { s as script$1, a as script$3 } from "./index-DpF-ptbJ.js";
-import { u as useKeybindingService } from "./keybindingService-Cak1En5n.js";
-import "./index-Q1cQr26V.js";
+import { d as defineComponent, c as computed, o as openBlock, f as createElementBlock, F as Fragment, D as renderList, k as createVNode, z as withCtx, a7 as createTextVNode, E as toDisplayString, j as unref, a4 as script, B as createCommentVNode, U as ref, dl as FilterMatchMode, an as useKeybindingStore, L as useCommandStore, K as useI18n, Y as normalizeI18nKey, w as watchEffect, aR as useToast, r as resolveDirective, y as createBlock, dm as SearchBox, m as createBaseVNode, l as script$2, bg as script$4, ar as withModifiers, bj as script$5, ab as script$6, i as withDirectives, dn as _sfc_main$2, dp as KeyComboImpl, dq as KeybindingImpl, _ as _export_sfc } from "./index-4Hb32CNk.js";
+import { g as script$1, h as script$3 } from "./index-nJubvliG.js";
+import { u as useKeybindingService } from "./keybindingService-BTNdTpfl.js";
+import "./index-D6zf5KAf.js";
 const _hoisted_1$1 = {
   key: 0,
   class: "px-2"
@@ -36,7 +36,6 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-2554ab36"), n = n(), popScopeId(), n), "_withScopeId");
 const _hoisted_1 = { class: "actions invisible flex flex-row" };
 const _hoisted_2 = ["title"];
 const _hoisted_3 = { key: 1 };
@@ -247,7 +246,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   severity: "error"
                 }, {
                   default: withCtx(() => [
-                    createTextVNode(" Keybinding already exists on "),
+                    _cache[3] || (_cache[3] = createTextVNode(" Keybinding already exists on ")),
                     createVNode(unref(script), {
                       severity: "secondary",
                       value: existingKeybindingOnCombo.value.commandId
@@ -280,4 +279,4 @@ const KeybindingPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "d
 export {
   KeybindingPanel as default
 };
-//# sourceMappingURL=KeybindingPanel-D6O16W_1.js.map
+//# sourceMappingURL=KeybindingPanel-C0Nt6GXU.js.map

web/assets/MaintenanceView-Bj5_Vr6o.css

@@ -0,0 +1,87 @@
+
+.task-card-ok[data-v-c3bd7658] {
+
+  position: absolute;
+
+  right: -1rem;
+
+  bottom: -1rem;
+
+  grid-column: 1 / -1;
+
+  grid-row: 1 / -1;
+
+  --tw-text-opacity: 1;
+
+  color: rgb(150 206 76 / var(--tw-text-opacity));
+
+  opacity: 1;
+
+  transition-property: opacity;
+
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+
+  transition-duration: 150ms;
+
+  font-size: 4rem;
+  text-shadow: 0.25rem 0 0.5rem black;
+  z-index: 10;
+}
+.p-card {
+&[data-v-c3bd7658] {
+
+  transition-property: opacity;
+
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+
+  transition-duration: 150ms;
+
+  --p-card-background: var(--p-button-secondary-background);
+  opacity: 0.9;
+  }
+&.opacity-65[data-v-c3bd7658] {
+    opacity: 0.4;
+}
+&[data-v-c3bd7658]:hover {
+    opacity: 1;
+}
+}
+[data-v-c3bd7658] .p-card-header {
+  z-index: 0;
+}
+[data-v-c3bd7658] .p-card-body {
+  z-index: 1;
+  flex-grow: 1;
+  justify-content: space-between;
+}
+.task-div {
+> i[data-v-c3bd7658] {
+    pointer-events: none;
+}
+&:hover > i[data-v-c3bd7658] {
+    opacity: 0.2;
+}
+}
+
+[data-v-74b78f7d] .p-tag {
+  --p-tag-gap: 0.375rem;
+}
+.backspan[data-v-74b78f7d]::before {
+  position: absolute;
+  margin: 0px;
+  color: var(--p-text-muted-color);
+  font-family: 'primeicons';
+  top: -2rem;
+  right: -2rem;
+  speak: none;
+  font-style: normal;
+  font-weight: normal;
+  font-variant: normal;
+  text-transform: none;
+  line-height: 1;
+  display: inline-block;
+  -webkit-font-smoothing: antialiased;
+  opacity: 0.02;
+  font-size: min(14rem, 90vw);
+  z-index: 0;
+}

web/assets/ManualConfigurationView-DueOvLuK.js

@@ -1,8 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, a3 as useI18n, ad as ref, t as onMounted, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, k as createVNode, j as unref, aK as script, bN as script$1, l as script$2, p as pushScopeId, q as popScopeId, bV as electronAPI, _ as _export_sfc } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
-const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-dc169863"), n = n(), popScopeId(), n), "_withScopeId");
+import { d as defineComponent, K as useI18n, U as ref, p as onMounted, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, k as createVNode, j as unref, a4 as script, a$ as script$1, l as script$2, b5 as electronAPI, _ as _export_sfc } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = { class: "comfy-installer grow flex flex-col gap-4 text-neutral-300 max-w-110" };
 const _hoisted_2 = { class: "text-2xl font-semibold text-neutral-100" };
 const _hoisted_3 = { class: "m-1 text-neutral-300" };
@@ -72,4 +71,4 @@ const ManualConfigurationView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scop
 export {
   ManualConfigurationView as default
 };
-//# sourceMappingURL=ManualConfigurationView-enyqGo0M.js.map
+//# sourceMappingURL=ManualConfigurationView-DueOvLuK.js.map

web/assets/MetricsConsentView-DTQYUF4Z.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
-import { d as defineComponent, bz as useToast, a3 as useI18n, ad as ref, c2 as useRouter, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, aG as createTextVNode, k as createVNode, j as unref, cc as script, l as script$1, bV as electronAPI } from "./index-QvfM__ze.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
+import { d as defineComponent, aR as useToast, K as useI18n, U as ref, be as useRouter, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, a7 as createTextVNode, k as createVNode, j as unref, bn as script, l as script$1, b5 as electronAPI } from "./index-4Hb32CNk.js";
 const _hoisted_1 = { class: "h-full p-8 2xl:p-16 flex flex-col items-center justify-center" };
 const _hoisted_2 = { class: "bg-neutral-800 rounded-lg shadow-lg p-6 w-full max-w-[600px] flex flex-col gap-6" };
 const _hoisted_3 = { class: "text-3xl font-semibold text-neutral-100" };
@@ -53,7 +53,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
               createBaseVNode("p", _hoisted_5, [
                 createTextVNode(toDisplayString(_ctx.$t("install.moreInfo")) + " ", 1),
                 createBaseVNode("a", _hoisted_6, toDisplayString(_ctx.$t("install.privacyPolicy")), 1),
-                createTextVNode(". ")
+                _cache[1] || (_cache[1] = createTextVNode(". "))
               ]),
               createBaseVNode("div", _hoisted_7, [
                 createVNode(unref(script), {
@@ -83,4 +83,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=MetricsConsentView-lSfLu4nr.js.map
+//# sourceMappingURL=MetricsConsentView-DTQYUF4Z.js.map

web/assets/NotSupportedView-PDDrAb9U.js

@@ -1,22 +1,16 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, c2 as useRouter, r as resolveDirective, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, k as createVNode, j as unref, l as script, i as withDirectives, p as pushScopeId, q as popScopeId, _ as _export_sfc } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
+import { d as defineComponent, be as useRouter, r as resolveDirective, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, k as createVNode, j as unref, l as script, i as withDirectives, _ as _export_sfc } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _imports_0 = "" + new URL("images/sad_girl.png", import.meta.url).href;
-const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-ebb20958"), n = n(), popScopeId(), n), "_withScopeId");
 const _hoisted_1 = { class: "sad-container" };
-const _hoisted_2 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createBaseVNode("img", {
-  class: "sad-girl",
-  src: _imports_0,
-  alt: "Sad girl illustration"
-}, null, -1));
-const _hoisted_3 = { class: "no-drag sad-text flex items-center" };
-const _hoisted_4 = { class: "flex flex-col gap-8 p-8 min-w-110" };
-const _hoisted_5 = { class: "text-4xl font-bold text-red-500" };
-const _hoisted_6 = { class: "space-y-4" };
-const _hoisted_7 = { class: "text-xl" };
-const _hoisted_8 = { class: "list-disc list-inside space-y-1 text-neutral-800" };
-const _hoisted_9 = { class: "flex gap-4" };
+const _hoisted_2 = { class: "no-drag sad-text flex items-center" };
+const _hoisted_3 = { class: "flex flex-col gap-8 p-8 min-w-110" };
+const _hoisted_4 = { class: "text-4xl font-bold text-red-500" };
+const _hoisted_5 = { class: "space-y-4" };
+const _hoisted_6 = { class: "text-xl" };
+const _hoisted_7 = { class: "list-disc list-inside space-y-1 text-neutral-800" };
+const _hoisted_8 = { class: "flex gap-4" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "NotSupportedView",
   setup(__props) {
@@ -38,18 +32,22 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       return openBlock(), createBlock(_sfc_main$1, null, {
         default: withCtx(() => [
           createBaseVNode("div", _hoisted_1, [
-            _hoisted_2,
-            createBaseVNode("div", _hoisted_3, [
-              createBaseVNode("div", _hoisted_4, [
-                createBaseVNode("h1", _hoisted_5, toDisplayString(_ctx.$t("notSupported.title")), 1),
-                createBaseVNode("div", _hoisted_6, [
-                  createBaseVNode("p", _hoisted_7, toDisplayString(_ctx.$t("notSupported.message")), 1),
-                  createBaseVNode("ul", _hoisted_8, [
+            _cache[0] || (_cache[0] = createBaseVNode("img", {
+              class: "sad-girl",
+              src: _imports_0,
+              alt: "Sad girl illustration"
+            }, null, -1)),
+            createBaseVNode("div", _hoisted_2, [
+              createBaseVNode("div", _hoisted_3, [
+                createBaseVNode("h1", _hoisted_4, toDisplayString(_ctx.$t("notSupported.title")), 1),
+                createBaseVNode("div", _hoisted_5, [
+                  createBaseVNode("p", _hoisted_6, toDisplayString(_ctx.$t("notSupported.message")), 1),
+                  createBaseVNode("ul", _hoisted_7, [
                     createBaseVNode("li", null, toDisplayString(_ctx.$t("notSupported.supportedDevices.macos")), 1),
                     createBaseVNode("li", null, toDisplayString(_ctx.$t("notSupported.supportedDevices.windows")), 1)
                   ])
                 ]),
-                createBaseVNode("div", _hoisted_9, [
+                createBaseVNode("div", _hoisted_8, [
                   createVNode(unref(script), {
                     label: _ctx.$t("notSupported.learnMore"),
                     icon: "pi pi-github",
@@ -85,4 +83,4 @@ const NotSupportedView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "
 export {
   NotSupportedView as default
 };
-//# sourceMappingURL=NotSupportedView-Vc8_xWgH.js.map
+//# sourceMappingURL=NotSupportedView-PDDrAb9U.js.map

web/assets/NotSupportedView-RFx6eCkN.css

@@ -1,9 +1,11 @@
 
-.sad-container[data-v-ebb20958] {
+.sad-container {
+&[data-v-ebb20958] {
   display: grid;
   align-items: center;
   justify-content: space-evenly;
   grid-template-columns: 25rem 1fr;
+}
 &[data-v-ebb20958] > * {
     grid-row: 1;
 }

web/assets/ServerConfigPanel-DnGhsuUV.js

@@ -1,25 +1,23 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { m as createBaseVNode, o as openBlock, f as createElementBlock, a0 as markRaw, d as defineComponent, a as useSettingStore, aS as storeToRefs, a7 as watch, cW as useCopyToClipboard, a3 as useI18n, J as createBlock, P as withCtx, j as unref, c6 as script, Z as toDisplayString, I as renderList, H as Fragment, k as createVNode, l as script$1, L as createCommentVNode, c4 as script$2, cX as FormItem, cw as _sfc_main$1, bV as electronAPI } from "./index-QvfM__ze.js";
-import { u as useServerConfigStore } from "./serverConfigStore-DCme3xlV.js";
+import { o as openBlock, f as createElementBlock, m as createBaseVNode, H as markRaw, d as defineComponent, a as useSettingStore, ae as storeToRefs, O as watch, dy as useCopyToClipboard, K as useI18n, y as createBlock, z as withCtx, j as unref, bj as script, E as toDisplayString, D as renderList, F as Fragment, k as createVNode, l as script$1, B as createCommentVNode, bh as script$2, dz as FormItem, dn as _sfc_main$1, b5 as electronAPI } from "./index-4Hb32CNk.js";
+import { u as useServerConfigStore } from "./serverConfigStore-BYbZcbWj.js";
 const _hoisted_1$1 = {
   viewBox: "0 0 24 24",
   width: "1.2em",
   height: "1.2em"
 };
-const _hoisted_2$1 = /* @__PURE__ */ createBaseVNode("path", {
-  fill: "none",
-  stroke: "currentColor",
-  "stroke-linecap": "round",
-  "stroke-linejoin": "round",
-  "stroke-width": "2",
-  d: "m4 17l6-6l-6-6m8 14h8"
-}, null, -1);
-const _hoisted_3$1 = [
-  _hoisted_2$1
-];
 function render(_ctx, _cache) {
-  return openBlock(), createElementBlock("svg", _hoisted_1$1, [..._hoisted_3$1]);
+  return openBlock(), createElementBlock("svg", _hoisted_1$1, _cache[0] || (_cache[0] = [
+    createBaseVNode("path", {
+      fill: "none",
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-linejoin": "round",
+      "stroke-width": "2",
+      d: "m4 17l6-6l-6-6m8 14h8"
+    }, null, -1)
+  ]));
 }
 __name(render, "render");
 const __unplugin_components_0 = markRaw({ name: "lucide-terminal", render });
@@ -155,4 +153,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=ServerConfigPanel-B-w0HFlz.js.map
+//# sourceMappingURL=ServerConfigPanel-DnGhsuUV.js.map

web/assets/ServerStartView-yzYZ8gms.js

@@ -1,8 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, a3 as useI18n, ad as ref, c7 as ProgressStatus, t as onMounted, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, aG as createTextVNode, Z as toDisplayString, j as unref, f as createElementBlock, L as createCommentVNode, k as createVNode, l as script, i as withDirectives, v as vShow, c8 as BaseTerminal, p as pushScopeId, q as popScopeId, bV as electronAPI, _ as _export_sfc } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
-const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-4140d62b"), n = n(), popScopeId(), n), "_withScopeId");
+import { d as defineComponent, K as useI18n, U as ref, bk as ProgressStatus, p as onMounted, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, a7 as createTextVNode, E as toDisplayString, j as unref, f as createElementBlock, B as createCommentVNode, k as createVNode, l as script, i as withDirectives, v as vShow, bl as BaseTerminal, b5 as electronAPI, _ as _export_sfc } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = { class: "flex flex-col w-full h-full items-center" };
 const _hoisted_2 = { class: "text-2xl font-bold" };
 const _hoisted_3 = { key: 0 };
@@ -98,4 +97,4 @@ const ServerStartView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "d
 export {
   ServerStartView as default
 };
-//# sourceMappingURL=ServerStartView-48wfE1MS.js.map
+//# sourceMappingURL=ServerStartView-yzYZ8gms.js.map

web/assets/UserSelectView-DeJDnrF0.js

@@ -1,18 +1,17 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, aX as useUserStore, c2 as useRouter, ad as ref, c as computed, t as onMounted, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, k as createVNode, c3 as withKeys, j as unref, ax as script, c4 as script$1, c5 as script$2, c6 as script$3, aG as createTextVNode, L as createCommentVNode, l as script$4 } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
+import { d as defineComponent, aj as useUserStore, be as useRouter, U as ref, c as computed, p as onMounted, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, k as createVNode, bf as withKeys, j as unref, bg as script, bh as script$1, bi as script$2, bj as script$3, a7 as createTextVNode, B as createCommentVNode, l as script$4 } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = {
   id: "comfy-user-selection",
   class: "min-w-84 relative rounded-lg bg-[var(--comfy-menu-bg)] p-5 px-10 shadow-lg"
 };
-const _hoisted_2 = /* @__PURE__ */ createBaseVNode("h1", { class: "my-2.5 mb-7 font-normal" }, "ComfyUI", -1);
-const _hoisted_3 = { class: "flex w-full flex-col items-center" };
-const _hoisted_4 = { class: "flex w-full flex-col gap-2" };
-const _hoisted_5 = { for: "new-user-input" };
-const _hoisted_6 = { class: "flex w-full flex-col gap-2" };
-const _hoisted_7 = { for: "existing-user-select" };
-const _hoisted_8 = { class: "mt-5" };
+const _hoisted_2 = { class: "flex w-full flex-col items-center" };
+const _hoisted_3 = { class: "flex w-full flex-col gap-2" };
+const _hoisted_4 = { for: "new-user-input" };
+const _hoisted_5 = { class: "flex w-full flex-col gap-2" };
+const _hoisted_6 = { for: "existing-user-select" };
+const _hoisted_7 = { class: "mt-5" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "UserSelectView",
   setup(__props) {
@@ -47,10 +46,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       return openBlock(), createBlock(_sfc_main$1, { dark: "" }, {
         default: withCtx(() => [
           createBaseVNode("main", _hoisted_1, [
-            _hoisted_2,
-            createBaseVNode("div", _hoisted_3, [
-              createBaseVNode("div", _hoisted_4, [
-                createBaseVNode("label", _hoisted_5, toDisplayString(_ctx.$t("userSelect.newUser")) + ":", 1),
+            _cache[2] || (_cache[2] = createBaseVNode("h1", { class: "my-2.5 mb-7 font-normal" }, "ComfyUI", -1)),
+            createBaseVNode("div", _hoisted_2, [
+              createBaseVNode("div", _hoisted_3, [
+                createBaseVNode("label", _hoisted_4, toDisplayString(_ctx.$t("userSelect.newUser")) + ":", 1),
                 createVNode(unref(script), {
                   id: "new-user-input",
                   modelValue: newUsername.value,
@@ -60,8 +59,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 }, null, 8, ["modelValue", "placeholder"])
               ]),
               createVNode(unref(script$1)),
-              createBaseVNode("div", _hoisted_6, [
-                createBaseVNode("label", _hoisted_7, toDisplayString(_ctx.$t("userSelect.existingUser")) + ":", 1),
+              createBaseVNode("div", _hoisted_5, [
+                createBaseVNode("label", _hoisted_6, toDisplayString(_ctx.$t("userSelect.existingUser")) + ":", 1),
                 createVNode(unref(script$2), {
                   modelValue: selectedUser.value,
                   "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => selectedUser.value = $event),
@@ -82,7 +81,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   _: 1
                 })) : createCommentVNode("", true)
               ]),
-              createBaseVNode("footer", _hoisted_8, [
+              createBaseVNode("footer", _hoisted_7, [
                 createVNode(unref(script$4), {
                   label: _ctx.$t("userSelect.next"),
                   onClick: login
@@ -99,4 +98,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=UserSelectView-CXmVKOeK.js.map
+//# sourceMappingURL=UserSelectView-DeJDnrF0.js.map

web/assets/WelcomeView-DkwLdayn.js

@@ -1,8 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { d as defineComponent, c2 as useRouter, o as openBlock, J as createBlock, P as withCtx, m as createBaseVNode, Z as toDisplayString, k as createVNode, j as unref, l as script, p as pushScopeId, q as popScopeId, _ as _export_sfc } from "./index-QvfM__ze.js";
-import { _ as _sfc_main$1 } from "./BaseViewTemplate-BhQMaVFP.js";
-const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-7dfaf74c"), n = n(), popScopeId(), n), "_withScopeId");
+import { d as defineComponent, be as useRouter, o as openBlock, y as createBlock, z as withCtx, m as createBaseVNode, E as toDisplayString, k as createVNode, j as unref, l as script, _ as _export_sfc } from "./index-4Hb32CNk.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-v6omkdXg.js";
 const _hoisted_1 = { class: "flex flex-col items-center justify-center gap-8 p-8" };
 const _hoisted_2 = { class: "animated-gradient-text text-glow select-none" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
@@ -37,4 +36,4 @@ const WelcomeView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-
 export {
   WelcomeView as default
 };
-//# sourceMappingURL=WelcomeView-C8whKl15.js.map
+//# sourceMappingURL=WelcomeView-DkwLdayn.js.map

web/assets/index-C1Hb_Yo9.css

@@ -2101,6 +2101,15 @@
   .inset-0{
     inset: 0px;
   }
+  .-bottom-4{
+    bottom: -1rem;
+  }
+  .-right-14{
+    right: -3.5rem;
+  }
+  .-right-4{
+    right: -1rem;
+  }
   .bottom-\[10px\]{
     bottom: 10px;
   }
@@ -2134,6 +2143,12 @@
   .z-\[9999\]{
     z-index: 9999;
   }
+  .col-span-full{
+    grid-column: 1 / -1;
+  }
+  .row-span-full{
+    grid-row: 1 / -1;
+  }
   .m-0{
     margin: 0px;
   }
@@ -2146,6 +2161,9 @@
   .m-2{
     margin: 0.5rem;
   }
+  .m-8{
+    margin: 2rem;
+  }
   .mx-1{
     margin-left: 0.25rem;
     margin-right: 0.25rem;
@@ -2226,6 +2244,9 @@
   .mt-5{
     margin-top: 1.25rem;
   }
+  .mt-6{
+    margin-top: 1.5rem;
+  }
   .block{
     display: block;
   }
@@ -2259,6 +2280,9 @@
   .h-1{
     height: 0.25rem;
   }
+  .h-1\/2{
+    height: 50%;
+  }
   .h-16{
     height: 4rem;
   }
@@ -2268,6 +2292,9 @@
   .h-64{
     height: 16rem;
   }
+  .h-8{
+    height: 2rem;
+  }
   .h-96{
     height: 26rem;
   }
@@ -2292,9 +2319,15 @@
   .max-h-full{
     max-height: 100%;
   }
+  .min-h-52{
+    min-height: 13rem;
+  }
   .min-h-8{
     min-height: 2rem;
   }
+  .min-h-full{
+    min-height: 100%;
+  }
   .min-h-screen{
     min-height: 100vh;
   }
@@ -2356,15 +2389,24 @@
   .min-w-110{
     min-width: 32rem;
   }
+  .min-w-32{
+    min-width: 8rem;
+  }
   .min-w-84{
     min-width: 22rem;
   }
   .min-w-96{
     min-width: 26rem;
   }
+  .min-w-full{
+    min-width: 100%;
+  }
   .max-w-110{
     max-width: 32rem;
   }
+  .max-w-48{
+    max-width: 12rem;
+  }
   .max-w-64{
     max-width: 16rem;
   }
@@ -2395,6 +2437,9 @@
   .grow{
     flex-grow: 1;
   }
+  .border-collapse{
+    border-collapse: collapse;
+  }
   .-translate-y-40{
     --tw-translate-y: -10rem;
     transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
@@ -2463,9 +2508,15 @@
   .justify-around{
     justify-content: space-around;
   }
+  .justify-evenly{
+    justify-content: space-evenly;
+  }
   .gap-0{
     gap: 0px;
   }
+  .gap-1{
+    gap: 0.25rem;
+  }
   .gap-2{
     gap: 0.5rem;
   }
@@ -2481,6 +2532,11 @@
   .gap-8{
     gap: 2rem;
   }
+  .space-x-1 > :not([hidden]) ~ :not([hidden]){
+    --tw-space-x-reverse: 0;
+    margin-right: calc(0.25rem * var(--tw-space-x-reverse));
+    margin-left: calc(0.25rem * calc(1 - var(--tw-space-x-reverse)));
+  }
   .space-y-1 > :not([hidden]) ~ :not([hidden]){
     --tw-space-y-reverse: 0;
     margin-top: calc(0.25rem * calc(1 - var(--tw-space-y-reverse)));
@@ -2528,9 +2584,6 @@
   .whitespace-pre-line{
     white-space: pre-line;
   }
-  .whitespace-pre-wrap{
-    white-space: pre-wrap;
-  }
   .text-wrap{
     text-wrap: wrap;
   }
@@ -2560,6 +2613,10 @@
     border-left-width: 0px;
     border-right-width: 0px;
   }
+  .border-y{
+    border-top-width: 1px;
+    border-bottom-width: 1px;
+  }
   .border-b{
     border-bottom-width: 1px;
   }
@@ -2575,9 +2632,16 @@
   .border-solid{
     border-style: solid;
   }
+  .border-hidden{
+    border-style: hidden;
+  }
   .border-none{
     border-style: none;
   }
+  .border-neutral-700{
+    --tw-border-opacity: 1;
+    border-color: rgb(64 64 64 / var(--tw-border-opacity));
+  }
   .bg-\[var\(--comfy-menu-bg\)\]{
     background-color: var(--comfy-menu-bg);
   }
@@ -2732,6 +2796,9 @@
   .text-center{
     text-align: center;
   }
+  .text-right{
+    text-align: right;
+  }
   .font-mono{
     font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
   }
@@ -2832,18 +2899,34 @@
   .no-underline{
     text-decoration-line: none;
   }
+  .antialiased{
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
   .opacity-0{
     opacity: 0;
   }
   .opacity-100{
     opacity: 1;
   }
+  .opacity-15{
+    opacity: 0.15;
+  }
+  .opacity-25{
+    opacity: 0.25;
+  }
   .opacity-40{
     opacity: 0.4;
   }
   .opacity-50{
     opacity: 0.5;
   }
+  .opacity-65{
+    opacity: 0.65;
+  }
+  .opacity-75{
+    opacity: 0.75;
+  }
   .shadow-lg{
     --tw-shadow: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
     --tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);
@@ -2891,6 +2974,9 @@
   .duration-100{
     transition-duration: 100ms;
   }
+  .duration-200{
+    transition-duration: 200ms;
+  }
   .duration-300{
     transition-duration: 300ms;
   }
@@ -3672,6 +3758,30 @@ audio.comfy-audio.empty-audio-widget {
   padding: var(--comfy-tree-explorer-item-padding) !important;
 }
 
+/* Load3d styles */
+.comfy-load-3d,
+.comfy-load-3d-animation,
+.comfy-preview-3d,
+.comfy-preview-3d-animation{
+  display: flex;
+  flex-direction: column;
+  background: transparent;
+  flex: 1;
+  position: relative;
+  overflow: hidden;
+}
+
+.comfy-load-3d canvas,
+.comfy-load-3d-animation canvas,
+.comfy-preview-3d canvas,
+.comfy-preview-3d-animation canvas{
+  display: flex;
+  width: 100% !important;
+  height: 100% !important;
+}
+
+/* End of Load3d styles */
+
 /* [Desktop] Electron window specific styles */
 .app-drag {
   app-region: drag;
@@ -3699,6 +3809,42 @@ audio.comfy-audio.empty-audio-widget {
 .hover\:opacity-100:hover{
   opacity: 1;
 }
+@media (prefers-reduced-motion: no-preference){
+
+  .motion-safe\:w-0{
+    width: 0px;
+  }
+
+  .motion-safe\:opacity-0{
+    opacity: 0;
+  }
+
+  .group\/sidebar-tab:focus-within .motion-safe\:group-focus-within\/sidebar-tab\:w-auto{
+    width: auto;
+  }
+
+  .group\/sidebar-tab:focus-within .motion-safe\:group-focus-within\/sidebar-tab\:opacity-100{
+    opacity: 1;
+  }
+
+  .group\/sidebar-tab:hover .motion-safe\:group-hover\/sidebar-tab\:w-auto{
+    width: auto;
+  }
+
+  .group\/sidebar-tab:hover .motion-safe\:group-hover\/sidebar-tab\:opacity-100{
+    opacity: 1;
+  }
+
+  .group\/tree-node:hover .motion-safe\:group-hover\/tree-node\:opacity-100{
+    opacity: 1;
+  }
+}
+@media not all and (min-width: 640px){
+
+  .max-sm\:hidden{
+    display: none;
+  }
+}
 @media (min-width: 768px){
 
   .md\:flex{
@@ -3798,17 +3944,17 @@ audio.comfy-audio.empty-audio-widget {
   margin-bottom: 1rem;
 }
 
-.comfy-error-report[data-v-09b72a20] {
+.comfy-error-report[data-v-3faf7785] {
   display: flex;
   flex-direction: column;
   gap: 1rem;
 }
-.action-container[data-v-09b72a20] {
+.action-container[data-v-3faf7785] {
   display: flex;
   gap: 1rem;
   justify-content: flex-end;
 }
-.wrapper-pre[data-v-09b72a20] {
+.wrapper-pre[data-v-3faf7785] {
   white-space: pre-wrap;
   word-wrap: break-word;
 }
@@ -3826,7 +3972,7 @@ audio.comfy-audio.empty-audio-widget {
   margin-left: auto;
 }
 
-.comfy-missing-models[data-v-ebf9fccc] {
+.comfy-missing-models[data-v-f8d63775] {
   max-height: 300px;
   overflow-y: auto;
 }
@@ -3868,22 +4014,22 @@ audio.comfy-audio.empty-audio-widget {
     background-color: rgb(234 179 8 / var(--tw-bg-opacity))
 }
 
-[data-v-ba13476b] .p-inputtext {
+[data-v-b3ab067d] .p-inputtext {
   --p-form-field-padding-x: 0.625rem;
 }
-.p-button.p-inputicon[data-v-ba13476b] {
+.p-button.p-inputicon[data-v-b3ab067d] {
   width: auto;
   border-style: none;
   padding: 0px;
 }
 
-.form-input[data-v-e4e3022d] .input-slider .p-inputnumber input,
-.form-input[data-v-e4e3022d] .input-slider .slider-part {
+.form-input[data-v-1451da7b] .input-slider .p-inputnumber input,
+.form-input[data-v-1451da7b] .input-slider .slider-part {
 
     width: 5rem
 }
-.form-input[data-v-e4e3022d] .p-inputtext,
-.form-input[data-v-e4e3022d] .p-select {
+.form-input[data-v-1451da7b] .p-inputtext,
+.form-input[data-v-1451da7b] .p-select {
 
     width: 11rem
 }
@@ -4504,28 +4650,28 @@ audio.comfy-audio.empty-audio-widget {
   box-sizing: border-box;
 }
 
-.tree-node[data-v-a6457774] {
+.tree-node[data-v-654109c7] {
   width: 100%;
   display: flex;
   align-items: center;
   justify-content: space-between;
 }
-.leaf-count-badge[data-v-a6457774] {
+.leaf-count-badge[data-v-654109c7] {
   margin-left: 0.5rem;
 }
-.node-content[data-v-a6457774] {
+.node-content[data-v-654109c7] {
   display: flex;
   align-items: center;
   flex-grow: 1;
 }
-.leaf-label[data-v-a6457774] {
+.leaf-label[data-v-654109c7] {
   margin-left: 0.5rem;
 }
-[data-v-a6457774] .editable-text span {
+[data-v-654109c7] .editable-text span {
   word-break: break-all;
 }
 
-[data-v-31d518da] .tree-explorer-node-label {
+[data-v-976a6d58] .tree-explorer-node-label {
   width: 100%;
   display: flex;
   align-items: center;
@@ -4538,10 +4684,10 @@ audio.comfy-audio.empty-audio-widget {
  * 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-31d518da] .p-tree-node-content:has(.tree-folder) {
+[data-v-976a6d58] .p-tree-node-content:has(.tree-folder) {
   position: relative;
 }
-[data-v-31d518da] .p-tree-node-content:has(.tree-folder.can-drop)::after {
+[data-v-976a6d58] .p-tree-node-content:has(.tree-folder.can-drop)::after {
   content: '';
   position: absolute;
   top: 0;
@@ -4552,21 +4698,21 @@ audio.comfy-audio.empty-audio-widget {
   pointer-events: none;
 }
 
-[data-v-5e759e25] .p-toolbar-end .p-button {
+[data-v-0061c432] .p-toolbar-end .p-button {
 
     padding-top: 0.25rem;
 
     padding-bottom: 0.25rem
 }
 @media (min-width: 1536px) {
-[data-v-5e759e25] .p-toolbar-end .p-button {
+[data-v-0061c432] .p-toolbar-end .p-button {
 
         padding-top: 0.5rem;
 
         padding-bottom: 0.5rem
 }
 }
-[data-v-5e759e25] .p-toolbar-start {
+[data-v-0061c432] .p-toolbar-start {
 
     min-width: 0px;
 
@@ -4649,31 +4795,6 @@ audio.comfy-audio.empty-audio-widget {
   width: 16px;
 }
 
-._content[data-v-c4279e6b] {
-
-    display: flex;
-
-    flex-direction: column
-}
-._content[data-v-c4279e6b] > :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-c4279e6b] {
-
-    display: flex;
-
-    flex-direction: column;
-
-    align-items: flex-end;
-
-    padding-top: 1rem
-}
-
 .slot_row[data-v-d9792337] {
   padding: 2px;
 }
@@ -4801,34 +4922,61 @@ audio.comfy-audio.empty-audio-widget {
   color: var(--error-text);
 }
 
+._content[data-v-c4279e6b] {
+
+    display: flex;
+
+    flex-direction: column
+}
+._content[data-v-c4279e6b] > :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-c4279e6b] {
+
+    display: flex;
+
+    flex-direction: column;
+
+    align-items: flex-end;
+
+    padding-top: 1rem
+}
+
 .node-lib-node-container[data-v-da9a8962] {
     height: 100%;
     width: 100%
 }
 
-.p-selectbutton .p-button[data-v-05364174] {
+.p-selectbutton .p-button[data-v-bd06e12b] {
   padding: 0.5rem;
 }
-.p-selectbutton .p-button .pi[data-v-05364174] {
+.p-selectbutton .p-button .pi[data-v-bd06e12b] {
   font-size: 1.5rem;
 }
-.field[data-v-05364174] {
+.field[data-v-bd06e12b] {
   display: flex;
   flex-direction: column;
   gap: 0.5rem;
 }
-.color-picker-container[data-v-05364174] {
+.color-picker-container[data-v-bd06e12b] {
   display: flex;
   align-items: center;
   gap: 0.5rem;
 }
 
-.scroll-container[data-v-ad33a347] {
+.scroll-container {
+&[data-v-ad33a347] {
   height: 100%;
   overflow-y: auto;
 
   /* Firefox */
   scrollbar-width: none;
+}
 &[data-v-ad33a347]::-webkit-scrollbar {
     width: 1px;
 }

web/assets/index-D6zf5KAf.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { bZ as script$1, o as openBlock, f as createElementBlock, as as mergeProps, m as createBaseVNode } from "./index-4Hb32CNk.js";
+var script = {
+  name: "BarsIcon",
+  "extends": script$1
+};
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", mergeProps({
+    width: "14",
+    height: "14",
+    viewBox: "0 0 14 14",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, _ctx.pti()), _cache[0] || (_cache[0] = [createBaseVNode("path", {
+    "fill-rule": "evenodd",
+    "clip-rule": "evenodd",
+    d: "M13.3226 3.6129H0.677419C0.497757 3.6129 0.325452 3.54152 0.198411 3.41448C0.0713707 3.28744 0 3.11514 0 2.93548C0 2.75581 0.0713707 2.58351 0.198411 2.45647C0.325452 2.32943 0.497757 2.25806 0.677419 2.25806H13.3226C13.5022 2.25806 13.6745 2.32943 13.8016 2.45647C13.9286 2.58351 14 2.75581 14 2.93548C14 3.11514 13.9286 3.28744 13.8016 3.41448C13.6745 3.54152 13.5022 3.6129 13.3226 3.6129ZM13.3226 7.67741H0.677419C0.497757 7.67741 0.325452 7.60604 0.198411 7.479C0.0713707 7.35196 0 7.17965 0 6.99999C0 6.82033 0.0713707 6.64802 0.198411 6.52098C0.325452 6.39394 0.497757 6.32257 0.677419 6.32257H13.3226C13.5022 6.32257 13.6745 6.39394 13.8016 6.52098C13.9286 6.64802 14 6.82033 14 6.99999C14 7.17965 13.9286 7.35196 13.8016 7.479C13.6745 7.60604 13.5022 7.67741 13.3226 7.67741ZM0.677419 11.7419H13.3226C13.5022 11.7419 13.6745 11.6706 13.8016 11.5435C13.9286 11.4165 14 11.2442 14 11.0645C14 10.8848 13.9286 10.7125 13.8016 10.5855C13.6745 10.4585 13.5022 10.3871 13.3226 10.3871H0.677419C0.497757 10.3871 0.325452 10.4585 0.198411 10.5855C0.0713707 10.7125 0 10.8848 0 11.0645C0 11.2442 0.0713707 11.4165 0.198411 11.5435C0.325452 11.6706 0.497757 11.7419 0.677419 11.7419Z",
+    fill: "currentColor"
+  }, null, -1)]), 16);
+}
+__name(render, "render");
+script.render = render;
+export {
+  script as s
+};
+//# sourceMappingURL=index-D6zf5KAf.js.map

web/assets/index-Q1cQr26V.js

@@ -1,29 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { cA as script$1, m as createBaseVNode, o as openBlock, f as createElementBlock, G as mergeProps } from "./index-QvfM__ze.js";
-var script = {
-  name: "BarsIcon",
-  "extends": script$1
-};
-var _hoisted_1 = /* @__PURE__ */ createBaseVNode("path", {
-  "fill-rule": "evenodd",
-  "clip-rule": "evenodd",
-  d: "M13.3226 3.6129H0.677419C0.497757 3.6129 0.325452 3.54152 0.198411 3.41448C0.0713707 3.28744 0 3.11514 0 2.93548C0 2.75581 0.0713707 2.58351 0.198411 2.45647C0.325452 2.32943 0.497757 2.25806 0.677419 2.25806H13.3226C13.5022 2.25806 13.6745 2.32943 13.8016 2.45647C13.9286 2.58351 14 2.75581 14 2.93548C14 3.11514 13.9286 3.28744 13.8016 3.41448C13.6745 3.54152 13.5022 3.6129 13.3226 3.6129ZM13.3226 7.67741H0.677419C0.497757 7.67741 0.325452 7.60604 0.198411 7.479C0.0713707 7.35196 0 7.17965 0 6.99999C0 6.82033 0.0713707 6.64802 0.198411 6.52098C0.325452 6.39394 0.497757 6.32257 0.677419 6.32257H13.3226C13.5022 6.32257 13.6745 6.39394 13.8016 6.52098C13.9286 6.64802 14 6.82033 14 6.99999C14 7.17965 13.9286 7.35196 13.8016 7.479C13.6745 7.60604 13.5022 7.67741 13.3226 7.67741ZM0.677419 11.7419H13.3226C13.5022 11.7419 13.6745 11.6706 13.8016 11.5435C13.9286 11.4165 14 11.2442 14 11.0645C14 10.8848 13.9286 10.7125 13.8016 10.5855C13.6745 10.4585 13.5022 10.3871 13.3226 10.3871H0.677419C0.497757 10.3871 0.325452 10.4585 0.198411 10.5855C0.0713707 10.7125 0 10.8848 0 11.0645C0 11.2442 0.0713707 11.4165 0.198411 11.5435C0.325452 11.6706 0.497757 11.7419 0.677419 11.7419Z",
-  fill: "currentColor"
-}, null, -1);
-var _hoisted_2 = [_hoisted_1];
-function render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("svg", mergeProps({
-    width: "14",
-    height: "14",
-    viewBox: "0 0 14 14",
-    fill: "none",
-    xmlns: "http://www.w3.org/2000/svg"
-  }, _ctx.pti()), _hoisted_2, 16);
-}
-__name(render, "render");
-script.render = render;
-export {
-  script as s
-};
-//# sourceMappingURL=index-Q1cQr26V.js.map

web/assets/keybindingService-BTNdTpfl.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { a$ as useKeybindingStore, a4 as useCommandStore, a as useSettingStore, cx as KeyComboImpl, cy as KeybindingImpl } from "./index-QvfM__ze.js";
+import { an as useKeybindingStore, L as useCommandStore, a as useSettingStore, dp as KeyComboImpl, dq as KeybindingImpl } from "./index-4Hb32CNk.js";
 const CORE_KEYBINDINGS = [
   {
     combo: {
@@ -247,4 +247,4 @@ const useKeybindingService = /* @__PURE__ */ __name(() => {
 export {
   useKeybindingService as u
 };
-//# sourceMappingURL=keybindingService-Cak1En5n.js.map
+//# sourceMappingURL=keybindingService-BTNdTpfl.js.map

web/assets/serverConfigStore-BYbZcbWj.js

@@ -1,6 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { a1 as defineStore, ad as ref, c as computed } from "./index-QvfM__ze.js";
+import { I as defineStore, U as ref, c as computed } from "./index-4Hb32CNk.js";
 const useServerConfigStore = defineStore("serverConfig", () => {
   const serverConfigById = ref({});
   const serverConfigs = computed(() => {
@@ -87,4 +87,4 @@ const useServerConfigStore = defineStore("serverConfig", () => {
 export {
   useServerConfigStore as u
 };
-//# sourceMappingURL=serverConfigStore-DCme3xlV.js.map
+//# sourceMappingURL=serverConfigStore-BYbZcbWj.js.map

web/assets/uvMirrors-B-HKMf6X.js

@@ -0,0 +1,16 @@
+const PYTHON_MIRROR = {
+  settingId: "Comfy-Desktop.UV.PythonInstallMirror",
+  mirror: "https://github.com/astral-sh/python-build-standalone/releases/download",
+  fallbackMirror: "https://bgithub.xyz/astral-sh/python-build-standalone/releases/download",
+  validationPathSuffix: "/20250115/cpython-3.10.16+20250115-aarch64-apple-darwin-debug-full.tar.zst.sha256"
+};
+const PYPI_MIRROR = {
+  settingId: "Comfy-Desktop.UV.PypiInstallMirror",
+  mirror: "https://pypi.org/simple/",
+  fallbackMirror: "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"
+};
+export {
+  PYTHON_MIRROR as P,
+  PYPI_MIRROR as a
+};
+//# sourceMappingURL=uvMirrors-B-HKMf6X.js.map

web/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
     <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-QvfM__ze.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-Cf-n7v0V.css">
+    <script type="module" crossorigin src="./assets/index-4Hb32CNk.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-C1Hb_Yo9.css">
   </head>
   <body class="litegraph grid">
     <div id="vue-app"></div>

web/templates/default.json

@@ -266,7 +266,7 @@
       ],
       "properties": {},
       "widgets_values": [
-        "v1-5-pruned-emaonly.safetensors"
+        "v1-5-pruned-emaonly-fp16.safetensors"
       ]
     }
   ],
@@ -349,8 +349,8 @@
   "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",
+    "name": "v1-5-pruned-emaonly-fp16.safetensors",
+    "url": "https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/resolve/main/v1-5-pruned-emaonly-fp16.safetensors?download=true",
     "directory": "checkpoints"
   }]
 }