feat(spaces): registry entries for renamed BF16 aliases + seed inputs + bootstrap

- MODEL_REGISTRY: 6 new entries for the renamed-but-actually-BF16 files the
master workflow references (gemma_3_12B_it_fp4_mixed → Comfy-Org/ltx-2,
_transformer_only_fp8_scaled → Kijai _bf16, ltx-2-3-22b-dev-Q4_K_M.gguf →
unsloth -BF16.gguf, taeltx2_3, distilled-lora-dynamic, gemma_3_12B_it).
ModelEntry gets `source_filename` so the HF-side name and the
workflow-expected name can differ.
- ensure_models honors source_filename, joins subfolder into the HF path,
and stages at comfyui/models/<comfy_type>/<workflow_filename>.
- requirements.txt: add ComfyUI core deps + custom-node deps that are
required for the LTX 2.3 workflow but aren't in their nodes' own
requirements.txt (gguf, imageio_ffmpeg, opencv-python, matplotlib,
diffusers, yt-dlp, psutil).
- assets/seed_inputs/: tiny placeholder image/audio/video files that the
bootstrap stages into comfyui/input/ so the workflow's always-on loaders
don't fail on cold start when the user hasn't uploaded yet.
- _bootstrap also pip-installs ComfyUI's own requirements.txt on Spaces
cold start (previously only custom-node deps were installed).

app.py

@@ -52,6 +52,7 @@ def _bootstrap() -> None:
     comfy_dir = pathlib.Path("/data/comfyui" if on_spaces else "comfyui")
 
     if on_spaces and not comfy_dir.exists():
+        print(f"[bootstrap] cold start on Spaces; cloning ComfyUI to {comfy_dir}", flush=True)
         comfy_dir.parent.mkdir(parents=True, exist_ok=True)
         _git_clone(COMFYUI_REPO, comfy_dir, ref=COMFYUI_COMMIT)
         for node_url, node_ref in CUSTOM_NODES_PINNED:
@@ -59,10 +60,16 @@ def _bootstrap() -> None:
             _git_clone(node_url, comfy_dir / "custom_nodes" / name, ref=node_ref)
         import subprocess
 
-        for cn in (comfy_dir / "custom_nodes").iterdir():
-            req = cn / "requirements.txt"
-            if req.exists():
-                subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", str(req)])
+        # ComfyUI core requirements + each custom node's requirements
+        for req_path in [
+            comfy_dir / "requirements.txt",
+            *(cn / "requirements.txt" for cn in (comfy_dir / "custom_nodes").iterdir()),
+        ]:
+            if req_path.exists():
+                print(f"[bootstrap] pip install -r {req_path}", flush=True)
+                subprocess.check_call(
+                    [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_path)]
+                )
 
     if str(comfy_dir) not in sys.path:
         sys.path.insert(0, str(comfy_dir))
@@ -71,6 +78,26 @@ def _bootstrap() -> None:
         str(pathlib.Path("/data/models") if on_spaces else (comfy_dir / "models")),
     )
 
+    # Stage placeholder input files so the workflow's hard-referenced loaders
+    # (LoadImage/VHS_Load*) don't error at runtime even when the active mode
+    # doesn't actually use the file. Real user uploads are placed alongside via
+    # `_stage_to_comfy_input` later.
+    seed_dir = pathlib.Path(__file__).parent / "assets" / "seed_inputs"
+    inputs_dir = comfy_dir / "input"
+    inputs_dir.mkdir(parents=True, exist_ok=True)
+    if seed_dir.exists():
+        import shutil
+
+        for src in seed_dir.iterdir():
+            if not src.is_file():
+                continue
+            dst = inputs_dir / src.name
+            if not dst.exists():
+                try:
+                    shutil.copy2(src, dst)
+                except OSError as exc:
+                    print(f"[bootstrap] could not seed {src.name}: {exc}", flush=True)
+
 
 _bootstrap()
 

models.py

@@ -20,8 +20,14 @@ logger = logging.getLogger(__name__)
 @dataclass(frozen=True)
 class ModelEntry:
     repo_id: str
-    subfolder: str = ""
+    subfolder: str = ""  # path within the HF repo
     comfy_type: str = "checkpoints"  # ComfyUI models/<comfy_type>/ subdirectory
+    # If the workflow expects a different filename than what's in the HF repo
+    # (e.g. user's local "ltx-2.3-22b-dev_transformer_only_fp8_scaled.safetensors"
+    # is actually `_transformer_only_bf16.safetensors` in Kijai's repo), set
+    # source_filename to the actual repo filename. The local symlink/copy uses
+    # the registry key as its name.
+    source_filename: str | None = None
 
 
 MODEL_REGISTRY: dict[str, ModelEntry] = {
@@ -94,6 +100,51 @@ MODEL_REGISTRY: dict[str, ModelEntry] = {
             "jib-down",
         )
     },
+    # ----- Renamed/aliased filenames the user's master workflow references.
+    # The names look like quantized variants (FP4, FP8, GGUF) but the actual
+    # bytes behind them are BF16 — the user's local setup uses symlinks to
+    # canonical sources. On Spaces we download the same canonical sources via
+    # huggingface_hub and place them under the workflow-expected filename.
+    # All of these entries set `subfolder` to the path within the repo and
+    # rely on hf_hub_download returning the cached snapshot path (which we
+    # then symlink to comfy_models/<comfy_type>/<filename>).
+    "gemma_3_12B_it_fp4_mixed.safetensors": ModelEntry(
+        # Comfy-Org/ltx-2 ships BF16 Gemma packed as `gemma_3_12B_it.safetensors`
+        # in split_files/text_encoders/. The workflow expects the FP4-named
+        # variant; we serve the same file under that name.
+        "Comfy-Org/ltx-2",
+        subfolder="split_files/text_encoders",
+        comfy_type="text_encoders",
+        source_filename="gemma_3_12B_it.safetensors",
+    ),
+    "gemma_3_12B_it.safetensors": ModelEntry(
+        "Comfy-Org/ltx-2",
+        subfolder="split_files/text_encoders",
+        comfy_type="text_encoders",
+    ),
+    "ltx-2.3-22b-dev_transformer_only_fp8_scaled.safetensors": ModelEntry(
+        # Kijai's BF16 transformer-only — actual repo filename has `_bf16` suffix.
+        "Kijai/LTX2.3_comfy",
+        subfolder="diffusion_models",
+        comfy_type="diffusion_models",
+        source_filename="ltx-2.3-22b-dev_transformer_only_bf16.safetensors",
+    ),
+    "ltx-2-3-22b-dev-Q4_K_M.gguf": ModelEntry(
+        # Unsloth's GGUF in BF16 (named `…-BF16.gguf` in repo).
+        "unsloth/LTX-2.3-GGUF",
+        comfy_type="diffusion_models",
+        source_filename="ltx-2.3-22b-dev-BF16.gguf",
+    ),
+    "taeltx2_3.safetensors": ModelEntry(
+        "Kijai/LTX2.3_comfy",
+        subfolder="vae",
+        comfy_type="vae",
+    ),
+    "ltx-2.3-22b-distilled-lora-dynamic_fro09_avg_rank_105_bf16.safetensors": ModelEntry(
+        "Kijai/LTX2.3_comfy",
+        subfolder="loras",
+        comfy_type="loras",
+    ),
 }
 
 
@@ -202,23 +253,25 @@ def ensure_models(filenames: set[str]) -> Iterator[DownloadEvent]:
         entry = MODEL_REGISTRY[filename]
 
         # Short-circuit: if the file is already present at its expected location
-        # in comfyui/models/<type>/[<subfolder>/]<filename>, skip the HF dance
-        # entirely. This is the local-dev hot path where the user's existing
-        # ComfyUI models/ is symlinked in.
-        existing_dest_dir = comfy_models / entry.comfy_type
-        if entry.subfolder:
-            existing_dest_dir = existing_dest_dir / entry.subfolder
-        existing_dest = existing_dest_dir / filename
+        # comfyui/models/<comfy_type>/<filename>, skip. Subfolder is part of the
+        # HF source path, not the destination, so the dest is always a flat
+        # comfyui/models/<comfy_type>/<filename>.
+        existing_dest = comfy_models / entry.comfy_type / filename
         if existing_dest.exists() or existing_dest.is_symlink():
             yield DownloadEvent(filename, 0.0, 0.0)
             continue
 
-        # Resolve source: hf_hub_download returns the cache path (or downloads).
+        # The HF-side filename may differ from the workflow-expected name
+        # (e.g. user's `_fp8_scaled.safetensors` is actually `_bf16.safetensors`
+        # in the upstream repo). Honor `source_filename` when set.
+        hf_filename = entry.source_filename or filename
+        hf_path = f"{entry.subfolder}/{hf_filename}" if entry.subfolder else hf_filename
+
         try:
             source = pathlib.Path(
                 hf_hub_download(
                     repo_id=entry.repo_id,
-                    filename=filename,
+                    filename=hf_path,
                     cache_dir=str(cache_dir),
                     local_dir=None,
                 )
@@ -226,22 +279,21 @@ def ensure_models(filenames: set[str]) -> Iterator[DownloadEvent]:
             size_mb = source.stat().st_size / 1024 / 1024
             yield DownloadEvent(filename, size_mb, size_mb)
         except Exception as exc:
-            # Fall back to scanning the cache for a placeholder file (test mode + offline mode).
-            candidates = list(cache_dir.rglob(filename))
+            # Fall back to scanning the cache for a matching file (test mode +
+            # offline mode). Look for either the workflow filename OR the
+            # HF-side filename — both might exist locally as symlinks.
+            candidates = list(cache_dir.rglob(filename)) or list(cache_dir.rglob(hf_filename))
             if not candidates:
                 logger.warning(
-                    "could not download or locate %r in HF cache: %s; skipping",
-                    filename,
-                    exc,
+                    "could not download or locate %r (hf=%r) in HF cache: %s; skipping",
+                    filename, hf_filename, exc,
                 )
                 continue
             source = candidates[0]
             yield DownloadEvent(filename, 0.0, 0.0)
 
-        # Build symlink target inside comfy_models
+        # Stage at comfy_models/<comfy_type>/<filename> (workflow-expected name).
         dest_dir = comfy_models / entry.comfy_type
-        if entry.subfolder:
-            dest_dir = dest_dir / entry.subfolder
         dest_dir.mkdir(parents=True, exist_ok=True)
         dest = dest_dir / filename
 

requirements.txt

@@ -1,6 +1,8 @@
 gradio>=5.0,<6.0
 spaces>=0.30.0
 huggingface_hub>=0.27.0
+psutil  # used by app.py model status badge
+
 torch>=2.4.0
 torchvision
 torchaudio
@@ -10,6 +12,43 @@ einops
 safetensors
 tqdm
 
+# ComfyUI core requirements (also pip-installed by setup.sh from comfyui/requirements.txt
+# locally, but Spaces won't run setup.sh — these are the deps ComfyUI itself needs)
+transformers>=4.50,<6
+tokenizers
+sentencepiece
+av
+kornia
+spandrel
+torchsde
+scipy
+aiohttp
+pydantic
+pydantic-settings
+python-dotenv
+yarl
+PyOpenGL
+glfw
+SQLAlchemy
+alembic
+Mako
+networkx
+sympy
+mpmath
+blake3
+comfyui-frontend-package>=1.42
+comfyui-workflow-templates>=0.9
+comfyui-embedded-docs
+
+# Custom-node deps that we discovered are required for the LTX 2.3 workflow
+# but aren't auto-installed by their respective nodes' requirements.txt.
+gguf  # ComfyUI-GGUF (UnetLoaderGGUF)
+imageio_ffmpeg  # ComfyUI-VideoHelperSuite (video write/read backend)
+opencv-python  # ComfyUI_LayerStyle, multiple custom nodes
+matplotlib  # comfyui_controlnet_aux dwpose / pose preprocessors
+diffusers  # ComfyUI-SeedVR2 (used during init even when the node isn't called)
+yt-dlp  # ComfyUI-MediaMixer (init-time import)
+
 # Dev / test
 pytest>=8.0
 pytest-asyncio>=0.23