Add tests for delete & update

.github/workflows/stable-release.yml

@@ -12,7 +12,7 @@ on:
         description: 'CUDA version'
         required: true
         type: string
-        default: "126"
+        default: "124"
       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", "3.13"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
@@ -28,4 +28,4 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install -r requirements.txt
+          pip install -r requirements.txt

.github/workflows/test-unit.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Set up Python      
       uses: actions/setup-python@v4
       with:
-        python-version: '3.12'
+        python-version: '3.10'
     - 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: "126"
+        default: "124"
 
       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: "126"
+        default: "124"
 
       python_minor:
         description: 'python minor version'

CODEOWNERS

@@ -15,7 +15,6 @@
 # Python web server
 /api_server/ @yoland68 @robinjhuang @huchenlei @webfiltered @pythongosssss @ltdrdata
 /app/ @yoland68 @robinjhuang @huchenlei @webfiltered @pythongosssss @ltdrdata
-/utils/ @yoland68 @robinjhuang @huchenlei @webfiltered @pythongosssss @ltdrdata
 
 # Frontend assets
 /web/ @huchenlei @webfiltered @pythongosssss @yoland68 @robinjhuang

README.md

@@ -47,13 +47,11 @@ 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/)
    - [LTX-Video](https://comfyanonymous.github.io/ComfyUI_examples/ltxv/)
    - [Hunyuan Video](https://comfyanonymous.github.io/ComfyUI_examples/hunyuan_video/)
-   - [Nvidia Cosmos](https://comfyanonymous.github.io/ComfyUI_examples/cosmos/)
 - [Stable Audio](https://comfyanonymous.github.io/ComfyUI_examples/audio/)
 - Asynchronous Queue system
 - Many optimizations: Only re-executes the parts of the workflow that changes between executions.
@@ -131,8 +129,6 @@ 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.
@@ -143,7 +139,7 @@ To run it on services like paperspace, kaggle or colab you can use my [Jupyter N
 
 ## Manual Install (Windows, Linux)
 
-python 3.13 is supported but using 3.12 is recommended because some custom nodes and their dependencies might not support it yet.
+Note that some dependencies do not yet support python 3.13 so using 3.12 is recommended.
 
 Git clone this repo.
 
@@ -155,11 +151,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.4```
+```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.2```
 
-This is the command to install the nightly with ROCm 6.3 which might have some performance improvements:
+This is the command to install the nightly with ROCm 6.2 which might have some performance improvements:
 
-```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.3```
+```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.2.4```
 
 ### Intel GPUs (Windows and Linux)
 
@@ -189,7 +185,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/cu126```
+```pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124```
 
 This is the command to install pytorch nightly instead which might have performance improvements:
 

app/custom_node_manager.py

@@ -4,93 +4,12 @@ import os
 import folder_paths
 import glob
 from aiohttp import web
-import json
-import logging
-from functools import lru_cache
-
-from utils.json_util import merge_json_recursive
-
-
-# Extra locale files to load into main.json
-EXTRA_LOCALE_FILES = [
-    "nodeDefs.json",
-    "commands.json",
-    "settings.json",
-]
-
-
-def safe_load_json_file(file_path: str) -> dict:
-    if not os.path.exists(file_path):
-        return {}
-
-    try:
-        with open(file_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except json.JSONDecodeError:
-        logging.error(f"Error loading {file_path}")
-        return {}
-
 
 class CustomNodeManager:
-    @lru_cache(maxsize=1)
-    def build_translations(self):
-        """Load all custom nodes translations during initialization. Translations are
-        expected to be loaded from `locales/` folder.
-
-        The folder structure is expected to be the following:
-        - custom_nodes/
-            - custom_node_1/
-                - locales/
-                    - en/
-                        - main.json
-                        - commands.json
-                        - settings.json
-
-        returned translations are expected to be in the following format:
-        {
-            "en": {
-                "nodeDefs": {...},
-                "commands": {...},
-                "settings": {...},
-                ...{other main.json keys}
-            }
-        }
-        """
-
-        translations = {}
-
-        for folder in folder_paths.get_folder_paths("custom_nodes"):
-            # Sort glob results for deterministic ordering
-            for custom_node_dir in sorted(glob.glob(os.path.join(folder, "*/"))):
-                locales_dir = os.path.join(custom_node_dir, "locales")
-                if not os.path.exists(locales_dir):
-                    continue
-
-                for lang_dir in glob.glob(os.path.join(locales_dir, "*/")):
-                    lang_code = os.path.basename(os.path.dirname(lang_dir))
-
-                    if lang_code not in translations:
-                        translations[lang_code] = {}
-
-                    # Load main.json
-                    main_file = os.path.join(lang_dir, "main.json")
-                    node_translations = safe_load_json_file(main_file)
-
-                    # Load extra locale files
-                    for extra_file in EXTRA_LOCALE_FILES:
-                        extra_file_path = os.path.join(lang_dir, extra_file)
-                        key = extra_file.split(".")[0]
-                        json_data = safe_load_json_file(extra_file_path)
-                        if json_data:
-                            node_translations[key] = json_data
-
-                    if node_translations:
-                        translations[lang_code] = merge_json_recursive(
-                            translations[lang_code], node_translations
-                        )
-
-        return translations
-
+    """
+    Placeholder to refactor the custom node management features from ComfyUI-Manager.
+    Currently it only contains the custom workflow templates feature.
+    """
     def add_routes(self, routes, webapp, loadedModules):
 
         @routes.get("/workflow_templates")
@@ -99,36 +18,17 @@ class CustomNodeManager:
             files = [
                 file
                 for folder in folder_paths.get_folder_paths("custom_nodes")
-                for file in glob.glob(
-                    os.path.join(folder, "*/example_workflows/*.json")
-                )
+                for file in glob.glob(os.path.join(folder, '*/example_workflows/*.json'))
             ]
-            workflow_templates_dict = (
-                {}
-            )  # custom_nodes folder name -> example workflow names
+            workflow_templates_dict = {} # custom_nodes folder name -> example workflow names
             for file in files:
-                custom_nodes_name = os.path.basename(
-                    os.path.dirname(os.path.dirname(file))
-                )
+                custom_nodes_name = os.path.basename(os.path.dirname(os.path.dirname(file)))
                 workflow_name = os.path.splitext(os.path.basename(file))[0]
-                workflow_templates_dict.setdefault(custom_nodes_name, []).append(
-                    workflow_name
-                )
+                workflow_templates_dict.setdefault(custom_nodes_name, []).append(workflow_name)
             return web.json_response(workflow_templates_dict)
 
         # Serve workflow templates from custom nodes.
         for module_name, module_dir in loadedModules:
-            workflows_dir = os.path.join(module_dir, "example_workflows")
+            workflows_dir = os.path.join(module_dir, 'example_workflows')
             if os.path.exists(workflows_dir):
-                webapp.add_routes(
-                    [
-                        web.static(
-                            "/api/workflow_templates/" + module_name, workflows_dir
-                        )
-                    ]
-                )
-
-        @routes.get("/i18n")
-        async def get_i18n(request):
-            """Returns translations from all custom nodes' locales folders."""
-            return web.json_response(self.build_translations())
+                webapp.add_routes([web.static('/api/workflow_templates/' + module_name, workflows_dir)])

app/database/db.py

@@ -0,0 +1,126 @@
+import logging
+import os
+import sqlite3
+from contextlib import contextmanager
+from queue import Queue, Empty, Full
+import threading
+from app.database.updater import DatabaseUpdater
+import folder_paths
+from comfy.cli_args import args
+
+
+class Database:
+    def __init__(self, database_path=None, pool_size=1):
+        if database_path is None:
+            self.exists = False
+            database_path = "file::memory:?cache=shared"
+        else:
+            self.exists = os.path.exists(database_path)
+
+        self.database_path = database_path
+        self.pool_size = pool_size
+        # Store connections in a pool, default to 1 as normal usage is going to be from a single thread at a time
+        self.connection_pool: Queue = Queue(maxsize=pool_size)
+        self._db_lock = threading.Lock()
+        self._initialized = False
+        self._closing = False
+        self._after_update_callbacks = []
+
+    def _setup(self):
+        if self._initialized:
+            return
+
+        with self._db_lock:
+            if not self._initialized:
+                self._make_db()
+                self._initialized = True
+
+    def _create_connection(self):
+        # TODO: Catch error for sqlite lib missing on linux
+        logging.info(f"Creating connection to {self.database_path}")
+        conn = sqlite3.connect(
+            self.database_path,
+            check_same_thread=False,
+            uri=self.database_path.startswith("file::"),
+        )
+        conn.execute("PRAGMA foreign_keys = ON")
+        self.exists = True
+        logging.info(f"Connected!")
+        return conn
+
+    def _make_db(self):
+        with self._get_connection() as con:
+            updater = DatabaseUpdater(con, self.database_path)
+            result = updater.update()
+            if result is not None:
+                old_version, new_version = result
+
+                for callback in self._after_update_callbacks:
+                    callback(old_version, new_version)
+
+    def _transform(self, row, columns):
+        return {col.name: value for value, col in zip(row, columns)}
+
+    @contextmanager
+    def _get_connection(self):
+        if self._closing:
+            raise Exception("Database is shutting down")
+
+        try:
+            # Try to get connection from pool
+            connection = self.connection_pool.get_nowait()
+        except Empty:
+            # Create new connection if pool is empty
+            connection = self._create_connection()
+
+        try:
+            yield connection
+        finally:
+            try:
+                # Try to add to pool if it's empty
+                self.connection_pool.put_nowait(connection)
+            except Full:
+                # Pool is full, close the connection
+                connection.close()
+
+    @contextmanager
+    def get_connection(self):
+        # Setup the database if it's not already initialized
+        self._setup()
+        with self._get_connection() as connection:
+            yield connection
+
+    def execute(self, sql, *args):
+        with self.get_connection() as connection:
+            cursor = connection.execute(sql, args)
+            results = cursor.fetchall()
+            return results
+
+    def register_after_update_callback(self, callback):
+        self._after_update_callbacks.append(callback)
+
+    def close(self):
+        if self._closing:
+            return
+        # Drain and close all connections in the pool
+        self._closing = True
+        while True:
+            try:
+                conn = self.connection_pool.get_nowait()
+                conn.close()
+            except Empty:
+                break
+        self._closing = False
+
+    def __del__(self):
+        try:
+            self.close()
+        except:
+            pass
+
+
+# Create a global instance
+db_path = None
+if not args.memory_database:
+    db_path = folder_paths.get_user_directory() + "/comfyui.db"
+db = Database(db_path)

app/database/entities.py

@@ -0,0 +1,343 @@
+from typing import Optional, Any, Callable
+from dataclasses import dataclass
+from functools import wraps
+from aiohttp import web
+from app.database.db import db
+
+primitives = (bool, str, int, float, type(None))
+
+
+def is_primitive(obj):
+    return isinstance(obj, primitives)
+
+
+class EntityError(Exception):
+    def __init__(
+        self, message: str, field: str = None, value: Any = None, status_code: int = 400
+    ):
+        self.message = message
+        self.field = field
+        self.value = value
+        self.status_code = status_code
+        super().__init__(self.message)
+
+    def to_json(self):
+        result = {"message": self.message}
+        if self.field is not None:
+            result["field"] = self.field
+        if self.value is not None:
+            result["value"] = self.value
+        return result
+
+    def __str__(self) -> str:
+        return f"{self.message} {self.field} {self.value}"
+
+
+class EntityCommon(dict):
+    @classmethod
+    def _get_route(cls, include_key: bool):
+        route = f"/db/{cls._table_name}"
+        if include_key:
+            route += "".join([f"/{{{k}}}" for k in cls._key_columns])
+        return route
+
+    @classmethod
+    def _register_route(cls, routes, verb: str, include_key: bool, handler: Callable):
+        route = cls._get_route(include_key)
+
+        @getattr(routes, verb)(route)
+        async def _(request):
+            try:
+                data = await handler(request)
+                if data is None:
+                    return web.json_response(status=204)
+
+                return web.json_response(data)
+            except EntityError as e:
+                return web.json_response(e.to_json(), status=e.status_code)
+
+    @classmethod
+    def _transform(cls, row: list[Any]):
+        return {col: value for col, value in zip(cls._columns, row)}
+
+    @classmethod
+    def _transform_rows(cls, rows: list[list[Any]]):
+        return [cls._transform(row) for row in rows]
+
+    @classmethod
+    def _extract_key(cls, request):
+        return {key: request.match_info.get(key, None) for key in cls._key_columns}
+
+    @classmethod
+    def _validate(cls, fields: list[str], data: dict, allow_missing: bool = False):
+        result = {}
+
+        if not isinstance(data, dict):
+            raise EntityError("Invalid data")
+
+        # Ensure all required fields are present
+        for field in data:
+            if field not in fields:
+                raise EntityError("Unknown field", field)
+
+        for key in fields:
+            col = cls._columns[key]
+            if key not in data:
+                if col.required and not allow_missing:
+                    raise EntityError("Missing field", key)
+                else:
+                    # e.g. for updates, we allow missing fields
+                    continue
+            elif data[key] is None and col.required:
+                # Dont allow None for required fields
+                raise EntityError("Required field", key)
+
+            # Validate data type
+            value = data[key]
+
+            if value is not None and not is_primitive(value):
+                raise EntityError("Invalid value", key, value)
+
+            try:
+                type = col.type
+                if value is not None and not isinstance(value, type):
+                    value = type(value)
+                result[key] = value
+            except Exception:
+                raise EntityError("Invalid value", key, value)
+
+        return result
+
+    @classmethod
+    def _validate_id(cls, id: dict):
+        return cls._validate(cls._key_columns, id)
+
+    @classmethod
+    def _validate_data(cls, data: dict, allow_missing: bool = False):
+        return cls._validate(cls._columns.keys(), data, allow_missing)
+
+    def __setattr__(self, name, value):
+        if name in self._columns:
+            self[name] = value
+        super().__setattr__(name, value)
+
+    def __getattr__(self, name):
+        if name in self:
+            return self[name]
+        raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")
+
+
+class GetEntity(EntityCommon):
+    @classmethod
+    def get(cls, top: Optional[int] = None, where: Optional[str] = None):
+        limit = ""
+        if top is not None and isinstance(top, int):
+            limit = f" LIMIT {top}"
+        result = db.execute(
+            f"SELECT * FROM {cls._table_name}{limit}{f' WHERE {where}' if where else ''}",
+        )
+
+        # Map each row in result to an instance of the class
+        return cls._transform_rows(result)
+
+    @classmethod
+    def register_route(cls, routes):
+        async def get_handler(request):
+            top = request.rel_url.query.get("top", None)
+            if top is not None:
+                try:
+                    top = int(top)
+                except Exception:
+                    raise EntityError("Invalid top parameter", "top", top)
+            return cls.get(top)
+
+        cls._register_route(routes, "get", False, get_handler)
+
+
+class GetEntityById(EntityCommon):
+    @classmethod
+    def get_by_id(cls, id: dict):
+        id = cls._validate_id(id)
+
+        result = db.execute(
+            f"SELECT * FROM {cls._table_name} WHERE {cls._where_clause}",
+            *[id[key] for key in cls._key_columns],
+        )
+
+        return cls._transform_rows(result)
+
+    @classmethod
+    def register_route(cls, routes):
+        async def get_by_id_handler(request):
+            id = cls._extract_key(request)
+            return cls.get_by_id(id)
+
+        cls._register_route(routes, "get", True, get_by_id_handler)
+
+
+class CreateEntity(EntityCommon):
+    @classmethod
+    def create(cls, data: dict, allow_upsert: bool = False):
+        data = cls._validate_data(data)
+        values = ", ".join(["?"] * len(data))
+        on_conflict = ""
+
+        data_keys = ", ".join(list(data.keys()))
+        if allow_upsert:
+            # Remove key columns from data
+            upsert_keys = [key for key in data if key not in cls._key_columns]
+
+            set_clause = ", ".join([f"{k} = excluded.{k}" for k in upsert_keys])
+            on_conflict = f" ON CONFLICT ({', '.join(cls._key_columns)}) DO UPDATE SET {set_clause}"
+        sql = f"INSERT INTO {cls._table_name} ({data_keys}) VALUES ({values}){on_conflict} RETURNING *"
+        result = db.execute(
+            sql,
+            *[data[key] for key in data],
+        )
+
+        if len(result) == 0:
+            raise EntityError("Failed to create entity", status_code=500)
+
+        return cls._transform_rows(result)[0]
+
+    @classmethod
+    def register_route(cls, routes):
+        async def create_handler(request):
+            data = await request.json()
+            return cls.create(data)
+
+        cls._register_route(routes, "post", False, create_handler)
+
+
+class UpdateEntity(EntityCommon):
+    @classmethod
+    def update(cls, id: list, data: dict):
+        id = cls._validate_id(id)
+        data = cls._validate_data(data, allow_missing=True)
+
+        sql = f"UPDATE {cls._table_name} SET {', '.join([f'{k} = ?' for k in data])} WHERE {cls._where_clause} RETURNING *"
+        result = db.execute(
+            sql,
+            *[data[key] for key in data],
+            *[id[key] for key in cls._key_columns],
+        )
+
+        if len(result) == 0:
+            raise EntityError("Failed to update entity", status_code=404)
+
+        return cls._transform_rows(result)[0]
+
+    @classmethod
+    def register_route(cls, routes):
+        async def update_handler(request):
+            id = cls._extract_key(request)
+            data = await request.json()
+            return cls.update(id, data)
+
+        cls._register_route(routes, "patch", True, update_handler)
+
+
+class UpsertEntity(CreateEntity):
+    @classmethod
+    def upsert(cls, data: dict):
+        return cls.create(data, allow_upsert=True)
+
+    @classmethod
+    def register_route(cls, routes):
+        async def upsert_handler(request):
+            data = await request.json()
+            return cls.upsert(data)
+
+        cls._register_route(routes, "put", False, upsert_handler)
+
+
+class DeleteEntity(EntityCommon):
+    @classmethod
+    def delete(cls, id: list):
+        id = cls._validate_id(id)
+        db.execute(
+            f"DELETE FROM {cls._table_name} WHERE {cls._where_clause}",
+            *[id[key] for key in cls._key_columns],
+        )
+
+    @classmethod
+    def register_route(cls, routes):
+        async def delete_handler(request):
+            id = cls._extract_key(request)
+            cls.delete(id)
+
+        cls._register_route(routes, "delete", True, delete_handler)
+
+
+class BaseEntity(GetEntity, CreateEntity, UpdateEntity, DeleteEntity, GetEntityById):
+    pass
+
+
+@dataclass
+class Column:
+    type: Any
+    required: bool = False
+    key: bool = False
+    default: Any = None
+
+
+def column(type_: Any, required: bool = False, key: bool = False, default: Any = None):
+    return Column(type_, required, key, default)
+
+
+def table(table_name: str):
+    def decorator(cls):
+        # Store table name
+        cls._table_name = table_name
+
+        # Process column definitions
+        columns: dict[str, Column] = {}
+        for attr_name, attr_value in cls.__dict__.items():
+            if isinstance(attr_value, Column):
+                columns[attr_name] = attr_value
+
+        # Store columns metadata
+        cls._columns = columns
+        cls._key_columns = [col for col in columns if columns[col].key]
+        cls._column_csv = ", ".join([col for col in columns])
+        cls._where_clause = " AND ".join([f"{col} = ?" for col in cls._key_columns])
+
+        # Add initialization
+        original_init = cls.__init__
+
+        @wraps(original_init)
+        def new_init(self, *args, **kwargs):
+            # Initialize columns with default values
+            for col_name, col_def in cls._columns.items():
+                setattr(self, col_name, col_def.default)
+            # Call original init
+            original_init(self, *args, **kwargs)
+
+        cls.__init__ = new_init
+        return cls
+
+    return decorator
+
+
+def test():
+    @table("models")
+    class Model(BaseEntity):
+        id: int = column(int, required=True, key=True)
+        path: str = column(str, required=True)
+        name: str = column(str, required=True)
+        description: Optional[str] = column(str)
+        architecture: Optional[str] = column(str)
+        type: str = column(str, required=True)
+        hash: Optional[str] = column(str)
+        source_url: Optional[str] = column(str)
+
+    return Model
+
+
+@table("test")
+class Test(GetEntity, CreateEntity):
+    id: int = column(int, required=True, key=True)
+    test: str = column(str, required=True)
+
+
+Model = test()

app/database/routes.py

@@ -0,0 +1,32 @@
+from app.database.db import db
+from aiohttp import web
+
+def create_routes(
+    routes, prefix, entity, get=False, get_by_id=False, post=False, delete=False
+):
+    if get:
+        @routes.get(f"/{prefix}/{table}")
+        async def get_table(request):
+            connection = db.get_connection()
+            cursor = connection.cursor()
+            cursor.execute(f"SELECT * FROM {table}")
+            rows = cursor.fetchall()
+            return web.json_response(rows)
+        
+    if get_by_id:
+        @routes.get(f"/{prefix}/{table}/{id}")
+        async def get_table_by_id(request):
+            connection = db.get_connection()
+            cursor = connection.cursor()
+            cursor.execute(f"SELECT * FROM {table} WHERE id = {id}")
+            row = cursor.fetchone()
+            return web.json_response(row)
+        
+    if post:
+        @routes.post(f"/{prefix}/{table}")
+        async def post_table(request):
+            data = await request.json()
+            connection = db.get_connection()
+            cursor = connection.cursor()
+            cursor.execute(f"INSERT INTO {table} ({data}) VALUES ({data})")
+            return web.json_response({"status": "success"})

app/database/updater.py

@@ -0,0 +1,79 @@
+import logging
+import os
+import sqlite3
+from app.database.versions.v1 import v1
+
+
+class DatabaseUpdater:
+    def __init__(self, connection, database_path):
+        self.connection = connection
+        self.database_path = database_path
+        self.current_version = self.get_db_version()
+        self.version_updates = {
+            1: v1,
+        }
+        self.max_version = max(self.version_updates.keys())
+        self.update_required = self.current_version < self.max_version
+        logging.info(f"Database version: {self.current_version}")
+
+    def get_db_version(self):
+        return self.connection.execute("PRAGMA user_version").fetchone()[0]
+
+    def backup(self):
+        bkp_path = self.database_path + ".bkp"
+        if os.path.exists(bkp_path):
+            # TODO: auto-rollback failed upgrades
+            raise Exception(
+                f"Database backup already exists, this indicates that a previous upgrade failed. Please restore this backup before continuing. Backup location: {bkp_path}"
+            )
+
+        bkp = sqlite3.connect(bkp_path)
+        self.connection.backup(bkp)
+        bkp.close()
+        logging.info("Database backup taken pre-upgrade.")
+        return bkp_path
+
+    def update(self):
+        if not self.update_required:
+            return None
+
+        bkp_version = self.current_version
+        bkp_path = None
+        if self.current_version > 0:
+            bkp_path = self.backup()
+
+        logging.info(f"Updating database: {self.current_version} -> {self.max_version}")
+
+        dirname = os.path.dirname(__file__)
+        cursor = self.connection.cursor()
+        for version in range(self.current_version + 1, self.max_version + 1):
+            filename = os.path.join(dirname, f"versions/v{version}.sql")
+            if not os.path.exists(filename):
+                raise Exception(
+                    f"Database update script for version {version} not found"
+                )
+
+            try:
+                with open(filename, "r") as file:
+                    sql = file.read()
+                    cursor.executescript(sql)
+            except Exception as e:
+                raise Exception(
+                    f"Failed to execute update script for version {version}: {e}"
+                )
+
+            method = self.version_updates[version]
+            if method is not None:
+                method(cursor)
+
+        cursor.execute("PRAGMA user_version = %d" % self.max_version)
+        self.connection.commit()
+        cursor.close()
+        self.current_version = self.get_db_version()
+
+        if bkp_path:
+            # Keep a copy of the backup in case something goes wrong and we need to rollback
+            os.rename(bkp_path, self.database_path + f".v{bkp_version}.bkp")
+        logging.info(f"Upgrade to successful.")
+
+        return (bkp_version, self.current_version)

app/database/versions/v1.py

@@ -0,0 +1,17 @@
+from folder_paths import folder_names_and_paths, get_filename_list, get_full_path
+
+
+def v1(cursor):
+    print("Updating to v1")
+    for folder_name in folder_names_and_paths.keys():
+        if folder_name == "custom_nodes":
+            continue
+
+        files = get_filename_list(folder_name)
+        for file in files:
+            file_path = get_full_path(folder_name, file)
+            file_without_extension = file.rsplit(".", maxsplit=1)[0]
+            cursor.execute(
+                "INSERT INTO models (path, name, type) VALUES (?, ?, ?)",
+                (file_path, file_without_extension, folder_name),
+            )

app/database/versions/v1.sql

@@ -0,0 +1,41 @@
+CREATE TABLE IF NOT EXISTS
+    models (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        architecture TEXT,
+        type TEXT NOT NULL,
+        hash TEXT,
+        source_url TEXT
+    );
+
+CREATE TABLE IF NOT EXISTS
+    tags (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE
+    );
+
+CREATE TABLE IF NOT EXISTS
+    model_tags (
+        model_id INTEGER NOT NULL,
+        tag_id INTEGER NOT NULL,
+        PRIMARY KEY (model_id, tag_id),
+        FOREIGN KEY (model_id) REFERENCES models (id) ON DELETE CASCADE,
+        FOREIGN KEY (tag_id) REFERENCES tags (id) ON DELETE CASCADE
+    );
+
+INSERT INTO
+    tags (name)
+VALUES
+    ('character'),
+    ('style'),
+    ('concept'),
+    ('clothing'),
+    ('poses'),
+    ('background'),
+    ('vehicle'),
+    ('buildings'),
+    ('objects'),
+    ('animal'),
+    ('action');

app/model_hasher.py

@@ -0,0 +1,63 @@
+import hashlib
+import logging
+import threading
+import time
+from comfy.cli_args import args
+
+
+class ModelHasher:
+
+    def __init__(self):
+        self._thread = None
+        self._lock = threading.Lock()
+        self._model_entity = None
+
+    def start(self, model_entity):
+        if args.disable_model_hashing:
+            return
+
+        self._model_entity = model_entity
+
+        if self._thread is None:
+            # Lock to prevent multiple threads from starting
+            with self._lock:
+                if self._thread is None:
+                    self._thread = threading.Thread(target=self._hash_models)
+                    self._thread.daemon = True
+                    self._thread.start()
+
+    def _get_models(self):
+        models = self._model_entity.get("WHERE hash IS NULL")
+        return models
+
+    def _hash_model(self, model_path):
+        h = hashlib.sha256()
+        b = bytearray(128 * 1024)
+        mv = memoryview(b)
+        with open(model_path, "rb", buffering=0) as f:
+            while n := f.readinto(mv):
+                h.update(mv[:n])
+        hash = h.hexdigest()
+        return hash
+
+    def _hash_models(self):
+        while True:
+            models = self._get_models()
+
+            if len(models) == 0:
+                break
+
+            for model in models:
+                time.sleep(0)
+                now = time.time()
+                logging.info(f"Hashing model {model['path']}")
+                hash = self._hash_model(model["path"])
+                logging.info(
+                    f"Hashed model {model['path']} in {time.time() - now} seconds"
+                )
+                self._model_entity.update((model["id"],), {"hash": hash})
+
+        self._thread = None
+
+
+model_hasher = ModelHasher()

comfy/cli_args.py

@@ -43,11 +43,10 @@ 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. 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("--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("--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.")
@@ -144,9 +143,13 @@ parser.add_argument("--multi-user", action="store_true", help="Enables per-user
 parser.add_argument("--verbose", default='INFO', const='DEBUG', nargs="?", choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], help='Set the logging level')
 parser.add_argument("--log-stdout", action="store_true", help="Send normal process output to stdout instead of stderr (default).")
 
+parser.add_argument("--memory-database", default=False, action="store_true", help="Use an in-memory database instead of a file-based one.")
+parser.add_argument("--disable-model-hashing", action="store_true", help="Disable model hashing.")
+
 # The default built-in provider hosted under web/
 DEFAULT_VERSION_STRING = "comfyanonymous/ComfyUI@latest"
 
+
 parser.add_argument(
     "--front-end-version",
     type=str,
@@ -177,9 +180,7 @@ 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. Overrides --base-directory.")
-
-parser.add_argument("--disable-compres-response-body", action="store_true", help="Disable compressing response body.")
+parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path.")
 
 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), -torch.finfo(x.dtype).max)
+            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
 
-        causal_mask = torch.empty(x.shape[1], x.shape[1], dtype=x.dtype, device=x.device).fill_(-torch.finfo(x.dtype).max).triu_(1)
+        causal_mask = torch.empty(x.shape[1], x.shape[1], dtype=x.dtype, device=x.device).fill_(float("-inf")).triu_(1)
         if mask is not None:
             mask += causal_mask
         else:

comfy/conds.py

@@ -3,6 +3,9 @@ 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
@@ -43,7 +46,7 @@ class CONDCrossAttn(CONDRegular):
             if s1[0] != s2[0] or s1[2] != s2[2]: #these 2 cases should not happen
                 return False
 
-            mult_min = math.lcm(s1[1], s2[1])
+            mult_min = lcm(s1[1], s2[1])
             diff = mult_min // min(s1[1], s2[1])
             if diff > 4: #arbitrary limit on the padding because it's probably going to impact performance negatively if it's too much
                 return False
@@ -54,7 +57,7 @@ class CONDCrossAttn(CONDRegular):
         crossattn_max_len = self.cond.shape[1]
         for x in others:
             c = x.cond
-            crossattn_max_len = math.lcm(crossattn_max_len, c.shape[1])
+            crossattn_max_len = lcm(crossattn_max_len, c.shape[1])
             conds.append(c)
 
         out = []

comfy/diffusers_convert.py

@@ -4,6 +4,105 @@ 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 #
 # ================#
@@ -114,7 +213,6 @@ 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
@@ -131,7 +229,6 @@ def cat_tensors(tensors):
 
     return out
 
-
 def convert_text_enc_state_dict_v20(text_enc_dict, prefix=""):
     new_state_dict = {}
     capture_qkv_weight = {}
@@ -187,3 +284,5 @@ 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/extra_samplers/uni_pc.py

@@ -661,7 +661,7 @@ class UniPC:
 
             if x_t is None:
                 if use_predictor:
-                    pred_res = torch.tensordot(D1s, rhos_p, dims=([1], [0]))  # torch.einsum('k,bkchw->bchw', rhos_p, D1s)
+                    pred_res = torch.einsum('k,bkchw->bchw', rhos_p, D1s)
                 else:
                     pred_res = 0
                 x_t = x_t_ - expand_dims(alpha_t * B_h, dims) * pred_res
@@ -669,7 +669,7 @@ class UniPC:
             if use_corrector:
                 model_t = self.model_fn(x_t, t)
                 if D1s is not None:
-                    corr_res = torch.tensordot(D1s, rhos_c[:-1], dims=([1], [0]))  # torch.einsum('k,bkchw->bchw', rhos_c[:-1], D1s)
+                    corr_res = torch.einsum('k,bkchw->bchw', rhos_c[:-1], D1s)
                 else:
                     corr_res = 0
                 D1_t = (model_t - model_prev_0)

comfy/k_diffusion/sampling.py

@@ -40,7 +40,7 @@ def get_sigmas_polyexponential(n, sigma_min, sigma_max, rho=1., device='cpu'):
 def get_sigmas_vp(n, beta_d=19.9, beta_min=0.1, eps_s=1e-3, device='cpu'):
     """Constructs a continuous VP noise schedule."""
     t = torch.linspace(1, eps_s, n, device=device)
-    sigmas = torch.sqrt(torch.special.expm1(beta_d * t ** 2 / 2 + beta_min * t))
+    sigmas = torch.sqrt(torch.exp(beta_d * t ** 2 / 2 + beta_min * t) - 1)
     return append_zero(sigmas)
 
 
@@ -1336,26 +1336,3 @@ def sample_res_multistep(model, x, sigmas, extra_args=None, callback=None, disab
 @torch.no_grad()
 def sample_res_multistep_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, s_churn=0., s_tmin=0., s_tmax=float('inf'), s_noise=1., noise_sampler=None):
     return res_multistep(model, x, sigmas, extra_args=extra_args, callback=callback, disable=disable, s_churn=s_churn, s_tmin=s_tmin, s_tmax=s_tmax, s_noise=s_noise, noise_sampler=noise_sampler, cfg_pp=True)
-
-@torch.no_grad()
-def sample_gradient_estimation(model, x, sigmas, extra_args=None, callback=None, disable=None, ge_gamma=2.):
-    """Gradient-estimation sampler. Paper: https://openreview.net/pdf?id=o2ND9v0CeK"""
-    extra_args = {} if extra_args is None else extra_args
-    s_in = x.new_ones([x.shape[0]])
-    old_d = None
-
-    for i in trange(len(sigmas) - 1, disable=disable):
-        denoised = model(x, sigmas[i] * s_in, **extra_args)
-        d = to_d(x, sigmas[i], denoised)
-        if callback is not None:
-            callback({'x': x, 'i': i, 'sigma': sigmas[i], 'sigma_hat': sigmas[i], 'denoised': denoised})
-        dt = sigmas[i + 1] - sigmas[i]
-        if i == 0:
-            # Euler method
-            x = x + d * dt
-        else:
-            # Gradient estimation
-            d_bar = ge_gamma * d + (1 - ge_gamma) * old_d
-            x = x + d_bar * dt
-        old_d = d
-    return x

comfy/ldm/cosmos/blocks.py

@@ -168,19 +168,15 @@ class Attention(nn.Module):
         k = self.to_k[1](k)
         v = self.to_v[1](v)
         if self.is_selfattn and rope_emb is not None:  # only apply to self-attention!
-            # apply_rotary_pos_emb inlined
-            q_shape = q.shape
-            q = q.reshape(*q.shape[:-1], 2, -1).movedim(-2, -1).unsqueeze(-2)
-            q = rope_emb[..., 0] * q[..., 0] + rope_emb[..., 1] * q[..., 1]
-            q = q.movedim(-1, -2).reshape(*q_shape).to(x.dtype)
-
-            # apply_rotary_pos_emb inlined
-            k_shape = k.shape
-            k = k.reshape(*k.shape[:-1], 2, -1).movedim(-2, -1).unsqueeze(-2)
-            k = rope_emb[..., 0] * k[..., 0] + rope_emb[..., 1] * k[..., 1]
-            k = k.movedim(-1, -2).reshape(*k_shape).to(x.dtype)
+            q = apply_rotary_pos_emb(q, rope_emb)
+            k = apply_rotary_pos_emb(k, rope_emb)
         return q, k, v
 
+    def cal_attn(self, q, k, v, mask=None):
+        out = optimized_attention(q, k, v, self.heads, skip_reshape=True, mask=mask, skip_output_reshape=True)
+        out = rearrange(out, " b n s c -> s b (n c)")
+        return self.to_out(out)
+
     def forward(
         self,
         x,
@@ -195,10 +191,7 @@ class Attention(nn.Module):
             context (Optional[Tensor]): The key tensor of shape [B, Mk, K] or use x as context [self attention] if None
         """
         q, k, v = self.cal_qkv(x, context, mask, rope_emb=rope_emb, **kwargs)
-        out = optimized_attention(q, k, v, self.heads, skip_reshape=True, mask=mask, skip_output_reshape=True)
-        del q, k, v
-        out = rearrange(out, " b n s c -> s b (n c)")
-        return self.to_out(out)
+        return self.cal_attn(q, k, v, mask)
 
 
 class FeedForward(nn.Module):
@@ -795,7 +788,10 @@ class GeneralDITTransformerBlock(nn.Module):
         crossattn_mask: Optional[torch.Tensor] = None,
         rope_emb_L_1_1_D: Optional[torch.Tensor] = None,
         adaln_lora_B_3D: Optional[torch.Tensor] = None,
+        extra_per_block_pos_emb: Optional[torch.Tensor] = None,
     ) -> torch.Tensor:
+        if extra_per_block_pos_emb is not None:
+            x = x + extra_per_block_pos_emb
         for block in self.blocks:
             x = block(
                 x,

comfy/ldm/cosmos/cosmos_tokenizer/layers3d.py

@@ -30,8 +30,6 @@ import torch.nn as nn
 import torch.nn.functional as F
 import logging
 
-from comfy.ldm.modules.diffusionmodules.model import vae_attention
-
 from .patching import (
     Patcher,
     Patcher3D,
@@ -402,8 +400,6 @@ class CausalAttnBlock(nn.Module):
             in_channels, in_channels, kernel_size=1, stride=1, padding=0
         )
 
-        self.optimized_attention = vae_attention()
-
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         h_ = x
         h_ = self.norm(h_)
@@ -417,7 +413,18 @@ class CausalAttnBlock(nn.Module):
         v, batch_size = time2batch(v)
 
         b, c, h, w = q.shape
-        h_ = self.optimized_attention(q, k, v)
+        q = q.reshape(b, c, h * w)
+        q = q.permute(0, 2, 1)
+        k = k.reshape(b, c, h * w)
+        w_ = torch.bmm(q, k)
+        w_ = w_ * (int(c) ** (-0.5))
+        w_ = F.softmax(w_, dim=2)
+
+        # attend to values
+        v = v.reshape(b, c, h * w)
+        w_ = w_.permute(0, 2, 1)
+        h_ = torch.bmm(v, w_)
+        h_ = h_.reshape(b, c, h, w)
 
         h_ = batch2time(h_, batch_size)
         h_ = self.proj_out(h_)
@@ -864,16 +871,18 @@ class EncoderFactorized(nn.Module):
         x = self.patcher3d(x)
 
         # downsampling
-        h = self.conv_in(x)
+        hs = [self.conv_in(x)]
         for i_level in range(self.num_resolutions):
             for i_block in range(self.num_res_blocks):
-                h = self.down[i_level].block[i_block](h)
+                h = self.down[i_level].block[i_block](hs[-1])
                 if len(self.down[i_level].attn) > 0:
                     h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
             if i_level != self.num_resolutions - 1:
-                h = self.down[i_level].downsample(h)
+                hs.append(self.down[i_level].downsample(hs[-1]))
 
         # middle
+        h = hs[-1]
         h = self.mid.block_1(h)
         h = self.mid.attn_1(h)
         h = self.mid.block_2(h)

comfy/ldm/cosmos/cosmos_tokenizer/patching.py

@@ -281,76 +281,54 @@ class UnPatcher3D(UnPatcher):
         hh = hh.to(dtype=dtype)
 
         xlll, xllh, xlhl, xlhh, xhll, xhlh, xhhl, xhhh = torch.chunk(x, 8, dim=1)
-        del x
 
         # Height height transposed convolutions.
         xll = F.conv_transpose3d(
             xlll, hl.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xlll
-
         xll += F.conv_transpose3d(
             xllh, hh.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xllh
 
         xlh = F.conv_transpose3d(
             xlhl, hl.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xlhl
-
         xlh += F.conv_transpose3d(
             xlhh, hh.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xlhh
 
         xhl = F.conv_transpose3d(
             xhll, hl.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xhll
-
         xhl += F.conv_transpose3d(
             xhlh, hh.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xhlh
 
         xhh = F.conv_transpose3d(
             xhhl, hl.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xhhl
-
         xhh += F.conv_transpose3d(
             xhhh, hh.unsqueeze(2).unsqueeze(3), groups=g, stride=(1, 1, 2)
         )
-        del xhhh
 
         # Handles width transposed convolutions.
         xl = F.conv_transpose3d(
             xll, hl.unsqueeze(2).unsqueeze(4), groups=g, stride=(1, 2, 1)
         )
-        del xll
-
         xl += F.conv_transpose3d(
             xlh, hh.unsqueeze(2).unsqueeze(4), groups=g, stride=(1, 2, 1)
         )
-        del xlh
-
         xh = F.conv_transpose3d(
             xhl, hl.unsqueeze(2).unsqueeze(4), groups=g, stride=(1, 2, 1)
         )
-        del xhl
-
         xh += F.conv_transpose3d(
             xhh, hh.unsqueeze(2).unsqueeze(4), groups=g, stride=(1, 2, 1)
         )
-        del xhh
 
         # Handles time axis transposed convolutions.
         x = F.conv_transpose3d(
             xl, hl.unsqueeze(3).unsqueeze(4), groups=g, stride=(2, 1, 1)
         )
-        del xl
-
         x += F.conv_transpose3d(
             xh, hh.unsqueeze(3).unsqueeze(4), groups=g, stride=(2, 1, 1)
         )

comfy/ldm/cosmos/model.py

@@ -168,7 +168,7 @@ class GeneralDIT(nn.Module):
             operations=operations,
         )
 
-        self.build_pos_embed(device=device, dtype=dtype)
+        self.build_pos_embed(device=device)
         self.block_x_format = block_x_format
         self.use_adaln_lora = use_adaln_lora
         self.adaln_lora_dim = adaln_lora_dim
@@ -210,7 +210,7 @@ class GeneralDIT(nn.Module):
             operations=operations,
         )
 
-    def build_pos_embed(self, device=None, dtype=None):
+    def build_pos_embed(self, device=None):
         if self.pos_emb_cls == "rope3d":
             cls_type = VideoRopePosition3DEmb
         else:
@@ -242,7 +242,6 @@ class GeneralDIT(nn.Module):
             kwargs["w_extrapolation_ratio"] = self.extra_w_extrapolation_ratio
             kwargs["t_extrapolation_ratio"] = self.extra_t_extrapolation_ratio
             kwargs["device"] = device
-            kwargs["dtype"] = dtype
             self.extra_pos_embedder = LearnablePosEmbAxis(
                 **kwargs,
             )
@@ -293,7 +292,7 @@ class GeneralDIT(nn.Module):
         x_B_T_H_W_D = self.x_embedder(x_B_C_T_H_W)
 
         if self.extra_per_block_abs_pos_emb:
-            extra_pos_emb = self.extra_pos_embedder(x_B_T_H_W_D, fps=fps, device=x_B_C_T_H_W.device, dtype=x_B_C_T_H_W.dtype)
+            extra_pos_emb = self.extra_pos_embedder(x_B_T_H_W_D, fps=fps, device=x_B_C_T_H_W.device)
         else:
             extra_pos_emb = None
 
@@ -477,8 +476,6 @@ class GeneralDIT(nn.Module):
             inputs["original_shape"],
         )
         extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D = inputs["extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D"].to(x.dtype)
-        del inputs
-
         if extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D is not None:
             assert (
                 x.shape == extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D.shape
@@ -489,8 +486,6 @@ class GeneralDIT(nn.Module):
                 self.blocks["block0"].x_format == block.x_format
             ), f"First block has x_format {self.blocks[0].x_format}, got {block.x_format}"
 
-            if extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D is not None:
-                x += extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D
             x = block(
                 x,
                 affline_emb_B_D,
@@ -498,6 +493,7 @@ class GeneralDIT(nn.Module):
                 crossattn_mask,
                 rope_emb_L_1_1_D=rope_emb_L_1_1_D,
                 adaln_lora_B_3D=adaln_lora_B_3D,
+                extra_per_block_pos_emb=extra_pos_emb_B_T_H_W_D_or_T_H_W_B_D,
             )
 
         x_B_T_H_W_D = rearrange(x, "T H W B D -> B T H W D")

comfy/ldm/cosmos/position_embedding.py

@@ -41,12 +41,12 @@ def normalize(x: torch.Tensor, dim: Optional[List[int]] = None, eps: float = 0)
 
 
 class VideoPositionEmb(nn.Module):
-    def forward(self, x_B_T_H_W_C: torch.Tensor, fps=Optional[torch.Tensor], device=None, dtype=None) -> torch.Tensor:
+    def forward(self, x_B_T_H_W_C: torch.Tensor, fps=Optional[torch.Tensor], device=None) -> torch.Tensor:
         """
         It delegates the embedding generation to generate_embeddings function.
         """
         B_T_H_W_C = x_B_T_H_W_C.shape
-        embeddings = self.generate_embeddings(B_T_H_W_C, fps=fps, device=device, dtype=dtype)
+        embeddings = self.generate_embeddings(B_T_H_W_C, fps=fps, device=device)
 
         return embeddings
 
@@ -104,7 +104,6 @@ class VideoRopePosition3DEmb(VideoPositionEmb):
         w_ntk_factor: Optional[float] = None,
         t_ntk_factor: Optional[float] = None,
         device=None,
-        dtype=None,
     ):
         """
         Generate embeddings for the given input size.
@@ -174,7 +173,6 @@ class LearnablePosEmbAxis(VideoPositionEmb):
         len_w: int,
         len_t: int,
         device=None,
-        dtype=None,
         **kwargs,
     ):
         """
@@ -186,16 +184,17 @@ class LearnablePosEmbAxis(VideoPositionEmb):
         self.interpolation = interpolation
         assert self.interpolation in ["crop"], f"Unknown interpolation method {self.interpolation}"
 
-        self.pos_emb_h = nn.Parameter(torch.empty(len_h, model_channels, device=device, dtype=dtype))
-        self.pos_emb_w = nn.Parameter(torch.empty(len_w, model_channels, device=device, dtype=dtype))
-        self.pos_emb_t = nn.Parameter(torch.empty(len_t, model_channels, device=device, dtype=dtype))
+        self.pos_emb_h = nn.Parameter(torch.empty(len_h, model_channels, device=device))
+        self.pos_emb_w = nn.Parameter(torch.empty(len_w, model_channels, device=device))
+        self.pos_emb_t = nn.Parameter(torch.empty(len_t, model_channels, device=device))
 
-    def generate_embeddings(self, B_T_H_W_C: torch.Size, fps=Optional[torch.Tensor], device=None, dtype=None) -> torch.Tensor:
+
+    def generate_embeddings(self, B_T_H_W_C: torch.Size, fps=Optional[torch.Tensor], device=None) -> torch.Tensor:
         B, T, H, W, _ = B_T_H_W_C
         if self.interpolation == "crop":
-            emb_h_H = self.pos_emb_h[:H].to(device=device, dtype=dtype)
-            emb_w_W = self.pos_emb_w[:W].to(device=device, dtype=dtype)
-            emb_t_T = self.pos_emb_t[:T].to(device=device, dtype=dtype)
+            emb_h_H = self.pos_emb_h[:H].to(device=device)
+            emb_w_W = self.pos_emb_w[:W].to(device=device)
+            emb_t_T = self.pos_emb_t[:T].to(device=device)
             emb = (
                 repeat(emb_t_T, "t d-> b t h w d", b=B, h=H, w=W)
                 + repeat(emb_h_H, "h d-> b t h w d", b=B, t=T, w=W)

comfy/ldm/cosmos/vae.py

@@ -18,7 +18,6 @@ import logging
 import torch
 from torch import nn
 from enum import Enum
-import math
 
 from .cosmos_tokenizer.layers3d import (
     EncoderFactorized,
@@ -90,8 +89,8 @@ class CausalContinuousVideoTokenizer(nn.Module):
         self.distribution = IdentityDistribution()  # ContinuousFormulation[formulation_name].value()
 
         num_parameters = sum(param.numel() for param in self.parameters())
-        logging.debug(f"model={self.name}, num_parameters={num_parameters:,}")
-        logging.debug(
+        logging.info(f"model={self.name}, num_parameters={num_parameters:,}")
+        logging.info(
             f"z_channels={z_channels}, latent_channels={self.latent_channels}."
         )
 
@@ -106,23 +105,17 @@ class CausalContinuousVideoTokenizer(nn.Module):
         z, posteriors = self.distribution(moments)
         latent_ch = z.shape[1]
         latent_t = z.shape[2]
-        in_dtype = z.dtype
-        mean = self.latent_mean.view(latent_ch, -1)
-        std = self.latent_std.view(latent_ch, -1)
-
-        mean = mean.repeat(1, math.ceil(latent_t / mean.shape[-1]))[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
-        std = std.repeat(1, math.ceil(latent_t / std.shape[-1]))[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
+        dtype = z.dtype
+        mean = self.latent_mean.view(latent_ch, -1)[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=dtype, device=z.device)
+        std = self.latent_std.view(latent_ch, -1)[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=dtype, device=z.device)
         return ((z - mean) / std) * self.sigma_data
 
     def decode(self, z):
         in_dtype = z.dtype
         latent_ch = z.shape[1]
         latent_t = z.shape[2]
-        mean = self.latent_mean.view(latent_ch, -1)
-        std = self.latent_std.view(latent_ch, -1)
-
-        mean = mean.repeat(1, math.ceil(latent_t / mean.shape[-1]))[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
-        std = std.repeat(1, math.ceil(latent_t / std.shape[-1]))[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
+        mean = self.latent_mean.view(latent_ch, -1)[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
+        std = self.latent_std.view(latent_ch, -1)[:, : latent_t].reshape([1, latent_ch, -1, 1, 1]).to(dtype=in_dtype, device=z.device)
 
         z = z / self.sigma_data
         z = z * std + mean

comfy/ldm/flux/layers.py

@@ -230,7 +230,8 @@ class SingleStreamBlock(nn.Module):
 
     def forward(self, x: Tensor, vec: Tensor, pe: Tensor, attn_mask=None) -> Tensor:
         mod, _ = self.modulation(vec)
-        qkv, mlp = torch.split(self.linear1((1 + mod.scale) * self.pre_norm(x) + mod.shift), [3 * self.hidden_size, self.mlp_hidden_dim], dim=-1)
+        x_mod = (1 + mod.scale) * self.pre_norm(x) + mod.shift
+        qkv, mlp = torch.split(self.linear1(x_mod), [3 * self.hidden_size, self.mlp_hidden_dim], dim=-1)
 
         q, k, v = qkv.view(qkv.shape[0], qkv.shape[1], 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
         q, k = self.norm(q, k, v)

comfy/ldm/flux/math.py

@@ -5,15 +5,8 @@ from torch import Tensor
 from comfy.ldm.modules.attention import optimized_attention
 import comfy.model_management
 
-
 def attention(q: Tensor, k: Tensor, v: Tensor, pe: Tensor, mask=None) -> Tensor:
-    q_shape = q.shape
-    k_shape = k.shape
-
-    q = q.float().reshape(*q.shape[:-1], -1, 1, 2)
-    k = k.float().reshape(*k.shape[:-1], -1, 1, 2)
-    q = (pe[..., 0] * q[..., 0] + pe[..., 1] * q[..., 1]).reshape(*q_shape).type_as(v)
-    k = (pe[..., 0] * k[..., 0] + pe[..., 1] * k[..., 1]).reshape(*k_shape).type_as(v)
+    q, k = apply_rope(q, k, pe)
 
     heads = q.shape[1]
     x = optimized_attention(q, k, v, heads, skip_reshape=True, mask=mask)

comfy/ldm/flux/model.py

@@ -109,8 +109,9 @@ class Flux(nn.Module):
         img = self.img_in(img)
         vec = self.time_in(timestep_embedding(timesteps, 256).to(img.dtype))
         if self.params.guidance_embed:
-            if guidance is not None:
-                vec = vec + self.guidance_in(timestep_embedding(guidance, 256).to(img.dtype))
+            if guidance is None:
+                raise ValueError("Didn't get guidance strength for guidance distilled model.")
+            vec = vec + self.guidance_in(timestep_embedding(guidance, 256).to(img.dtype))
 
         vec = vec + self.vector_in(y[:,:self.params.vec_in_dim])
         txt = self.txt_in(txt)
@@ -185,7 +186,7 @@ class Flux(nn.Module):
         img = self.final_layer(img, vec)  # (N, T, patch_size ** 2 * out_channels)
         return img
 
-    def forward(self, x, timestep, context, y, guidance=None, control=None, transformer_options={}, **kwargs):
+    def forward(self, x, timestep, context, y, guidance, control=None, transformer_options={}, **kwargs):
         bs, c, h, w = x.shape
         patch_size = self.patch_size
         x = comfy.ldm.common_dit.pad_to_patch_size(x, (patch_size, patch_size))

comfy/ldm/hunyuan_video/model.py

@@ -240,8 +240,9 @@ class HunyuanVideo(nn.Module):
         vec = vec + self.vector_in(y[:, :self.params.vec_in_dim])
 
         if self.params.guidance_embed:
-            if guidance is not None:
-                vec = vec + self.guidance_in(timestep_embedding(guidance, 256).to(img.dtype))
+            if guidance is None:
+                raise ValueError("Didn't get guidance strength for guidance distilled model.")
+            vec = vec + self.guidance_in(timestep_embedding(guidance, 256).to(img.dtype))
 
         if txt_mask is not None and not torch.is_floating_point(txt_mask):
             txt_mask = (txt_mask - 1).to(img.dtype) * torch.finfo(img.dtype).max
@@ -313,7 +314,7 @@ class HunyuanVideo(nn.Module):
         img = img.reshape(initial_shape)
         return img
 
-    def forward(self, x, timestep, context, y, guidance=None, attention_mask=None, control=None, transformer_options={}, **kwargs):
+    def forward(self, x, timestep, context, y, guidance, attention_mask=None, control=None, transformer_options={}, **kwargs):
         bs, c, t, h, w = x.shape
         patch_size = self.patch_size
         t_len = ((t + (patch_size[0] // 2)) // patch_size[0])

comfy/ldm/lumina/model.py

@@ -1,674 +0,0 @@
-# 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,6 +1,4 @@
 import math
-import sys
-
 import torch
 import torch.nn.functional as F
 from torch import nn, einsum
@@ -18,11 +16,7 @@ if model_management.xformers_enabled():
     import xformers.ops
 
 if model_management.sage_attention_enabled():
-    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 sageattention import sageattn
 
 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, **kwargs
+        self, dim: int, elementwise_affine: bool = False, eps: float = 1e-6, device=None, dtype=None
     ):
         """
         Initialize the RMSNorm normalization layer.

comfy/ldm/modules/diffusionmodules/model.py

@@ -293,17 +293,6 @@ def pytorch_attention(q, k, v):
     return out
 
 
-def vae_attention():
-    if model_management.xformers_enabled_vae():
-        logging.info("Using xformers attention in VAE")
-        return xformers_attention
-    elif model_management.pytorch_attention_enabled():
-        logging.info("Using pytorch attention in VAE")
-        return pytorch_attention
-    else:
-        logging.info("Using split attention in VAE")
-        return normal_attention
-
 class AttnBlock(nn.Module):
     def __init__(self, in_channels, conv_op=ops.Conv2d):
         super().__init__()
@@ -331,7 +320,15 @@ class AttnBlock(nn.Module):
                                         stride=1,
                                         padding=0)
 
-        self.optimized_attention = vae_attention()
+        if model_management.xformers_enabled_vae():
+            logging.info("Using xformers attention in VAE")
+            self.optimized_attention = xformers_attention
+        elif model_management.pytorch_attention_enabled():
+            logging.info("Using pytorch attention in VAE")
+            self.optimized_attention = pytorch_attention
+        else:
+            logging.info("Using split attention in VAE")
+            self.optimized_attention = normal_attention
 
     def forward(self, x):
         h_ = x
@@ -702,6 +699,9 @@ 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,6 +307,7 @@ 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
@@ -326,13 +327,6 @@ 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,7 +34,6 @@ 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
@@ -149,9 +148,7 @@ class BaseModel(torch.nn.Module):
 
         xc = xc.to(dtype)
         t = self.model_sampling.timestep(t).float()
-        if context is not None:
-            context = context.to(dtype)
-
+        context = context.to(dtype)
         extra_conds = {}
         for o in kwargs:
             extra = kwargs[o]
@@ -552,10 +549,6 @@ class SD_X4Upscaler(BaseModel):
 
         out['c_concat'] = comfy.conds.CONDNoiseShape(image)
         out['y'] = comfy.conds.CONDRegular(noise_level)
-
-        cross_attn = kwargs.get("cross_attn", None)
-        if cross_attn is not None:
-            out['c_crossattn'] = comfy.conds.CONDCrossAttn(cross_attn)
         return out
 
 class IP2P:
@@ -813,10 +806,7 @@ class Flux(BaseModel):
             (h_tok, w_tok) = (math.ceil(shape[2] / self.diffusion_model.patch_size), math.ceil(shape[3] / self.diffusion_model.patch_size))
             attention_mask = utils.upscale_dit_mask(attention_mask, mask_ref_size, (h_tok, w_tok))
             out['attention_mask'] = comfy.conds.CONDRegular(attention_mask)
-
-        guidance = kwargs.get("guidance", 3.5)
-        if guidance is not None:
-            out['guidance'] = comfy.conds.CONDRegular(torch.FloatTensor([guidance]))
+        out['guidance'] = comfy.conds.CONDRegular(torch.FloatTensor([kwargs.get("guidance", 3.5)]))
         return out
 
 class GenmoMochi(BaseModel):
@@ -873,10 +863,7 @@ class HunyuanVideo(BaseModel):
         cross_attn = kwargs.get("cross_attn", None)
         if cross_attn is not None:
             out['c_crossattn'] = comfy.conds.CONDRegular(cross_attn)
-
-        guidance = kwargs.get("guidance", 6.0)
-        if guidance is not None:
-            out['guidance'] = comfy.conds.CONDRegular(torch.FloatTensor([guidance]))
+        out['guidance'] = comfy.conds.CONDRegular(torch.FloatTensor([kwargs.get("guidance", 6.0)]))
         return out
 
 class CosmosVideo(BaseModel):
@@ -905,19 +892,3 @@ 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:  # Cosmos
+    if '{}blocks.block0.blocks.0.block.attn.to_q.0.weight'.format(key_prefix) in state_dict_keys:
         dit_config = {}
         dit_config["image_model"] = "cosmos"
         dit_config["max_img_h"] = 240
@@ -284,21 +284,6 @@ 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.1
+    MIN_WEIGHT_MEMORY_RATIO = 0.2
 
 ENABLE_PYTORCH_ATTENTION = False
 if args.use_pytorch_cross_attention:
@@ -535,11 +535,14 @@ 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,7 +31,6 @@ 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:
@@ -62,11 +61,9 @@ 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/sampler_helpers.py

@@ -58,6 +58,7 @@ def convert_cond(cond):
         temp = c[1].copy()
         model_conds = temp.get("model_conds", {})
         if c[0] is not None:
+            model_conds["c_crossattn"] = comfy.conds.CONDCrossAttn(c[0]) #TODO: remove
             temp["cross_attn"] = c[0]
         temp["model_conds"] = model_conds
         temp["uuid"] = uuid.uuid4()

comfy/samplers.py

@@ -12,6 +12,7 @@ import collections
 from comfy import model_management
 import math
 import logging
+import comfy.samplers
 import comfy.sampler_helpers
 import comfy.model_patcher
 import comfy.patcher_extension
@@ -177,7 +178,7 @@ def finalize_default_conds(model: 'BaseModel', hooked_to_run: dict[comfy.hooks.H
         cond = default_conds[i]
         for x in cond:
             # do get_area_and_mult to get all the expected values
-            p = get_area_and_mult(x, x_in, timestep)
+            p = comfy.samplers.get_area_and_mult(x, x_in, timestep)
             if p is None:
                 continue
             # replace p's mult with calculated mult
@@ -214,7 +215,7 @@ def _calc_cond_batch(model: 'BaseModel', conds: list[list[dict]], x_in: torch.Te
                     default_c.append(x)
                     has_default_conds = True
                     continue
-                p = get_area_and_mult(x, x_in, timestep)
+                p = comfy.samplers.get_area_and_mult(x, x_in, timestep)
                 if p is None:
                     continue
                 if p.hooks is not None:
@@ -686,7 +687,7 @@ class Sampler:
 KSAMPLER_NAMES = ["euler", "euler_cfg_pp", "euler_ancestral", "euler_ancestral_cfg_pp", "heun", "heunpp2","dpm_2", "dpm_2_ancestral",
                   "lms", "dpm_fast", "dpm_adaptive", "dpmpp_2s_ancestral", "dpmpp_2s_ancestral_cfg_pp", "dpmpp_sde", "dpmpp_sde_gpu",
                   "dpmpp_2m", "dpmpp_2m_cfg_pp", "dpmpp_2m_sde", "dpmpp_2m_sde_gpu", "dpmpp_3m_sde", "dpmpp_3m_sde_gpu", "ddpm", "lcm",
-                  "ipndm", "ipndm_v", "deis", "res_multistep", "res_multistep_cfg_pp", "gradient_estimation"]
+                  "ipndm", "ipndm_v", "deis", "res_multistep", "res_multistep_cfg_pp"]
 
 class KSAMPLER(Sampler):
     def __init__(self, sampler_function, extra_options={}, inpaint_options={}):

comfy/sd.py

@@ -36,7 +36,6 @@ 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
@@ -389,8 +388,8 @@ class VAE:
                 ddconfig = {'z_channels': 16, 'latent_channels': self.latent_channels, 'z_factor': 1, 'resolution': 1024, 'in_channels': 3, 'out_channels': 3, 'channels': 128, 'channels_mult': [2, 4, 4], 'num_res_blocks': 2, 'attn_resolutions': [32], 'dropout': 0.0, 'patch_size': 4, 'num_groups': 1, 'temporal_compression': 8, 'spacial_compression': 8}
                 self.first_stage_model = comfy.ldm.cosmos.vae.CausalContinuousVideoTokenizer(**ddconfig)
                 #TODO: these values are a bit off because this is not a standard VAE
-                self.memory_used_decode = lambda shape, dtype: (50 * shape[2] * shape[3] * shape[4] * (8 * 8 * 8)) * model_management.dtype_size(dtype)
-                self.memory_used_encode = lambda shape, dtype: (50 * (round((shape[2] + 7) / 8) * 8) * shape[3] * shape[4]) * model_management.dtype_size(dtype)
+                self.memory_used_decode = lambda shape, dtype: (220 * shape[2] * shape[3] * shape[4] * (8 * 8 * 8)) * model_management.dtype_size(dtype)
+                self.memory_used_encode = lambda shape, dtype: (500 * max(shape[2], 2) * shape[3] * shape[4]) * model_management.dtype_size(dtype)
                 self.working_dtypes = [torch.bfloat16, torch.float32]
             else:
                 logging.warning("WARNING: No VAE weights detected, VAE not initalized.")
@@ -658,7 +657,6 @@ 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={}):
@@ -677,7 +675,6 @@ 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:
@@ -696,8 +693,6 @@ 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
@@ -735,7 +730,6 @@ 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:
@@ -775,10 +769,6 @@ 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)
@@ -808,6 +798,7 @@ 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={}, tokenizer_args={}):
+    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={}):
         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, **tokenizer_args)
+        self.tokenizer = tokenizer_class.from_pretrained(tokenizer_path)
         self.max_length = max_length
         self.min_length = min_length
         self.end_token = None
@@ -585,14 +585,9 @@ class SDTokenizer:
         return {}
 
 class SD1Tokenizer:
-    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)
-
+    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)
         tokenizer = tokenizer_data.get("{}_tokenizer_class".format(self.clip), tokenizer)
         setattr(self, self.clip, tokenizer(embedding_directory=embedding_directory, tokenizer_data=tokenizer_data))
 
@@ -605,7 +600,7 @@ class SD1Tokenizer:
         return getattr(self, self.clip).untokenize(token_weight_pair)
 
     def state_dict(self):
-        return getattr(self, self.clip).state_dict()
+        return {}
 
 class SD1CheckpointClipModel(SDClipModel):
     def __init__(self, device="cpu", dtype=None, model_options={}):

comfy/supported_models.py

@@ -15,7 +15,6 @@ 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
@@ -789,7 +788,7 @@ class HunyuanVideo(supported_models_base.BASE):
     unet_extra_config = {}
     latent_format = latent_formats.HunyuanVideo
 
-    memory_usage_factor = 1.8 #TODO
+    memory_usage_factor = 2.0 #TODO
 
     supported_inference_dtypes = [torch.bfloat16, torch.float32]
 
@@ -840,7 +839,7 @@ class CosmosT2V(supported_models_base.BASE):
     unet_extra_config = {}
     latent_format = latent_formats.Cosmos1CV8x8x8
 
-    memory_usage_factor = 1.6 #TODO
+    memory_usage_factor = 2.4 #TODO
 
     supported_inference_dtypes = [torch.bfloat16, torch.float16, torch.float32] #TODO
 
@@ -866,35 +865,6 @@ class CosmosI2V(CosmosT2V):
         out = model_base.CosmosVideo(self, image_to_video=True, device=device)
         return out
 
-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 = [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]
 
 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), -torch.finfo(x.dtype).max)
+            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
 
         x, i = self.encoder(x, mask, intermediate_output)
         return x, i

comfy/text_encoders/llama.py

@@ -1,5 +1,6 @@
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
 from dataclasses import dataclass
 from typing import Optional, Any
 
@@ -20,41 +21,15 @@ 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, add=False, device=None, dtype=None):
+    def __init__(self, dim: int, eps: float = 1e-5, 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):
-        w = self.weight
-        if self.add:
-            w = w + 1.0
-
-        return comfy.ldm.common_dit.rms_norm(x, w, self.eps)
-
+        return comfy.ldm.common_dit.rms_norm(x, self.weight, self.eps)
 
 
 def rotate_half(x):
@@ -93,15 +68,13 @@ 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 = config.head_dim
-        self.inner_size = self.num_heads * self.head_dim
+        self.head_dim = self.hidden_size // self.num_heads
 
         ops = ops or nn
-        self.q_proj = ops.Linear(config.hidden_size, self.inner_size, bias=False, device=device, dtype=dtype)
+        self.q_proj = ops.Linear(config.hidden_size, config.hidden_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(self.inner_size, config.hidden_size, bias=False, device=device, dtype=dtype)
+        self.o_proj = ops.Linear(config.hidden_size, config.hidden_size, bias=False, device=device, dtype=dtype)
 
     def forward(
         self,
@@ -111,6 +84,7 @@ 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)
@@ -134,13 +108,9 @@ 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(self.activation(self.gate_proj(x)) * self.up_proj(x))
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
 
 class TransformerBlock(nn.Module):
     def __init__(self, config: Llama2Config, device=None, dtype=None, ops: Any = None):
@@ -176,45 +146,6 @@ 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__()
@@ -227,27 +158,17 @@ 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([
-            transformer(config, device=device, dtype=dtype, ops=ops)
+            TransformerBlock(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, add=config.rms_norm_add, device=device, dtype=dtype)
+        self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps, 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)
 
-        if self.normalize_in:
-            x *= self.config.hidden_size ** 0.5
-
-        freqs_cis = precompute_freqs_cis(self.config.head_dim,
+        freqs_cis = precompute_freqs_cis(self.config.hidden_size // self.config.num_attention_heads,
                                          x.shape[1],
                                          self.config.rope_theta,
                                          device=x.device)
@@ -285,18 +206,8 @@ class Llama2_(nn.Module):
 
         return x, intermediate
 
-class BaseLlama:
-    def get_input_embeddings(self):
-        return self.model.embed_tokens
 
-    def set_input_embeddings(self, embeddings):
-        self.model.embed_tokens = embeddings
-
-    def forward(self, input_ids, *args, **kwargs):
-        return self.model(input_ids, *args, **kwargs)
-
-
-class Llama2(BaseLlama, torch.nn.Module):
+class Llama2(torch.nn.Module):
     def __init__(self, config_dict, dtype, device, operations):
         super().__init__()
         config = Llama2Config(**config_dict)
@@ -305,12 +216,11 @@ class Llama2(BaseLlama, torch.nn.Module):
         self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
         self.dtype = dtype
 
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
 
-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
+    def set_input_embeddings(self, embeddings):
+        self.model.embed_tokens = embeddings
 
-        self.model = Llama2_(config, device=device, dtype=dtype, ops=operations)
-        self.dtype = dtype
+    def forward(self, input_ids, *args, **kwargs):
+        return self.model(input_ids, *args, **kwargs)

comfy/text_encoders/lumina2.py

@@ -1,44 +0,0 @@
-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:
-    @staticmethod
-    def from_pretrained(path, **kwargs):
-        return SPieceTokenizer(path, **kwargs)
+    add_eos = True
 
-    def __init__(self, tokenizer_path, add_bos=False, add_eos=True):
-        self.add_bos = add_bos
-        self.add_eos = add_eos
+    @staticmethod
+    def from_pretrained(path):
+        return SPieceTokenizer(path)
+
+    def __init__(self, tokenizer_path):
         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_bos=self.add_bos, add_eos=self.add_eos)
+            self.tokenizer = sentencepiece.SentencePieceProcessor(model_proto=tokenizer_path, add_eos=self.add_eos)
         else:
-            self.tokenizer = sentencepiece.SentencePieceProcessor(model_file=tokenizer_path, add_bos=self.add_bos, add_eos=self.add_eos)
+            self.tokenizer = sentencepiece.SentencePieceProcessor(model_file=tokenizer_path, 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), -torch.finfo(x.dtype).max)
+            mask = mask.masked_fill(mask.to(torch.bool), float("-inf"))
 
         intermediate = None
         optimized_attention = optimized_attention_for_device(x.device, mask=attention_mask is not None, small_input=True)

comfy/utils.py

@@ -43,23 +43,13 @@ if hasattr(torch.serialization, "add_safe_globals"):  # TODO: this was added in
     torch.serialization.add_safe_globals([ModelCheckpoint, scalar, dtype, Float64DType, encode])
     ALWAYS_SAFE_LOAD = True
     logging.info("Checkpoint files will always be loaded safely.")
-else:
-    logging.info("Warning, you are using an old pytorch version and some ckpt/pt files might be loaded unsafely. Upgrading to 2.4 or above is recommended.")
+
 
 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"):
-        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
+        sd = safetensors.torch.load_file(ckpt, device=device.type)
     else:
         if safe_load or ALWAYS_SAFE_LOAD:
             pl_sd = torch.load(ckpt, map_location=device, weights_only=True)

comfy_extras/nodes_cosmos.py

@@ -71,8 +71,8 @@ class CosmosImageToVideoLatent:
             mask[:, :, -latent_temp.shape[-3]:] *= 0.0
 
         out_latent = {}
-        out_latent["samples"] = latent.repeat((batch_size, ) + (1,) * (latent.ndim - 1))
-        out_latent["noise_mask"] = mask.repeat((batch_size, ) + (1,) * (mask.ndim - 1))
+        out_latent["samples"] = latent
+        out_latent["noise_mask"] = mask
         return (out_latent,)
 
 

comfy_extras/nodes_flux.py

@@ -38,26 +38,7 @@ class FluxGuidance:
         return (c, )
 
 
-class FluxDisableGuidance:
-    @classmethod
-    def INPUT_TYPES(s):
-        return {"required": {
-            "conditioning": ("CONDITIONING", ),
-            }}
-
-    RETURN_TYPES = ("CONDITIONING",)
-    FUNCTION = "append"
-
-    CATEGORY = "advanced/conditioning/flux"
-    DESCRIPTION = "This node completely disables the guidance embed on Flux and Flux like models"
-
-    def append(self, conditioning):
-        c = node_helpers.conditioning_set_values(conditioning, {"guidance": None})
-        return (c, )
-
-
 NODE_CLASS_MAPPINGS = {
     "CLIPTextEncodeFlux": CLIPTextEncodeFlux,
     "FluxGuidance": FluxGuidance,
-    "FluxDisableGuidance": FluxDisableGuidance,
 }

comfy_extras/nodes_latent.py

@@ -2,14 +2,10 @@ import comfy.utils
 import comfy_extras.nodes_post_processing
 import torch
 
-
-def reshape_latent_to(target_shape, latent, repeat_batch=True):
+def reshape_latent_to(target_shape, latent):
     if latent.shape[1:] != target_shape[1:]:
-        latent = comfy.utils.common_upscale(latent, target_shape[-1], target_shape[-2], "bilinear", "center")
-    if repeat_batch:
-        return comfy.utils.repeat_to_batch_size(latent, target_shape[0])
-    else:
-        return latent
+        latent = comfy.utils.common_upscale(latent, target_shape[3], target_shape[2], "bilinear", "center")
+    return comfy.utils.repeat_to_batch_size(latent, target_shape[0])
 
 
 class LatentAdd:
@@ -120,7 +116,8 @@ class LatentBatch:
         s1 = samples1["samples"]
         s2 = samples2["samples"]
 
-        s2 = reshape_latent_to(s1.shape, s2, repeat_batch=False)
+        if s1.shape[1:] != s2.shape[1:]:
+            s2 = comfy.utils.common_upscale(s2, s1.shape[3], s1.shape[2], "bilinear", "center")
         s = torch.cat((s1, s2), dim=0)
         samples_out["samples"] = s
         samples_out["batch_index"] = samples1.get("batch_index", [x for x in range(0, s1.shape[0])]) + samples2.get("batch_index", [x for x in range(0, s2.shape[0])])

comfy_extras/nodes_load_3d.py

@@ -19,7 +19,11 @@ class Load3D():
             "image": ("LOAD_3D", {}),
             "width": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "height": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
+            "show_grid": ([True, False],),
+            "camera_type": (["perspective", "orthographic"],),
+            "view": (["front", "right", "top", "isometric"],),
             "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}),
@@ -65,9 +69,14 @@ class Load3DAnimation():
             "image": ("LOAD_3D_ANIMATION", {}),
             "width": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
             "height": ("INT", {"default": 1024, "min": 1, "max": 4096, "step": 1}),
+            "show_grid": ([True, False],),
+            "camera_type": (["perspective", "orthographic"],),
+            "view": (["front", "right", "top", "isometric"],),
             "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}),
         }}
 
@@ -100,29 +109,11 @@ class Preview3D():
     def INPUT_TYPES(s):
         return {"required": {
             "model_file": ("STRING", {"default": "", "multiline": False}),
+            "show_grid": ([True, False],),
+            "camera_type": (["perspective", "orthographic"],),
+            "view": (["front", "right", "top", "isometric"],),
             "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}),
-        }}
-
-    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"],),
+            "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}),
@@ -142,13 +133,11 @@ class Preview3DAnimation():
 NODE_CLASS_MAPPINGS = {
     "Load3D": Load3D,
     "Load3DAnimation": Load3DAnimation,
-    "Preview3D": Preview3D,
-    "Preview3DAnimation": Preview3DAnimation
+    "Preview3D": Preview3D
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
     "Load3D": "Load 3D",
     "Load3DAnimation": "Load 3D - Animation",
-    "Preview3D": "Preview 3D",
-    "Preview3DAnimation": "Preview 3D - Animation"
+    "Preview3D": "Preview 3D"
 }

comfy_extras/nodes_model_merging_model_specific.py

@@ -196,54 +196,6 @@ 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
@@ -254,6 +206,4 @@ 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.14"
+__version__ = "0.3.10"

folder_paths.py

@@ -7,18 +7,11 @@ import logging
 from typing import Literal
 from collections.abc import Collection
 
-from comfy.cli_args import args
-
-supported_pt_extensions: set[str] = {'.ckpt', '.pt', '.pt2', '.bin', '.pth', '.safetensors', '.pkl', '.sft'}
+supported_pt_extensions: set[str] = {'.ckpt', '.pt', '.bin', '.pth', '.safetensors', '.pkl', '.sft'}
 
 folder_names_and_paths: dict[str, tuple[list[str], set[str]]] = {}
 
-# --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__))
-
+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"])
@@ -46,10 +39,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(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")
+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")
 
 filename_list_cache: dict[str, tuple[list[str], dict[str, float], float]] = {}
 

latent_preview.py

@@ -12,10 +12,7 @@ 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
-                            )
-        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))
+                            ).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,8 +138,6 @@ 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()
@@ -294,7 +292,6 @@ 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,8 +63,6 @@ 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), )
 
@@ -914,7 +912,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", "lumina2"], ),
+                              "type": (["stable_diffusion", "stable_cascade", "sd3", "stable_audio", "mochi", "ltxv", "pixart", "cosmos"], ),
                               },
                 "optional": {
                               "device": (["default", "cpu"], {"advanced": True}),
@@ -939,10 +937,6 @@ class CLIPLoader:
             clip_type = comfy.sd.CLIPType.LTXV
         elif type == "pixart":
             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.14"
+version = "0.3.10"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"

requirements.txt

@@ -2,7 +2,6 @@ torch
 torchsde
 torchvision
 torchaudio
-numpy>=1.25.0
 einops
 transformers>=4.28.1
 tokenizers>=0.13.3

server.py

@@ -34,6 +34,9 @@ from app.model_manager import ModelFileManager
 from app.custom_node_manager import CustomNodeManager
 from typing import Optional
 from api_server.routes.internal.internal_routes import InternalRoutes
+from app.database.entities import get_entity, init_entities
+from app.database.db import db
+from app.model_hasher import model_hasher
 
 class BinaryEventTypes:
     PREVIEW_IMAGE = 1
@@ -52,22 +55,6 @@ 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):
@@ -165,7 +152,7 @@ class PromptServer():
         self.client_session:Optional[aiohttp.ClientSession] = None
         self.number = 0
 
-        middlewares = [cache_control, compress_body]
+        middlewares = [cache_control]
         if args.enable_cors_header:
             middlewares.append(create_cors_middleware(args.enable_cors_header))
         else:
@@ -345,9 +332,6 @@ class PromptServer():
                 original_ref = json.loads(post.get("original_ref"))
                 filename, output_dir = folder_paths.annotated_filepath(original_ref['filename'])
 
-                if not filename:
-                    return web.Response(status=400)
-
                 # validation for security: prevent accessing arbitrary path
                 if filename[0] == '/' or '..' in filename:
                     return web.Response(status=400)
@@ -389,9 +373,6 @@ class PromptServer():
                 filename = request.rel_url.query["filename"]
                 filename,output_dir = folder_paths.annotated_filepath(filename)
 
-                if not filename:
-                    return web.Response(status=400)
-
                 # validation for security: prevent accessing arbitrary path
                 if filename[0] == '/' or '..' in filename:
                     return web.Response(status=400)
@@ -704,11 +685,25 @@ class PromptServer():
         timeout = aiohttp.ClientTimeout(total=None) # no timeout
         self.client_session = aiohttp.ClientSession(timeout=timeout)
 
+    def init_db(self, routes):
+        init_entities(routes)
+        models = get_entity("models")
+        
+        if db.exists:
+            model_hasher.start(models)
+        else:
+            def on_db_update(_, __):
+                model_hasher.start(models)
+
+            db.register_after_update_callback(on_db_update)
+
+
     def add_routes(self):
         self.user_manager.add_routes(self.routes)
         self.model_file_manager.add_routes(self.routes)
         self.custom_node_manager.add_routes(self.routes, self.app, nodes.LOADED_MODULE_DIRS.items())
         self.app.add_subapp('/internal', self.internal_routes.get_app())
+        self.init_db(self.routes)
 
         # Prefix every route with /api for easier matching for delegation.
         # This is very useful for frontend dev server, which need to forward

tests-unit/app_test/custom_node_manager_test.py

@@ -2,146 +2,39 @@ import pytest
 from aiohttp import web
 from unittest.mock import patch
 from app.custom_node_manager import CustomNodeManager
-import json
 
 pytestmark = (
     pytest.mark.asyncio
 )  # This applies the asyncio mark to all test functions in the module
 
-
 @pytest.fixture
 def custom_node_manager():
     return CustomNodeManager()
 
-
 @pytest.fixture
 def app(custom_node_manager):
     app = web.Application()
     routes = web.RouteTableDef()
-    custom_node_manager.add_routes(
-        routes, app, [("ComfyUI-TestExtension1", "ComfyUI-TestExtension1")]
-    )
+    custom_node_manager.add_routes(routes, app, [("ComfyUI-TestExtension1", "ComfyUI-TestExtension1")])
     app.add_routes(routes)
     return app
 
-
 async def test_get_workflow_templates(aiohttp_client, app, tmp_path):
     client = await aiohttp_client(app)
     # Setup temporary custom nodes file structure with 1 workflow file
     custom_nodes_dir = tmp_path / "custom_nodes"
-    example_workflows_dir = (
-        custom_nodes_dir / "ComfyUI-TestExtension1" / "example_workflows"
-    )
+    example_workflows_dir = custom_nodes_dir / "ComfyUI-TestExtension1" / "example_workflows"
     example_workflows_dir.mkdir(parents=True)
     template_file = example_workflows_dir / "workflow1.json"
-    template_file.write_text("")
+    template_file.write_text('')
 
-    with patch(
-        "folder_paths.folder_names_and_paths",
-        {"custom_nodes": ([str(custom_nodes_dir)], None)},
-    ):
-        response = await client.get("/workflow_templates")
+    with patch('folder_paths.folder_names_and_paths', {
+        'custom_nodes': ([str(custom_nodes_dir)], None)
+    }):
+        response = await client.get('/workflow_templates')
         assert response.status == 200
         workflows_dict = await response.json()
         assert isinstance(workflows_dict, dict)
         assert "ComfyUI-TestExtension1" in workflows_dict
         assert isinstance(workflows_dict["ComfyUI-TestExtension1"], list)
         assert workflows_dict["ComfyUI-TestExtension1"][0] == "workflow1"
-
-
-async def test_build_translations_empty_when_no_locales(custom_node_manager, tmp_path):
-    custom_nodes_dir = tmp_path / "custom_nodes"
-    custom_nodes_dir.mkdir(parents=True)
-
-    with patch("folder_paths.get_folder_paths", return_value=[str(custom_nodes_dir)]):
-        translations = custom_node_manager.build_translations()
-        assert translations == {}
-
-
-async def test_build_translations_loads_all_files(custom_node_manager, tmp_path):
-    # Setup test directory structure
-    custom_nodes_dir = tmp_path / "custom_nodes" / "test-extension"
-    locales_dir = custom_nodes_dir / "locales" / "en"
-    locales_dir.mkdir(parents=True)
-
-    # Create test translation files
-    main_content = {"title": "Test Extension"}
-    (locales_dir / "main.json").write_text(json.dumps(main_content))
-
-    node_defs = {"node1": "Node 1"}
-    (locales_dir / "nodeDefs.json").write_text(json.dumps(node_defs))
-
-    commands = {"cmd1": "Command 1"}
-    (locales_dir / "commands.json").write_text(json.dumps(commands))
-
-    settings = {"setting1": "Setting 1"}
-    (locales_dir / "settings.json").write_text(json.dumps(settings))
-
-    with patch(
-        "folder_paths.get_folder_paths", return_value=[tmp_path / "custom_nodes"]
-    ):
-        translations = custom_node_manager.build_translations()
-
-        assert translations == {
-            "en": {
-                "title": "Test Extension",
-                "nodeDefs": {"node1": "Node 1"},
-                "commands": {"cmd1": "Command 1"},
-                "settings": {"setting1": "Setting 1"},
-            }
-        }
-
-
-async def test_build_translations_handles_invalid_json(custom_node_manager, tmp_path):
-    # Setup test directory structure
-    custom_nodes_dir = tmp_path / "custom_nodes" / "test-extension"
-    locales_dir = custom_nodes_dir / "locales" / "en"
-    locales_dir.mkdir(parents=True)
-
-    # Create valid main.json
-    main_content = {"title": "Test Extension"}
-    (locales_dir / "main.json").write_text(json.dumps(main_content))
-
-    # Create invalid JSON file
-    (locales_dir / "nodeDefs.json").write_text("invalid json{")
-
-    with patch(
-        "folder_paths.get_folder_paths", return_value=[tmp_path / "custom_nodes"]
-    ):
-        translations = custom_node_manager.build_translations()
-
-        assert translations == {
-            "en": {
-                "title": "Test Extension",
-            }
-        }
-
-
-async def test_build_translations_merges_multiple_extensions(
-    custom_node_manager, tmp_path
-):
-    # Setup test directory structure for two extensions
-    custom_nodes_dir = tmp_path / "custom_nodes"
-    ext1_dir = custom_nodes_dir / "extension1" / "locales" / "en"
-    ext2_dir = custom_nodes_dir / "extension2" / "locales" / "en"
-    ext1_dir.mkdir(parents=True)
-    ext2_dir.mkdir(parents=True)
-
-    # Create translation files for extension 1
-    ext1_main = {"title": "Extension 1", "shared": "Original"}
-    (ext1_dir / "main.json").write_text(json.dumps(ext1_main))
-
-    # Create translation files for extension 2
-    ext2_main = {"description": "Extension 2", "shared": "Override"}
-    (ext2_dir / "main.json").write_text(json.dumps(ext2_main))
-
-    with patch("folder_paths.get_folder_paths", return_value=[str(custom_nodes_dir)]):
-        translations = custom_node_manager.build_translations()
-
-        assert translations == {
-            "en": {
-                "title": "Extension 1",
-                "description": "Extension 2",
-                "shared": "Override",  # Second extension should override first
-            }
-        }

tests-unit/app_test/entities_test.py

@@ -0,0 +1,513 @@
+from comfy.cli_args import args
+
+args.memory_database = True  # force in-memory database for testing
+
+from typing import Callable, Optional
+import pytest
+import pytest_asyncio
+from unittest.mock import patch
+from aiohttp import web
+from app.database.entities import (
+    DeleteEntity,
+    column,
+    table,
+    Column,
+    GetEntity,
+    GetEntityById,
+    CreateEntity,
+    UpsertEntity,
+    UpdateEntity,
+)
+from app.database.db import db
+
+pytestmark = pytest.mark.asyncio
+
+
+def create_table(entity):
+    # reset db
+    db.close()
+
+    cols: list[Column] = entity._columns
+    # Create tables as temporary so when we close the db, the tables are dropped for next test
+    sql = f"CREATE TEMPORARY TABLE {entity._table_name} (  "
+    for col_name, col in cols.items():
+        type = None
+        if col.type == int:
+            type = "INTEGER"
+        elif col.type == str:
+            type = "TEXT"
+
+        sql += f"{col_name} {type}"
+        if col.required:
+            sql += " NOT NULL"
+        sql += ", "
+
+    sql += f"PRIMARY KEY ({', '.join(entity._key_columns)})"
+    sql += ")"
+    db.execute(sql)
+
+
+async def wrap_db(method: Callable, expected_sql: str, expected_args: list):
+    with patch.object(db, "execute", wraps=db.execute) as mock:
+        response = await method()
+        assert mock.call_count == 1
+        assert mock.call_args[0][0] == expected_sql
+        assert mock.call_args[0][1:] == expected_args
+        return response
+
+
+@pytest.fixture
+def getable_entity():
+    @table("getable_entity")
+    class GetableEntity(GetEntity):
+        id: int = column(int, required=True, key=True)
+        test: str = column(str, required=True)
+        nullable: Optional[str] = column(str)
+
+    return GetableEntity
+
+
+@pytest.fixture
+def getable_by_id_entity():
+    @table("getable_by_id_entity")
+    class GetableByIdEntity(GetEntityById):
+        id: int = column(int, required=True, key=True)
+        test: str = column(str, required=True)
+
+    return GetableByIdEntity
+
+
+@pytest.fixture
+def getable_by_id_composite_entity():
+    @table("getable_by_id_composite_entity")
+    class GetableByIdCompositeEntity(GetEntityById):
+        id1: str = column(str, required=True, key=True)
+        id2: int = column(int, required=True, key=True)
+        test: str = column(str, required=True)
+
+    return GetableByIdCompositeEntity
+
+
+@pytest.fixture
+def creatable_entity():
+    @table("creatable_entity")
+    class CreatableEntity(CreateEntity):
+        id: int = column(int, required=True, key=True)
+        test: str = column(str, required=True)
+        reqd: str = column(str, required=True)
+        nullable: Optional[str] = column(str)
+
+    return CreatableEntity
+
+
+@pytest.fixture
+def upsertable_entity():
+    @table("upsertable_entity")
+    class UpsertableEntity(UpsertEntity):
+        id: int = column(int, required=True, key=True)
+        test: str = column(str, required=True)
+        reqd: str = column(str, required=True)
+        nullable: Optional[str] = column(str)
+
+    return UpsertableEntity
+
+
+@pytest.fixture
+def updateable_entity():
+    @table("updateable_entity")
+    class UpdateableEntity(UpdateEntity):
+        id: int = column(int, required=True, key=True)
+        reqd: str = column(str, required=True)
+
+    return UpdateableEntity
+
+
+@pytest.fixture
+def deletable_entity():
+    @table("deletable_entity")
+    class DeletableEntity(DeleteEntity):
+        id: int = column(int, required=True, key=True)
+
+    return DeletableEntity
+
+
+@pytest.fixture
+def deletable_composite_entity():
+    @table("deletable_composite_entity")
+    class DeletableCompositeEntity(DeleteEntity):
+        id1: str = column(str, required=True, key=True)
+        id2: int = column(int, required=True, key=True)
+
+    return DeletableCompositeEntity
+
+
+@pytest.fixture()
+def entity(request):
+    value = request.getfixturevalue(request.param)
+    create_table(value)
+    return value
+
+
+@pytest_asyncio.fixture
+async def client(aiohttp_client, app):
+    return await aiohttp_client(app)
+
+
+@pytest.fixture
+def app(entity):
+    app = web.Application()
+    routes = web.RouteTableDef()
+    entity.register_route(routes)
+    app.add_routes(routes)
+    return app
+
+
+@pytest.mark.parametrize("entity", ["getable_entity"], indirect=True)
+async def test_get_model_empty_response(client):
+    expected_sql = "SELECT * FROM getable_entity"
+    expected_args = ()
+    response = await wrap_db(
+        lambda: client.get("/db/getable_entity"), expected_sql, expected_args
+    )
+
+    assert response.status == 200
+    assert await response.json() == []
+
+
+@pytest.mark.parametrize("entity", ["getable_entity"], indirect=True)
+async def test_get_model_with_data(client):
+    # seed db
+    db.execute(
+        "INSERT INTO getable_entity (id, test, nullable) VALUES (1, 'test1', NULL), (2, 'test2', 'test2')"
+    )
+
+    expected_sql = "SELECT * FROM getable_entity"
+    expected_args = ()
+    response = await wrap_db(
+        lambda: client.get("/db/getable_entity"), expected_sql, expected_args
+    )
+
+    assert response.status == 200
+    assert await response.json() == [
+        {"id": 1, "test": "test1", "nullable": None},
+        {"id": 2, "test": "test2", "nullable": "test2"},
+    ]
+
+
+@pytest.mark.parametrize("entity", ["getable_entity"], indirect=True)
+async def test_get_model_with_top_parameter(client):
+    # seed with 3 rows
+    db.execute(
+        "INSERT INTO getable_entity (id, test, nullable) VALUES (1, 'test1', NULL), (2, 'test2', 'test2'), (3, 'test3', 'test3')"
+    )
+
+    expected_sql = "SELECT * FROM getable_entity LIMIT 2"
+    expected_args = ()
+    response = await wrap_db(
+        lambda: client.get("/db/getable_entity?top=2"),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == [
+        {"id": 1, "test": "test1", "nullable": None},
+        {"id": 2, "test": "test2", "nullable": "test2"},
+    ]
+
+
+@pytest.mark.parametrize("entity", ["getable_entity"], indirect=True)
+async def test_get_model_with_invalid_top_parameter(client):
+    response = await client.get("/db/getable_entity?top=hello")
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid top parameter",
+        "field": "top",
+        "value": "hello",
+    }
+
+
+@pytest.mark.parametrize("entity", ["getable_by_id_entity"], indirect=True)
+async def test_get_model_by_id_empty_response(client):
+    # seed db
+    db.execute("INSERT INTO getable_by_id_entity (id, test) VALUES (1, 'test1')")
+
+    expected_sql = "SELECT * FROM getable_by_id_entity WHERE id = ?"
+    expected_args = (1,)
+    response = await wrap_db(
+        lambda: client.get("/db/getable_by_id_entity/1"),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == [
+        {"id": 1, "test": "test1"},
+    ]
+
+
+@pytest.mark.parametrize("entity", ["getable_by_id_entity"], indirect=True)
+async def test_get_model_by_id_with_invalid_id(client):
+    response = await client.get("/db/getable_by_id_entity/hello")
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid value",
+        "field": "id",
+        "value": "hello",
+    }
+
+
+@pytest.mark.parametrize("entity", ["getable_by_id_composite_entity"], indirect=True)
+async def test_get_model_by_id_composite(client):
+    # seed db
+    db.execute(
+        "INSERT INTO getable_by_id_composite_entity (id1, id2, test) VALUES ('one', 2, 'test')"
+    )
+
+    expected_sql = (
+        "SELECT * FROM getable_by_id_composite_entity WHERE id1 = ? AND id2 = ?"
+    )
+    expected_args = ("one", 2)
+    response = await wrap_db(
+        lambda: client.get("/db/getable_by_id_composite_entity/one/2"),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == [
+        {"id1": "one", "id2": 2, "test": "test"},
+    ]
+
+
+@pytest.mark.parametrize("entity", ["getable_by_id_composite_entity"], indirect=True)
+async def test_get_model_by_id_composite_with_invalid_id(client):
+    response = await client.get("/db/getable_by_id_composite_entity/hello/hello")
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid value",
+        "field": "id2",
+        "value": "hello",
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model(client):
+    expected_sql = (
+        "INSERT INTO creatable_entity (id, test, reqd) VALUES (?, ?, ?) RETURNING *"
+    )
+    expected_args = (1, "test1", "reqd1")
+    response = await wrap_db(
+        lambda: client.post(
+            "/db/creatable_entity", json={"id": 1, "test": "test1", "reqd": "reqd1"}
+        ),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == {
+        "id": 1,
+        "test": "test1",
+        "reqd": "reqd1",
+        "nullable": None,
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_missing_required_field(client):
+    response = await client.post(
+        "/db/creatable_entity", json={"id": 1, "test": "test1"}
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Missing field",
+        "field": "reqd",
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_missing_key_field(client):
+    response = await client.post(
+        "/db/creatable_entity",
+        json={"test": "test1", "reqd": "reqd1"},  # Missing 'id' which is a key
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Missing field",
+        "field": "id",
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_invalid_key_data(client):
+    response = await client.post(
+        "/db/creatable_entity",
+        json={
+            "id": "not_an_integer",
+            "test": "test1",
+            "reqd": "reqd1",
+        },  # id should be int
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid value",
+        "field": "id",
+        "value": "not_an_integer",
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_invalid_field_data(client):
+    response = await client.post(
+        "/db/creatable_entity",
+        json={"id": "aaa", "test": "123", "reqd": "reqd1"},  # id should be int
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid value",
+        "field": "id",
+        "value": "aaa",
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_invalid_field_type(client):
+    response = await client.post(
+        "/db/creatable_entity",
+        json={
+            "id": 1,
+            "test": ["invalid_array"],
+            "reqd": "reqd1",
+        },  # test should be string
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Invalid value",
+        "field": "test",
+        "value": ["invalid_array"],
+    }
+
+
+@pytest.mark.parametrize("entity", ["creatable_entity"], indirect=True)
+async def test_create_model_invalid_field_name(client):
+    response = await client.post(
+        "/db/creatable_entity",
+        json={"id": 1, "test": "test1", "reqd": "reqd1", "nonexistent_field": "value"},
+    )
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Unknown field",
+        "field": "nonexistent_field",
+    }
+
+
+@pytest.mark.parametrize("entity", ["upsertable_entity"], indirect=True)
+async def test_upsert_model(client):
+    expected_sql = (
+        "INSERT INTO upsertable_entity (id, test, reqd) VALUES (?, ?, ?) "
+        "ON CONFLICT (id) DO UPDATE SET test = excluded.test, reqd = excluded.reqd "
+        "RETURNING *"
+    )
+    expected_args = (1, "test1", "reqd1")
+    response = await wrap_db(
+        lambda: client.put(
+            "/db/upsertable_entity", json={"id": 1, "test": "test1", "reqd": "reqd1"}
+        ),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == {
+        "id": 1,
+        "test": "test1",
+        "reqd": "reqd1",
+        "nullable": None,
+    }
+
+
+@pytest.mark.parametrize("entity", ["updateable_entity"], indirect=True)
+async def test_update_model(client):
+    # seed db
+    db.execute("INSERT INTO updateable_entity (id, reqd) VALUES (1, 'test1')")
+
+    expected_sql = "UPDATE updateable_entity SET reqd = ? WHERE id = ? RETURNING *"
+    expected_args = ("updated_test", 1)
+    response = await wrap_db(
+        lambda: client.patch("/db/updateable_entity/1", json={"reqd": "updated_test"}),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 200
+    assert await response.json() == {
+        "id": 1,
+        "reqd": "updated_test",
+    }
+
+
+@pytest.mark.parametrize("entity", ["updateable_entity"], indirect=True)
+async def test_update_model_reject_null_required_field(client):
+    response = await client.patch("/db/updateable_entity/1", json={"reqd": None})
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Required field",
+        "field": "reqd",
+    }
+
+
+@pytest.mark.parametrize("entity", ["updateable_entity"], indirect=True)
+async def test_update_model_reject_invalid_field(client):
+    response = await client.patch("/db/updateable_entity/1", json={"hello": "world"})
+
+    assert response.status == 400
+    assert await response.json() == {
+        "message": "Unknown field",
+        "field": "hello",
+    }
+
+
+@pytest.mark.parametrize("entity", ["updateable_entity"], indirect=True)
+async def test_update_model_reject_missing_record(client):
+    response = await client.patch(
+        "/db/updateable_entity/1", json={"reqd": "updated_test"}
+    )
+
+    assert response.status == 404
+    assert await response.json() == {
+        "message": "Failed to update entity",
+    }
+
+
+@pytest.mark.parametrize("entity", ["deletable_entity"], indirect=True)
+async def test_delete_model(client):
+    expected_sql = "DELETE FROM deletable_entity WHERE id = ?"
+    expected_args = (1,)
+    response = await wrap_db(
+        lambda: client.delete("/db/deletable_entity/1"),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 204
+
+
+@pytest.mark.parametrize("entity", ["deletable_composite_entity"], indirect=True)
+async def test_delete_model_composite_key(client):
+    expected_sql = "DELETE FROM deletable_composite_entity WHERE id1 = ? AND id2 = ?"
+    expected_args = ("one", 2)
+    response = await wrap_db(
+        lambda: client.delete("/db/deletable_composite_entity/one/2"),
+        expected_sql,
+        expected_args,
+    )
+
+    assert response.status == 204

tests-unit/comfy_test/folder_path_test.py

@@ -1,23 +1,19 @@
 ### 🗻 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():
-    # Reload the module after each test to ensure isolation
+    # 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()
     yield
-    reload(folder_paths)
+    folder_paths.folder_names_and_paths = original
 
 @pytest.fixture
 def temp_dir():
@@ -25,21 +21,7 @@ def temp_dir():
         yield tmpdirname
 
 
-@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):
+def test_get_directory_by_type():
     test_dir = "/test/dir"
     folder_paths.set_output_directory(test_dir)
     assert folder_paths.get_directory_by_type("output") == test_dir
@@ -114,49 +96,3 @@ 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

tests-unit/utils/json_util_test.py

@@ -1,71 +0,0 @@
-from utils.json_util import merge_json_recursive
-
-
-def test_merge_simple_dicts():
-    base = {"a": 1, "b": 2}
-    update = {"b": 3, "c": 4}
-    expected = {"a": 1, "b": 3, "c": 4}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_nested_dicts():
-    base = {"a": {"x": 1, "y": 2}, "b": 3}
-    update = {"a": {"y": 4, "z": 5}}
-    expected = {"a": {"x": 1, "y": 4, "z": 5}, "b": 3}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_lists():
-    base = {"a": [1, 2], "b": 3}
-    update = {"a": [3, 4]}
-    expected = {"a": [1, 2, 3, 4], "b": 3}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_nested_lists():
-    base = {"a": {"x": [1, 2]}}
-    update = {"a": {"x": [3, 4]}}
-    expected = {"a": {"x": [1, 2, 3, 4]}}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_mixed_types():
-    base = {"a": [1, 2], "b": {"x": 1}}
-    update = {"a": [3], "b": {"y": 2}}
-    expected = {"a": [1, 2, 3], "b": {"x": 1, "y": 2}}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_overwrite_non_dict():
-    base = {"a": 1}
-    update = {"a": {"x": 2}}
-    expected = {"a": {"x": 2}}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_empty_dicts():
-    base = {}
-    update = {"a": 1}
-    expected = {"a": 1}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_none_values():
-    base = {"a": None}
-    update = {"a": {"x": 1}}
-    expected = {"a": {"x": 1}}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_different_types():
-    base = {"a": [1, 2]}
-    update = {"a": "string"}
-    expected = {"a": "string"}
-    assert merge_json_recursive(base, update) == expected
-
-
-def test_merge_complex_nested():
-    base = {"a": [1, 2], "b": {"x": [3, 4], "y": {"p": 1}}}
-    update = {"a": [5], "b": {"x": [6], "y": {"q": 2}}}
-    expected = {"a": [1, 2, 5], "b": {"x": [3, 4, 6], "y": {"p": 1, "q": 2}}}
-    assert merge_json_recursive(base, update) == expected

utils/json_util.py

@@ -1,26 +0,0 @@
-def merge_json_recursive(base, update):
-    """Recursively merge two JSON-like objects.
-    - Dictionaries are merged recursively
-    - Lists are concatenated
-    - Other types are overwritten by the update value
-
-    Args:
-        base: Base JSON-like object
-        update: Update JSON-like object to merge into base
-
-    Returns:
-        Merged JSON-like object
-    """
-    if not isinstance(base, dict) or not isinstance(update, dict):
-        if isinstance(base, list) and isinstance(update, list):
-            return base + update
-        return update
-
-    merged = base.copy()
-    for key, value in update.items():
-        if key in merged:
-            merged[key] = merge_json_recursive(merged[key], value)
-        else:
-            merged[key] = value
-
-    return merged

web/assets/BaseViewTemplate-BNGF4K22.js

@@ -0,0 +1,23 @@
+import { d as defineComponent, o as openBlock, f as createElementBlock, J as renderSlot, T as normalizeClass } from "./index-DjNHn37O.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "BaseViewTemplate",
+  props: {
+    dark: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["font-sans w-screen h-screen flex items-center justify-center pointer-events-auto overflow-auto", [
+          props.dark ? "text-neutral-300 bg-neutral-900 dark-theme" : "text-neutral-900 bg-neutral-300"
+        ]])
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};
+//# sourceMappingURL=BaseViewTemplate-BNGF4K22.js.map

web/assets/BaseViewTemplate-v6omkdXg.js

@@ -1,51 +0,0 @@
-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",
-  props: {
-    dark: { type: Boolean, default: false }
-  },
-  setup(__props) {
-    const props = __props;
-    const darkTheme = {
-      color: "rgba(0, 0, 0, 0)",
-      symbolColor: "#d4d4d4"
-    };
-    const lightTheme = {
-      color: "rgba(0, 0, 0, 0)",
-      symbolColor: "#171717"
-    };
-    const topMenuRef = ref(null);
-    onMounted(async () => {
-      if (isElectron()) {
-        await nextTick();
-        electronAPI().changeTheme({
-          ...props.dark ? darkTheme : lightTheme,
-          height: topMenuRef.value.getBoundingClientRect().height
-        });
-      }
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["font-sans w-screen h-screen flex flex-col pointer-events-auto", [
-          props.dark ? "text-neutral-300 bg-neutral-900 dark-theme" : "text-neutral-900 bg-neutral-300"
-        ]])
-      }, [
-        withDirectives(createBaseVNode("div", {
-          ref_key: "topMenuRef",
-          ref: topMenuRef,
-          class: "app-drag w-full h-[var(--comfy-topbar-height)]"
-        }, null, 512), [
-          [vShow, unref(isNativeWindow)()]
-        ]),
-        createBaseVNode("div", _hoisted_1, [
-          renderSlot(_ctx.$slots, "default")
-        ])
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as _
-};
-//# sourceMappingURL=BaseViewTemplate-v6omkdXg.js.map

web/assets/DesktopStartView-coDnSXEF.js

@@ -1,22 +0,0 @@
-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",
-  setup(__props) {
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(_sfc_main$1, { dark: "" }, {
-        default: withCtx(() => [
-          createBaseVNode("div", _hoisted_1, [
-            createVNode(unref(script), { mode: "indeterminate" })
-          ])
-        ]),
-        _: 1
-      });
-    };
-  }
-});
-export {
-  _sfc_main as default
-};
-//# sourceMappingURL=DesktopStartView-coDnSXEF.js.map

web/assets/DownloadGitView-DeC7MBzG.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, 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";
+import { d as defineComponent, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, X as toDisplayString, N as createVNode, j as unref, l as script, bW as useRouter } from "./index-DjNHn37O.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.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-3STu4yxt.js.map
+//# sourceMappingURL=DownloadGitView-DeC7MBzG.js.map

web/assets/ExtensionPanel-D4Phn0Zr.js

@@ -1,8 +1,9 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { d as defineComponent, ab as ref, cn as FilterMatchMode, cs as useExtensionStore, a as useSettingStore, m as onMounted, c as computed, o as openBlock, k as createBlock, M as withCtx, N as createVNode, co as SearchBox, j as unref, bZ as script, H as createBaseVNode, f as createElementBlock, E as renderList, X as toDisplayString, aE as createTextVNode, F as Fragment, l as script$1, I as createCommentVNode, aI as script$3, bO as script$4, c4 as script$5, cp as _sfc_main$1 } from "./index-DjNHn37O.js";
+import { s as script$2, a as script$6 } from "./index-B5F0uxTQ.js";
+import "./index-B-aVupP5.js";
+import "./index-5HFeZax4.js";
 const _hoisted_1 = { class: "flex justify-end" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "ExtensionPanel",
@@ -179,4 +180,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=ExtensionPanel-GE0aOkbr.js.map
+//# sourceMappingURL=ExtensionPanel-D4Phn0Zr.js.map

web/assets/GraphView-CIRWBKTm.css

@@ -1,10 +1,8 @@
 
-.comfy-menu-hamburger[data-v-7ed57d1a] {
-    pointer-events: auto;
-    position: fixed;
-    z-index: 9999;
-    display: flex;
-    flex-direction: row
+.comfy-menu-hamburger[data-v-5661bed0] {
+  pointer-events: auto;
+  position: fixed;
+  z-index: 9999;
 }
 
 [data-v-e50caa15] .p-splitter-gutter {
@@ -41,14 +39,14 @@
   z-index: 999;
 }
 
-.p-buttongroup-vertical[data-v-cb8f9a1a] {
+.p-buttongroup-vertical[data-v-cf40dd39] {
   display: flex;
   flex-direction: column;
   border-radius: var(--p-button-border-radius);
   overflow: hidden;
   border: 1px solid var(--p-panel-border-color);
 }
-.p-buttongroup-vertical .p-button[data-v-cb8f9a1a] {
+.p-buttongroup-vertical .p-button[data-v-cf40dd39] {
   margin: 0;
   border-radius: 0;
 }
@@ -84,7 +82,7 @@
   font-size: inherit;
 }
 
-[data-v-fd0a74bd] .highlight {
+[data-v-5741c9ae] .highlight {
   background-color: var(--p-primary-color);
   color: var(--p-primary-contrast-color);
   font-weight: bold;
@@ -133,7 +131,16 @@
   border-right: 4px solid var(--p-button-text-primary-color);
 }
 
-.side-tool-bar-container[data-v-33cac83a] {
+:root {
+  --sidebar-width: 64px;
+  --sidebar-icon-size: 1.5rem;
+}
+:root .small-sidebar {
+  --sidebar-width: 40px;
+  --sidebar-icon-size: 1rem;
+}
+
+.side-tool-bar-container[data-v-37d8d7b4] {
   display: flex;
   flex-direction: column;
   align-items: center;
@@ -146,91 +153,18 @@
   background-color: var(--comfy-menu-secondary-bg);
   color: var(--fg-color);
   box-shadow: var(--bar-shadow);
-
-  --sidebar-width: 4rem;
-  --sidebar-icon-size: 1.5rem;
 }
-.side-tool-bar-container.small-sidebar[data-v-33cac83a] {
-  --sidebar-width: 2.5rem;
-  --sidebar-icon-size: 1rem;
-}
-.side-tool-bar-end[data-v-33cac83a] {
+.side-tool-bar-end[data-v-37d8d7b4] {
   align-self: flex-end;
   margin-top: auto;
 }
 
-.status-indicator[data-v-8d011a31] {
-  position: absolute;
-  font-weight: 700;
-  font-size: 1.5rem;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%)
-}
-
-[data-v-54fadc45] .p-togglebutton {
-  position: relative;
-  flex-shrink: 0;
-  border-radius: 0px;
-  border-width: 0px;
-  border-right-width: 1px;
-  border-style: solid;
-  background-color: transparent;
-  padding: 0px;
-  border-right-color: var(--border-color)
-}
-[data-v-54fadc45] .p-togglebutton::before {
-  display: none
-}
-[data-v-54fadc45] .p-togglebutton:first-child {
-  border-left-width: 1px;
-  border-style: solid;
-  border-left-color: var(--border-color)
-}
-[data-v-54fadc45] .p-togglebutton:not(:first-child) {
-  border-left-width: 0px
-}
-[data-v-54fadc45] .p-togglebutton.p-togglebutton-checked {
-  height: 100%;
-  border-bottom-width: 1px;
-  border-style: solid;
-  border-bottom-color: var(--p-button-text-primary-color)
-}
-[data-v-54fadc45] .p-togglebutton:not(.p-togglebutton-checked) {
-  opacity: 0.75
-}
-[data-v-54fadc45] .p-togglebutton-checked .close-button,[data-v-54fadc45] .p-togglebutton:hover .close-button {
-  visibility: visible
-}
-[data-v-54fadc45] .p-togglebutton:hover .status-indicator {
-  display: none
-}
-[data-v-54fadc45] .p-togglebutton .close-button {
-  visibility: hidden
-}
-[data-v-54fadc45] .p-scrollpanel-content {
-  height: 100%
-}
-
-/* Scrollbar half opacity to avoid blocking the active tab bottom border */
-[data-v-54fadc45] .p-scrollpanel:hover .p-scrollpanel-bar,[data-v-54fadc45] .p-scrollpanel:active .p-scrollpanel-bar {
-  opacity: 0.5
-}
-[data-v-54fadc45] .p-selectbutton {
-  height: 100%;
-  border-radius: 0px
-}
-
-[data-v-38831d8e] .workflow-tabs {
-  background-color: var(--comfy-menu-bg);
-}
-
-[data-v-26957f1f] .p-inputtext {
+[data-v-b9328350] .p-inputtext {
   border-top-left-radius: 0;
   border-bottom-left-radius: 0;
 }
 
-.comfyui-queue-button[data-v-91a628af] .p-splitbutton-dropdown {
+.comfyui-queue-button[data-v-7f4f551b] .p-splitbutton-dropdown {
   border-top-right-radius: 0;
   border-bottom-right-radius: 0;
 }
@@ -261,23 +195,55 @@
   display: none;
 }
 
-.top-menubar[data-v-56df69d2] .p-menubar-item-link svg {
+.top-menubar[data-v-6fecd137] .p-menubar-item-link svg {
   display: none;
 }
-[data-v-56df69d2] .p-menubar-submenu.dropdown-direction-up {
+[data-v-6fecd137] .p-menubar-submenu.dropdown-direction-up {
   top: auto;
   bottom: 100%;
   flex-direction: column-reverse;
 }
-.keybinding-tag[data-v-56df69d2] {
+.keybinding-tag[data-v-6fecd137] {
   background: var(--p-content-hover-background);
   border-color: var(--p-content-border-color);
   border-style: solid;
 }
 
-.comfyui-menu[data-v-929e7543] {
+.status-indicator[data-v-8d011a31] {
+  position: absolute;
+  font-weight: 700;
+  font-size: 1.5rem;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%)
+}
+
+[data-v-d485c044] .p-togglebutton::before {
+  display: none
+}
+[data-v-d485c044] .p-togglebutton {
+  position: relative;
+  flex-shrink: 0;
+  border-radius: 0px;
+  background-color: transparent;
+  padding: 0px
+}
+[data-v-d485c044] .p-togglebutton.p-togglebutton-checked {
+  border-bottom-width: 2px;
+  border-bottom-color: var(--p-button-text-primary-color)
+}
+[data-v-d485c044] .p-togglebutton-checked .close-button,[data-v-d485c044] .p-togglebutton:hover .close-button {
+  visibility: visible
+}
+[data-v-d485c044] .p-togglebutton:hover .status-indicator {
+  display: none
+}
+[data-v-d485c044] .p-togglebutton .close-button {
+  visibility: hidden
+}
+
+.comfyui-menu[data-v-878b63b8] {
   width: 100vw;
-  height: var(--comfy-topbar-height);
   background: var(--comfy-menu-bg);
   color: var(--fg-color);
   box-shadow: var(--bar-shadow);
@@ -287,17 +253,18 @@
   z-index: 1000;
   order: 0;
   grid-column: 1/-1;
+  max-height: 90vh;
 }
-.comfyui-menu.dropzone[data-v-929e7543] {
+.comfyui-menu.dropzone[data-v-878b63b8] {
   background: var(--p-highlight-background);
 }
-.comfyui-menu.dropzone-active[data-v-929e7543] {
+.comfyui-menu.dropzone-active[data-v-878b63b8] {
   background: var(--p-highlight-background-focus);
 }
-[data-v-929e7543] .p-menubar-item-label {
+[data-v-878b63b8] .p-menubar-item-label {
   line-height: revert;
 }
-.comfyui-logo[data-v-929e7543] {
+.comfyui-logo[data-v-878b63b8] {
   font-size: 1.2em;
   -webkit-user-select: none;
      -moz-user-select: none;

web/assets/InstallView-CwQdoH-C.css

@@ -1,20 +1,18 @@
 
-.p-tag[data-v-79125ff6] {
+:root {
   --p-tag-gap: 0.5rem;
 }
 .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 {
+&:hover {
     filter: brightness(107%) contrast(105%);
     box-shadow: 0 0 0.25rem #ffffff79;
 }
 }
-.p-accordioncontent-content[data-v-79125ff6] {
+.p-accordioncontent-content {
   border-radius: 0.5rem;
   --tw-bg-opacity: 1;
   background-color: rgb(23 23 23 / var(--tw-bg-opacity));
@@ -23,14 +21,14 @@
   transition-duration: 150ms;
 }
 div.selected {
-.gpu-button[data-v-79125ff6]:not(.selected) {
+.gpu-button:not(.selected) {
     opacity: 0.5;
 }
-.gpu-button[data-v-79125ff6]:not(.selected):hover {
+.gpu-button:not(.selected):hover {
     opacity: 1;
 }
 }
-.gpu-button[data-v-79125ff6] {
+.gpu-button {
   margin: 0px;
   display: flex;
   width: 50%;
@@ -45,37 +43,37 @@ div.selected {
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
   transition-duration: 150ms;
 }
-.gpu-button[data-v-79125ff6]:hover {
+.gpu-button:hover {
   --tw-bg-opacity: 0.75;
 }
 .gpu-button {
-&.selected[data-v-79125ff6] {
+&.selected {
     --tw-bg-opacity: 1;
     background-color: rgb(64 64 64 / var(--tw-bg-opacity));
 }
-&.selected[data-v-79125ff6] {
+&.selected {
     --tw-bg-opacity: 0.5;
 }
-&.selected[data-v-79125ff6] {
+&.selected {
     opacity: 1;
 }
-&.selected[data-v-79125ff6]:hover {
+&.selected:hover {
     --tw-bg-opacity: 0.6;
 }
 }
-.disabled[data-v-79125ff6] {
+.disabled {
   pointer-events: none;
   opacity: 0.4;
 }
-.p-card-header[data-v-79125ff6] {
+.p-card-header {
   flex-grow: 1;
   text-align: center;
 }
-.p-card-body[data-v-79125ff6] {
+.p-card-body {
   padding-top: 0px;
   text-align: center;
 }
 
-[data-v-cd6731d2] .p-steppanel {
+[data-v-de33872d] .p-steppanel {
     background-color: transparent
 }

web/assets/InstallView-DTDlVr0Z.js

@@ -1,945 +0,0 @@
-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/KeybindingPanel-Dc3C4lG1.js

@@ -1,9 +1,10 @@
 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, 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";
+import { d as defineComponent, c as computed, o as openBlock, f as createElementBlock, F as Fragment, E as renderList, N as createVNode, M as withCtx, aE as createTextVNode, X as toDisplayString, j as unref, aI as script, I as createCommentVNode, ab as ref, cn as FilterMatchMode, a$ as useKeybindingStore, a2 as useCommandStore, a1 as useI18n, af as normalizeI18nKey, w as watchEffect, bs as useToast, r as resolveDirective, k as createBlock, co as SearchBox, H as createBaseVNode, l as script$2, av as script$4, bM as withModifiers, bZ as script$5, aP as script$6, i as withDirectives, cp as _sfc_main$2, aL as pushScopeId, aM as popScopeId, cq as KeyComboImpl, cr as KeybindingImpl, _ as _export_sfc } from "./index-DjNHn37O.js";
+import { s as script$1, a as script$3 } from "./index-B5F0uxTQ.js";
+import { u as useKeybindingService } from "./keybindingService-Bx7YdkXn.js";
+import "./index-B-aVupP5.js";
+import "./index-5HFeZax4.js";
 const _hoisted_1$1 = {
   key: 0,
   class: "px-2"
@@ -36,6 +37,7 @@ 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 };
@@ -246,7 +248,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   severity: "error"
                 }, {
                   default: withCtx(() => [
-                    _cache[3] || (_cache[3] = createTextVNode(" Keybinding already exists on ")),
+                    createTextVNode(" Keybinding already exists on "),
                     createVNode(unref(script), {
                       severity: "secondary",
                       value: existingKeybindingOnCombo.value.commandId
@@ -279,4 +281,4 @@ const KeybindingPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "d
 export {
   KeybindingPanel as default
 };
-//# sourceMappingURL=KeybindingPanel-C0Nt6GXU.js.map
+//# sourceMappingURL=KeybindingPanel-Dc3C4lG1.js.map

web/assets/MaintenanceView-Bj5_Vr6o.css

@@ -1,87 +0,0 @@
-
-.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-B6ecEClB.css

@@ -1,7 +1,7 @@
 
-.p-tag[data-v-dc169863] {
+:root {
   --p-tag-gap: 0.5rem;
 }
-.comfy-installer[data-v-dc169863] {
+.comfy-installer {
   margin-top: max(1rem, max(0px, calc((100vh - 42rem) * 0.5)));
 }

web/assets/ManualConfigurationView-Bi_qHE-n.js

@@ -1,7 +1,9 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { d as defineComponent, a1 as useI18n, ab as ref, m as onMounted, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, X as toDisplayString, N as createVNode, j as unref, aI as script, l as script$2, c0 as electronAPI } from "./index-DjNHn37O.js";
+import { s as script$1 } from "./index-jXPKy3pP.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.js";
+import "./index-5HFeZax4.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" };
@@ -67,8 +69,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const ManualConfigurationView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-dc169863"]]);
 export {
-  ManualConfigurationView as default
+  _sfc_main as default
 };
-//# sourceMappingURL=ManualConfigurationView-DueOvLuK.js.map
+//# sourceMappingURL=ManualConfigurationView-Bi_qHE-n.js.map

web/assets/MetricsConsentView-DTQYUF4Z.js

@@ -1,86 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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" };
-const _hoisted_4 = { class: "text-neutral-400" };
-const _hoisted_5 = { class: "text-neutral-400" };
-const _hoisted_6 = {
-  href: "https://comfy.org/privacy",
-  target: "_blank",
-  class: "text-blue-400 hover:text-blue-300 underline"
-};
-const _hoisted_7 = { class: "flex items-center gap-4" };
-const _hoisted_8 = {
-  id: "metricsDescription",
-  class: "text-neutral-100"
-};
-const _hoisted_9 = { class: "flex pt-6 justify-end" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "MetricsConsentView",
-  setup(__props) {
-    const toast = useToast();
-    const { t } = useI18n();
-    const allowMetrics = ref(true);
-    const router = useRouter();
-    const isUpdating = ref(false);
-    const updateConsent = /* @__PURE__ */ __name(async () => {
-      isUpdating.value = true;
-      try {
-        await electronAPI().setMetricsConsent(allowMetrics.value);
-      } catch (error) {
-        toast.add({
-          severity: "error",
-          summary: t("install.errorUpdatingConsent"),
-          detail: t("install.errorUpdatingConsentDetail"),
-          life: 3e3
-        });
-      } finally {
-        isUpdating.value = false;
-      }
-      router.push("/");
-    }, "updateConsent");
-    return (_ctx, _cache) => {
-      const _component_BaseViewTemplate = _sfc_main$1;
-      return openBlock(), createBlock(_component_BaseViewTemplate, { dark: "" }, {
-        default: withCtx(() => [
-          createBaseVNode("div", _hoisted_1, [
-            createBaseVNode("div", _hoisted_2, [
-              createBaseVNode("h2", _hoisted_3, toDisplayString(_ctx.$t("install.helpImprove")), 1),
-              createBaseVNode("p", _hoisted_4, toDisplayString(_ctx.$t("install.updateConsent")), 1),
-              createBaseVNode("p", _hoisted_5, [
-                createTextVNode(toDisplayString(_ctx.$t("install.moreInfo")) + " ", 1),
-                createBaseVNode("a", _hoisted_6, toDisplayString(_ctx.$t("install.privacyPolicy")), 1),
-                _cache[1] || (_cache[1] = createTextVNode(". "))
-              ]),
-              createBaseVNode("div", _hoisted_7, [
-                createVNode(unref(script), {
-                  modelValue: allowMetrics.value,
-                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => allowMetrics.value = $event),
-                  "aria-describedby": "metricsDescription"
-                }, null, 8, ["modelValue"]),
-                createBaseVNode("span", _hoisted_8, toDisplayString(allowMetrics.value ? _ctx.$t("install.metricsEnabled") : _ctx.$t("install.metricsDisabled")), 1)
-              ]),
-              createBaseVNode("div", _hoisted_9, [
-                createVNode(unref(script$1), {
-                  label: _ctx.$t("g.ok"),
-                  icon: "pi pi-check",
-                  loading: isUpdating.value,
-                  iconPos: "right",
-                  onClick: updateConsent
-                }, null, 8, ["label", "loading"])
-              ])
-            ])
-          ])
-        ]),
-        _: 1
-      });
-    };
-  }
-});
-export {
-  _sfc_main as default
-};
-//# sourceMappingURL=MetricsConsentView-DTQYUF4Z.js.map

web/assets/NotSupportedView-Drz3x2d-.js

@@ -1,16 +1,21 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { d as defineComponent, bW as useRouter, r as resolveDirective, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, X as toDisplayString, N as createVNode, j as unref, l as script, i as withDirectives } from "./index-DjNHn37O.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.js";
 const _imports_0 = "" + new URL("images/sad_girl.png", import.meta.url).href;
 const _hoisted_1 = { class: "sad-container" };
-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 _hoisted_2 = /* @__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 _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "NotSupportedView",
   setup(__props) {
@@ -32,22 +37,18 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       return openBlock(), createBlock(_sfc_main$1, null, {
         default: withCtx(() => [
           createBaseVNode("div", _hoisted_1, [
-            _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, [
+            _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, [
                     createBaseVNode("li", null, toDisplayString(_ctx.$t("notSupported.supportedDevices.macos")), 1),
                     createBaseVNode("li", null, toDisplayString(_ctx.$t("notSupported.supportedDevices.windows")), 1)
                   ])
                 ]),
-                createBaseVNode("div", _hoisted_8, [
+                createBaseVNode("div", _hoisted_9, [
                   createVNode(unref(script), {
                     label: _ctx.$t("notSupported.learnMore"),
                     icon: "pi pi-github",
@@ -79,8 +80,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const NotSupportedView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ebb20958"]]);
 export {
-  NotSupportedView as default
+  _sfc_main as default
 };
-//# sourceMappingURL=NotSupportedView-PDDrAb9U.js.map
+//# sourceMappingURL=NotSupportedView-Drz3x2d-.js.map

web/assets/NotSupportedView-bFzHmqNj.css

@@ -1,19 +1,17 @@
 
 .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;
 }
 }
-.sad-text[data-v-ebb20958] {
+.sad-text {
   grid-column: 1/3;
 }
-.sad-girl[data-v-ebb20958] {
+.sad-girl {
   grid-column: 2/3;
   width: min(75vw, 100vh);
 }

web/assets/ServerConfigPanel-Be4StJmv.js

@@ -1,23 +1,25 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { H as createBaseVNode, o as openBlock, f as createElementBlock, Z as markRaw, d as defineComponent, a as useSettingStore, aS as storeToRefs, a5 as watch, cO as useCopyToClipboard, a1 as useI18n, k as createBlock, M as withCtx, j as unref, bZ as script, X as toDisplayString, E as renderList, F as Fragment, N as createVNode, l as script$1, I as createCommentVNode, bQ as script$2, cP as FormItem, cp as _sfc_main$1, c0 as electronAPI } from "./index-DjNHn37O.js";
+import { u as useServerConfigStore } from "./serverConfigStore-CvyKFVuP.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, _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)
-  ]));
+  return openBlock(), createElementBlock("svg", _hoisted_1$1, [..._hoisted_3$1]);
 }
 __name(render, "render");
 const __unplugin_components_0 = markRaw({ name: "lucide-terminal", render });
@@ -153,4 +155,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=ServerConfigPanel-DnGhsuUV.js.map
+//# sourceMappingURL=ServerConfigPanel-Be4StJmv.js.map

web/assets/ServerStartView-CIDTUh4x.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { d as defineComponent, a1 as useI18n, ab as ref, b_ as ProgressStatus, m as onMounted, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, aE as createTextVNode, X as toDisplayString, j as unref, f as createElementBlock, I as createCommentVNode, N as createVNode, l as script, i as withDirectives, v as vShow, b$ as BaseTerminal, aL as pushScopeId, aM as popScopeId, c0 as electronAPI, _ as _export_sfc } from "./index-DjNHn37O.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.js";
+const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-42c1131d"), n = n(), popScopeId(), n), "_withScopeId");
+const _hoisted_1 = { class: "text-2xl font-bold" };
+const _hoisted_2 = { key: 0 };
+const _hoisted_3 = {
+  key: 0,
+  class: "flex flex-col items-center gap-4"
+};
+const _hoisted_4 = { class: "flex items-center my-4 gap-2" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ServerStartView",
+  setup(__props) {
+    const electron = electronAPI();
+    const { t } = useI18n();
+    const status = ref(ProgressStatus.INITIAL_STATE);
+    const electronVersion = ref("");
+    let xterm;
+    const terminalVisible = ref(true);
+    const updateProgress = /* @__PURE__ */ __name(({ status: newStatus }) => {
+      status.value = newStatus;
+      if (newStatus === ProgressStatus.ERROR) terminalVisible.value = false;
+      else xterm?.clear();
+    }, "updateProgress");
+    const terminalCreated = /* @__PURE__ */ __name(({ terminal, useAutoSize }, root) => {
+      xterm = terminal;
+      useAutoSize(root, true, true);
+      electron.onLogMessage((message) => {
+        terminal.write(message);
+      });
+      terminal.options.cursorBlink = false;
+      terminal.options.disableStdin = true;
+      terminal.options.cursorInactiveStyle = "block";
+    }, "terminalCreated");
+    const reinstall = /* @__PURE__ */ __name(() => electron.reinstall(), "reinstall");
+    const reportIssue = /* @__PURE__ */ __name(() => {
+      window.open("https://forum.comfy.org/c/v1-feedback/", "_blank");
+    }, "reportIssue");
+    const openLogs = /* @__PURE__ */ __name(() => electron.openLogsFolder(), "openLogs");
+    onMounted(async () => {
+      electron.sendReady();
+      electron.onProgressUpdate(updateProgress);
+      electronVersion.value = await electron.getElectronVersion();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        dark: "",
+        class: "flex-col"
+      }, {
+        default: withCtx(() => [
+          createBaseVNode("h2", _hoisted_1, [
+            createTextVNode(toDisplayString(unref(t)(`serverStart.process.${status.value}`)) + " ", 1),
+            status.value === unref(ProgressStatus).ERROR ? (openBlock(), createElementBlock("span", _hoisted_2, " v" + toDisplayString(electronVersion.value), 1)) : createCommentVNode("", true)
+          ]),
+          status.value === unref(ProgressStatus).ERROR ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            createBaseVNode("div", _hoisted_4, [
+              createVNode(unref(script), {
+                icon: "pi pi-flag",
+                severity: "secondary",
+                label: unref(t)("serverStart.reportIssue"),
+                onClick: reportIssue
+              }, null, 8, ["label"]),
+              createVNode(unref(script), {
+                icon: "pi pi-file",
+                severity: "secondary",
+                label: unref(t)("serverStart.openLogs"),
+                onClick: openLogs
+              }, null, 8, ["label"]),
+              createVNode(unref(script), {
+                icon: "pi pi-refresh",
+                label: unref(t)("serverStart.reinstall"),
+                onClick: reinstall
+              }, null, 8, ["label"])
+            ]),
+            !terminalVisible.value ? (openBlock(), createBlock(unref(script), {
+              key: 0,
+              icon: "pi pi-search",
+              severity: "secondary",
+              label: unref(t)("serverStart.showTerminal"),
+              onClick: _cache[0] || (_cache[0] = ($event) => terminalVisible.value = true)
+            }, null, 8, ["label"])) : createCommentVNode("", true)
+          ])) : createCommentVNode("", true),
+          withDirectives(createVNode(BaseTerminal, { onCreated: terminalCreated }, null, 512), [
+            [vShow, terminalVisible.value]
+          ])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const ServerStartView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-42c1131d"]]);
+export {
+  ServerStartView as default
+};
+//# sourceMappingURL=ServerStartView-CIDTUh4x.js.map

web/assets/ServerStartView-CnyN4Ib6.css

@@ -1,5 +1,5 @@
 
-[data-v-4140d62b] .xterm-helper-textarea {
+[data-v-42c1131d] .xterm-helper-textarea {
   /* Hide this as it moves all over when uv is running */
   display: none;
 }

web/assets/ServerStartView-yzYZ8gms.js

@@ -1,100 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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 };
-const _hoisted_4 = {
-  key: 0,
-  class: "flex flex-col items-center gap-4"
-};
-const _hoisted_5 = { class: "flex items-center my-4 gap-2" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ServerStartView",
-  setup(__props) {
-    const electron = electronAPI();
-    const { t } = useI18n();
-    const status = ref(ProgressStatus.INITIAL_STATE);
-    const electronVersion = ref("");
-    let xterm;
-    const terminalVisible = ref(true);
-    const updateProgress = /* @__PURE__ */ __name(({ status: newStatus }) => {
-      status.value = newStatus;
-      if (newStatus === ProgressStatus.ERROR) terminalVisible.value = false;
-      else xterm?.clear();
-    }, "updateProgress");
-    const terminalCreated = /* @__PURE__ */ __name(({ terminal, useAutoSize }, root) => {
-      xterm = terminal;
-      useAutoSize({ root, autoRows: true, autoCols: true });
-      electron.onLogMessage((message) => {
-        terminal.write(message);
-      });
-      terminal.options.cursorBlink = false;
-      terminal.options.disableStdin = true;
-      terminal.options.cursorInactiveStyle = "block";
-    }, "terminalCreated");
-    const reinstall = /* @__PURE__ */ __name(() => electron.reinstall(), "reinstall");
-    const reportIssue = /* @__PURE__ */ __name(() => {
-      window.open("https://forum.comfy.org/c/v1-feedback/", "_blank");
-    }, "reportIssue");
-    const openLogs = /* @__PURE__ */ __name(() => electron.openLogsFolder(), "openLogs");
-    onMounted(async () => {
-      electron.sendReady();
-      electron.onProgressUpdate(updateProgress);
-      electronVersion.value = await electron.getElectronVersion();
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(_sfc_main$1, {
-        dark: "",
-        class: "flex-col"
-      }, {
-        default: withCtx(() => [
-          createBaseVNode("div", _hoisted_1, [
-            createBaseVNode("h2", _hoisted_2, [
-              createTextVNode(toDisplayString(unref(t)(`serverStart.process.${status.value}`)) + " ", 1),
-              status.value === unref(ProgressStatus).ERROR ? (openBlock(), createElementBlock("span", _hoisted_3, " v" + toDisplayString(electronVersion.value), 1)) : createCommentVNode("", true)
-            ]),
-            status.value === unref(ProgressStatus).ERROR ? (openBlock(), createElementBlock("div", _hoisted_4, [
-              createBaseVNode("div", _hoisted_5, [
-                createVNode(unref(script), {
-                  icon: "pi pi-flag",
-                  severity: "secondary",
-                  label: unref(t)("serverStart.reportIssue"),
-                  onClick: reportIssue
-                }, null, 8, ["label"]),
-                createVNode(unref(script), {
-                  icon: "pi pi-file",
-                  severity: "secondary",
-                  label: unref(t)("serverStart.openLogs"),
-                  onClick: openLogs
-                }, null, 8, ["label"]),
-                createVNode(unref(script), {
-                  icon: "pi pi-refresh",
-                  label: unref(t)("serverStart.reinstall"),
-                  onClick: reinstall
-                }, null, 8, ["label"])
-              ]),
-              !terminalVisible.value ? (openBlock(), createBlock(unref(script), {
-                key: 0,
-                icon: "pi pi-search",
-                severity: "secondary",
-                label: unref(t)("serverStart.showTerminal"),
-                onClick: _cache[0] || (_cache[0] = ($event) => terminalVisible.value = true)
-              }, null, 8, ["label"])) : createCommentVNode("", true)
-            ])) : createCommentVNode("", true),
-            withDirectives(createVNode(BaseTerminal, { onCreated: terminalCreated }, null, 512), [
-              [vShow, terminalVisible.value]
-            ])
-          ])
-        ]),
-        _: 1
-      });
-    };
-  }
-});
-const ServerStartView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4140d62b"]]);
-export {
-  ServerStartView as default
-};
-//# sourceMappingURL=ServerStartView-yzYZ8gms.js.map

web/assets/UserSelectView-B3jYchWu.js

@@ -1,17 +1,18 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { d as defineComponent, aX as useUserStore, bW as useRouter, ab as ref, c as computed, m as onMounted, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, X as toDisplayString, N as createVNode, bX as withKeys, j as unref, av as script, bQ as script$1, bY as script$2, bZ as script$3, aE as createTextVNode, I as createCommentVNode, l as script$4 } from "./index-DjNHn37O.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.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 = { 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 _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 _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "UserSelectView",
   setup(__props) {
@@ -46,10 +47,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       return openBlock(), createBlock(_sfc_main$1, { dark: "" }, {
         default: withCtx(() => [
           createBaseVNode("main", _hoisted_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),
+            _hoisted_2,
+            createBaseVNode("div", _hoisted_3, [
+              createBaseVNode("div", _hoisted_4, [
+                createBaseVNode("label", _hoisted_5, toDisplayString(_ctx.$t("userSelect.newUser")) + ":", 1),
                 createVNode(unref(script), {
                   id: "new-user-input",
                   modelValue: newUsername.value,
@@ -59,8 +60,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 }, null, 8, ["modelValue", "placeholder"])
               ]),
               createVNode(unref(script$1)),
-              createBaseVNode("div", _hoisted_5, [
-                createBaseVNode("label", _hoisted_6, toDisplayString(_ctx.$t("userSelect.existingUser")) + ":", 1),
+              createBaseVNode("div", _hoisted_6, [
+                createBaseVNode("label", _hoisted_7, toDisplayString(_ctx.$t("userSelect.existingUser")) + ":", 1),
                 createVNode(unref(script$2), {
                   modelValue: selectedUser.value,
                   "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => selectedUser.value = $event),
@@ -81,7 +82,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   _: 1
                 })) : createCommentVNode("", true)
               ]),
-              createBaseVNode("footer", _hoisted_7, [
+              createBaseVNode("footer", _hoisted_8, [
                 createVNode(unref(script$4), {
                   label: _ctx.$t("userSelect.next"),
                   onClick: login
@@ -98,4 +99,4 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
 export {
   _sfc_main as default
 };
-//# sourceMappingURL=UserSelectView-DeJDnrF0.js.map
+//# sourceMappingURL=UserSelectView-B3jYchWu.js.map

web/assets/WelcomeView-N0ZXLjdi.js

@@ -1,7 +1,8 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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";
+import { d as defineComponent, bW as useRouter, o as openBlock, k as createBlock, M as withCtx, H as createBaseVNode, X as toDisplayString, N as createVNode, j as unref, l as script, aL as pushScopeId, aM as popScopeId, _ as _export_sfc } from "./index-DjNHn37O.js";
+import { _ as _sfc_main$1 } from "./BaseViewTemplate-BNGF4K22.js";
+const _withScopeId = /* @__PURE__ */ __name((n) => (pushScopeId("data-v-7dfaf74c"), n = n(), popScopeId(), n), "_withScopeId");
 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({
@@ -36,4 +37,4 @@ const WelcomeView = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-
 export {
   WelcomeView as default
 };
-//# sourceMappingURL=WelcomeView-DkwLdayn.js.map
+//# sourceMappingURL=WelcomeView-N0ZXLjdi.js.map

web/assets/index-5HFeZax4.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ct as script$1, H as createBaseVNode, o as openBlock, f as createElementBlock, D as mergeProps } from "./index-DjNHn37O.js";
+var script = {
+  name: "PlusIcon",
+  "extends": script$1
+};
+var _hoisted_1 = /* @__PURE__ */ createBaseVNode("path", {
+  d: "M7.67742 6.32258V0.677419C7.67742 0.497757 7.60605 0.325452 7.47901 0.198411C7.35197 0.0713707 7.17966 0 7 0C6.82034 0 6.64803 0.0713707 6.52099 0.198411C6.39395 0.325452 6.32258 0.497757 6.32258 0.677419V6.32258H0.677419C0.497757 6.32258 0.325452 6.39395 0.198411 6.52099C0.0713707 6.64803 0 6.82034 0 7C0 7.17966 0.0713707 7.35197 0.198411 7.47901C0.325452 7.60605 0.497757 7.67742 0.677419 7.67742H6.32258V13.3226C6.32492 13.5015 6.39704 13.6725 6.52358 13.799C6.65012 13.9255 6.82106 13.9977 7 14C7.17966 14 7.35197 13.9286 7.47901 13.8016C7.60605 13.6745 7.67742 13.5022 7.67742 13.3226V7.67742H13.3226C13.5022 7.67742 13.6745 7.60605 13.8016 7.47901C13.9286 7.35197 14 7.17966 14 7C13.9977 6.82106 13.9255 6.65012 13.799 6.52358C13.6725 6.39704 13.5015 6.32492 13.3226 6.32258H7.67742Z",
+  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-5HFeZax4.js.map

web/assets/index-B-aVupP5.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { ct as script$1, H as createBaseVNode, o as openBlock, f as createElementBlock, D as mergeProps } from "./index-DjNHn37O.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-B-aVupP5.js.map

web/assets/index-D6zf5KAf.js

@@ -1,27 +0,0 @@
-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