Merge remote-tracking branch 'origin/master' into synap5e/fix/assets-defer-prune

# Conflicts:
#	app/assets/manager.py
#	tests-unit/assets_test/services/test_manager_isolated.py

Author: synap5e

.coderabbit.yaml

@@ -140,5 +140,16 @@ knowledge_base:
     filePatterns:
       - files: "AGENTS.md"
         applyTo: "**"
+  linked_repositories:
+    - repository: "Comfy-Org/ComfyUI_frontend"
+      instructions: |
+        Frontend consumer of Core APIs, routes, feature flags, asset behavior,
+        node metadata, and package-version rollouts. Check for compatibility
+        issues and changes that require coordinated rollout or merge ordering.
+    - repository: "Comfy-Org/comfy-kitchen"
+      instructions: |
+        Owns optimized inference operations and kernels used by ComfyUI. Check
+        whether new model math or backend-specific operations duplicate an
+        existing implementation or belong in comfy-kitchen instead of Core.
   learnings:
     scope: "auto"

app/assets/api/routes.py

@@ -91,7 +91,7 @@ async def wrapper(request: web.Request) -> web.Response:
             return _build_error_response(
                 503,
                 "SERVICE_DISABLED",
-                "Assets system is disabled. Start the server with --enable-assets to use this feature.",
+                "Assets system is disabled because the server was started with --disable-assets.",
             )
         return await handler(request)
 
@@ -1036,7 +1036,7 @@ async def get_tags_refine(request: web.Request) -> web.Response:
 @ROUTES.post("/api/assets/seed")
 @_require_assets_feature_enabled
 async def seed_assets(request: web.Request) -> web.Response:
-    """Trigger asset seeding for specified roots (models, input, output).
+    """Trigger asset seeding for specified roots (models, input).
 
     Query params:
         wait: If "true", block until scan completes (synchronous behavior for tests)
@@ -1048,11 +1048,11 @@ async def seed_assets(request: web.Request) -> web.Response:
     """
     try:
         payload = await request.json()
-        roots = payload.get("roots", ["models", "input", "output"])
+        roots = payload.get("roots", ["models", "input"])
     except Exception:
-        roots = ["models", "input", "output"]
+        roots = ["models", "input"]
 
-    valid_roots = tuple(r for r in roots if r in ("models", "input", "output"))
+    valid_roots = tuple(r for r in roots if r in ("models", "input"))
     if not valid_roots:
         return _build_error_response(400, "INVALID_BODY", "No valid roots specified")
 

app/assets/lifecycle.py

@@ -101,12 +101,12 @@ def start_asset_seeder() -> bool:
     from app.assets.seeder import asset_seeder
 
     started = asset_seeder.start(
-        roots=("models", "input", "output"),
+        roots=("models", "input"),
         prune_first=True,
         compute_hashes=args.enable_asset_hashing,
     )
     if started:
-        logging.info("Background asset scan initiated for models, input, output")
+        logging.info("Background asset scan initiated for models, input")
     return started
 
 

app/assets/manager.py

@@ -1,7 +1,7 @@
 """Selects and implements the enabled and disabled asset managers.
 
-``default_asset_manager`` checks database dependencies before enabling assets
-and chooses ``NoAssets`` when the requested mode cannot run.
+``default_asset_manager`` chooses ``NoAssets`` only for ``--disable-assets``; main.py
+stops startup before that if assets are on and the database packages are missing.
 """
 
 from __future__ import annotations
@@ -13,16 +13,15 @@
 
 from app.assets import mode
 from app.assets.lifecycle import record_hash_mode_transition_intent, run_shutdown, run_startup
-from app.database.db import dependencies_available, missing_dependencies
+from app.database.db import dependencies_available
 from app.user_manager import UserManager
 from comfy.cli_args import args
-from utils.install_util import get_missing_requirements_message
 
 # These need the database packages. Without them only NoAssets is used, and it
 # does not touch these names.
 if dependencies_available():
     from app.assets.api.routes import register_assets_routes
-    from app.assets.seeder import ScanPhase, asset_seeder
+    from app.assets.seeder import asset_seeder
     from app.assets.services.ingest import (
         register_cached_output as ingest_register_cached_output,
         register_executed_output as ingest_register_executed_output,
@@ -74,7 +73,7 @@ def set_event_sink(self, sink: Callable[[str, dict[str, Any]], None] | None) ->
 
 
 class _ArgsLike(Protocol):
-    enable_assets: bool
+    disable_assets: bool
     enable_asset_hashing: bool
 
 
@@ -167,20 +166,14 @@ def register_routes(
 
     def ensure_scan_started(self) -> None:
         asset_seeder.start_after_node_list(
-            roots=("models", "input", "output"), compute_hashes=self._args.enable_asset_hashing
+            roots=("models", "input"), compute_hashes=self._args.enable_asset_hashing
         )
 
     def pause_background_scan(self) -> None:
         asset_seeder.pause()
 
     def queue_output_scan(self) -> None:
-        if not asset_seeder.is_disabled():
-            # FULL, not ENRICH: only a walk finds outputs a node never declared. Do not downgrade without re-weighing the cost.
-            asset_seeder.enqueue_scan(
-                roots=("output",),
-                phase=ScanPhase.FULL,
-                compute_hashes=self._args.enable_asset_hashing,
-            )
+        return None
 
     def resume_background_scan(self) -> None:
         asset_seeder.resume()
@@ -235,11 +228,4 @@ def set_event_sink(self, sink: Callable[[str, dict[str, Any]], None] | None) ->
 
 
 def default_asset_manager() -> AssetManager:
-    if args.enable_assets and not dependencies_available():
-        missing = ", ".join(missing_dependencies()) or "see the import error above"
-        logging.error(
-            f"--enable-assets requires packages that could not be imported: {missing}. "
-            f"Assets are disabled.\n{get_missing_requirements_message()}"
-        )
-        return NoAssets(args)
-    return AssetsEnabled(args) if args.enable_assets else NoAssets(args)
+    return NoAssets(args) if args.disable_assets else AssetsEnabled(args)

app/assets/seeder.py

@@ -227,7 +227,7 @@ def is_disabled(self) -> bool:
 
     def start(
         self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
+        roots: tuple[RootType, ...] = ("models", "input"),
         phase: ScanPhase = ScanPhase.FULL,
         progress_callback: ProgressCallback | None = None,
         prune_first: bool = False,
@@ -282,7 +282,7 @@ def start(
 
     def start_fast(
         self,
-        roots: tuple[RootType, ...] = ("models", "input", "output"),
+        roots: tuple[RootType, ...] = ("models", "input"),
         progress_callback: ProgressCallback | None = None,
         prune_first: bool = False,
     ) -> bool:

app/database/db.py

@@ -6,7 +6,6 @@
 import time
 from contextlib import closing
 from app.logger import log_startup_warning
-from utils.install_util import get_missing_requirements_message
 from filelock import FileLock, Timeout
 from comfy.cli_args import args, database_default_path
 
@@ -23,6 +22,7 @@
     from alembic.runtime.migration import MigrationContext
     from alembic.script import ScriptDirectory
     from sqlalchemy import create_engine, event
+    from sqlalchemy.engine import URL, make_url
     from sqlalchemy.exc import OperationalError
     from sqlalchemy.orm import sessionmaker
     from sqlalchemy.pool import StaticPool
@@ -32,16 +32,9 @@
     import blake3  # noqa: F401 — verify the hard dependency is importable at startup
 
     _DB_AVAILABLE = True
-except ImportError as e:
-    log_startup_warning(
-        f"""
-------------------------------------------------------------------------
-Error importing dependencies: {e}
-{get_missing_requirements_message()}
-This error is happening because ComfyUI now uses a local sqlite database.
-------------------------------------------------------------------------
-""".strip()
-    )
+except ImportError:
+    # Only the assets system needs these; with it on, startup stops and says what to install.
+    logging.debug("Database packages failed to import", exc_info=True)
 
 
 def dependencies_available():
@@ -76,8 +69,11 @@ def get_alembic_config():
     scripts_path = os.path.abspath(os.path.join(root_path, "alembic_db"))
 
     config = Config(config_path)
-    config.set_main_option("script_location", scripts_path)
-    config.set_main_option("sqlalchemy.url", get_database_url())
+    # Config values go through ConfigParser interpolation, so a literal % in a path must be doubled,
+    # including in the %(here)s default that alembic fills in unescaped.
+    config.file_config.set("DEFAULT", "here", os.path.dirname(config_path).replace("%", "%%"))
+    config.set_main_option("script_location", scripts_path.replace("%", "%%"))
+    config.set_main_option("sqlalchemy.url", get_database_url().replace("%", "%%"))
 
     return config
 
@@ -89,7 +85,9 @@ def get_database_url():
     import folder_paths
 
     db_path = os.path.join(folder_paths.get_user_directory(), "comfyui.db")
-    return f"sqlite:///{db_path}"
+    # Built by SQLAlchemy so its own parser reads the path back intact: 2.1+ decodes %xx, and every version
+    # stops the path at ? (which only 2.1+ quotes).
+    return URL.create("sqlite", database=db_path).render_as_string()
 
 
 def get_legacy_default_db_path():
@@ -99,7 +97,7 @@ def get_legacy_default_db_path():
 def get_db_path():
     url = get_database_url()
     if url.startswith("sqlite:///"):
-        return url.split("///", 1)[1]
+        return make_url(url).database
     else:
         raise ValueError(f"Unsupported database URL '{url}'.")
 
@@ -229,7 +227,6 @@ def _is_memory_db(db_url):
 
 def init_db():
     db_url = get_database_url()
-    logging.debug(f"Database URL: {db_url}")
 
     if _is_memory_db(db_url):
         _init_memory_db(db_url)
@@ -363,7 +360,7 @@ def begin_immediate(connection):
             command.upgrade(config, target_rev)
             logging.info(f"Database upgraded from {current_rev} to {target_rev}")
         except Exception as e:
-            logging.exception("Error upgrading database: ")
+            logging.debug("Error upgrading database", exc_info=True)
             if backup_path:
                 # Restore the database from backup if upgrade fails
                 try:

comfy/cli_args.py

@@ -275,8 +275,9 @@ def is_valid_directory(path: str) -> str:
     os.path.join(os.path.dirname(__file__), "..", "user", "comfyui.db")
 )
 parser.add_argument("--database-url", type=str, default=None, help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'. Defaults to 'comfyui.db' in the effective user directory.")
-parser.add_argument("--enable-assets", action="store_true", help="Enable the assets system (API routes, database synchronization, and background scanning).")
-parser.add_argument("--enable-asset-hashing", action="store_true", help="Compute blake3 content hashes when scanning assets. Hashing enables future asset-portability features (deduplication, cross-machine model resolution) but adds startup cost and per-output cost on large models directories. Off by default; enable to opt in.")
+parser.add_argument("--disable-assets", action="store_true", help="Disable the assets system (API routes, database synchronization, and background scanning).")
+parser.add_argument("--enable-assets", action="store_true", help="Deprecated: the assets system is on by default, so this does nothing. Use --disable-assets to turn it off.")
+parser.add_argument("--enable-asset-hashing", action="store_true", help="Compute blake3 content hashes when scanning assets. Files uploaded through the API are hashed either way. Hashing enables future asset-portability features (deduplication, cross-machine model resolution) but adds startup cost and per-output cost on large models directories. Off by default; enable to opt in.")
 parser.add_argument("--feature-flag", type=str, action='append', default=[], metavar="KEY[=VALUE]", help="Set a server feature flag. Use KEY=VALUE to set an explicit value, or bare KEY to set it to true. Can be specified multiple times. Boolean values (true/false) and numbers are auto-converted. Examples: --feature-flag show_signin_button=true  or  --feature-flag show_signin_button")
 parser.add_argument("--list-feature-flags", action="store_true", help="Print the registry of known CLI-settable feature flags as JSON and exit.")
 

comfy/configurable.py

@@ -0,0 +1,7 @@
+from torch import nn
+
+
+class ConfigurableModule(nn.Module):
+    def with_config(self, encoded_config):
+        """Return a new module configured from a uint8 JSON tensor, without modifying this module."""
+        raise NotImplementedError

comfy/ldm/modules/attention.py

@@ -17,6 +17,7 @@
 from .sub_quadratic_attention import efficient_dot_product_attention
 
 from comfy import model_management
+from comfy.configurable import ConfigurableModule
 
 if model_management.xformers_enabled():
     import xformers
@@ -73,12 +74,17 @@ def get_attention_function(name: str, default: Any=...) -> Union[Callable, None]
     return REGISTERED_ATTENTION_FUNCTIONS[name]
 
 
-class ComfyAttention(nn.Module):
+class ComfyAttention(ConfigurableModule):
     def __init__(self):
         super().__init__()
         self.config = None
         self.function = None
 
+    def with_config(self, encoded_config):
+        attention = ComfyAttention()
+        attention.load_state_dict({"config": encoded_config})
+        return attention
+
     def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs):
         self.config = None
         self.function = None

comfy/ldm/wan/model_animate2.py

@@ -11,6 +11,7 @@
 
 import comfy.ldm.common_dit
 import comfy.model_management
+import comfy.model_prefetch
 import comfy.quant_ops
 import comfy.utils
 from comfy.ldm.flux.math import apply_rope1
@@ -200,16 +201,17 @@ def prefetch(self, i, device, dtype):
         stream = None
         r = None
         if t.device != device:
-            stream = comfy.model_management.get_offload_stream(device)
-            cs = comfy.model_management.current_stream(device)
-            if stream is not None and cs is not None:
-                # the handed-out stream last waited on the main stream a full rotation ago, which does not cover the previous consumer's reads of this slot; wait now so the copy cannot overwrite a slot still being read
-                stream.wait_stream(cs)
             # two persistent staging buffers per tensor shape instead of a fresh allocation per block (~29 GB of churn per pass at 720p); windows of different lengths get their own pair
             buf_key = (tuple(t.shape), cast_dtype if cast_dtype is not None else t.dtype)
             if buf_key not in self._staging:
-                self._staging[buf_key] = [torch.empty(t.shape, dtype=buf_key[1], device=device) for _ in range(2)]
+                with comfy.model_prefetch.pause_malloc_graph():
+                    self._staging[buf_key] = [torch.empty(t.shape, dtype=buf_key[1], device=device) for _ in range(2)]
             r = self._staging[buf_key][i % 2]
+            stream = comfy.model_management.get_offload_stream(device)
+            cs = comfy.model_management.current_stream(device)
+            if stream is not None and cs is not None:
+                # Wait for staging allocation and the previous consumer's reads before overwriting the buffer.
+                stream.wait_stream(cs)
         self._pending[i] = (comfy.model_management.cast_to(t, cast_dtype, device, non_blocking=True, stream=stream, r=r), stream)
 
     def take(self, i, device, dtype, batch_size):