LTX 2.5

.gitignore

@@ -1,46 +0,0 @@
-# Superpowers brainstorming session artifacts
-.superpowers/
-
-# Python
-.venv/
-venv/
-__pycache__/
-*.pyc
-*.pyo
-*.egg-info/
-.pytest_cache/
-.mypy_cache/
-.ruff_cache/
-
-# Models (downloaded to HF cache, never to repo)
-models/
-checkpoints/
-*.safetensors
-*.gguf
-
-# Outputs
-outputs/
-generated/
-*.mp4
-*.wav
-*.webm
-!demo/**/*.mp4
-!demo/**/*.wav
-!assets/seed_inputs/**
-
-# OS
-.DS_Store
-Thumbs.db
-
-# IDE
-.vscode/
-.idea/
-
-# Env
-.env
-.env.local
-*.log
-
-# Gradio cache
-gradio_cached_examples/
-flagged/

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "comfyui"]
-	path = comfyui
-	url = https://github.com/comfyanonymous/ComfyUI.git

CLAUDE.md

@@ -1,263 +0,0 @@
-# Project Guidelines — ltx2.3-AIO-generator
-
-Working notes for AI assistants and subagents implementing this project.
-
-> Companion: see `SKILLS.md` for process rules — how to investigate, verify,
-> commit, and ship changes here. This file is the *what* and *why*; SKILLS.md
-> is the *how*.
-
----
-
-## ⚠ Git authorship — sole author rule
-
-**Mayank Gupta is the sole author on every commit in this repo.** No exceptions.
-
-When committing:
-
-- Do **NOT** append `Co-Authored-By: Claude ...` (or any other agent name).
-- Do **NOT** add "Generated with Claude Code" / "🤖 Generated with..." footers.
-- Do **NOT** pass `--author=...` — let git use the user's existing config.
-- Do **NOT** include attribution in PR descriptions.
-
-If asked to amend, re-commit, or rebase, strip any prior agent attribution from the commit message. Treat any tooling that suggests adding a Claude trailer as a bug to ignore.
-
----
-
-## Project overview
-
-Gradio app wrapping the existing ComfyUI LTX 2.3 All-In-One workflow into mode-specific UIs. Same code runs locally (Apple Silicon MPS / NVIDIA CUDA) and on Hugging Face Spaces (ZeroGPU, Pro tier).
-
-**Spec:** `docs/superpowers/specs/2026-04-30-ltx23-aio-generator-design.md`
-**Plan:** `docs/superpowers/plans/2026-04-30-ltx23-aio-generator.md`
-**Future-improvements backlog:** `docs/future_improvements.md`
-
-If you're a subagent picking up a task, the plan file is your assignment.
-
----
-
-## Modes (six)
-
-`t2v` text→video · `i2v` image→video · `a2v` audio→video · `lipsync` (image+audio) · `keyframe` (first+last frame→video) · `style` (preprocessor + IC-LoRA → restyle).
-
-Each is a separate API-format JSON in `workflows/`. Per-mode parameter patches live in `modes.py` `parameterize_fn`.
-
----
-
-## Architectural facts (locked — do not relitigate)
-
-1. **Backend is ComfyUI in library mode.** We call `comfy.execution.PromptExecutor` directly with workflow JSONs we parameterize. We do NOT run ComfyUI as a subprocess.
-2. **Six mode-specific workflow JSON files** in `workflows/` are user-exported "API format" from the master workflow. Do not hand-edit. Editor-format (with `nodes` array) does NOT work — `walk_workflow_for_models` and `PromptExecutor` both expect API format.
-3. **Models live in HF cache.** Local: `~/.cache/huggingface/hub` symlinked into `comfyui/models/<comfy_type>/`. Spaces: same hub cache mirrored into `~/hf-cache-rw/` (see "Spaces deployment" below). Never commit `*.safetensors`, `*.gguf`, `*.bin`, `*.pt`. The `assets/seed_inputs/` exception in `.gitignore` covers the small placeholder files.
-4. **One backend, one process.** The `@spaces.GPU` decorator is the only divergence between local and Spaces runtimes.
-5. **VRAM is ComfyUI's job.** The only `empty_cache()` calls live in `backend.py`'s `try/finally`. Don't sprinkle them elsewhere.
-6. **Bundled ComfyUI, never user's existing.** Local: git submodule. Spaces: runtime clone via `_git_clone()` in `app.py:_bootstrap()`.
-7. **comfy_dir resolves per-platform.** `~/comfyui` on Spaces (writable HOME), `<repo>/comfyui` locally. Both `app.py` and `backend.py` have `_comfy_dir()`-style helpers that MUST stay in sync.
-8. **Custom nodes are pinned to SHAs**, not branches. See `CUSTOM_NODES_PINNED` in `app.py`. `--branch <SHA>` doesn't work in `git clone`; we use init+fetch+checkout via `_git_clone()`.
-
----
-
-## Spaces deployment specifics (where the gotchas live)
-
-### Model loading: `preload_from_hub` + runtime cache mirror
-
-HF Spaces' `preload_from_hub` directive in README YAML downloads listed files at build time into `~/.cache/huggingface/hub`. **Limitation: those files are owned by the build user** (root-ish). At runtime we run as uid 1000 and can't write there — any `hf_hub_download` for a non-preloaded file fails with `Permission denied (os error 13)`.
-
-**Fix:** `_mirror_preload_hf_cache()` in `app.py` walks the read-only preload tree once at bootstrap and builds a parallel writable tree at `~/hf-cache-rw/`:
-- `blobs/<sha>` files → **hardlinked** (zero-copy, shared inode, instant reads)
-- `snapshots/<commit>/...` symlinks → **preserved** (relative paths resolve within the mirror)
-- `refs/<branch>` → **byte-copied** (HF lib overwrites these on etag check; hardlinks would fail)
-- All dirs → mkdir (we own them)
-- Falls back to symlink if `os.link()` returns EXDEV (cross-device)
-
-Then sets `HF_HOME=~/hf-cache-rw` and `HF_HUB_CACHE=~/hf-cache-rw/hub`. After this, preloaded reads are instant cache hits AND lazy downloads write to dirs we own.
-
-The 10-entry cap on `preload_from_hub` is a hard HF limit. Total preload size cap is 150 GB (Spaces ephemeral storage). Current list is ~111 GB; see `docs/future_improvements.md` for what got dropped (84 GB of unused Lightricks transformers, 39 GB GGUF — both lazy-load when actually referenced).
-
-### Per-call ZeroGPU duration: dynamic estimator + auto-retry
-
-`@spaces.GPU(duration=N)` is a per-call timeout, not a billing cap. Shorter declared duration = faster queue priority on the shared pool. Setting a one-size-fits-all 600s caps everything in the slow lane.
-
-**`_duration_for(executor, workflow, output_ids, mode, preset, multiplier=1.0)`** in `backend.py` estimates from:
-- `_BASE_DURATION_S[mode]` — t2v 90s, lipsync 240s, style 360s, etc.
-- `_PRESET_MULT[preset]` — fast 1×, balanced 1.5×, quality 3×
-- `_frames_from_workflow(workflow)` — read from `EmptyLTXVLatentVideo` `length`
-- +60s cold-cache buffer, +0.3s/frame VAE decode
-- Clamped to `[60s, 900s]`
-
-`@spaces.GPU(duration=_duration_for)` decorates `_execute_workflow` — ZeroGPU calls the estimator with the same args.
-
-**Auto-retry on timeout** in `_on_generate` (app.py): if first attempt raises `gradio.exceptions.Error('GPU task aborted')`, classified as `category='gpu_timeout'`, the handler shows a "Retrying with extended GPU budget" banner and re-submits with `duration_multiplier=2.0`. The estimator clamps the retry at 900s anyway. One retry only.
-
-### Returning the video path through ZeroGPU's subprocess boundary
-
-`executor.history_result` was unreliable across the `@spaces.GPU` boundary — sometimes the parent process saw an empty dict even when the file was on disk. Fix: `_execute_workflow` reads `history_result["outputs"]` INSIDE the GPU context and returns the path string directly (picklable). Plus a filesystem fallback `_newest_recent_video()` that scans `comfyui/output/` for the newest mp4 modified in the last 60s.
-
-### `allowed_paths` for video output
-
-Gradio 5 refuses to expose files outside cwd / temp / `allowed_paths`. ComfyUI writes to `~/comfyui/output/...` which is outside our app's cwd `/home/user/app` on Spaces. `app.launch(..., allowed_paths=[str(_output_dir)])` whitelists the entire ComfyUI output tree. Without this, video generates fine but `gr.Video` shows blank.
-
-### HF Spaces' header widget z-index (DOM-injected)
-
-When a Space is loaded via the bare embed URL (`https://*.hf.space`), HF injects `#huggingface-space-header` at fixed `z-index: 20` in the top-right (the heart/share widget). Our header z-index has to coexist:
-- Default: header `z-index: 15` (below HF widget — visible)
-- Drawer open: `.drawer-elevated` class bumps to `z-index: 60` (above scrim 45 / drawer 50, hamburger × clickable as close)
-
-JS toggles `.drawer-elevated` on `.aio-header` in lockstep with `.drawer-open` on `.aio-shell`. Three call sites: hamburger onclick, click-outside dismisser (in `gr.Blocks(head=...)` because `<script>` in `gr.HTML` gets stripped), mode-button auto-close.
-
-### Custom nodes the workflow needs
-
-Pinned in `CUSTOM_NODES_PINNED` (`app.py`):
-
-```
-Lightricks/ComfyUI-LTXVideo
-kijai/ComfyUI-KJNodes
-rgthree/rgthree-comfy
-Kosinkadink/ComfyUI-VideoHelperSuite
-pythongosssss/ComfyUI-Custom-Scripts
-city96/ComfyUI-GGUF
-Fannovel16/comfyui_controlnet_aux
-evanspearman/ComfyMath
-Smirnov75/ComfyUI-mxToolkit
-DoctorDiffusion/ComfyUI-MediaMixer  (provides FinalFrameSelector)
-```
-
-Also `requirements.txt` includes deps the custom nodes need but their own `requirements.txt` files don't list (gguf, imageio_ffmpeg, opencv-python, matplotlib, diffusers, yt-dlp, psutil).
-
----
-
-## UI design system: Topaz Cinema Slate
-
-Dark slate background + amber accent, IBM Plex typography. Defined as `_TOPAZ_THEME = gr.themes.Base(...).set(...)` in `app.py`. Custom CSS in `_CUSTOM_CSS` for everything Gradio's theme machinery doesn't cover (drawer, header, mode buttons, status banner).
-
-Layout: hamburger drawer. Pinned 220 px sidebar at ≥1024 px; below that, `position: fixed` overlay sliding from `left: -100%` to `left: 0` via `.aio-shell.drawer-open`.
-
-Mode-tag in header (`#aio-mode-tag`) shows current mode (T2V/A2V/I2V/LIPSYNC/KEY/STYLE), updated by JS in mode-button click handlers.
-
-Spec: `docs/superpowers/specs/2026-05-01-topaz-drawer-redesign-design.md`
-Plan: `docs/superpowers/plans/2026-05-01-topaz-drawer-redesign.md`
-
----
-
-## Critical Gradio scoping facts
-
-- **Gradio prefixes user CSS** with `.gradio-container.gradio-container-<version> .contain ` — selectors that need to escape upward (`body:has(...)`, `html.foo .bar`) are rewritten to nonsense and silently break. Toggle classes via JS on elements INSIDE `.contain` (we use `.aio-shell` and `.aio-header`).
-- **Gradio strips `<script>` tags inside `gr.HTML`** at sanitization. Inline scripts MUST go in `gr.Blocks(head=...)` to actually run. The `_HEAD_HTML` string in `app.py` is where the global click-outside dismisser lives.
-- **Gradio's form labels have `z-index: 40`** built in. Anything we want above them (drawer, scrim) needs `z-index >= 41`. Our hierarchy: header (15 default → 60 elevated) > drawer (50) > scrim (45) > Gradio labels (40) > body.
-- **`onclick="..."` attributes on plain HTML buttons DO survive** sanitization. Use them for tiny per-element interactions (hamburger toggle).
-
----
-
-## Coding conventions
-
-### Language and structure
-
-- **Python 3.11.** No `match` statements (Spaces Python pin compatibility — Spaces base image is 3.10).
-- **Flat layout.** No `src/`, no nested packages. Top-level `.py` files only, each with one clear responsibility.
-- **No conda.** Always `python3.11 -m venv .venv`. System binaries via `brew`.
-
-### Style
-
-- **No emojis** in code or commit messages unless the user explicitly asks. UI text and stage labels in `modes.py` / `ui.py` are OK because they are user-facing — not code.
-- **Comments only for non-obvious WHY.** Never narrate WHAT. Code with a good name doesn't need a comment.
-- **Type hints on public functions.** Internal helpers can skip them if obvious.
-- **Imports at top of file.** Inline imports only to break circular deps (e.g., `models.ensure_models_for_mode` imports `workflow` lazily — keep this, it's load-bearing).
-- **Format with `ruff format`.** Lint with `ruff check`. Both must pass in CI.
-
-### Commits
-
-- **Conventional Commits style:** `<type>(<scope>): <subject>` — types: `feat`, `fix`, `chore`, `docs`, `test`, `refactor`, `ci`, `perf`.
-- **Subject is imperative, lowercase, no trailing period.**
-- **Body explains WHY when not obvious.** Reference spec/plan section if relevant.
-- **Frequent small commits.** One logical change per commit.
-- **No agent attribution** (see top of file).
-- See `SKILLS.md` for the full process around when to commit vs hold.
-
-### Testing
-
-- **TDD per the plan.** Each implementation task has the failing test first.
-- **No mocks for ComfyUI.** Tests run against real workflow JSONs. Stubs only for HTTP boundaries (HF Hub) and filesystem (use `tmp_path` and the `fake_hf_cache` fixture).
-- **L1 + L3 in CI** (no GPU). L2 + L4 are local-developer-only.
-- **Test naming:** `test_<unit>_<behavior_under_test>`.
-- **`pytest --gpu`** enables L4 smoke tests. Default skips them.
-- **`pytest --comfy-real`** uses bundled ComfyUI for L2 instead of the static stub validator.
-
----
-
-## Editing the master workflow
-
-When the user updates `~/Projects/comfyui/user/default/workflows/1. LTX 2.3 All-In-One 260406-05.json`:
-
-```bash
-python3.11 tools/extract_modes.py \
-  --master ~/Projects/comfyui/user/default/workflows/"1. LTX 2.3 All-In-One 260406-05.json" \
-  --out workflows
-```
-
-Then run the test suite — L2 graph-validation catches any node that became invalid in any mode.
-
-After templates regenerate, the node-id constants in `modes.py` (e.g., `T2V_NODE_PROMPT = 240`) may need updating if ComfyUI re-numbered nodes. Procedure in plan Task 11 Step 4.
-
-The user has explicitly said **don't change JSON** — when adding capabilities, prefer parameterize_fn patches over hand-edits. The user re-exports from ComfyUI editor when the workflow changes.
-
----
-
-## Common pitfalls (read before opening a PR)
-
-### ComfyUI / models
-
-- **Loading models eagerly at import time.** Don't. `backend.py` constructs `PromptExecutor` once at instantiation; models load only when nodes execute.
-- **Hard-coded `torch.cuda` calls.** Use `comfy.model_management.get_torch_device()` or guard with `if torch.cuda.is_available()`. Never assume CUDA.
-- **Forgetting `.deepcopy` on workflow templates.** `workflow.load_template` already does this; if you bypass it for performance, you'll mutate the cached template.
-- **Importing `comfy.*` before `sys.path.insert(0, comfy_dir)`.** Will `ModuleNotFoundError`. The order in `backend.py:__init__` is intentional.
-- **`walk_workflow_for_models` returning empty.** Check that the workflow is API format (`{node_id: {class_type, inputs}}`), not editor format (`{nodes: [...]}`). The walker recurses into `Power Lora Loader` rows and skips ones with `on: false`.
-- **Hardcoded paths in seed inputs.** The workflow's `LoadImage` / `VHS_LoadVideo` nodes have baked-in default filenames (`Screenshot 2026-04-23 023318.jpeg`, `4. Lipsync Music.mp3`, etc.). Our `assets/seed_inputs/` covers the ones that ship with the master, plus `_stage_to_comfy_input` copies user uploads into `comfyui/input/`. If a workflow update adds a new default filename, add a placeholder file.
-- **`_COMFY_INPUT_DIR` and `_comfy_dir()` must agree.** Bug we hit: `app.py` had it hardcoded to `<repo>/comfyui/input` but on Spaces ComfyUI runs at `~/comfyui`. User uploads went to a directory ComfyUI never read. Both have to use the same on-Spaces vs local logic.
-
-### Gradio / UI
-
-- **Adding `<script>` to `gr.HTML`.** Gets stripped. Use `gr.Blocks(head=...)`.
-- **Selectors that escape `.contain`.** Gradio rewrites them. Use a class on `.aio-shell` or `.aio-header` instead.
-- **`gr.Video` paths outside cwd.** Need `allowed_paths=` on launch.
-- **Z-index above HF's injected widget.** Header default z-index must be < 20 to not cover the heart/share widget. We use 15, bump to 60 only when drawer is open.
-
-### Spaces
-
-- **`/data` requires the persistent-storage add-on** (separate paid feature, not included in Pro). We use `~/comfyui` and `~/hf-cache-rw` instead.
-- **Build user vs runtime user permissions.** preload_from_hub files are read-only for us. Mirror them — see "Spaces deployment specifics" above.
-- **`@spaces.GPU` requires module-level decoration.** Runtime-applied decoration isn't detected by ZeroGPU's startup analyzer. Module-level static decorator + dynamic-duration callable is the supported pattern.
-- **`history_result` may not survive ZeroGPU's subprocess boundary.** Compute outputs INSIDE the decorated function and return primitive types (str, int, dict of strs).
-- **`allowed_paths` on `app.launch()`** must include the ComfyUI output dir or videos won't display.
-- **Custom Dockerfile breaks ZeroGPU.** ZeroGPU is exclusively compatible with `sdk: gradio`. Switching to `sdk: docker` loses GPU access.
-
-### Authoring
-
-- **Adding `Co-Authored-By` because tooling suggests it.** See top of file. Strip it.
-- **Don't push during HF testing.** When the user is running tests on the live Space, hold local commits until they say push. They'll explicitly tell you when to push.
-
----
-
-## Out of scope for v1 (do not implement without asking)
-
-These are documented as v1.1+ in spec § 11. Don't pre-build them just because they'd be easy:
-
-- **Lite mode** (`LTX23_AIO_LITE=1`) for free HF Spaces tier
-- **Custom LoRA** add/remove rows (Power-Lora-Loader clone)
-- **GGUF Q4 transformer** / "Low VRAM" preset (the GGUF is loaded but always BF16-served at the moment)
-- **Auto-launch of user's external ComfyUI** (`LTX23_AIO_COMFYUI_URL`)
-- **Multi-prompt queueing**
-- **Output history persistence** across sessions
-- **Visual regression tests** for the Gradio UI
-- **Property-based / fuzz testing** of workflow parameters
-- **Persistent Storage add-on integration** (see future_improvements.md item 6)
-- **Telemetry-driven duration estimator** (see future_improvements.md item, requires persistent storage)
-
-If a task feels like it needs one of these, stop and ask the user.
-
----
-
-## When in doubt
-
-1. Read the spec and plan. 15 min of reading vs a day of wrong implementation.
-2. Read `docs/future_improvements.md` to see if the change you're considering is already on a known list.
-3. Check `git log --oneline` for similar changes — most non-obvious decisions have a fix-commit explaining the reasoning.
-4. Ask the user before changing architectural shape.

LICENSE

@@ -1,21 +1,674 @@
-MIT License
-
-Copyright (c) 2026 Mayank Gupta
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,81 +1,13 @@
 ---
-title: LTX 2.3 Studio
+title: LTX-2.5
 emoji: 🎬
 colorFrom: purple
-colorTo: blue
+colorTo: red
 sdk: gradio
-sdk_version: "5.50.0"
+sdk_version: 5.50.0
 app_file: app.py
-python_version: "3.11"
-suggested_hardware: zero-a10g
-hf_oauth: false
+python_version: 3.12
+short_description: Multi-task image generator with dynamic, chainable workflows
 models:
-  - openai/clip-vit-large-patch14
-  - Qwen/Qwen3-0.6B
-  - facebook/opt-125m
-  - openai/whisper-large-v3-turbo
-  - k2-fsa/OmniVoice
-  - Lightricks/LTX-2.3
-  - Kijai/LTX2.3_comfy
-  - unsloth/LTX-2.3-GGUF
-  - facebook/opt-350m
-  - eustlb/higgs-audio-v2-tokenizer
-  - google/gemma-3-12b-it-qat-q4_0-unquantized
-  - ai-forever/Real-ESRGAN
-  - Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control
-  - Lightricks/LTX-2.3-22b-IC-LoRA-Motion-Track-Control
-  - k2-fsa/TTS_eval_models
-  - Lightricks/LTX-2-19b-IC-LoRA-Pose-Control
-  - Lightricks/LTX-2-19b-IC-LoRA-Detailer
-  - Comfy-Org/ltx-2
-preload_from_hub:
-  - Comfy-Org/ltx-2 split_files/text_encoders/gemma_3_12B_it.safetensors
-  - Kijai/LTX2.3_comfy diffusion_models/ltx-2.3-22b-dev_transformer_only_bf16.safetensors,loras/ltx-2.3-22b-distilled-lora-dynamic_fro09_avg_rank_105_bf16.safetensors,text_encoders/ltx-2.3_text_projection_bf16.safetensors,vae/LTX23_audio_vae_bf16.safetensors,vae/LTX23_video_vae_bf16.safetensors,vae/taeltx2_3.safetensors
-  - Lightricks/LTX-2-19b-IC-LoRA-Detailer ltx-2-19b-ic-lora-detailer.safetensors
-  - Lightricks/LTX-2-19b-LoRA-Camera-Control-Jib-Down ltx-2-19b-lora-camera-control-jib-down.safetensors
-  - Lightricks/LTX-2-19b-LoRA-Camera-Control-Jib-Up ltx-2-19b-lora-camera-control-jib-up.safetensors
-  - Lightricks/LTX-2-19b-LoRA-Camera-Control-Static ltx-2-19b-lora-camera-control-static.safetensors
-  - Lightricks/LTX-2.3 ltx-2.3-22b-distilled-lora-384.safetensors,ltx-2.3-spatial-upscaler-x2-1.0.safetensors
-  - Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control ltx-2.3-22b-ic-lora-union-control-ref0.5.safetensors
-  - google/gemma-3-12b-it-qat-q4_0-unquantized gemma-3-12b-it/model-00001-of-00005.safetensors,gemma-3-12b-it/model-00002-of-00005.safetensors,gemma-3-12b-it/model-00003-of-00005.safetensors,gemma-3-12b-it/model-00004-of-00005.safetensors,gemma-3-12b-it/model-00005-of-00005.safetensors,gemma-3-12b-it/model.safetensors.index.json,gemma-3-12b-it/preprocessor_config.json,gemma-3-12b-it/tokenizer.model
+  - Lightricks/LTX-2.5
 ---
-
-# LTX 2.3 All-in-One Video Generator
-
-A Gradio app for [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) wrapping all six modes of the official ComfyUI All-In-One workflow under a single, focused UI. Runs locally on Apple Silicon (MPS) or NVIDIA (CUDA), and deploys to Hugging Face Spaces (ZeroGPU).
-
-## Modes
-
-1. **Text → Video** (+ optional Audio)
-2. **Audio → Video** (Text + Audio → Video + Audio)
-3. **Image → Video** (+ optional Audio)
-4. **Lipsync** (Image + Audio → Video + Audio)
-5. **First / Last Frame → Video** (keyframe interpolation)
-6. **Style Transfer** (Video → Video, motion control)
-
-## Local quickstart
-
-Requires Python 3.11, ~80 GB free disk for model weights, and ~24 GB+ GPU memory (CUDA) or 32 GB+ unified memory (Apple Silicon).
-
-```bash
-git clone --recurse-submodules https://github.com/<your-handle>/ltx2.3-AIO-generator
-cd ltx2.3-AIO-generator
-bash setup.sh
-source .venv/bin/activate
-python app.py
-```
-
-The first run downloads ~70 GB of models into your existing `~/.cache/huggingface/hub` (no duplicate copies in this repo) and symlinks them into `comfyui/models/`.
-
-## HF Spaces deployment
-
-This repo is a Gradio Space. The required Pro tier provides ~50 GB persistent `/data` storage and longer per-call ZeroGPU budgets needed for Balanced and Quality presets.
-
-```bash
-git remote add space https://huggingface.co/spaces/<your-handle>/ltx2.3-aio
-git push space main
-```
-
-## License
-
-MIT for the AIO app code. ComfyUI and LTX-2.3 retain their respective licenses.

SKILLS.md

@@ -1,299 +0,0 @@
-# Skills — how to make changes in this project
-
-Process rules and habits for AI assistants working on this repo. Companion to `CLAUDE.md` (which is *what & why*); this file is *how*.
-
-> Default rule when in doubt: **stop and ask the user**. The user prefers a question over wrong work.
-
----
-
-## Investigation before fix
-
-### Reproduce the bug visually before patching CSS / UI
-
-When the user reports a layout, color, click, or visibility issue, **the first action is Playwright + screenshot, not code**. The user has called this out explicitly:
-
-> "Make sure to check playwright with screenshot to verify issues before making fix."
-
-Skipping the visual repro twice in a row produced patches that addressed a different symptom than what the user was seeing. Reproduce, then fix, then re-screenshot to verify the fix.
-
-**Tools:** local dev server (port 7860, see "Running locally" below) + `mcp__playwright__browser_*` tools. Resize to the affected viewport (typically 380 px / 900 px / 1280 px). `browser_evaluate` is the most reliable way to inspect DOM state — getBoundingClientRect, getComputedStyle, elementFromPoint.
-
-### Pull HF Space logs first when something runs there
-
-For Spaces failures, the run logs are the source of truth. Pull and search:
-
-```bash
-HF_TOKEN=$(cat ~/.cache/huggingface/token)
-curl -s -H "Authorization: Bearer ${HF_TOKEN}" \
-  "https://huggingface.co/api/spaces/techfreakworm/LTX2.3-Studio/logs/run" \
-  -o /tmp/hf_run.log
-
-# Find last submit and tail from there
-python3 << 'PY'
-import json
-events = []
-for line in open('/tmp/hf_run.log'):
-    line = line.strip()
-    if line.startswith('data: '):
-        try: events.append(json.loads(line[6:]))
-        except Exception: pass
-last = max(i for i, e in enumerate(events) if 'submitting workflow' in e.get('data', ''))
-for ev in events[last:]:
-    print(ev.get('timestamp', '')[:19], ev.get('data', '').rstrip()[:240])
-PY
-```
-
-`/logs/build` is the other endpoint. Build logs show preload, image-build, pip; run logs show container output.
-
-### Stage check before action
-
-```bash
-HF_TOKEN=$(cat ~/.cache/huggingface/token)
-curl -s -H "Authorization: Bearer ${HF_TOKEN}" \
-  "https://huggingface.co/api/spaces/techfreakworm/LTX2.3-Studio" | jq -r '.runtime'
-```
-
-Stages: `BUILDING` (image), `APP_STARTING` (boot), `RUNNING`, `RUNTIME_ERROR`, `RUNNING_BUILDING` (live serving + new build queued). If `RUNTIME_ERROR` is non-null, that's your headline.
-
-### Sequential thinking for repeated failures
-
-The user has called this out:
-
-> "On 2nd failed fix, stop patching; use sequential-thinking MCP + brainstorming skill"
-
-If your first fix didn't land, **stop patching**. Use `mcp__sequential-thinking__sequentialthinking` to think through the failure mode end-to-end, plus web search for canonical solutions. Do not loop on speculative one-line patches.
-
-### Web-search for HF / Gradio errors with the literal message
-
-HF docs change. The `Spaces Configuration Reference` and `Spaces ZeroGPU` pages often have undocumented behavior captured in forum threads. When you hit a Gradio/Spaces error, web-search the literal exception message. Examples that paid off:
-
-- `gradio.exceptions.InvalidPathError` → fix was `allowed_paths=` (Gradio 5 file-access policy)
-- `'Workload evicted, storage limit exceeded (150G)'` → 150 GB ephemeral cap
-- `'No @spaces.GPU function detected during startup'` → must be module-level decorator
-- `'GPU task aborted'` → `@spaces.GPU(duration=...)` cap
-
----
-
-## Verification
-
-### Run the full repro in Playwright before declaring done
-
-After a UI fix, re-run the same Playwright sequence that exposed the bug. Take a screenshot. Read the DOM state. Don't trust "it should work now" — show that it does.
-
-### Local before push
-
-When iterating on app behavior, the local dev server gives instant feedback. The user explicitly asks for this — they do most testing on the WiFi-accessible local URL. **Never push during HF testing windows.** When the user is testing on the live Space, hold local commits until they say push.
-
-```bash
-# In repo root
-source .venv/bin/activate
-python app.py  # or background it; see "Running locally"
-```
-
-The user has stated:
-
-> "DO NOT PUSH since testing is happening on HF"
-
-When in doubt, hold and ask.
-
-### Smoke import + build_app after backend/app changes
-
-```bash
-python -c "import app; b = app.build_app(); print(type(b).__name__)"
-```
-
-Should print `Blocks`. Catches most syntax / import-cycle issues without spinning up the full server.
-
-### Sanity-test isolated functions when changing logic
-
-For workflow walkers, model registry, duration estimators — write a tiny `python3 -c '...'` or HEREDOC to feed synthetic inputs and verify outputs. Faster than running the full app, catches regressions that the full app would mask.
-
----
-
-## Running locally
-
-### Standard launch (port 7860)
-
-```bash
-cd /Users/techfreakworm/Projects/llm/ltx2.3-AIO-generator
-source .venv/bin/activate
-nohup python app.py > /tmp/ltx_studio_run.log 2>&1 &
-echo $! > /tmp/ltx_studio.pid
-```
-
-Wait ~18 seconds for ComfyUI to import + Gradio to bind, then check:
-
-```bash
-lsof -nP -iTCP:7860 -sTCP:LISTEN
-```
-
-### LAN-accessible URL
-
-Bound to `0.0.0.0:7860` by default. Get the LAN IP:
-
-```bash
-ipconfig getifaddr en0 || ipconfig getifaddr en1
-```
-
-Open `http://<LAN_IP>:7860` on phone/tablet on the same WiFi. macOS firewall: allow inbound for `python` if connection refused.
-
-### Stop
-
-```bash
-PID=$(cat /tmp/ltx_studio.pid)
-kill -9 $PID
-lsof -nP -iTCP:7860 -sTCP:LISTEN | awk 'NR>1 {print $2}' | xargs -r kill -9
-```
-
----
-
-## Pushing changes
-
-### Two remotes
-
-```bash
-git push origin master                                                 # GitHub
-HF_TOKEN=$(cat ~/.cache/huggingface/token)                             # HF auth (cli removed `hf auth token`)
-git push "https://techfreakworm:${HF_TOKEN}@huggingface.co/spaces/techfreakworm/LTX2.3-Studio" master:main
-```
-
-GitHub: `master`. HF Space: `main`. The Space accepts force-push only with explicit user consent.
-
-### When to push
-
-- Default: hold all commits locally, ask the user before pushing.
-- The user usually says "push" or "push them" when ready.
-- During the user's HF testing windows, NEVER push.
-- After a successful local Playwright verification of a fix, summarize the queued commits and ask.
-
----
-
-## Spaces deploy lifecycle
-
-Each push triggers a Docker image rebuild. Most layers are cached unless requirements.txt or README YAML changes. The first push that adds/changes `preload_from_hub:` triggers a long preload step (download all listed files into `~/.cache/huggingface/hub`).
-
-Container start sequence (after image push):
-1. HF brings up the container as user 1000
-2. Our `_bootstrap()` runs:
-   - clones ComfyUI + custom nodes (cold-start only — frozen ZeroGPU containers retain them)
-   - pip installs each custom node's requirements
-   - `_mirror_preload_hf_cache()` builds writable cache mirror
-   - copies seed inputs
-   - sets HF_HOME / HF_HUB_CACHE env vars
-3. `gr.Blocks(...).launch()` binds 7860
-4. Stage transitions to `RUNNING`
-
-ZeroGPU container freeze on idle: keeps `~/comfyui`, `~/hf-cache-rw`, etc. Wake on next request restores in seconds. Push or rebuild loses everything.
-
----
-
-## When the user says "deep think"
-
-The user explicitly invokes deeper investigation when stuck:
-
-> "Use deep thinking using sequential thinking and web search and code exploration."
-
-Use `mcp__sequential-thinking__sequentialthinking` to lay out the problem end-to-end. Web-search literal error messages. Read code beyond the immediate failure site. Avoid speculative one-line patches when in this mode.
-
----
-
-## What never to do
-
-- **Push without explicit permission** during HF test windows.
-- **Add Co-Authored-By** or any agent attribution to commit messages.
-- **Hand-edit `workflows/*.json`** — the user re-exports from ComfyUI editor.
-- **`chmod` the HF preload cache** — we don't own it. See cache-mirror approach in CLAUDE.md.
-- **Switch `sdk: gradio` → `sdk: docker`** in README. Loses ZeroGPU.
-- **Move models into the repo via git LFS without asking.** Pro has 1 TB LFS but bandwidth is finite.
-- **Implement out-of-scope v1.1+ features** without asking. See "Out of scope" in CLAUDE.md.
-- **Eagerly load models at module import.** `_bootstrap()` only ensures clones + cache mirroring. Model load happens when ComfyUI's executor evaluates a node.
-
----
-
-## Memory (cross-session)
-
-The user's preferences live at `~/.claude/projects/-Users-techfreakworm-Projects/memory/`. Key entries:
-
-- **Git authorship:** sole author, no co-author footers
-- **Verify before fix:** Playwright + screenshot first
-- **Don't push during HF testing:** hold local commits
-- **Autonomous execution:** prefer scripts over notebooks, report results
-- **No conda:** `python3.11 -m venv`, brew for system bins
-- **Tests folder:** keep `~/Projects/tests/` separate from `~/Projects/`
-
-When the user asks to remember something new, save it as a memory file and update `MEMORY.md` index.
-
----
-
-## When stuck for too long
-
-Three escalation steps:
-
-1. **`mcp__sequential-thinking__sequentialthinking`** — think the whole flow through, identify the unknown.
-2. **WebSearch + WebFetch** — find canonical fix or known issue.
-3. **Ask the user** — describe what's been tried, what's still unknown, propose options.
-
-Do not loop on patches when you've patched twice and it's still broken.
-
----
-
-## Repo structure (high level)
-
-```
-.
-├── app.py               # Gradio entry, _bootstrap, _on_generate, build_app
-├── backend.py           # ComfyUILibraryBackend, _execute_workflow, _GPU
-├── modes.py             # MODE_REGISTRY + per-mode parameterize_fn + node-id constants
-├── models.py            # MODEL_REGISTRY, walk_workflow_for_models, ensure_models
-├── ui.py                # render_status, _render_idle, mode-form layout primitives
-├── workflow.py          # load_template, set_input
-├── workflows/           # API-format mode JSONs (do not hand-edit)
-│   ├── t2v.json
-│   ├── i2v.json
-│   ├── a2v.json
-│   ├── lipsync.json
-│   ├── keyframe.json
-│   └── style.json
-├── assets/seed_inputs/  # placeholder image/audio/video for cold-start (gitignored except this dir)
-├── docs/
-│   ├── superpowers/specs/    # design specs (per-feature)
-│   ├── superpowers/plans/    # implementation plans (per-feature)
-│   └── future_improvements.md
-├── tools/extract_modes.py    # regenerate workflows/ from master
-├── tests/
-├── README.md            # HF Space YAML + project description
-├── CLAUDE.md            # what & why (this project's facts)
-├── SKILLS.md            # how (this file)
-├── requirements.txt
-└── comfyui/             # git submodule (local) / runtime clone target (Spaces)
-```
-
----
-
-## Useful one-liners
-
-```bash
-# What's the Space's current SHA vs local HEAD
-hf_sha=$(curl -s -H "Authorization: Bearer $(cat ~/.cache/huggingface/token)" \
-  "https://huggingface.co/api/spaces/techfreakworm/LTX2.3-Studio" \
-  | jq -r '.sha')
-echo "HF: ${hf_sha:0:8}  local: $(git rev-parse HEAD | cut -c1-8)"
-
-# Local commits ahead of origin
-git log origin/master..HEAD --oneline
-
-# All class_types referenced by workflows (cross-check against custom_nodes)
-python3 -c "import json, glob, sys
-seen = set()
-for p in glob.glob('workflows/*.json'):
-    seen |= {n.get('class_type','') for n in json.load(open(p)).values()}
-for c in sorted(seen): print(c)"
-
-# Models referenced by workflows but not in registry
-python3 -c "import json, glob, models
-needed = set()
-for p in glob.glob('workflows/*.json'):
-    needed |= models.walk_workflow_for_models(json.load(open(p)))
-unmapped = needed - set(models.MODEL_REGISTRY)
-print('unmapped:', sorted(unmapped) or 'none')"
-```

app.py

@@ -1,1242 +1,101 @@
-# app.py
-"""LTX 2.3 All-in-One — Gradio entry point."""
-
-from __future__ import annotations
-
+import spaces
 import os
-import imageio_ffmpeg
-import tempfile
-import shutil
-import subprocess
-from datetime import datetime
-import pathlib
-import random
 import sys
-import time
-import math
-from typing import Any
-
-import gradio as gr
-
-import backend as backend_module
-import modes
-import ui
-import workflow as wf_module
-
-# ---------------------------------------------------------------------------
-# Bootstrap — runs once on cold start.
-# ---------------------------------------------------------------------------
-
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-COMFYUI_REPO = "https://github.com/comfyanonymous/ComfyUI.git"
-COMFYUI_COMMIT = os.environ.get(
-    "LTX23_AIO_COMFYUI_COMMIT",
-    "eb0686bbb60c83e44c3a3e4f7defd0f589cfef10",
-)
-
-CUSTOM_NODES_PINNED: list[tuple[str, str]] = [
-    ("https://github.com/Lightricks/ComfyUI-LTXVideo.git", "2acf7af8991f33b5cc06ec26753cb6e88e057d04"),
-    ("https://github.com/kijai/ComfyUI-KJNodes.git", "01d9fa9c983273532cacdf9532c74a93c7dc86d2"),
-    ("https://github.com/rgthree/rgthree-comfy.git", "683836c46e898668936c433502504cc0627482c5"),
-    ("https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git", "2984ec4c4b93292421888f38db74a5e8802a8ff8"),
-    ("https://github.com/pythongosssss/ComfyUI-Custom-Scripts.git", "609f3afaa74b2f88ef9ce8d939626065e3247469"),
-    ("https://github.com/city96/ComfyUI-GGUF.git", "6ea2651e7df66d7585f6ffee804b20e92fb38b8a"),
-    ("https://github.com/Fannovel16/comfyui_controlnet_aux.git", "e8b689a513c3e6b63edc44066560ca5919c0576e"),
-    ("https://github.com/evanspearman/ComfyMath.git", "c01177221c31b8e5fbc062778fc8254aeb541638"),
-    ("https://github.com/Smirnov75/ComfyUI-mxToolkit.git", "7f7a0e584f12078a1c589645d866ae96bad0cc35"),
-    ("https://github.com/DoctorDiffusion/ComfyUI-MediaMixer.git", "2bae7b5ea8fc52d8a4d668d62fed76265f4eec2c"),
-]
-
-mode_debug_value = [None]
-input_image_debug_value = [None]
-end_image_debug_value = [None]
-audio_debug_value = [None]
-prompt_debug_value = [None]
-negative_prompt_debug_value = [None]
-total_second_length_debug_value = [None]
-width_debug_value = [None]
-height_debug_value = [None]
-resolution_debug_value = [None]
-allocation_time_debug_value = [None]
-
-
-def _git_clone(url: str, dst: pathlib.Path, ref: str) -> None:
-    """Clone *url* at *ref* into *dst*. *ref* may be a branch, tag, or SHA.
-
-    `git clone --branch` only accepts branch/tag names, so we use init+fetch
-    which works for any object GitHub allows fetching (default: reachable
-    commits in public repos).
-    """
-    import subprocess
-
-    dst = pathlib.Path(dst)
-    dst.mkdir(parents=True, exist_ok=True)
-    subprocess.check_call(["git", "-C", str(dst), "init", "-q"])
-    subprocess.check_call(["git", "-C", str(dst), "remote", "add", "origin", url])
-    subprocess.check_call(["git", "-C", str(dst), "fetch", "--depth", "1", "origin", ref])
-    subprocess.check_call(["git", "-C", str(dst), "checkout", "-q", "FETCH_HEAD"])
-
-
-def _mirror_preload_hf_cache() -> None:
-    """Mirror the build-populated HF cache into a writable runtime tree.
-
-    HF Spaces' build pipeline runs `preload_from_hub` as a different user
-    than the runtime container, so the populated `~/.cache/huggingface/`
-    is read-only for us (uid 1000). Any subsequent `hf_hub_download` call
-    that needs to write a NEW file (lazy-loaded LoRAs, GGUF, etc.) fails
-    with "Permission denied" because the parent dir isn't writable.
-
-    Fix: build a parallel tree at `~/hf-cache-rw/` that we own, with:
-    - dirs: created fresh via mkdir
-    - blob files (`blobs/<sha>`): hardlinked (shared inode, instant)
-    - relative snapshot symlinks: preserved as symlinks
-    - `refs/<branch>` files: byte-copied (HF lib overwrites these)
-    - everything else: byte-copied (safest default)
-    Then set HF_HOME / HF_HUB_CACHE so HF lib reads/writes through the
-    mirror. Reads are zero-copy via hardlink/symlink; new downloads land
-    in dirs we created.
-    """
-    import shutil
-
-    src_root = pathlib.Path.home() / ".cache" / "huggingface"
-    dst_root = pathlib.Path.home() / "hf-cache-rw"
-    dst_root.mkdir(parents=True, exist_ok=True)
-    os.environ["HF_HOME"] = str(dst_root)
-    os.environ["HF_HUB_CACHE"] = str(dst_root / "hub")
-
-    if not src_root.exists():
-        return
-
-    counts = {"dirs": 0, "hardlinks": 0, "symlinks": 0, "copies": 0, "errors": 0}
-
-    def _treat_as_copy(rel_path: pathlib.PurePath) -> bool:
-        # Anything under a refs/ dir, anywhere in the tree.
-        return any(part == "refs" for part in rel_path.parts)
-
-    def _walk(s: pathlib.Path, d: pathlib.Path) -> None:
-        try:
-            d.mkdir(parents=True, exist_ok=True)
-            counts["dirs"] += 1
-        except OSError as exc:
-            print(f"[bootstrap] mirror mkdir fail {d}: {exc}", flush=True)
-            counts["errors"] += 1
-            return
-
-        for entry in s.iterdir():
-            de = d / entry.name
-            try:
-                if entry.is_symlink():
-                    if de.exists() or de.is_symlink():
-                        continue
-                    target = os.readlink(str(entry))
-                    de.symlink_to(target)
-                    counts["symlinks"] += 1
-                elif entry.is_dir():
-                    _walk(entry, de)
-                elif entry.is_file():
-                    if de.exists():
-                        continue
-                    rel = de.relative_to(dst_root)
-                    if _treat_as_copy(rel):
-                        shutil.copy2(entry, de)
-                        counts["copies"] += 1
-                    else:
-                        try:
-                            os.link(str(entry), str(de))
-                            counts["hardlinks"] += 1
-                        except OSError:
-                            # Cross-device or other — fall back to symlink.
-                            de.symlink_to(entry)
-                            counts["symlinks"] += 1
-            except OSError as exc:
-                print(f"[bootstrap] mirror skip {entry}: {exc}", flush=True)
-                counts["errors"] += 1
-
-    _walk(src_root, dst_root)
-    print(
-        f"[bootstrap] hf cache mirrored to {dst_root}: "
-        f"{counts['dirs']} dirs, {counts['hardlinks']} hardlinks, "
-        f"{counts['symlinks']} symlinks, {counts['copies']} copies, "
-        f"{counts['errors']} errors",
-        flush=True,
-    )
-
-
-def _bootstrap() -> None:
-    on_spaces = _on_spaces()
-    # /data requires the paid persistent-storage add-on (separate from Pro).
-    # Without it, /data is unwritable. $HOME is writable and — because ZeroGPU
-    # containers freeze on sleep rather than tear down — the clone persists
-    # across calls within a single deploy.
-    comfy_dir = (pathlib.Path.home() / "comfyui") if on_spaces else pathlib.Path("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:
-            name = node_url.rstrip(".git").rsplit("/", 1)[-1]
-            _git_clone(node_url, comfy_dir / "custom_nodes" / name, ref=node_ref)
-        import subprocess
-
-        # 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))
-    os.environ.setdefault("COMFY_MODELS_DIR", str(comfy_dir / "models"))
-
-    # Mirror the build-time HF cache (populated by preload_from_hub, owned by
-    # build user → read-only for runtime user 1000) into a writable parallel
-    # tree under $HOME, then point HF_HUB_CACHE / HF_HOME at it. After this:
-    # - preloaded blobs are accessible via hardlink (no data copy, instant reads)
-    # - relative snapshot symlinks resolve within the mirror
-    # - refs/* are byte-copies so HF lib can overwrite when commits advance
-    # - new lazy-downloaded files write to dirs we own → no permission errors
-    if on_spaces:
-        _mirror_preload_hf_cache()
-
-    # 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
+import site
+import logging
 
-        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)
+class IgnoreUnetUnexpectedFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return "unet unexpected" not in record.getMessage()
 
+logging.getLogger().addFilter(IgnoreUnetUnexpectedFilter())
 
-_bootstrap()
+if "--use-sage-attention" not in sys.argv:
+    sys.argv.append("--use-sage-attention")
+    print("🚀 [SageAttention] Injected '--use-sage-attention' into sys.argv.")
 
+APP_DIR = os.path.dirname(os.path.abspath(__file__))
+if APP_DIR not in sys.path:
+    sys.path.insert(0, APP_DIR)
+    print(f"✅ Added project root '{APP_DIR}' to sys.path.")
 
-# ---------------------------------------------------------------------------
-# Styling: hide the default top tab strip (drawer nav drives selection),
-# add status-card styling, plus single responsive breakpoint at 1023 px
-# (drawer slides over body) / 1024 px+ (drawer pinned).
-# ---------------------------------------------------------------------------
+SAGE_PATCH_APPLIED = False
 
-_CUSTOM_CSS = """
-/* Hide Gradio's top tab strip — sidebar drives selection. */
-.aio-tabs > .tab-nav,
-.aio-tabs > div:first-child[role="tablist"],
-.aio-tabs > div:first-child:has([role="tab"]) {
-    position: absolute !important;
-    left: -99999px !important;
-    top: -99999px !important;
-    height: 0 !important;
-    overflow: hidden !important;
-    visibility: visible !important;
-    pointer-events: auto !important;
-}
+def apply_sage_attention_patch():
+    global SAGE_PATCH_APPLIED
+    if SAGE_PATCH_APPLIED:
+        return "SageAttention patch already applied."
 
-/* === Header === */
-.aio-header {
-    display: flex;
-    align-items: center;
-    gap: 12px;
-    padding: 11px 18px;
-    border-bottom: 1px solid #262C35;
-    position: relative;
-    /* HF injects #huggingface-space-header at fixed z-index 20 (top-right
-       like/share widget). Stay below it by default so we don't cover it. */
-    z-index: 15;
-}
-/* When drawer is open, lift header above scrim (z-45) and drawer (z-50) so
-   the hamburger flips to × and remains clickable as a close affordance.
-   Toggled in lockstep with .aio-shell.drawer-open via the inline JS below. */
-.aio-header.drawer-elevated {
-    z-index: 60;
-}
-.aio-ham-label {
-    display: none;
-    width: 32px; height: 32px;
-    border: 1px solid #262C35;
-    border-radius: 5px;
-    cursor: pointer;
-    align-items: center; justify-content: center;
-    font-size: 18px; font-weight: 300;
-    user-select: none;
-}
-.aio-ham-label:hover { border-color: #E0A458; }
-.aio-title {
-    font-size: 15px; font-weight: 600; letter-spacing: -0.01em;
-}
-.aio-mode-tag {
-    margin-left: auto;
-    padding: 4px 9px;
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-    font-size: 11px; font-weight: 500; letter-spacing: 0.04em;
-    border: 1px solid #E0A458;
-    border-radius: 4px;
-}
-
-.aio-tipbar {
-    margin: 0 0 6px 0;
-    padding: 6px 14px;
-    font-family: 'IBM Plex Sans', system-ui, sans-serif;
-    font-size: 12px;
-    border-bottom: 1px solid #262C35;
-    text-align: center;
-}
-.aio-tipbar strong { font-weight: 500; }
-
-/* === Drawer === */
-.aio-shell { position: relative; }
-.aio-drawer {
-    width: 220px;
-    border-right: 1px solid #262C35;
-    padding: 14px 10px !important;
-    flex-shrink: 0;
-    transition: left 0.2s ease;
-}
-.aio-drawer-heading {
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-    font-size: 10px; text-transform: uppercase; letter-spacing: 0.07em;
-    padding: 6px 8px 4px !important;
-    margin: 0 !important;
-}
-
-/* Mode buttons */
-.aio-mode-btn { width: 100%; text-align: left; margin: 2px 0 !important; }
-.aio-mode-btn-active {
-    border-left: 3px solid #E0A458 !important;
-}
-
-/* Model status / settings panels */
-.aio-model-badge {
-    padding: 9px 11px;
-    border-radius: 6px;
-    border: 1px solid #262C35;
-    font-size: 11.5px;
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-}
-#default_examples {
-display:none;
-}
-
-/* === Status banner === */
-.status-card {
-    padding: 12px 16px;
-    border-radius: 6px;
-    border: 1px solid #262C35;
-}
-.status-row { display: flex; gap: 14px; align-items: center; margin-bottom: 8px; flex-wrap: wrap; }
-.status-stage { font-weight: 600; }
-.status-meta { font-size: 12px; font-family: 'IBM Plex Mono', ui-monospace, monospace; }
-.status-bar { height: 4px; border-radius: 99px; overflow: hidden; }
-.status-fill { height: 100%; transition: width .3s; }
-.status-mem { font-size: 11px; margin-top: 6px; font-family: 'IBM Plex Mono', ui-monospace, monospace; }
-.status-error {
-    border-color: #F4A6A8 !important;
-}
-
-/* === Drawer toggle behavior at the desktop boundary === */
-@media (max-width: 1023px) {
-    .aio-ham-label { display: flex; }
-    .aio-drawer {
-        position: fixed;
-        top: 0; bottom: 0;
-        left: -100%;
-        z-index: 50;
-        box-shadow: 4px 0 24px rgba(0,0,0,0.6);
-        max-width: 80vw;
-        overflow-y: auto;
-        overflow-x: hidden;
-        padding-top: 80px !important;
-    }
-    /* `.aio-shell.drawer-open` is toggled by the hamburger's inline JS.
-       `body:has(:checked)` would be cleaner but Gradio prefixes user CSS
-       with `.gradio-container .contain `, breaking ancestor selectors. */
-    .aio-shell.drawer-open .aio-drawer { left: 0; }
-    .aio-shell.drawer-open::before {
-        content: ""; position: fixed; inset: 0;
-        z-index: 45;
-        backdrop-filter: blur(10px);
-        -webkit-backdrop-filter: blur(10px);
-    }
-
-    /* Mobile sub-tweaks */
-    .aio-mode-btn { font-size: 13px !important; padding: 7px 10px !important; }
-    .aio-body [class*="row"] { flex-wrap: wrap !important; }
-    .aio-body [class*="row"] > div { flex: 1 1 100% !important; min-width: 0 !important; }
-}
-
-@media (min-width: 1024px) {
-    .aio-ham-label { display: none; }
-}
-"""
-
-
-# ---------------------------------------------------------------------------
-# UI
-# ---------------------------------------------------------------------------
-
-
-
-_HEAD_HTML = """
-<script>
-(function(){
-  if (window._aioDismissInstalled) return;
-  window._aioDismissInstalled = true;
-  document.addEventListener("click", function(e) {
-    var s = document.querySelector(".aio-shell");
-    if (!s || !s.classList.contains("drawer-open")) return;
-    if (e.target.closest(".aio-drawer") || e.target.closest(".aio-ham-label")) return;
-    s.classList.remove("drawer-open");
-    var h = document.querySelector(".aio-header");
-    if (h) h.classList.remove("drawer-elevated");
-    var b = document.querySelector(".aio-ham-label");
-    if (b) {
-      b.textContent = "\\u2261";
-      b.setAttribute("aria-expanded", "false");
-    }
-  });
-})();
-</script>
-"""
-
-
-def build_app() -> gr.Blocks:
-    with gr.Blocks(title="LTX 2.3 Studio", css=_CUSTOM_CSS, head=_HEAD_HTML) as app:
-        # Header: hamburger button toggles `.drawer-open` on `.aio-shell`.
-        # The click-outside dismisser is registered via gr.Blocks(head=...)
-        # below — Gradio strips <script> tags inside gr.HTML so it has to
-        # live in <head> to actually run.
-        gr.HTML(
-            '<div class="aio-header">'
-            '  <button type="button" class="aio-ham-label" '
-            '          onclick="(function(b){var s=document.querySelector(\'.aio-shell\');'
-            'var o=s.classList.toggle(\'drawer-open\');'
-            'var h=document.querySelector(\'.aio-header\');'
-            'if(h)h.classList.toggle(\'drawer-elevated\',o);'
-            'b.textContent=o?\'\\u00d7\':\'\\u2261\';'
-            'b.setAttribute(\'aria-expanded\',o?\'true\':\'false\');})(this)" '
-            '          aria-expanded="false" aria-label="Toggle navigation">≡</button>'
-            '  <span class="aio-title">LTX 2.3 <span class="accent">Studio</span></span>'
-            '  <span class="aio-mode-tag" id="aio-mode-tag">T2V</span>'
-            '</div>'
-        )
-        gr.HTML(
-            '<div class="aio-tipbar">'
-            'Liking this project? '
-            '<strong>Drop a <span class="aio-heart">♥</span> at the top of this page</strong> '
-            'to support it.'
-            '<br/>'
-            'If you don\'t care about the sound, I advise you Wan 2.2 instead.'
-            '</div>'
-        )
-
-        with gr.Row(elem_classes=["aio-shell"]):
-            # Drawer (drawer behaves as fixed sidebar ≥1024 px;
-            # absolute-positioned overlay <1024 px — see _CUSTOM_CSS).
-            with gr.Column(scale=1, min_width=200, elem_classes=["aio-drawer"]):
-                gr.Markdown("Modes", elem_classes=["aio-drawer-heading"])
-                mode_buttons = {
-                    name: gr.Button(
-                        f"{m.icon}  {m.label}",
-                        elem_classes=["aio-mode-btn"],
-                        variant="secondary",
-                    )
-                    for name, m in modes.MODE_REGISTRY.items()
-                }
-                gr.Markdown("Models", elem_classes=["aio-drawer-heading"])
-                model_status = gr.HTML(_render_model_status_idle(), elem_id="aio-model-status")
-                refresh_btn = gr.Button("Refresh", size="sm", variant="secondary")
-                unload_btn = gr.Button("Unload all models", size="sm", variant="secondary")
-                gr.Markdown("Settings", elem_classes=["aio-drawer-heading"])
-                gr.Markdown(
-                    "Output: `comfyui/output/LTX2.3/`<br>"
-                    "Set `LTX23_AIO_VRAM=lowvram|normalvram|highvram` to override "
-                    "the auto-detected VRAM tier.",
-                    elem_classes=["aio-model-badge"],
-                )
-
-            # Body — unchanged, still hosts the 6 mode tabs.
-            with gr.Column(scale=4, elem_classes=["aio-body"]):
-                handles, tabs_component = _render_mode_panels()
-
-        # Wire generate buttons
-        for name, h in handles.items():
-            inputs = _collect_inputs_for_mode(name, h)
-            h["generate_btn"].click(
-                fn=_make_handler(name, h),
-                inputs=inputs,
-                outputs=[h["status"], h["video_out"]],
-            )
-
-        # JS to update the header mode tag without a server round-trip.
-        # Each mode button injects a tiny on-click that rewrites #aio-mode-tag
-        # and (on mobile) auto-collapses the drawer.
-        _MODE_TAG_BY_NAME = {
-            "t2v": "T2V", "a2v": "A2V", "i2v": "I2V",
-            "lipsync": "LIPSYNC", "keyframe": "KEY", "style": "STYLE",
-        }
-        for name, btn in mode_buttons.items():
-            tag = _MODE_TAG_BY_NAME.get(name, name.upper())
-            btn.click(
-                fn=lambda mode_id=name: gr.Tabs(selected=mode_id),
-                inputs=None,
-                outputs=[tabs_component],
-                js=f"() => {{ "
-                   f"const el = document.getElementById('aio-mode-tag'); "
-                   f"if (el) el.textContent = {tag!r}; "
-                   f"if (window.matchMedia('(max-width: 1023px)').matches) {{ "
-                   f"  document.querySelector('.aio-shell')?.classList.remove('drawer-open'); "
-                   f"  document.querySelector('.aio-header')?.classList.remove('drawer-elevated'); "
-                   f"  const hb = document.querySelector('.aio-ham-label'); "
-                   f"  if (hb) {{ hb.textContent = '\\u2261'; hb.setAttribute('aria-expanded', 'false'); }} "
-                   f"}} return []; }}",
-            )
-
-        # Sidebar model info wiring
-        refresh_btn.click(fn=_render_model_status, inputs=None, outputs=[model_status])
-        unload_btn.click(fn=_unload_models, inputs=None, outputs=[model_status])
-
-    return app
-
-
-def _render_model_status_idle() -> str:
-    return (
-        '<div class="aio-model-badge">device: detecting…<br>'
-        "loaded: —<br>free: —</div>"
-    )
-
-
-def _render_model_status() -> str:
-    """Best-effort device + memory readout for the sidebar."""
     try:
-        be = _get_backend()  # ensure ComfyUI is loaded
-    except Exception as exc:
-        return f'<div class="aio-model-badge">backend not ready<br>{exc}</div>'
-    try:
-        import comfy.model_management as mm
-        import torch
-
-        device = mm.get_torch_device()
-        free_gb = mm.get_free_memory(device) / (1024**3)
-        if torch.backends.mps.is_available():
-            # MPS unified memory: total physical = total system RAM. The
-            # "recommended max" from torch.mps is a soft cap (~75% of total)
-            # used by the allocator, but actual free can exceed it because
-            # macOS shares RAM between CPU and GPU.
-            try:
-                import psutil
-
-                total_gb = psutil.virtual_memory().total / (1024**3)
-            except Exception:
-                total_gb = torch.mps.recommended_max_memory() / (1024**3)
-            cap_gb = torch.mps.recommended_max_memory() / (1024**3)
-            label = "MPS (unified)"
-            extra = f"<br>mps cap: {cap_gb:.1f} GB"
-        elif torch.cuda.is_available():
-            total_gb = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            label = "CUDA"
-            extra = ""
-        else:
-            total_gb = 0.0
-            label = "CPU"
-            extra = ""
-        loaded = len(getattr(mm, "current_loaded_models", []))
-        return (
-            '<div class="aio-model-badge">'
-            f"device: {label}<br>"
-            f"loaded: {loaded} model(s)<br>"
-            f"free: {free_gb:.1f} GB / {total_gb:.1f} GB total"
-            f"{extra}"
-            "</div>"
-        )
-    except Exception as exc:
-        return f'<div class="aio-model-badge">memory probe failed: {exc}</div>'
-
-
-def _unload_models() -> str:
-    try:
-        import comfy.model_management as mm
-        import torch
-
-        mm.unload_all_models()
-        if torch.backends.mps.is_available():
-            torch.mps.empty_cache()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-    except Exception as exc:
-        return f'<div class="aio-model-badge">unload failed: {exc}</div>'
-    return _render_model_status()
-
-
-def _render_mode_panels() -> tuple[dict[str, dict], gr.Tabs]:
-    """Render one (hidden-tab) panel per mode. Returns the component handles + the Tabs component."""
-    handles: dict[str, dict] = {}
-    with gr.Tabs(elem_classes=["aio-tabs"]) as tabs:
-        for name, mode in modes.MODE_REGISTRY.items():
-            with gr.Tab(label=f"{mode.icon}  {mode.label}", id=name):
-                handles[name] = _render_one_mode(name)
-    return handles, tabs
-
-
-def _render_one_mode(name: str) -> dict:
-    """Render a per-mode form. Returns component handles for the generate handler."""
-    handles: dict = {"mode": name}
-
-    with gr.Row():
-        with gr.Column(scale=2, min_width=280):
-            handles["prompt"] = gr.Textbox(
-                label="Prompt", lines=4, placeholder="The creature moves. We clearly hear the motion of the creature. Then the creature says in Italian: \"Ciao\". Realistic behavior and character motion. Dynamic characters. Audio: birdsong."
-            )
-
-            # Mode-specific media inputs
-            if name == "i2v":
-                handles["image"] = gr.Image(label="Source image (crop before to go faster)", type="filepath")
-            elif name == "a2v":
-                handles["audio"] = gr.Audio(label="Source audio", type="filepath")
-            elif name == "lipsync":
-                handles["image"] = gr.Image(label="Portrait (if the AI doesn't follow the lips, crop the face even more)", type="filepath")
-                handles["audio"] = gr.Audio(label="Speech audio", type="filepath")
-            elif name == "keyframe":
-                handles["first_frame"] = gr.Image(label="First frame (crop before to go faster)", type="filepath")
-                handles["last_frame"] = gr.Image(label="Last frame (crop before to go faster)", type="filepath")
-            elif name == "style":
-                handles["image"] = gr.Image(label="Style reference (crop before to go faster)", type="filepath")
-                handles["input_video"] = gr.Video(label="Source video")
-
-            handles["preset"] = ui.preset_bar()
-
-            # Resolution — up to 4K, /32 step
-            with gr.Row():
-                handles["width"] = gr.Slider(
-                    256, 4096, value=512, step=32, label="Width"
-                )
-                handles["height"] = gr.Slider(
-                    256, 4096, value=768, step=32, label="Height"
-                )
-
-            # Length controlled in seconds (matches the master workflow's mxSlider).
-            # Frames are derived: frames = round(seconds * fps / 8) * 8 + 1.
-            with gr.Row():
-                handles["seconds"] = gr.Slider(
-                    minimum=1, maximum=30, value=3, step=1,
-                    label="Length (seconds)",
-                    info="Frames are computed as 8·round(seconds·fps/8)+1 (LTX requires 8k+1)",
-                )
-                handles["fps"] = gr.Slider(8, 30, value=24, step=1, label="FPS")
-
-            handles["frames_display"] = gr.Markdown("Frames: 73", elem_classes=["aio-frames-display"])
-
-            with gr.Row():
-                handles["negative_prompt"] = gr.Textbox(label="Negative prompt", info="music, speech, jumpcut, crossfader...", lines=2, value="unrealistic position, shapeshifting, morphing, ugly, low quality, average quality, translation, subtitle, text, logo, error, bug, artefact, white noise, recording sound")
-                handles["lora"] = ui.lora_chrome(name)
-
-            with gr.Accordion("Advanced ▾", open=False):
-                handles["seed"] = gr.Number(label="Seed", value=42, precision=0, minimum=0)
-                handles["randomize_seed"] = gr.Checkbox(label="Randomize seed each run", value=True)
-
-            handles["generate_btn"] = gr.Button("🚀 Generate", variant="primary", size="lg")
-
-            # Live frames-display update when seconds/fps change
-            def _update_frames(seconds, fps):
-                f = max(9, int(round(float(seconds) * float(fps) / 8) * 8) + 1)
-                return f"**Frames:** {f}  (`{seconds}s` × `{fps} fps`)"
-
-            handles["seconds"].change(
-                fn=_update_frames,
-                inputs=[handles["seconds"], handles["fps"]],
-                outputs=[handles["frames_display"]],
-            )
-            handles["fps"].change(
-                fn=_update_frames,
-                inputs=[handles["seconds"], handles["fps"]],
-                outputs=[handles["frames_display"]],
-            )
-
-        with gr.Column(scale=2, min_width=280):
-            handles["status"] = ui.status_banner()
-            handles["video_out"] = gr.Video(label="Output", autoplay=True)
-            handles["history"] = gr.Markdown("")
-
-    
-    with gr.Row(elem_id="default_examples"):
-        dummy_debug = gr.Text(visible = False)
-        mode_image_debug = gr.Radio(
-                    label="Mode Debug",
-                    choices=["t2v", "i2v", "a2v", "lipsync", "keyframe", "style"],
-                    value="keyframe",
-                )
-        input_image_debug = gr.Image(type="filepath", label="Image Debug")
-        end_image_debug = gr.Image(type="filepath", label="End image Debug")
-        audio_debug = gr.Audio(label="Source audio Debug", type="filepath")
-        allocation_time_debug = gr.Slider(1, 60 * 60, value=1000, step=1, label="Time Debug")
-        output_video_debug = gr.Video(label="Generated Video", autoplay = False, loop = True, interactive = False)
-        reset_button_debug = gr.Button(value="Reset", visible = True, interactive = True)
-        download_button_debug = gr.DownloadButton(elem_id="download_btn", visible = True, interactive = True)
-        video_information = gr.HTML(value = "")
-        gr.Examples(
-        label=" ",
-            examples=[[""]],
-            inputs=[dummy_debug],
-            outputs=[output_video_debug, download_button_debug, video_information],
-            fn=run_example,
-            run_on_click=True,
-            cache_examples=True,
-            cache_mode='lazy',
-        )
-    
-        video_information.change(
-        fn=lambda output: output,
-        inputs=[output_video_debug],
-        js="(v) => { try {is_to_download = !is_to_download;} catch (e) {is_to_download = true;} if (is_to_download) {document.getElementById('download_btn').click();}}"
-    )
-    
-    def handle_field_debug_change(
-        mode_image_debug_data,
-        input_image_debug_data,
-        end_image_debug_data,
-        audio_debug_data,
-        prompt_debug_data,
-        negative_prompt_debug_data,
-        total_second_length_debug_data,
-        width_debug_data,
-        height_debug_data,
-        allocation_time_debug_data
-    ):
-        mode_debug_value[0] = mode_image_debug_data
-        input_image_debug_value[0] = input_image_debug_data
-        end_image_debug_value[0] = end_image_debug_data
-        audio_debug_value[0] = audio_debug_data
-        prompt_debug_value[0] = prompt_debug_data
-        negative_prompt_debug_value[0] = negative_prompt_debug_data
-        total_second_length_debug_value[0] = total_second_length_debug_data
-        width_debug_value[0] = width_debug_data
-        height_debug_value[0] = height_debug_data
-        allocation_time_debug_value[0] = allocation_time_debug_data
-        print("All done!")
-        print(str(mode_debug_value[0]))
-        print(str(input_image_debug_value[0]))
-        print(str(end_image_debug_value[0]))
-        print(str(audio_debug_value[0]))
-        print(str(prompt_debug_value[0]))
-        print(str(negative_prompt_debug_value[0]))
-        print(str(total_second_length_debug_value[0]))
-        print(str(width_debug_value[0]))
-        print(str(height_debug_value[0]))
-        print(str(allocation_time_debug_value[0]))
+        from comfy import model_management
+        import sageattention
+        
+        print("--- [Runtime Patch] sageattention package found. Applying patch... ---")
+        model_management.sage_attention_enabled = lambda: True
+        model_management.pytorch_attention_enabled = lambda: False
+        
+        SAGE_PATCH_APPLIED = True
+        return "✅ Successfully enabled SageAttention."
+    except ImportError:
+        SAGE_PATCH_APPLIED = False
+        msg = "--- [Runtime Patch] ⚠️ sageattention package not found. Continuing with default attention. ---"
+        print(msg)
+        return msg
+    except Exception as e:
+        SAGE_PATCH_APPLIED = False
+        msg = f"--- [Runtime Patch] ❌ An error occurred while applying SageAttention patch: {e} ---"
+        print(msg)
+        return msg
+
+@spaces.GPU
+def dummy_gpu_for_startup():
+    print("--- [GPU Startup] Dummy function for startup check initiated. ---")
+    patch_result = apply_sage_attention_patch()
+    print(f"--- [GPU Startup] {patch_result} ---")
+    print("--- [GPU Startup] Startup check passed. ---")
+    return "Startup check passed."
+
+
+def main():
+    from comfy_integration import setup as setup_comfyui
     
-    inputs_debug=[mode_image_debug, input_image_debug, end_image_debug, audio_debug, handles["prompt"], handles["negative_prompt"], handles["seconds"], handles["width"], handles["height"], allocation_time_debug]
-    mode_image_debug.change(fn=handle_field_debug_change, inputs=inputs_debug)
-    input_image_debug.upload(fn=handle_field_debug_change, inputs=inputs_debug)
-    end_image_debug.upload(fn=handle_field_debug_change, inputs=inputs_debug)
-    audio_debug.upload(fn=handle_field_debug_change, inputs=inputs_debug)
-    handles["prompt"].change(fn=handle_field_debug_change, inputs=inputs_debug)
-    handles["negative_prompt"].change(fn=handle_field_debug_change, inputs=inputs_debug)
-    handles["width"].change(fn=handle_field_debug_change, inputs=inputs_debug)
-    handles["height"].change(fn=handle_field_debug_change, inputs=inputs_debug)
-    handles["seconds"].change(fn=handle_field_debug_change, inputs=inputs_debug)
-    allocation_time_debug.change(fn=handle_field_debug_change, inputs=inputs_debug)
-
-    def handle_field_debug_reset():
-        return ["keyframe", None, None, None, "", "cut, jumpcut, crossfader, unrealistic position, shapeshifting, morphing, ugly, low quality, average quality, translation, subtitle, text, logo, error, bug, artefact, white noise, recording sound", 22, 2048, 1536, 1000]
-
-    reset_button_debug.click(fn=handle_field_debug_reset, inputs=[], outputs=inputs_debug).then(fn=handle_field_debug_change, inputs=inputs_debug)
-
-    return handles
+    print("--- [Setup] Starting ComfyUI initialization ---")
+    setup_comfyui.initialize_comfyui()
     
-# ---------------------------------------------------------------------------
-# Backend wiring
-# ---------------------------------------------------------------------------
-
-_BACKEND: backend_module.ComfyUILibraryBackend | None = None
-
+    print("--- [Setup] Applying SageAttention Runtime Patch ---")
+    patch_result = apply_sage_attention_patch()
+    print(f"--- [Setup] {patch_result} ---")
 
-def _get_backend() -> backend_module.ComfyUILibraryBackend:
-    global _BACKEND
-    if _BACKEND is None:
-        _BACKEND = backend_module.ComfyUILibraryBackend()
-    return _BACKEND
-
-
-# Must match the comfy_dir used in _bootstrap() — on Spaces this is
-# ~/comfyui (mirroring backend.py's _comfy_dir), otherwise repo-local.
-_COMFY_INPUT_DIR = (
-    (pathlib.Path.home() / "comfyui" / "input")
-    if _on_spaces()
-    else pathlib.Path(__file__).parent / "comfyui" / "input"
-)
-
-
-def _stage_to_comfy_input(file_path) -> str | None:
-    """Copy/stage a path into comfyui/input/ so ComfyUI's LoadImage etc. can find it."""
-    if not file_path:
-        return None
-    if not isinstance(file_path, (str, pathlib.Path)):
-        file_path = (
-            file_path.get("name") or file_path.get("path") or file_path.get("orig_name")
-            if isinstance(file_path, dict)
-            else None
-        )
-        if not file_path:
-            return None
-    src = pathlib.Path(file_path)
-    if not src.exists() or not src.is_file():
-        print(f"[_stage] skip {file_path!r}", flush=True)
-        return None
-    _COMFY_INPUT_DIR.mkdir(parents=True, exist_ok=True)
+    print("--- [Setup] Reloading site-packages to detect newly installed packages... ---")
     try:
-        if src.resolve().is_relative_to(_COMFY_INPUT_DIR.resolve()):
-            return src.name
-    except (ValueError, OSError):
-        pass
-    dst = _COMFY_INPUT_DIR / src.name
-    if not dst.exists() or dst.stat().st_size != src.stat().st_size:
-        import shutil
-
-        shutil.copy2(src, dst)
-    return src.name
-
-
-PRESET_DURATION = {"Fast": 60, "Balanced": 120, "Quality": 300}
-
-
-_FRIENDLY_ERRORS: dict[str, tuple[str, str]] = {
-    "gpu_timeout": (
-        "Hit the GPU time limit",
-        "This run took longer than the GPU budget. Try the Fast preset, a "
-        "shorter video, or a smaller resolution — then click Generate again.",
-    ),
-    "expired_token": (
-        "Session timed out",
-        "Your sign-in session expired. Refresh the page and try again — "
-        "you'll keep your spot in the GPU queue.",
-    ),
-    "illegal_duration": (
-        "GPU budget too high",
-        "The estimator asked for more GPU time than the server allows. "
-        "Try Fast preset or a shorter video.",
-    ),
-    "unlogged": (
-        "Sign-in not detected",
-        "Make sure you're signed into huggingface.co (top-right avatar), "
-        "then refresh this page. Pro accounts get 25 min of GPU per day.",
-    ),
-    "quota_exceeded": (
-        "Daily GPU quota used up",
-        "You've used today's GPU minutes. Wait for the rolling 24-hour "
-        "reset, or upgrade Pro at huggingface.co/subscribe/pro for more.",
-    ),
-    "oom": (
-        "Ran out of GPU memory",
-        "Try a smaller resolution, fewer frames, or the Fast preset.",
-    ),
-    "interrupt": (
-        "Cancelled",
-        "Generation was cancelled. Click Generate to start a fresh run.",
-    ),
-    "download": (
-        "Model download failed",
-        "Couldn't fetch a required model file. Check your internet and try again.",
-    ),
-}
-
-
-def _friendly_error(category: str, raw_message: str) -> tuple[str, str]:
-    """Translate a backend error category into (title, body) the user can act on."""
-    if category in _FRIENDLY_ERRORS:
-        return _FRIENDLY_ERRORS[category]
-    return (
-        "Generation failed",
-        "Something went wrong. Click Generate to retry, or check the Space "
-        "logs if it keeps happening.",
-    )
-
-
-def _seconds_to_frames(seconds: float, fps: int) -> int:
-    return max(9, int(round(float(seconds) * float(fps) / 8) * 8) + 1)
-
-
-async def _on_generate(mode_name: str, *, progress: Any = None, **inputs: Any):
-    """Generate handler — async generator yielding (status_html, video_path).
-
-    `progress` is a `gr.Progress` instance injected by Gradio. It's the only
-    progress channel that survives the @spaces.GPU subprocess boundary on HF
-    Spaces; we forward it to the backend so ComfyUI's per-step counter renders
-    a real progress bar instead of a generic Gradio spinner.
-    """
-    if mode_name == "i2v":
-        if inputs["image"] is None:
-            raise gr.Error("Please upload an image.")
-        if not os.path.exists(inputs["image"]):
-            raise gr.Error("The file has been lost. Please upload an image again.")
-    elif mode_name == "a2v":
-        if inputs["audio"] is None:
-            raise gr.Error("Please upload an audio.")
-        if not os.path.exists(inputs["audio"]):
-            raise gr.Error("The file has been lost. Please upload an audio again.")
-    elif mode_name == "lipsync":
-        if inputs["image"] is None:
-            raise gr.Error("Please upload an image.")
-        if not os.path.exists(inputs["image"]):
-            raise gr.Error("The file has been lost. Please upload an image again.")
-        if inputs["audio"] is None:
-            raise gr.Error("Please upload an audio.")
-        if not os.path.exists(inputs["audio"]):
-            raise gr.Error("The file has been lost. Please upload an audio again.")
-    elif mode_name == "keyframe":
-        if inputs["first_frame"] is None:
-            raise gr.Error("Please upload an image for the begining.")
-        if not os.path.exists(inputs["first_frame"]):
-            raise gr.Error("The file has been lost. Please upload an image for the begining again.")
-        if inputs["last_frame"] is None:
-            raise gr.Error("Please upload an image for the end.")
-        if not os.path.exists(inputs["last_frame"]):
-            raise gr.Error("The file has been lost. Please upload an image for the end again.")
-    elif mode_name == "style":
-        if inputs["image"] is None:
-            raise gr.Error("Please upload an image.")
-        if not os.path.exists(inputs["image"]):
-            raise gr.Error("The file has been lost. Please upload an image again.")
-        if inputs["input_video"] is None:
-            raise gr.Error("Please upload a video.")
-        if not os.path.exists(inputs["input_video"]):
-            raise gr.Error("The file has been lost. Please upload a video again.")
-
-    mode = modes.MODE_REGISTRY[mode_name]
-
-    fps = int(inputs.get("fps", 24))
-    seconds = float(inputs.get("seconds", 3))
-    frames = _seconds_to_frames(seconds, fps)
-    gpu_duration = int(inputs.get("gpu_duration", -1))
-
-    # Seed: respect the explicit value unless the "randomize" checkbox is on.
-    seed = int(inputs.get("seed", 42))
-    if inputs.get("randomize_seed"):
-        seed = random.randint(0, 2**31 - 1)
-
-    print("prompt:" + str(inputs.get("prompt", "")))
-    print("negative_prompt:" + str(inputs.get("negative_prompt", "")))
-    print("preset:" + str(inputs.get("preset", "Balanced")).lower())
-    print("width:" + str(int(inputs.get("width", 512))))
-    print("height:" + str(int(inputs.get("height", 768))))
-    print("frames:" + str(frames))
-    print("fps:" + str(fps))
-    print("seed:" + str(seed))
-
-    params: dict[str, Any] = {
-        "prompt": inputs.get("prompt", ""),
-        "negative_prompt": inputs.get("negative_prompt", ""),
-        "preset": str(inputs.get("preset", "Balanced")).lower(),
-        "width": int(inputs.get("width", 512)),
-        "height": int(inputs.get("height", 768)),
-        "frames": frames,
-        "fps": fps,
-        "seed": seed,
-    }
-
-    for k in (
-        "image", "audio", "first_frame", "last_frame", "input_video",
-        "camera_lora", "camera_strength", "detailer_on", "detailer_strength",
-        "ic_lora", "ic_strength", "pose_on", "audio_cfg", "image_strength",
-    ):
-        if k in inputs:
-            params[k] = inputs[k]
-
-    for key in ("image", "audio", "first_frame", "last_frame", "input_video"):
-        if key in params and params[key]:
-            staged = _stage_to_comfy_input(params[key])
-            if staged is None:
-                params.pop(key, None)
-            else:
-                params[key] = staged
-
-    patches = mode.parameterize_fn(params)
-    workflow = wf_module.load_template(mode_name)
-    for patch in patches:
-        wf_module.set_input(workflow, *patch)
-
-    backend = _get_backend()
-    preset = params["preset"]  # already lowercased above
-
-    async def _translate(event, started_at):
-        """Translate one backend event into Gradio (status_html, video) yields.
-
-        Returns the tuple to yield, plus a flag indicating terminal state.
-        """
-        elapsed = time.time() - started_at
-        if isinstance(event, backend_module.DownloadEvent):
-            return (
-                ui.render_status(
-                    stage_index=0,
-                    stage_label=f"Downloading {event.filename}",
-                    step=int(event.mb_done),
-                    total_steps=int(max(event.mb_total, 1)),
-                    elapsed_s=elapsed,
-                    eta_s=0,
-                ),
-                gr.update(),
-            )
-        if isinstance(event, backend_module.ProgressEvent):
-            label = f"Diffusion (Stage {event.stage})"
-            eta = (elapsed / max(event.step, 1)) * (event.total_steps - event.step)
-            return (
-                ui.render_status(
-                    stage_index=event.stage,
-                    stage_label=label,
-                    step=event.step,
-                    total_steps=event.total_steps,
-                    elapsed_s=elapsed,
-                    eta_s=eta,
-                ),
-                gr.update(),
-            )
-        if isinstance(event, backend_module.OutputEvent):
-            video_update = event.video_path if event.video_path else gr.update()
-            return (ui._render_idle(), video_update)
-        if isinstance(event, backend_module.ErrorEvent):
-            title, body = _friendly_error(event.category, event.message)
-            return (
-                f'<div class="status-card status-error">'
-                f'  <div class="status-row"><span class="status-stage">{title}</span></div>'
-                f"  <div>{body}</div>"
-                f"</div>",
-                gr.update(),
-            )
-        return None
-
-    # Single attempt. ZeroGPU-side abort (duration cap) and 401 expired-token
-    # surface as friendly messages via _friendly_error; user clicks Generate
-    # again to retry with a fresh request and fresh X-IP-Token.
-    started = time.time()
-    async for event in backend.submit(
-        mode_name,
-        workflow,
-        preset=preset,
-        duration_multiplier=1.0,
-        gpu_duration=gpu_duration,
-        progress=progress,
-    ):
-        translated = await _translate(event, started)
-        if translated is not None:
-            yield translated
-
-
-def _input_keys_for_mode(mode_name: str, h: dict) -> list[str]:
-    base = ["prompt", "preset", "width", "height", "seconds", "fps", "seed", "randomize_seed"]
-    if mode_name == "i2v":
-        base.append("image")
-    elif mode_name == "a2v":
-        base.append("audio")
-    elif mode_name == "lipsync":
-        base.extend(["image", "audio"])
-    elif mode_name == "keyframe":
-        base.extend(["first_frame", "last_frame"])
-    elif mode_name == "style":
-        base.extend(["image", "input_video"])
-    base.append("negative_prompt")
-    base.extend(["camera_lora", "camera_strength", "detailer_on", "detailer_strength"])
-    if h["lora"].ic_lora is not None:
-        base.extend(["ic_lora", "ic_strength"])
-    if h["lora"].pose_on is not None:
-        base.append("pose_on")
-    return base
-
-
-def _collect_inputs_for_mode(mode_name: str, h: dict) -> list:
-    base = [
-        h["prompt"], h["preset"], h["width"], h["height"],
-        h["seconds"], h["fps"], h["seed"], h["randomize_seed"],
-    ]
-    if mode_name == "i2v":
-        base.append(h["image"])
-    elif mode_name == "a2v":
-        base.append(h["audio"])
-    elif mode_name == "lipsync":
-        base.extend([h["image"], h["audio"]])
-    elif mode_name == "keyframe":
-        base.extend([h["first_frame"], h["last_frame"]])
-    elif mode_name == "style":
-        base.extend([h["image"], h["input_video"]])
-    base.append(h["negative_prompt"])
-    base.extend([
-        h["lora"].camera_lora, h["lora"].camera_strength,
-        h["lora"].detailer_on, h["lora"].detailer_strength,
-    ])
-    if h["lora"].ic_lora is not None:
-        base.extend([h["lora"].ic_lora, h["lora"].ic_strength])
-    if h["lora"].pose_on is not None:
-        base.append(h["lora"].pose_on)
-    return base
-
-
-def _make_handler(mode_name: str, h: dict):
-    keys = _input_keys_for_mode(mode_name, h)
-
-    async def handler(*values, progress=gr.Progress()):
-        kwargs = dict(zip(keys, values, strict=False))
-        async for output in _on_generate(mode_name, progress=progress, **kwargs):
-        #async for output in []:
-            yield output
-
-    return handler
+        site.main()
+        print("--- [Setup] ✅ Site-packages reloaded. ---")
+    except Exception as e:
+        print(f"--- [Setup] ⚠️  Warning: Could not fully reload site-packages: {e} ---")
 
-def set_mp4_comments_imageio_ffmpeg(input_file, comments):
+    print("--- Initiating GPU Startup Check & SageAttention Patch Verification ---")
     try:
-        # Get the path to the bundled FFmpeg binary from imageio-ffmpeg
-        ffmpeg_path = imageio_ffmpeg.get_ffmpeg_exe()
-
-        # Check if input file exists
-        if not os.path.exists(input_file):
-            #print(f"Error: Input file {input_file} does not exist")
-            return False
+        dummy_gpu_for_startup()
+    except BaseException as e:
+        err_msg = f"{type(e).__name__}: {str(e)}"
+        print(f"--- [GPU Startup] ⚠️ Warning: Startup check failed: {err_msg} ---")
 
-        # Create a temporary file path
-        temp_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False).name
+    print("--- Starting Application Setup ---")
 
-        # FFmpeg command using the bundled binary
-        command = [
-            ffmpeg_path,                   # Use imageio-ffmpeg's FFmpeg
-            '-i', input_file,              # input file
-            '-metadata', f'comment={comments}',  # set comment metadata
-            '-c:v', 'copy',                # copy video stream without re-encoding
-            '-c:a', 'copy',                # copy audio stream without re-encoding
-            '-y',                          # overwrite output file if it exists
-            temp_file                      # temporary output file
-        ]
 
-        # Run the FFmpeg command
-        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    print("--- Environment configured. Proceeding with module imports. ---")
+    from ui.layout import build_ui
+    from ui.events import attach_event_handlers
+    import mcp_tools as mcp
+    print(f"✅ Loaded MCP module with tools: {[fn.__name__ for fn in mcp.MCP_FUNCTIONS]}")
 
-        if result.returncode == 0:
-            # Replace the original file with the modified one
-            shutil.move(temp_file, input_file)
-            #print(f"Successfully added comments to {input_file}")
-            return True
-        else:
-            # Clean up temp file if FFmpeg fails
-            if os.path.exists(temp_file):
-                os.remove(temp_file)
-            #print(f"Error: FFmpeg failed with message:\n{result.stderr}")
-            return False
+    print(f"✅ Working directory is stable: {os.getcwd()}")
 
-    except Exception as e:
-        # Clean up temp file in case of other errors
-        if 'temp_file' in locals() and os.path.exists(temp_file):
-            os.remove(temp_file)
-        print(f"Error saving prompt to video metadata, ffmpeg may be required: "+str(e))
-        return False
+    demo = build_ui(attach_event_handlers)
 
-async def run_example(dummy_image):
-    start = time.time()
-    example_inputs = {
-        "prompt": prompt_debug_value[0],
-        "negative_prompt": negative_prompt_debug_value[0],
-        "preset": str("Quality").lower(),
-        "width": int(width_debug_value[0]),
-        "height": int(height_debug_value[0]),
-        "frames": [],
-        "randomize_seed": True,
-        "seed": 42,
-        "fps": 24,
-        "seconds": total_second_length_debug_value[0],
-        "image": input_image_debug_value[0],
-        "audio": audio_debug_value[0],
-        "first_frame": input_image_debug_value[0] if input_image_debug_value[0] is not None else end_image_debug_value[0],
-        "last_frame": end_image_debug_value[0] if end_image_debug_value[0] is not None else input_image_debug_value[0],
-        "input_video": None,
-        "camera_lora": None,
-        "camera_strength": None,
-        "detailer_on": None,
-        "detailer_strength": None,
-        "ic_lora": None,
-        "ic_strength": None,
-        "pose_on": None,
-        "audio_cfg": None,
-        "image_strength": None,
-        "gpu_duration": allocation_time_debug_value[0]
-    }
-    mode_name=mode_debug_value[0]
-    allocation_time = allocation_time_debug_value[0]
-    target_width = int(width_debug_value[0])
-    target_height = int(height_debug_value[0])
-    mode_debug_value[0] = input_image_debug_value[0] = end_image_debug_value[0] = audio_debug_value[0] = prompt_debug_value[0] = negative_prompt_debug_value[0] = total_second_length_debug_value[0] = width_debug_value[0] = height_debug_value[0] = allocation_time_debug_value[0] = None
-    final_output = None
-    count = 10
-    while count > 0:
-        try:
-            async for output in _on_generate(mode_name=mode_name, progress=gr.Progress(), **example_inputs):
-                final_output = output
-            count = 0
-        except BaseException as err:
-            print("An exception occurred: " + str(err))
-            try:
-                print('e.message: ' + err.message) # No GPU is currently available for you after 60s
-            except Exception as e2:
-                print('Failure')
-            if not str(err.message if err is not None and hasattr(err, 'message') else '').startswith("No GPU is currently available for you after 60s"):
-                count = 0
-            else:
-                count = int(count) - 1
-        except:
-            print("An error occurred")
-            if not str(e).startswith("No GPU is currently available for you after 60s"):
-                count = 0
-            else:
-                count = int(count) - 1
+    print("--- Launching Gradio Interface ---")
+    demo.queue().launch(mcp_server=True)
 
-    print("Video exported: " + str(final_output))
-    set_mp4_comments_imageio_ffmpeg(final_output[1], f"Prompt: {example_inputs['prompt']} | Negative Prompt: {example_inputs['negative_prompt']}")
-    end = time.time()
-    secondes = int(end - start)
-    minutes = math.floor(secondes / 60)
-    secondes = secondes - (minutes * 60)
-    hours = math.floor(minutes / 60)
-    minutes = minutes - (hours * 60)
-    information = ("Start the process again if you want a different result. " if True else "") + \
-    "The video has been generated in " + \
-    ((str(hours) + " h, ") if hours != 0 else "") + \
-    ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
-    str(secondes) + " sec (including " + str(allocation_time) + " seconds of GPU). " + \
-    "The video resolution is " + str(target_width) + \
-    " pixels large and " + str(target_height) + \
-    " pixels high, so a resolution of " + f'{target_width * target_height:,}' + " pixels." + \
-    " Your prompt is saved into the metadata of the video."
-    return final_output[1], final_output[1], information
 
 if __name__ == "__main__":
-    # Gradio 5's file-access policy refuses to serve files outside cwd /
-    # tempdir / allowed_paths. ComfyUI writes generated videos to
-    # `<comfy_dir>/output/...` which is outside our cwd on Spaces, so
-    # whitelist that directory tree explicitly.
-    _on_spaces_at_launch = bool(os.environ.get("SPACES_ZERO_GPU"))
-    _comfy_dir_at_launch = (
-        (pathlib.Path.home() / "comfyui") if _on_spaces_at_launch
-        else pathlib.Path(__file__).parent / "comfyui"
-    )
-    _output_dir = _comfy_dir_at_launch / "output"
-    _output_dir.mkdir(parents=True, exist_ok=True)
-
-    app = build_app()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        allowed_paths=[str(_output_dir)],
-    )
+    main()

backend.py

@@ -1,603 +0,0 @@
-"""ComfyUI library-mode backend.
-
-Single-process, single-implementation. The @spaces.GPU decorator is the only
-divergence between local and HF Spaces deployment.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import contextvars
-import os
-import pathlib
-import sys
-import threading
-import traceback as tb_mod
-from collections.abc import AsyncIterator, Iterable
-from dataclasses import dataclass, field
-from typing import Any
-
-import models
-
-
-@dataclass
-class DownloadEvent:
-    filename: str
-    mb_done: float
-    mb_total: float
-
-
-@dataclass
-class ProgressEvent:
-    stage: int
-    stage_label: str
-    step: int
-    total_steps: int
-
-
-@dataclass
-class OutputEvent:
-    video_path: str
-    audio_path: str | None = None
-    meta: dict = field(default_factory=dict)
-
-
-@dataclass
-class ErrorEvent:
-    category: str  # "oom" | "zerogpu_timeout" | "execution" | "interrupt" | "download"
-    message: str
-    stage: int | None = None
-    traceback: str = ""
-
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-try:
-    import spaces  # type: ignore
-except ImportError:
-    spaces = None  # type: ignore[assignment]
-
-
-def _identity(fn):
-    return fn
-
-
-# --- Per-call ZeroGPU duration estimator -----------------------------------
-# `duration` is a per-call timeout. Shorter declared duration → faster queue
-# priority on the shared ZeroGPU pool. Estimating from (mode, preset, frames)
-# instead of using a one-size-fits-all 600s cap means light T2V calls jump
-# the queue while heavy modes (lipsync, style) reserve real headroom.
-
-_BASE_DURATION_S: dict[str, int] = {
-    # Rough sampler+decode time at ~120 frames, balanced preset, warm cache.
-    "t2v": 90,
-    "i2v": 90,
-    "a2v": 120,
-    "lipsync": 240,   # extra: audio encoder + audio VAE + extra LoRAs
-    "keyframe": 180,
-    "style": 360,     # extra: preprocessor (canny/dwpose/depth) + IC-LoRAs
-}
-_PRESET_MULT: dict[str, float] = {"fast": 1.0, "balanced": 1.5, "quality": 3.0}
-
-
-def _frames_from_workflow(workflow: dict) -> int:
-    """Read the frame count from the workflow's EmptyLTXVLatentVideo node."""
-    for node in workflow.values():
-        if isinstance(node, dict) and node.get("class_type") == "EmptyLTXVLatentVideo":
-            try:
-                return int((node.get("inputs") or {}).get("length", 121))
-            except (TypeError, ValueError):
-                return 121
-    return 121
-
-
-def _duration_for(
-    executor: Any,
-    workflow: dict,
-    output_ids: list[str],
-    mode: str,
-    preset: str,
-    multiplier: float = 1.0,
-    gpu_duration: int = -1,
-    progress: Any = None,
-) -> int:
-    """ZeroGPU duration estimator. Same signature as _execute_workflow.
-
-    `progress` is a gr.Progress instance forwarded by the caller; we ignore it
-    here (estimator doesn't emit progress) but must accept it positionally so
-    ZeroGPU can call us with the same arg list it'll use for _execute_workflow.
-
-    Estimate = (base × preset multiplier + cold-cache buffer + per-frame VAE
-    decode time) × retry multiplier, clamped to [60s, 240s]. ZeroGPU rejects
-    durations above the server's per-call max with "ZeroGPU illegal duration"
-    (client.py:137); 240s is observed to work for Pro identity (~2 min runs
-    needed for style + lipsync detailer paths). If the server rejects values
-    in this range, the user will see a clear error and can retry.
-    """
-    if gpu_duration != -1:
-        return gpu_duration
-        
-    base = _BASE_DURATION_S.get(mode, 180)
-    mult = _PRESET_MULT.get(preset.lower(), 1.5)
-    frames = _frames_from_workflow(workflow)
-    est = int((base * mult + 60 + frames * 0.3) * multiplier)
-    return max(60, min(est, 240))
-
-
-# Decorate at module load time so ZeroGPU's startup analyzer detects it.
-_GPU = (
-    spaces.GPU(duration=_duration_for)
-    if (spaces is not None and _on_spaces())
-    else _identity
-)
-
-
-@_GPU
-def _execute_workflow(
-    executor: Any,
-    workflow: dict,
-    output_ids: list[str],
-    mode: str,
-    preset: str,
-    multiplier: float = 1.0,
-    gpu_duration: int = -1,
-    progress: Any = None,
-) -> str:
-    """Run the workflow on GPU and return the path of the first video output.
-
-    Returns just the video path (a plain string, picklable across the
-    @spaces.GPU subprocess boundary). The `mode`, `preset`, and `multiplier`
-    args are consumed by `_duration_for` to estimate the GPU slot to reserve.
-
-    `progress` is an optional `gr.Progress` instance. It's the only progress
-    channel that crosses the @spaces.GPU subprocess boundary on HF Spaces —
-    Gradio + the `spaces` library wrap it with cross-process IPC. When set,
-    we mirror ComfyUI's step counter into it via the global progress hook,
-    chaining to whatever hook was already installed (so the local event-based
-    status banner keeps working alongside).
-    """
-    if progress is not None:
-        import comfy.utils as _cu
-        _saved_hook = getattr(_cu, "PROGRESS_BAR_HOOK", None)
-
-        def _gp_hook(value, total, _preview=None, **_kw):
-            try:
-                v, t = int(value), int(total)
-                progress(v / max(t, 1), desc=f"Sampling step {v}/{t}")
-            except Exception:
-                pass
-            if _saved_hook is not None:
-                try:
-                    _saved_hook(value, total, _preview)
-                except Exception:
-                    pass
-
-        _cu.set_progress_bar_global_hook(_gp_hook)
-
-    executor.execute(
-        workflow,
-        prompt_id="ltx23-aio",
-        extra_data={"client_id": "ltx23-aio"},
-        execute_outputs=output_ids,
-    )
-    hist = getattr(executor, "history_result", {}) or {}
-    outs = hist.get("outputs") or {}
-    for output in outs.values():
-        if not isinstance(output, dict):
-            continue
-        for value in output.values():
-            if not isinstance(value, list):
-                continue
-            for item in value:
-                if isinstance(item, dict):
-                    fn = item.get("filename") or ""
-                    if fn.endswith((".mp4", ".webm", ".mov")):
-                        return item.get("fullpath") or fn
-    return ""
-
-
-class _StubServer:
-    """Minimal stub matching the surface ComfyUI's PromptExecutor expects."""
-
-    client_id: str | None = "ltx23-aio"
-    last_node_id: str | None = None
-
-    def send_sync(self, event: str, data: dict, sid: str | None = None) -> None:
-        pass
-
-    def queue_updated(self) -> None:
-        pass
-
-
-class _StubPromptQueue:
-    """Stub matching the surface VideoHelperSuite + others touch."""
-
-    currently_running: dict = {}
-    history: dict = {}
-    flags: dict = {}
-
-    def get_current_queue(self) -> tuple[list, list]:
-        return ([], [])
-
-    def get_tasks_remaining(self) -> int:
-        return 0
-
-    def set_flag(self, name: str, data) -> None:
-        pass
-
-    def get_flags(self, *a, **kw) -> dict:
-        return {}
-
-    def task_done(self, *a, **kw) -> None:
-        pass
-
-    def put(self, *a, **kw) -> None:
-        pass
-
-    def wipe_queue(self) -> None:
-        pass
-
-    def delete_queue_item(self, *a, **kw) -> None:
-        pass
-
-
-class _StubPromptServerInstance:
-    """Surface that ComfyUI's `server.PromptServer.instance` exposes to custom nodes.
-
-    VideoHelperSuite, KJNodes, and others read this at import time. They mostly
-    use it to register HTTP routes or send WS events or peek at the prompt queue.
-    No-ops here are fine — we have no real server.
-    """
-
-    client_id: str | None = "ltx23-aio"
-    # KJNodes' preview thread reads `last_node_id.encode('ascii')` directly.
-    # ComfyUI's real server keeps it as a string per executing node and resets
-    # to None at end-of-prompt — which races the preview thread. Keep it a
-    # safe non-empty string so .encode() never NPEs.
-    last_node_id: str = "ltx23-aio"
-    web_root: str = ""
-
-    class _Routes:
-        def get(self, *a, **kw):
-            return lambda fn: fn
-
-        def post(self, *a, **kw):
-            return lambda fn: fn
-
-        def static(self, *a, **kw):
-            return None
-
-    routes = _Routes()
-    sockets: dict = {}
-    prompt_queue = _StubPromptQueue()
-    # Custom-Scripts checks PromptServer.instance.supports — claim the
-    # "custom_nodes_from_web" capability so it skips its JS install path.
-    supports: list[str] = ["custom_nodes_from_web"]
-    web_root: str = ""
-
-    def add_routes(self) -> None:
-        pass
-
-    def send_sync(self, event: str, data: dict, sid: str | None = None) -> None:
-        pass
-
-    def send_progress_text(self, text: str, node_id=None, sid=None) -> None:
-        # Comfy_extras nodes call this; we just no-op since we don't have a UI
-        # to surface intermediate text on.
-        pass
-
-    def queue_updated(self) -> None:
-        pass
-
-    def get_node_class_def(self, *a, **kw):
-        return None
-
-    def __getattr__(self, name):
-        # Anything else our custom nodes might reach for — give them a no-op.
-        # This is a deliberate liberal catch-all so the inference path doesn't
-        # die on cosmetic UI hooks. Inspection-style access (hasattr) gets True.
-        def _noop(*a, **kw):
-            return None
-        return _noop
-
-
-def _comfy_dir() -> pathlib.Path:
-    if _on_spaces():
-        return pathlib.Path.home() / "comfyui"
-    return pathlib.Path(__file__).parent / "comfyui"
-
-
-class ComfyUILibraryBackend:
-    """Wraps PromptExecutor for in-process workflow execution."""
-
-    def __init__(self) -> None:
-        self._comfy_dir = _comfy_dir()
-        if not self._comfy_dir.exists():
-            raise RuntimeError(
-                f"ComfyUI not found at {self._comfy_dir}. "
-                f"Local: run `bash setup.sh`. Spaces: see app.py:_bootstrap()."
-            )
-        if str(self._comfy_dir) not in sys.path:
-            sys.path.insert(0, str(self._comfy_dir))
-
-        # Defer comfy imports until the path is set up.
-        # NOTE: ComfyUI ships PromptExecutor in the top-level `execution.py`
-        # module, NOT under `comfy.execution`. Same for `nodes`. Both must be
-        # imported AFTER the sys.path insert above.
-        import asyncio
-        import threading
-
-        import comfy.cli_args  # noqa: F401 — side-effect: registers CLI flags
-        import execution  # top-level module — provides PromptExecutor
-        import nodes  # top-level module — provides init_extra_nodes (async)
-
-        # CRITICAL ordering fix: ComfyUI's nodes.py:24 inserts `comfyui/comfy/`
-        # at sys.path[0]. That dir contains a module-style `utils.py`, which
-        # shadows `comfyui/utils/` (a package containing install_util.py).
-        # Some custom nodes (KJNodes, VideoHelperSuite via app.frontend_management)
-        # do `from utils.install_util import …` and get `comfy/utils.py` instead,
-        # raising "'utils' is not a package". Rewrite sys.path so comfy_dir is
-        # ahead of comfy_dir/comfy and force-clear any cached `utils` binding.
-        comfy_subdir = str(self._comfy_dir / "comfy")
-        sys.path = [p for p in sys.path if p not in (str(self._comfy_dir), comfy_subdir)]
-        sys.path.insert(0, comfy_subdir)
-        sys.path.insert(0, str(self._comfy_dir))
-        if "utils" in sys.modules and not getattr(sys.modules["utils"], "__path__", None):
-            del sys.modules["utils"]
-
-        # Some custom nodes (e.g. VideoHelperSuite) read `server.PromptServer.instance`
-        # at import time. We don't run a real ComfyUI server, so install a stub
-        # that exposes the attributes those nodes touch (sockets, send, etc.).
-        import server as comfy_server
-
-        if getattr(comfy_server.PromptServer, "instance", None) is None:
-            comfy_server.PromptServer.instance = _StubPromptServerInstance()
-
-        # `nodes.init_extra_nodes` is async. We may be called from within a
-        # running event loop (Gradio's handler) — running `asyncio.run()` there
-        # raises. Run the coroutine in a fresh loop on a worker thread instead.
-        def _init_in_thread() -> None:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            try:
-                loop.run_until_complete(nodes.init_extra_nodes())
-            finally:
-                loop.close()
-
-        thread = threading.Thread(target=_init_in_thread, daemon=False)
-        thread.start()
-        thread.join()
-        # PromptExecutor expects a `server` with client_id, send_sync, last_node_id,
-        # queue_updated. A minimal stub no-ops all of them — we don't run a real
-        # websocket server, we surface progress via comfy.utils.PROGRESS_BAR_HOOK.
-        # cache_args["ram"] is read unconditionally inside execute_async even when
-        # cache_type is the default false — provide a sensible default so it doesn't
-        # NoneType-subscript at line 727.
-        self._executor = execution.PromptExecutor(
-            server=_StubServer(),
-            cache_args={"ram": 16.0, "lru": 0},
-        )
-
-    def __repr__(self) -> str:
-        return f"ComfyUILibraryBackend(comfy_dir={self._comfy_dir!r})"
-
-    async def submit(
-        self,
-        mode: str,
-        workflow: dict,
-        *,
-        preset: str = "balanced",
-        duration_multiplier: float = 1.0,
-        gpu_duration: int = -1,
-        progress: Any = None,
-    ) -> AsyncIterator[Any]:
-        """Run a workflow end-to-end. Yields Download/Progress/Output/Error events.
-
-        `preset` and `duration_multiplier` flow through to the @spaces.GPU
-        duration estimator. The handler can re-call submit() with
-        duration_multiplier=2.0 if the first attempt aborts on timeout.
-        """
-        # Pre-flight: ensure all model files exist.
-        try:
-            needed = models.walk_workflow_for_models(workflow)
-            for download_event in models.ensure_models(needed):
-                yield download_event
-        except Exception as e:
-            yield ErrorEvent(
-                category="download",
-                message=str(e),
-                traceback=tb_mod.format_exc(),
-            )
-            return
-
-        # Run the inference in a worker thread; pass progress events through a queue.
-        queue: asyncio.Queue = asyncio.Queue()
-        loop = asyncio.get_running_loop()
-
-        def _push(event: Any) -> None:
-            asyncio.run_coroutine_threadsafe(queue.put(event), loop)
-
-        # Track stage progression. ComfyUI fires the progress hook from inside
-        # samplers, so we advance the stage every time we observe a new sampler
-        # starting (step==0 with a different total than before, or a "new run"
-        # signal — value smaller than the running max for the same total).
-        progress_state = {"stage": 0, "prev_total": -1, "max_step": -1}
-
-        def _hook(value: int, total: int, _preview=None, **_kwargs: Any) -> None:
-            v, t = int(value), int(total)
-            # New sampler started (different total, or step rewound)
-            if t != progress_state["prev_total"] or v < progress_state["max_step"]:
-                progress_state["stage"] += 1
-                progress_state["prev_total"] = t
-                progress_state["max_step"] = v
-            else:
-                progress_state["max_step"] = max(progress_state["max_step"], v)
-            _push(
-                ProgressEvent(
-                    stage=progress_state["stage"],
-                    stage_label="diffusion",
-                    step=v,
-                    total_steps=t,
-                )
-            )
-
-        def _worker() -> None:
-            import comfy.utils
-
-            saved_hook = getattr(comfy.utils, "PROGRESS_BAR_HOOK", None)
-            try:
-                # Workflow is already API-format (saved from ComfyUI editor's
-                # "Save (API Format)"), so it can be handed to PromptExecutor
-                # directly. The execute_outputs list pinpoints which output
-                # nodes to evaluate — we let PromptExecutor walk the whole
-                # graph by passing every output-class node id.
-                output_ids = [
-                    nid for nid, n in workflow.items()
-                    if n.get("class_type", "").startswith(("SaveVideo", "VHS_VideoCombine", "PreviewAudio", "CreateVideo"))
-                ]
-                print(
-                    f"[backend] submitting workflow: {len(workflow)} nodes, "
-                    f"output_ids={output_ids}",
-                    file=sys.stderr,
-                    flush=True,
-                )
-                # Use the public setter; it writes the same global the
-                # ProgressBar class reads, but is the documented API.
-                comfy.utils.set_progress_bar_global_hook(_hook)
-                # _execute_workflow is module-level and decorated with a
-                # @spaces.GPU(duration=callable) on Spaces — the callable
-                # estimates per-call timeout from (mode, preset, frames) so
-                # light calls get fast queue priority while heavy ones reserve
-                # real headroom. Off-Spaces it's a plain call.
-                video_path = _execute_workflow(
-                    self._executor, workflow, output_ids, mode, preset, duration_multiplier, gpu_duration, progress,
-                )
-                # Fallback: if history_result didn't surface a path (rare on
-                # Spaces — happens when ZeroGPU's subprocess boundary drops
-                # mutated state), scan the output dir for the newest mp4
-                # written within the last 60 s.
-                if not video_path:
-                    video_path = _newest_recent_video(self._comfy_dir / "output") or ""
-                print(
-                    f"[backend] workflow done; video_path={video_path!r}",
-                    file=sys.stderr,
-                    flush=True,
-                )
-                _push(OutputEvent(video_path=video_path))
-            except Exception as exc:
-                tb_text = tb_mod.format_exc()
-                print(f"[backend] worker exception:\n{tb_text}", file=sys.stderr, flush=True)
-                _push(
-                    ErrorEvent(
-                        category=_classify(exc),
-                        message=str(exc),
-                        traceback=tb_text,
-                    )
-                )
-            finally:
-                comfy.utils.set_progress_bar_global_hook(saved_hook)
-                _free_memory()
-                _push(None)  # sentinel: stop the consumer
-
-        # ZeroGPU's @spaces.GPU wrapper reads the user's identity from the
-        # current Gradio request via gradio.context.LocalContext.request,
-        # which is a contextvar. Plain threads don't inherit contextvars, so
-        # without this the worker sees request=None, X-IP-Token never gets
-        # read, and `client.schedule` raises "Space app has reached its GPU
-        # limit" (token-is-None branch in spaces/zero/client.py:138). Copy
-        # the calling task's context so the request — and therefore the Pro
-        # user's quota attribution — survives the thread boundary.
-        ctx = contextvars.copy_context()
-        thread = threading.Thread(target=ctx.run, args=(_worker,), daemon=True)
-        thread.start()
-
-        while True:
-            event = await queue.get()
-            if event is None:
-                return
-            yield event
-
-    def interrupt(self) -> None:
-        """Cancel the currently running workflow (if any)."""
-        try:
-            import comfy.model_management as mm
-
-            mm.interrupt_current_processing()
-        except Exception:
-            pass
-
-
-def _classify(exc: Exception) -> str:
-    name = type(exc).__name__.lower()
-    msg = str(exc).lower()
-    if "outofmemory" in name or "cuda out of memory" in msg:
-        return "oom"
-    if "expired zerogpu proxy token" in msg or "expired" in msg and "token" in msg:
-        return "expired_token"
-    if "illegal duration" in msg:
-        return "illegal_duration"
-    if "unlogged user" in msg:
-        return "unlogged"
-    if "exceeded your" in msg and "gpu" in msg:
-        return "quota_exceeded"
-    # ZeroGPU enforces the @spaces.GPU(duration=N) cap and re-raises as
-    # gradio.exceptions.Error('GPU task aborted').
-    if "gpu task aborted" in msg or ("gpu" in msg and "aborted" in msg):
-        return "gpu_timeout"
-    if "interrupt" in name:
-        return "interrupt"
-    return "execution"
-
-
-def _free_memory() -> None:
-    """Free VRAM after a workflow finishes (success or failure)."""
-    try:
-        import comfy.model_management as mm
-
-        mm.unload_all_models()
-    except Exception:
-        pass
-    try:
-        import torch
-
-        if torch.backends.mps.is_available():
-            torch.mps.empty_cache()
-    except Exception:
-        pass
-    try:
-        import torch
-
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-    except Exception:
-        pass
-
-
-def _newest_recent_video(output_root: pathlib.Path, within_seconds: float = 60.0) -> str | None:
-    """Filesystem fallback: return the newest .mp4/.webm/.mov under *output_root*
-    that was modified within the last *within_seconds* seconds.
-
-    Used when the executor's history_result didn't surface a path — typically
-    happens when ZeroGPU's subprocess boundary drops the mutation. The disk
-    is shared, so the file is there even when the in-memory state isn't.
-    """
-    import time
-
-    if not output_root.exists():
-        return None
-    cutoff = time.time() - within_seconds
-    candidates: list[tuple[float, pathlib.Path]] = []
-    for ext in (".mp4", ".webm", ".mov"):
-        for p in output_root.rglob(f"*{ext}"):
-            try:
-                mtime = p.stat().st_mtime
-            except OSError:
-                continue
-            if mtime >= cutoff:
-                candidates.append((mtime, p))
-    if not candidates:
-        return None
-    candidates.sort(reverse=True)
-    return str(candidates[0][1])

chain_injectors/__init__.py

@@ -0,0 +1,50 @@
+import os
+import importlib
+import pkgutil
+
+def discover_injectors():
+    injectors = {}
+    package_dir = os.path.dirname(__file__)
+
+    for _, module_name, is_pkg in pkgutil.iter_modules([package_dir]):
+        if is_pkg or module_name.startswith('_'):
+            continue
+
+        full_module_name = f"chain_injectors.{module_name}"
+        try:
+            module = importlib.import_module(full_module_name)
+            if hasattr(module, 'inject') and callable(module.inject):
+                feature_name = getattr(module, 'FEATURE_NAME', None)
+                if not feature_name:
+                    feature_name = module_name[:-9] if module_name.endswith('_injector') else module_name
+
+                chain_type = getattr(module, 'CHAIN_TYPE', None)
+                if not chain_type:
+                    chain_type = f"dynamic_{feature_name}_chains"
+
+                injectors[chain_type] = module.inject
+            else:
+                print(f"Warning: Module '{full_module_name}' does not have a callable 'inject' function.")
+        except Exception as e:
+            print(f"Error importing injector module '{full_module_name}': {e}")
+
+    return injectors
+
+def get_registered_features():
+    features = {}
+    package_dir = os.path.dirname(__file__)
+
+    for _, module_name, is_pkg in pkgutil.iter_modules([package_dir]):
+        if is_pkg or module_name.startswith('_'):
+            continue
+
+        feature_name = module_name[:-9] if module_name.endswith('_injector') else module_name
+        full_module_name = f"chain_injectors.{module_name}"
+        chain_type = f"dynamic_{feature_name}_chains"
+
+        features[feature_name] = {
+            'module': full_module_name,
+            'chain_type': chain_type
+        }
+
+    return features

chain_injectors/lora_injector.py

@@ -0,0 +1,76 @@
+from copy import deepcopy
+
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    start_node_name = chain_definition.get('start')
+    start_node_id = None
+    if start_node_name:
+        if start_node_name not in assembler.node_map:
+            print(f"Warning: Start node '{start_node_name}' for dynamic LoRA chain not found. Skipping chain.")
+            return
+        start_node_id = assembler.node_map[start_node_name]
+    
+    output_map = chain_definition.get('output_map', {})
+    current_connections = {}
+    for key, type_name in output_map.items():
+        if ':' in str(key):
+            node_name, idx_str = key.split(':')
+            if node_name not in assembler.node_map:
+                print(f"Warning: Node '{node_name}' in chain's output_map not found. Skipping.")
+                continue
+            node_id = assembler.node_map[node_name]
+            start_output_idx = int(idx_str)
+            current_connections[type_name] = [node_id, start_output_idx]
+        elif start_node_id:
+            start_output_idx = int(key)
+            current_connections[type_name] = [start_node_id, start_output_idx]
+        else:
+            print(f"Warning: LoRA chain has no 'start' node defined, and an output_map key '{key}' is not in 'node:index' format. Skipping this connection.")
+
+
+    input_map = chain_definition.get('input_map', {})
+    chain_output_map = chain_definition.get('template_output_map', { "0": "model", "1": "clip" })
+
+    for item_data in chain_items:
+        template_name = chain_definition['template']
+        template = assembler._get_node_template(template_name)
+        node_data = deepcopy(template)
+        
+        for param_name, value in item_data.items():
+            if param_name in node_data['inputs']:
+                node_data['inputs'][param_name] = value
+        
+        if 'scale' in item_data:
+            scale_val = item_data['scale']
+            if 'strength_model' in node_data['inputs'] and (node_data['inputs']['strength_model'] is None or node_data['inputs']['strength_model'] == 1.0):
+                node_data['inputs']['strength_model'] = scale_val
+            if 'strength_clip' in node_data['inputs'] and (node_data['inputs']['strength_clip'] is None or node_data['inputs']['strength_clip'] == 1.0):
+                node_data['inputs']['strength_clip'] = scale_val
+        if 'lora_value' in item_data and ('lora_name' in node_data['inputs'] and not node_data['inputs']['lora_name']):
+            node_data['inputs']['lora_name'] = item_data['lora_value']
+        
+        for type_name, input_name in input_map.items():
+            if type_name in current_connections:
+                node_data['inputs'][input_name] = current_connections[type_name]
+
+        new_node_id = assembler._get_unique_id()
+        assembler.workflow[new_node_id] = node_data
+        
+        for idx_str, type_name in chain_output_map.items():
+            current_connections[type_name] = [new_node_id, int(idx_str)]
+
+    end_input_map = chain_definition.get('end_input_map', {})
+    for type_name, targets in end_input_map.items():
+        if type_name in current_connections:
+            if not isinstance(targets, list):
+                targets = [targets]
+            
+            for target_str in targets:
+                end_node_name, end_input_name = target_str.split(':')
+                if end_node_name in assembler.node_map:
+                    end_node_id = assembler.node_map[end_node_name]
+                    assembler.workflow[end_node_id]['inputs'][end_input_name] = current_connections[type_name]
+                else:
+                    print(f"Warning: End node '{end_node_name}' for dynamic chain not found. Skipping connection.")

comfy_integration/nodes.py

@@ -0,0 +1,44 @@
+import asyncio
+import execution
+import server
+from nodes import (
+    init_extra_nodes, CheckpointLoaderSimple, EmptyLatentImage, KSampler, 
+    VAEDecode, VAEDecodeTiled, SaveImage, NODE_CLASS_MAPPINGS, LoadImage, VAEEncode,
+    VAEEncodeForInpaint, ImagePadForOutpaint, LatentUpscaleBy, RepeatLatentBatch
+)
+
+
+def import_custom_nodes() -> None:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    server_instance = server.PromptServer(loop)
+    execution.PromptQueue(server_instance)
+    
+    loop.run_until_complete(init_extra_nodes())
+
+import_custom_nodes()
+
+CLIPTextEncode = NODE_CLASS_MAPPINGS['CLIPTextEncode']
+CLIPTextEncodeSDXL = NODE_CLASS_MAPPINGS['CLIPTextEncodeSDXL']
+LoraLoader = NODE_CLASS_MAPPINGS['LoraLoader']
+CLIPSetLastLayer = NODE_CLASS_MAPPINGS['CLIPSetLastLayer']
+
+if 'EmptyHunyuanImageLatent' in NODE_CLASS_MAPPINGS:
+    EmptyHunyuanImageLatent = NODE_CLASS_MAPPINGS['EmptyHunyuanImageLatent']
+else:
+    print("⚠️ Warning: 'EmptyHunyuanImageLatent' not found in NODE_CLASS_MAPPINGS. HunyuanImage txt2img may fail if this node is required.")
+
+try:
+    KSamplerNode = NODE_CLASS_MAPPINGS['KSampler']
+    SAMPLER_CHOICES = KSamplerNode.INPUT_TYPES()["required"]["sampler_name"][0]
+    SCHEDULER_CHOICES = KSamplerNode.INPUT_TYPES()["required"]["scheduler"][0]
+except Exception:
+    print("⚠️ Could not dynamically get sampler/scheduler choices, using fallback list.")
+    SAMPLER_CHOICES = ['euler', 'dpmpp_2m_sde_gpu']
+    SCHEDULER_CHOICES = ['normal', 'karras']
+
+checkpointloadersimple = CheckpointLoaderSimple()
+loraloader = LoraLoader()
+
+
+print("✅ ComfyUI custom nodes and class mappings are ready.")

comfy_integration/setup.py

@@ -0,0 +1,74 @@
+import os
+import sys
+import shutil
+
+from core.settings import *
+
+def move_and_overwrite(src, dst):
+    if os.path.isdir(src):
+        os.makedirs(dst, exist_ok=True)
+        for item in os.listdir(src):
+            s_child = os.path.join(src, item)
+            d_child = os.path.join(dst, item)
+            move_and_overwrite(s_child, d_child)
+    elif os.path.isfile(src):
+        if os.path.exists(dst):
+            try:
+                os.remove(dst)
+            except OSError:
+                pass
+        shutil.move(src, dst)
+
+def initialize_comfyui():
+    APP_DIR = sys.path[0]
+    COMFYUI_TEMP_DIR = "ComfyUI_temp"
+
+    print("--- Cloning ComfyUI Repository ---")
+    if not os.path.exists(COMFYUI_TEMP_DIR):
+        os.system(f"git clone https://github.com/comfy-Org/ComfyUI {COMFYUI_TEMP_DIR}")
+        print("✅ ComfyUI repository cloned.")
+    else:
+        print("✅ ComfyUI repository already exists.")
+
+    print(f"--- Merging ComfyUI from '{COMFYUI_TEMP_DIR}' to '{APP_DIR}' ---")
+    for item in os.listdir(COMFYUI_TEMP_DIR):
+        src_path = os.path.join(COMFYUI_TEMP_DIR, item)
+        dst_path = os.path.join(APP_DIR, item)
+        if item == '.git':
+            continue
+        move_and_overwrite(src_path, dst_path)
+    
+    try:
+        shutil.rmtree(COMFYUI_TEMP_DIR)
+        print("✅ ComfyUI merged and temporary directory removed.")
+    except OSError as e:
+        print(f"⚠️ Could not remove temporary directory '{COMFYUI_TEMP_DIR}': {e}")
+
+
+
+
+    print(f"✅ Current working directory is: {os.getcwd()}")
+    
+    import comfy.model_management
+    print("--- Environment Ready ---")
+
+    print("✅ ComfyUI initialized with default attention mechanism.")
+
+    try:
+        import comfy.sd
+        orig_vae_init = comfy.sd.VAE.__init__
+        def patched_vae_init(self, *args, **kwargs):
+            orig_vae_init(self, *args, **kwargs)
+            self.process_output = lambda image: (image.clone() if getattr(image, 'is_inference', False) else image).add_(1.0).div_(2.0).clamp_(0.0, 1.0)
+        comfy.sd.VAE.__init__ = patched_vae_init
+        print("✅ Applied VAE process_output inference tensor safety patch.")
+    except Exception as e:
+        print(f"⚠️ Could not patch VAE process_output: {e}")
+
+    for dir_path in CATEGORY_TO_DIR_MAP.values():
+        os.makedirs(os.path.join(APP_DIR, dir_path), exist_ok=True)
+    
+    os.makedirs(os.path.join(APP_DIR, INPUT_DIR), exist_ok=True)
+    os.makedirs(os.path.join(APP_DIR, OUTPUT_DIR), exist_ok=True)
+    
+    print("✅ All required model directories are present.")

core/generation_logic.py

@@ -0,0 +1,149 @@
+import os
+import glob
+from typing import Any, Dict, List
+import gradio as gr
+import spaces
+
+from core.pipelines.workflow_executor import WorkflowExecutor
+from core.model_manager import model_manager
+
+def _extract_required_models(workflow: Dict[str, Any]) -> List[str]:
+    required_models = []
+    MODEL_KEYS = {'unet_name', 'clip_name', 'vae_name', 'model_name', 'ckpt_name', 'clip_name1', 'clip_name2'}
+    MODEL_EXTENSIONS = ('.safetensors', '.ckpt', '.pt', '.bin', '.pth')
+    
+    for node_id, node_data in workflow.items():
+        if node_data.get('class_type') == 'LoraLoader':
+            continue
+        inputs = node_data.get('inputs', {})
+        for k, v in inputs.items():
+            if isinstance(v, str) and v and k != 'lora_name':
+                if k in MODEL_KEYS or any(v.lower().endswith(ext) for ext in MODEL_EXTENSIONS):
+                    if v not in required_models and not v.startswith('[') and not v.endswith(']'):
+                        required_models.append(v)
+    return required_models
+
+def _extract_video_paths(out: Any) -> List[str]:
+    video_files = []
+    
+    def process_item(item):
+        if item is None:
+            return
+        if isinstance(item, (list, tuple)):
+            for sub in item:
+                process_item(sub)
+            return
+        if isinstance(item, str) and os.path.exists(item):
+            if item.lower().endswith(('.mp4', '.webm', '.gif', '.mov', '.mkv')):
+                video_files.append(item)
+            return
+        for attr in ['path', 'saved_path', 'filepath', 'filename', 'full_path']:
+            val = getattr(item, attr, None)
+            if isinstance(val, str) and os.path.exists(val):
+                video_files.append(val)
+                return
+            elif isinstance(val, str):
+                try:
+                    import folder_paths
+                    possible = os.path.join(folder_paths.get_output_directory(), val)
+                    if os.path.exists(possible):
+                        video_files.append(possible)
+                        return
+                except Exception:
+                    pass
+        if hasattr(item, '__dict__'):
+            for k, v in item.__dict__.items():
+                if isinstance(v, str) and (v.endswith('.mp4') or v.endswith('.webm') or v.endswith('.gif')):
+                    if os.path.exists(v):
+                        video_files.append(v)
+                        return
+                    try:
+                        import folder_paths
+                        possible = os.path.join(folder_paths.get_output_directory(), v)
+                        if os.path.exists(possible):
+                            video_files.append(possible)
+                            return
+                    except Exception:
+                        pass
+        if isinstance(item, dict):
+            ui_info = item.get("ui", {})
+            for key in ["images", "videos", "video"]:
+                for sub in ui_info.get(key, []):
+                    if isinstance(sub, dict) and "filename" in sub:
+                        fn = sub["filename"]
+                        subfolder = sub.get("subfolder", "")
+                        try:
+                            import folder_paths
+                            full = os.path.join(folder_paths.get_output_directory(), subfolder, fn) if subfolder else os.path.join(folder_paths.get_output_directory(), fn)
+                            if os.path.exists(full):
+                                video_files.append(full)
+                                return
+                        except Exception:
+                            pass
+
+    process_item(out)
+
+    if not video_files:
+        try:
+            import folder_paths
+            out_dir = folder_paths.get_output_directory()
+            mp4_files = glob.glob(os.path.join(out_dir, "**", "*.mp4"), recursive=True)
+            if mp4_files:
+                mp4_files.sort(key=os.path.getmtime, reverse=True)
+                video_files.append(mp4_files[0])
+        except Exception:
+            pass
+            
+    return video_files
+
+def _execute_ltx_workflow_gpu(workflow: Dict[str, Any]):
+    initial_objects = {}
+    return WorkflowExecutor.execute_workflow(workflow, initial_objects=initial_objects)
+
+def generate_ltx_video_wrapper(process_inputs_func, ui_inputs: dict, progress=gr.Progress(track_tqdm=True)):
+    progress(0.1, desc="Assembling LTX-2.5 Video Workflow...")
+    batch_count = int(ui_inputs.get('batch_count', 1))
+    all_video_files = []
+
+    for b_idx in range(batch_count):
+        batch_msg = f" (Batch {b_idx + 1}/{batch_count})" if batch_count > 1 else ""
+        current_ui_inputs = ui_inputs.copy()
+        
+        orig_seed = int(current_ui_inputs.get('seed', -1))
+        if orig_seed != -1 and b_idx > 0:
+            current_ui_inputs['seed'] = orig_seed + b_idx
+
+        try:
+            workflow, extra_data = process_inputs_func(current_ui_inputs, progress=progress)
+        except TypeError:
+            workflow, extra_data = process_inputs_func(current_ui_inputs)
+        
+        required_models = _extract_required_models(workflow)
+        if required_models:
+            progress(0.2, desc=f"Ensuring models are downloaded: {len(required_models)} file(s)...")
+            model_manager.ensure_models_downloaded(required_models, progress=progress)
+
+        zero_gpu_duration = current_ui_inputs.get('zero_gpu_duration', 60)
+        try:
+            duration = int(zero_gpu_duration)
+        except (ValueError, TypeError):
+            duration = 60
+        if duration <= 0:
+            duration = 60
+
+        progress(0.4, desc=f"Executing LTX-2.5 Workflow on GPU{batch_msg} (ZeroGPU {duration}s)...")
+        gpu_runner = spaces.GPU(duration=duration)(_execute_ltx_workflow_gpu)
+        raw_output = gpu_runner(workflow)
+        
+        batch_videos = _extract_video_paths(raw_output)
+        if batch_videos:
+            all_video_files.extend(batch_videos)
+            print(f"✅ LTX-2.5 Video generated{batch_msg}")
+    
+    progress(1.0, desc="LTX-2.5 Video Generation Complete!")
+    if not all_video_files:
+        return None
+    return all_video_files[0] if batch_count == 1 else all_video_files
+
+# Alias for backwards compatibility
+generate_h3_video_wrapper = generate_ltx_video_wrapper

core/model_manager.py

@@ -0,0 +1,32 @@
+import gc
+from typing import List
+import gradio as gr
+from utils.app_utils import _ensure_model_downloaded
+from core.settings import ALL_MODEL_MAP
+
+class ModelManager:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(ModelManager, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, 'initialized'):
+            return
+        self.initialized = True
+        print("✅ ModelManager initialized.")
+
+    def ensure_models_downloaded(self, required_models: List[str], progress):
+        print(f"--- [ModelManager] Ensuring models are downloaded: {required_models} ---")
+        for i, display_name in enumerate(required_models):
+            if progress and hasattr(progress, '__call__'):
+                progress(i / max(len(required_models), 1), desc=f"Checking file: {display_name}")
+            try:
+                _ensure_model_downloaded(display_name, progress)
+            except Exception as e:
+                raise gr.Error(f"Failed to download model '{display_name}'. Reason: {e}")
+        print(f"--- [ModelManager] ✅ All required models are present on disk. ---")
+    
+model_manager = ModelManager()

core/pipelines/base_pipeline.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from typing import List, Any, Dict
+import gradio as gr
+import spaces
+import tempfile
+import imageio
+import numpy as np
+import sys
+import os
+
+class BasePipeline(ABC):
+    def __init__(self):
+        from core.model_manager import model_manager
+        self.model_manager = model_manager
+
+    @abstractmethod
+    def get_required_models(self, **kwargs) -> List[str]:
+        pass
+
+    @abstractmethod
+    def run(self, *args, progress: gr.Progress, **kwargs) -> Any:
+        pass
+
+    def _ensure_models_downloaded(self, progress: gr.Progress, **kwargs):
+        """Ensures model files are downloaded before requesting GPU."""
+        required_models = self.get_required_models(**kwargs)
+        self.model_manager.ensure_models_downloaded(required_models, progress=progress)
+
+    def _execute_gpu_logic(self, gpu_function: callable, duration: int, default_duration: int, task_name: str, *args, **kwargs):
+        final_duration = default_duration
+        try:
+            if duration is not None and int(duration) > 0:
+                final_duration = int(duration)
+        except (ValueError, TypeError):
+            print(f"Invalid ZeroGPU duration input for {task_name}. Using default {default_duration}s.")
+            pass
+        
+        print(f"Requesting ZeroGPU for {task_name} with duration: {final_duration} seconds.")
+        gpu_runner = spaces.GPU(duration=final_duration)(gpu_function)
+        
+        return gpu_runner(*args, **kwargs)
+
+    def _encode_video_from_frames(self, frames_tensor_cpu: 'torch.Tensor', fps: int, progress: gr.Progress) -> str:
+        progress(0.9, desc="Encoding video on CPU...")
+        frames_np = (frames_tensor_cpu.numpy() * 255.0).astype(np.uint8)
+        
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_video_file:
+            video_path = temp_video_file.name
+            writer = imageio.get_writer(video_path, fps=fps, codec='libx264', quality=8)
+            for frame in frames_np:
+                writer.append_data(frame)
+            writer.close()
+            
+        progress(1.0, desc="Done!")
+        return video_path

core/pipelines/pipeline_input_processor.py

@@ -0,0 +1,36 @@
+import os
+import gradio as gr
+from typing import Dict, Any
+
+from core.settings import LORA_DIR
+from utils.app_utils import sanitize_filename, get_lora_path
+
+def process_pipeline_inputs(ui_inputs: Dict[str, Any], progress: gr.Progress, workflow_model_type: str = "h3") -> Dict[str, Any]:
+    active_loras_for_gpu, active_loras_for_meta = [], []
+    lora_data = ui_inputs.get('lora_data', [])
+    if lora_data:
+        sources, ids, scales, files = lora_data[0::4], lora_data[1::4], lora_data[2::4], lora_data[3::4]
+        for i, (source, lora_id, scale, _) in enumerate(zip(sources, ids, scales, files)):
+            if scale > 0 and lora_id and lora_id.strip():
+                lora_filename = None
+                if source == "File":
+                    lora_filename = sanitize_filename(lora_id)
+                    local_path = os.path.join(LORA_DIR, lora_filename)
+                    if not os.path.exists(local_path):
+                        raise gr.Error(f"Uploaded LoRA file '{lora_id}' no longer exists on server. Please re-upload it.")
+                elif source in ("Civitai", "Hugging Face"):
+                    local_path, status = get_lora_path(source, lora_id, os.environ.get("CIVITAI_API_KEY", ""), progress)
+                    if local_path:
+                        lora_filename = os.path.basename(local_path)
+                    else:
+                        raise gr.Error(f"Failed to prepare LoRA {lora_id}: {status}")
+                
+                if lora_filename:
+                    active_loras_for_gpu.append({"lora_name": lora_filename, "strength_model": scale, "strength_clip": scale})
+                    active_loras_for_meta.append(f"{source} {lora_id}:{scale}")
+
+    return {
+        "active_loras_for_gpu": active_loras_for_gpu,
+        "active_loras_for_meta": active_loras_for_meta,
+        "temp_files_to_clean": []
+    }

core/pipelines/workflow_executor.py

@@ -0,0 +1,131 @@
+import os
+import torch
+from collections import defaultdict, deque
+from typing import Dict, Any, List
+from comfy_integration.nodes import NODE_CLASS_MAPPINGS
+from utils.app_utils import get_value_at_index
+
+class DummyHidden:
+    extra_pnginfo = None
+    prompt = None
+
+class WorkflowExecutor:
+    @staticmethod
+    def topological_sort(workflow: Dict[str, Any]) -> List[str]:
+        graph = defaultdict(list)
+        in_degree = {node_id: 0 for node_id in workflow}
+
+        for node_id, node_info in workflow.items():
+            for input_value in node_info.get('inputs', {}).values():
+                if isinstance(input_value, list) and len(input_value) == 2 and isinstance(input_value[0], str):
+                    source_node_id = input_value[0]
+                    if source_node_id in workflow:
+                        graph[source_node_id].append(node_id)
+                        in_degree[node_id] += 1
+
+        queue = deque([node_id for node_id, degree in in_degree.items() if degree == 0])
+        
+        sorted_nodes = []
+        while queue:
+            current_node_id = queue.popleft()
+            sorted_nodes.append(current_node_id)
+
+            for neighbor_node_id in graph[current_node_id]:
+                in_degree[neighbor_node_id] -= 1
+                if in_degree[neighbor_node_id] == 0:
+                    queue.append(neighbor_node_id)
+        
+        if len(sorted_nodes) != len(workflow):
+            raise RuntimeError("Workflow contains a cycle and cannot be executed.")
+            
+        return sorted_nodes
+
+    @staticmethod
+    def execute_workflow(workflow: Dict[str, Any], initial_objects: Dict[str, Any]):
+        with torch.inference_mode():
+            computed_outputs = initial_objects
+            
+            sorted_node_ids = WorkflowExecutor.topological_sort(workflow)
+            
+            final_node_id = None
+            for node_id in reversed(sorted_node_ids):
+                if workflow[node_id].get('class_type') in ['SaveVideo', 'CreateVideo']:
+                    final_node_id = node_id
+                    break
+            
+            if final_node_id:
+                required_nodes = set()
+                nodes_to_visit = [final_node_id]
+                while nodes_to_visit:
+                    curr_id = nodes_to_visit.pop()
+                    if curr_id in required_nodes:
+                        continue
+                    required_nodes.add(curr_id)
+                    curr_info = workflow.get(curr_id, {})
+                    for input_val in curr_info.get('inputs', {}).values():
+                        if isinstance(input_val, list) and len(input_val) == 2 and isinstance(input_val[0], str):
+                            src_id = input_val[0]
+                            if src_id in workflow and src_id not in required_nodes:
+                                nodes_to_visit.append(src_id)
+                
+                sorted_node_ids = [nid for nid in sorted_node_ids if nid in required_nodes]
+
+            print(f"--- [Workflow Executor] Execution order: {sorted_node_ids}")
+
+            for node_id in sorted_node_ids:
+                if node_id in computed_outputs:
+                    continue
+                    
+                node_info = workflow[node_id]
+                class_type = node_info['class_type']
+                
+                is_loader_with_filename = 'Loader' in class_type and any(key.endswith('_name') for key in node_info['inputs'])
+                if node_id in initial_objects and is_loader_with_filename:
+                    continue
+                
+                node_class = NODE_CLASS_MAPPINGS.get(class_type)
+                if node_class is None:
+                    raise RuntimeError(f"Could not find node class '{class_type}'. Is it imported in comfy_integration/nodes.py?")
+                
+                node_instance = node_class()
+                
+                if not hasattr(node_class, 'hidden') or getattr(node_class, 'hidden', None) is None:
+                    setattr(node_class, 'hidden', DummyHidden())
+                if not hasattr(node_instance, 'hidden') or getattr(node_instance, 'hidden', None) is None:
+                    setattr(node_instance, 'hidden', DummyHidden())
+
+                kwargs = {}
+                for param_name, param_value in node_info['inputs'].items():
+                    if isinstance(param_value, list) and len(param_value) == 2 and isinstance(param_value[0], str):
+                        source_node_id, output_index = param_value
+                        if source_node_id not in computed_outputs:
+                            raise RuntimeError(f"Workflow integrity error: Output of node {source_node_id} needed for {node_id} but not yet computed.")
+                        
+                        source_output_tuple = computed_outputs[source_node_id]
+                        actual_value = get_value_at_index(source_output_tuple, output_index)
+                    else:
+                        actual_value = param_value
+
+                    if '.' in param_name:
+                        parent_key, child_key = param_name.split('.', 1)
+                        if parent_key not in kwargs or not isinstance(kwargs[parent_key], dict):
+                            kwargs[parent_key] = {}
+                        kwargs[parent_key][child_key] = actual_value
+                    else:
+                        kwargs[param_name] = actual_value
+
+                if class_type == 'SaveVideo':
+                    if 'codec' in kwargs and isinstance(kwargs['codec'], str):
+                        kwargs['codec'] = {"codec": "h264" if kwargs['codec'] in ["auto", ""] else kwargs['codec']}
+                    if kwargs.get('format') == 'auto':
+                        kwargs['format'] = 'mp4'
+
+                function_name = getattr(node_class, 'FUNCTION')
+                execution_method = getattr(node_instance, function_name)
+                
+                result = execution_method(**kwargs)
+                computed_outputs[node_id] = result
+            
+            out = computed_outputs.get(final_node_id, {})
+            print(f"--- [Workflow Executor] Raw final node output: {type(out)}")
+            return out

core/settings.py

@@ -0,0 +1,135 @@
+import yaml
+import os
+from collections import OrderedDict
+
+CHECKPOINT_DIR = "models/checkpoints"
+LORA_DIR = "models/loras"
+EMBEDDING_DIR = "models/embeddings" 
+CONTROLNET_DIR = "models/controlnet"
+MODEL_PATCHES_DIR = "models/model_patches"
+DIFFUSION_MODELS_DIR = "models/diffusion_models"
+VAE_DIR = "models/vae"
+TEXT_ENCODERS_DIR = "models/text_encoders"
+STYLE_MODELS_DIR = "models/style_models"
+CLIP_VISION_DIR = "models/clip_vision"
+IPADAPTER_DIR = "models/ipadapter"
+IPADAPTER_FLUX_DIR = "models/ipadapter-flux"
+LATENT_UPSCALE_MODELS_DIR = "models/latent_upscale_models"
+INPUT_DIR = "input"
+OUTPUT_DIR = "output"
+
+CATEGORY_TO_DIR_MAP = {
+    "diffusion_models": DIFFUSION_MODELS_DIR,
+    "text_encoders": TEXT_ENCODERS_DIR,
+    "vae": VAE_DIR,
+    "latent_upscale_models": LATENT_UPSCALE_MODELS_DIR,
+    "checkpoints": CHECKPOINT_DIR,
+    "loras": LORA_DIR,
+    "controlnet": CONTROLNET_DIR,
+    "model_patches": MODEL_PATCHES_DIR,
+    "embeddings": EMBEDDING_DIR,
+    "style_models": STYLE_MODELS_DIR,
+    "clip_vision": CLIP_VISION_DIR,
+    "ipadapter": IPADAPTER_DIR,
+    "ipadapter-flux": IPADAPTER_FLUX_DIR
+}
+
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_FILE_LIST_PATH = os.path.join(_PROJECT_ROOT, 'yaml', 'file_list.yaml')
+_CONSTANTS_PATH = os.path.join(_PROJECT_ROOT, 'yaml', 'constants.yaml')
+
+def load_constants_from_yaml(filepath=_CONSTANTS_PATH):
+    if not os.path.exists(filepath):
+        print(f"Warning: Constants file not found at {filepath}. Using fallback values.")
+        return {}
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return yaml.safe_load(f)
+
+def load_file_download_map(filepath=_FILE_LIST_PATH):
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"The file list (for downloads) was not found at: {filepath}")
+    
+    with open(filepath, 'r', encoding='utf-8') as f:
+        file_list_data = yaml.safe_load(f)
+    
+    download_info_map = {}
+    for category, files in file_list_data.get('file', {}).items():
+        if isinstance(files, list):
+            for file_info in files:
+                if 'filename' in file_info:
+                    file_info['category'] = category
+                    download_info_map[file_info['filename']] = file_info
+    return download_info_map
+
+try:
+    ALL_FILE_DOWNLOAD_MAP = load_file_download_map()
+    
+    category_to_model_type = {
+        "diffusion_models": "UNET",
+        "text_encoders": "TEXT_ENCODER",
+        "vae": "VAE",
+        "latent_upscale_models": "LATENT_UPSCALE_MODEL",
+        "checkpoints": "SDXL",
+        "loras": "LORA",
+        "controlnet": "CONTROLNET",
+        "model_patches": "MODEL_PATCH",
+        "style_models": "STYLE",
+        "clip_vision": "CLIP_VISION",
+        "ipadapter": "IPADAPTER",
+        "ipadapter-flux": "IPADAPTER_FLUX"
+    }
+
+    MODEL_MAP_CHECKPOINT = OrderedDict()
+    ALL_MODEL_MAP = OrderedDict()
+
+    for filename, file_info in ALL_FILE_DOWNLOAD_MAP.items():
+        category = file_info.get('category')
+        repo_id = file_info.get('repo_id', '')
+        model_type = category_to_model_type.get(category, 'UNKNOWN')
+        
+        model_tuple = (repo_id, filename, model_type, "latent", category)
+        ALL_MODEL_MAP[filename] = model_tuple
+        
+        if category == 'checkpoints':
+            MODEL_MAP_CHECKPOINT[filename] = model_tuple
+
+    MODEL_TYPE_MAP = {k: v[2] for k, v in ALL_MODEL_MAP.items()}
+
+    ARCH_CATEGORIES_MAP = {}
+    for display_name, info in MODEL_MAP_CHECKPOINT.items():
+        arch = info[2]
+        cat = info[4] if len(info) > 4 else None
+        if arch not in ARCH_CATEGORIES_MAP:
+            ARCH_CATEGORIES_MAP[arch] = []
+        if cat and cat not in ARCH_CATEGORIES_MAP[arch]:
+            ARCH_CATEGORIES_MAP[arch].append(cat)
+
+except Exception as e:
+    print(f"FATAL: Could not load file download map from YAML. Error: {e}")
+    ALL_FILE_DOWNLOAD_MAP = {}
+    MODEL_MAP_CHECKPOINT, ALL_MODEL_MAP = OrderedDict(), OrderedDict()
+    MODEL_TYPE_MAP = {}
+    ARCH_CATEGORIES_MAP = {}
+
+try:
+    _constants = load_constants_from_yaml()
+    MAX_LORAS = _constants.get('MAX_LORAS', 5)
+    MAX_EMBEDDINGS = _constants.get('MAX_EMBEDDINGS', 5)
+    MAX_CONDITIONINGS = _constants.get('MAX_CONDITIONINGS', 10)
+    MAX_CONTROLNETS = _constants.get('MAX_CONTROLNETS', 5)
+    MAX_IPADAPTERS = _constants.get('MAX_IPADAPTERS', 5)
+    LORA_SOURCE_CHOICES = _constants.get('LORA_SOURCE_CHOICES', ["Hugging Face", "Civitai", "File"])
+    RESOLUTION_MAP = _constants.get('RESOLUTION_MAP', {})
+    MULTIPLIERS_MAP = _constants.get('MULTIPLIERS_MAP', {})
+    ARCHITECTURES_CONFIG = {"architectures": {}, "architecture_order": []}
+    FEATURES_CONFIG = {"default": {"enabled_chains": ["lora"]}}
+    MODEL_DEFAULTS_CONFIG = {"Default": {}}
+except Exception as e:
+    print(f"FATAL: Could not load constants from YAML. Error: {e}")
+    MAX_LORAS, MAX_EMBEDDINGS, MAX_CONDITIONINGS, MAX_CONTROLNETS, MAX_IPADAPTERS = 5, 5, 10, 5, 5
+    LORA_SOURCE_CHOICES = ["Hugging Face", "Civitai", "File"]
+    RESOLUTION_MAP = {}
+    MULTIPLIERS_MAP = {}
+    ARCHITECTURES_CONFIG = {"architectures": {}, "architecture_order": []}
+    FEATURES_CONFIG = {"default": {"enabled_chains": ["lora"]}}
+    MODEL_DEFAULTS_CONFIG = {"Default": {}}

core/shared_state.py

@@ -0,0 +1 @@
+INVALID_MODEL_URLS = {}

core/workflow_assembler.py

@@ -0,0 +1,203 @@
+import yaml
+import os
+import re
+import importlib
+from copy import deepcopy
+from comfy_integration.nodes import NODE_CLASS_MAPPINGS
+from chain_injectors import discover_injectors, get_registered_features
+from core.settings import FEATURES_CONFIG
+
+class WorkflowAssembler:
+    def __init__(self, recipe_path, dynamic_values=None):
+        self.base_path = os.path.dirname(recipe_path)
+        self.dynamic_values = dynamic_values or {}
+        self.node_counter = 0
+        self.workflow = {}
+        self.node_map = {}
+        
+        model_type = self.dynamic_values.get('model_type')
+        self._load_injector_config(model_type=model_type)
+        
+        self.recipe = self._load_and_merge_recipe(os.path.basename(recipe_path), self.dynamic_values)
+
+    def _load_injector_config(self, model_type=None):
+        self.global_injectors = discover_injectors()
+        registered_features = get_registered_features()
+
+        order = []
+        if model_type and model_type in FEATURES_CONFIG:
+            enabled_features = FEATURES_CONFIG[model_type].get('enabled_chains', [])
+            for feat in enabled_features:
+                if feat in registered_features:
+                    chain_key = registered_features[feat]['chain_type']
+                else:
+                    chain_key = f"dynamic_{feat}_chains"
+                if chain_key in self.global_injectors and chain_key not in order:
+                    order.append(chain_key)
+
+        for chain_key in self.global_injectors.keys():
+            if chain_key not in order:
+                order.append(chain_key)
+
+        self.injector_order = order
+
+    def _get_unique_id(self):
+        self.node_counter += 1
+        return str(self.node_counter)
+
+    def _get_node_template(self, class_type):
+        if class_type not in NODE_CLASS_MAPPINGS:
+            raise ValueError(f"Node class '{class_type}' not found. Ensure it's correctly imported in comfy_integration/nodes.py.")
+        
+        node_class = NODE_CLASS_MAPPINGS[class_type]
+        input_types = node_class.INPUT_TYPES()
+        
+        template = {
+            "inputs": {},
+            "class_type": class_type,
+            "_meta": {"title": node_class.NODE_NAME if hasattr(node_class, 'NODE_NAME') else class_type}
+        }
+        
+        all_inputs = {**input_types.get('required', {}), **input_types.get('optional', {})}
+        for name, details in all_inputs.items():
+            config = details[1] if len(details) > 1 and isinstance(details[1], dict) else {}
+            template["inputs"][name] = config.get("default")
+            
+        return template
+
+    def _load_and_merge_recipe(self, recipe_filename, dynamic_values, search_context_dir=None):
+        search_path = search_context_dir or self.base_path
+        recipe_path_to_use = os.path.join(search_path, recipe_filename)
+
+        if not os.path.exists(recipe_path_to_use):
+            raise FileNotFoundError(f"Recipe file not found: {recipe_path_to_use}")
+
+        with open(recipe_path_to_use, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        for key, value in dynamic_values.items():
+            if value is not None:
+                content = content.replace(f"{{{{ {key} }}}}", str(value))
+        
+        main_recipe = yaml.safe_load(content)
+        
+        merged_recipe = {'nodes': {}, 'connections': [], 'ui_map': {}}
+        for key in self.injector_order:
+            if key.startswith('dynamic_'):
+                merged_recipe[key] = {}
+
+        parent_recipe_dir = os.path.dirname(recipe_path_to_use)
+        for import_path_template in main_recipe.get('imports', []):
+            import_path = import_path_template
+            for key, value in dynamic_values.items():
+                if value is not None:
+                    import_path = import_path.replace(f"{{{{ {key} }}}}", str(value))
+            
+            try:
+                imported_recipe = self._load_and_merge_recipe(import_path, dynamic_values, search_context_dir=parent_recipe_dir)
+                merged_recipe['nodes'].update(imported_recipe.get('nodes', {}))
+                merged_recipe['connections'].extend(imported_recipe.get('connections', []))
+                merged_recipe['ui_map'].update(imported_recipe.get('ui_map', {}))
+                for key in self.injector_order:
+                    if key in imported_recipe and key.startswith('dynamic_'):
+                        merged_recipe[key].update(imported_recipe.get(key, {}))
+            except FileNotFoundError:
+                print(f"Warning: Optional recipe partial '{import_path}' not found. Skipping.")
+
+        merged_recipe['nodes'].update(main_recipe.get('nodes', {}))
+        merged_recipe['connections'].extend(main_recipe.get('connections', []))
+        merged_recipe['ui_map'].update(main_recipe.get('ui_map', {}))
+        for key in self.injector_order:
+            if key in main_recipe and key.startswith('dynamic_'):
+                merged_recipe[key].update(main_recipe.get(key, {}))
+        
+        return merged_recipe
+
+    def add_node(self, class_type: str, inputs: dict = None, title: str = None) -> str:
+        template = self._get_node_template(class_type)
+        node_data = deepcopy(template)
+        if title:
+            node_data['_meta']['title'] = title
+        if inputs:
+            for k, v in inputs.items():
+                node_data['inputs'][k] = v
+        node_id = self._get_unique_id()
+        self.workflow[node_id] = node_data
+        return node_id
+
+    def connect(self, from_node: str, from_output_idx: int, to_node: str, to_input_name: str):
+        from_id = self.node_map.get(from_node, from_node)
+        to_id = self.node_map.get(to_node, to_node)
+        if from_id in self.workflow and to_id in self.workflow:
+            self.workflow[to_id]['inputs'][to_input_name] = [from_id, int(from_output_idx)]
+        else:
+            print(f"Warning: Cannot connect '{from_node}' -> '{to_node}'. Node ID not found.")
+
+    def assemble(self, ui_values):
+        self.ui_values = ui_values
+        for name, details in self.recipe['nodes'].items():
+            if 'class_type' not in details:
+                continue
+            class_type = details['class_type']
+            template = self._get_node_template(class_type)
+            node_data = deepcopy(template)
+            
+            unique_id = self._get_unique_id()
+            self.node_map[name] = unique_id
+
+            if 'title' in details:
+                node_data['_meta']['title'] = details['title']
+            
+            if 'params' in details:
+                for param, value in details['params'].items():
+                    if '.' in param:
+                        parent_param, sub_param = param.split('.', 1)
+                        if parent_param in node_data['inputs']:
+                            if not isinstance(node_data['inputs'][parent_param], dict):
+                                node_data['inputs'][parent_param] = {parent_param: node_data['inputs'][parent_param]} if node_data['inputs'][parent_param] else {}
+                            node_data['inputs'][parent_param][sub_param] = value
+                    elif param in node_data['inputs']:
+                        if isinstance(node_data['inputs'][param], dict) and isinstance(value, dict):
+                            node_data['inputs'][param].update(value)
+                        else:
+                            node_data['inputs'][param] = value
+            
+            self.workflow[unique_id] = node_data
+
+        for ui_key, target in self.recipe.get('ui_map', {}).items():
+            if ui_key in ui_values and ui_values[ui_key] is not None:
+                target_list = target if isinstance(target, list) else [target]
+                for t in target_list:
+                    if isinstance(t, str) and ':' in t:
+                        target_name, target_param = t.split(':')
+                        if target_name in self.node_map:
+                            self.workflow[self.node_map[target_name]]['inputs'][target_param] = ui_values[ui_key]
+
+        for conn in self.recipe.get('connections', []):
+            if not isinstance(conn.get('to'), str) or not isinstance(conn.get('from'), str):
+                continue
+            from_name, from_output_idx = conn['from'].split(':')
+            to_name, to_input_name = conn['to'].split(':')
+            
+            from_id = self.node_map.get(from_name)
+            to_id = self.node_map.get(to_name)
+            
+            if from_id and to_id:
+                self.workflow[to_id]['inputs'][to_input_name] = [from_id, int(from_output_idx)]
+        
+        print("--- [Assembler] Applying dynamic injectors ---")
+        recipe_chain_types = {key for key in self.recipe if key.startswith('dynamic_')}
+        processing_order = [key for key in self.injector_order if key in recipe_chain_types]
+
+        for chain_type in processing_order:
+            injector_func = self.global_injectors.get(chain_type)
+            if injector_func:
+                for chain_key, chain_def in self.recipe.get(chain_type, {}).items():
+                    if chain_key in ui_values and ui_values[chain_key]:
+                        print(f"  -> Injecting '{chain_type}' for '{chain_key}'...")
+                        chain_items = ui_values[chain_key]
+                        injector_func(self, chain_def, chain_items)
+        
+        print("--- [Assembler] Finished applying injectors ---")
+        
+        return self.workflow

docs/future_improvements.md

@@ -1,148 +0,0 @@
-# Future improvements
-
-A backlog of optimizations that aren't blocking but would tighten the deploy.
-None of these are required for current functionality. Order is rough priority,
-not commitment.
-
-## Spaces / preload
-
-### ~~0. Re-enable `preload_from_hub` via runtime cache mirror~~ — DONE 2026-05-02
-
-Initial preload deployment failed because HF's build pipeline writes
-`~/.cache/huggingface/` as the build user, leaving it read-only for runtime
-user 1000. Lazy `hf_hub_download` for non-preloaded files (GGUF, camera LoRAs)
-failed with `Permission denied (os error 13)`. `chmod` couldn't help — we
-don't own the inode.
-
-Fix landed in `_bootstrap()`'s `_mirror_preload_hf_cache()`:
-- Walks `~/.cache/huggingface/` to a parallel `~/hf-cache-rw/` we own
-- Hardlinks `blobs/<sha>` files (zero-copy, shared inode, instant reads)
-- Preserves relative snapshot symlinks (resolve within the mirror tree)
-- Byte-copies `refs/<branch>` files (HF lib overwrites these on etag check)
-- Sets `HF_HOME` + `HF_HUB_CACHE` to the mirror so HF lib uses our writable copy
-- Falls back to symlink if `os.link()` returns EXDEV (cross-device)
-
-Result: preloaded files are instantly available (cache hit on first generate),
-non-preloaded files lazy-download into dirs we own (no permission errors).
-
-### ~~1. Stop preloading models that aren't referenced by any workflow~~ — DONE 2026-05-02
-
-Audit on 2026-05-02 showed two `Lightricks/LTX-2.3` files in `preload_from_hub`
-that aren't actually referenced by any workflow JSON we ship:
-
-- `ltx-2.3-22b-dev.safetensors` (~42 GB)
-- `ltx-2.3-22b-distilled.safetensors` (~42 GB)
-
-The active path uses `Kijai/LTX2.3_comfy ltx-2.3-22b-dev_transformer_only_bf16.safetensors`.
-Removed both — ~84 GB saved. Forced by HF eviction with `storage limit
-exceeded (150G)` when total preload was ~234 GB. Risk: if a future workflow
-update reintroduces the Lightricks-side filenames, lazy download takes over.
-
-### ~~2. Drop `unsloth/LTX-2.3-GGUF` from preload (~39 GB)~~ — DONE 2026-05-02
-
-Removed alongside (1). GGUF transformer is the low-VRAM alternative; ZeroGPU
-H200 has 70 GB so the BF16 transformer always fits. Lazy-loads on first use
-of any preset that wires the GGUF path.
-
-### 3. Drop the `Lightricks/LTX-2-19b-LoRA-Camera-Control-Static/Jib-Up/Jib-Down` preload
-
-Each is ~2 GB. The Power Lora Loader has them all listed but defaults all to
-`on: false`, so they only load when the user picks one. Lazy-load is
-appropriate. Currently kept in preload because of the 10-entry cap +
-"easier to keep what we had".
-
-### 4. Auto-generate `preload_from_hub` from `MODEL_REGISTRY`
-
-Today the README list and `MODEL_REGISTRY` in `models.py` can drift. Build a
-small `tools/sync_preload.py` that:
-
-1. Reads `MODEL_REGISTRY`
-2. Walks the workflow JSONs to find which entries are actually referenced
-3. Sorts referenced entries by size (using `huggingface_hub` `repo_info`)
-4. Picks the top N entries that fit in the 10-cap
-5. Writes them back into the README YAML
-
-Run as a pre-commit or CI step.
-
-### 5. Bake custom-node clones into the build via `requirements.txt` git installs
-
-We currently `git clone` 10 custom-node repos in `_bootstrap()` at runtime.
-That's ~30 s of cold start. Some custom nodes ship as pip-installable; for
-the others, we could write a small `tools/install_custom_nodes.py` that
-runs at build time (via `pip install --no-deps` against git URLs) so the
-repos land in the image instead of being fetched at boot.
-
-Tradeoff: Spaces' build pipeline runs the gradio SDK Dockerfile which we
-don't control directly. The custom-node clone has to happen at runtime
-unless we can move it into the standard `requirements.txt` build step.
-
-### 6. Persistent storage add-on as the "$25/mo button"
-
-If iteration speed becomes the binding constraint, the persistent storage
-add-on (Spaces > Settings) at $25/mo for 150 GB makes everything just work
-— `/data` is writable, models live there forever, no preload dance.
-Sketched approach: `HF_HOME=/data/hf-cache` env var + `_bootstrap()` mkdir
-fallback. One-line code change.
-
-## Workflow / runtime
-
-### 7. Move ComfyUI custom-node `requirements.txt` install to build time
-
-Bootstrap currently `pip install`s each custom node's requirements at
-runtime. Most are no-ops (deps already in our top-level `requirements.txt`)
-but the `pip install --quiet` calls still take a few seconds each. Could
-audit and just merge them into the top-level `requirements.txt`.
-
-### 8. Clean up `nodes_replacements.py` warning
-
-ComfyUI core at our pinned commit (`eb0686bb`) emits
-`'function' object has no attribute 'register'` because the node-replacement
-API surface is incomplete at that SHA. Bumping `COMFYUI_COMMIT` to a newer
-tag should silence it. Pure cosmetic — no functional impact.
-
-### 9. Auto-close drawer when user navigates away from header
-
-Currently relies on document-level click listener. Works but has a
-microsecond race when the click target is between elements. Could use
-`pointerleave` on the drawer instead.
-
-## Cost-of-running
-
-### 10. Trim ZeroGPU duration cap
-
-Currently `@spaces.GPU(duration=300)` reserves 5 min per call. For Fast preset
-(distilled 8 steps) actual usage is ~30 s. Could shorten to 120 s — improves
-queue priority for the user (per HF docs). Use dynamic duration based on
-preset.
-
-### 11. Local-perf "low-VRAM" path for style mode (GGUF Q4 transformer)
-
-Style mode on Apple Silicon runs ~37× slower per sampling step than the other
-modes (~596 s/step on Mac vs ~16 s/step for lipsync). Root cause is
-architectural — `LTXAddVideoICLoRAGuide` concatenates the source video's
-DWPose latents into the noisy target latent, doubling the attention sequence
-to ~56 k tokens. Combined with MPS having no flash-attn-2 and the 22B BF16
-model approaching the working-memory ceiling, perf collapses on Mac.
-
-H200 handles this fine (flash-attn-3 + tensor cores + dedicated VRAM ⇒
-~30–60 s end to end on Spaces). So this is fundamentally a Mac/MPS gap, not
-a code bug.
-
-A "Low VRAM" preset that swaps the BF16 transformer for the GGUF Q4
-quantized one would reduce per-step memory pressure and may bring local
-style perf into the workable range (still slow, but maybe ~60–90 s/step
-instead of 600). The GGUF file is already declared in `MODEL_REGISTRY`
-(`UnetLoaderGGUF` consumer). What's missing:
-
-1. A workflow toggle that swaps `UNETLoader` → `UnetLoaderGGUF` for the main
-   transformer in style.json (and other modes that benefit).
-2. A UI control on the Advanced accordion: "Low VRAM (GGUF Q4)".
-3. Wire-through in `_style_parameterize` (and friends) to flip the loader
-   class.
-4. Delete the matching BF16 path nodes when GGUF is selected (or set them
-   to bypass) so we don't load both.
-
-Risk: GGUF transformers behave slightly differently from BF16 — output
-quality drops, especially for IC-LoRA paths where the dynamic range matters.
-Should be opt-in only, never default. Probably v1.1+ scope (it's listed in
-"Out of scope for v1" in CLAUDE.md as the GGUF Q4 / Low VRAM preset).

docs/superpowers/plans/2026-04-30-ltx23-aio-generator.md

@@ -1,2932 +0,0 @@
-# LTX 2.3 AIO Generator Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Build a Gradio app that wraps the existing ComfyUI LTX 2.3 All-In-One workflow into a polished mode-specific UI, runnable locally (MPS/CUDA) and on Hugging Face Spaces (ZeroGPU, Pro tier).
-
-**Architecture:** Gradio frontend → workflow JSON parameterizer → bundled ComfyUI in library mode (`comfy.execution.PromptExecutor`). Six mode-specific workflow JSON templates extracted from the master workflow; per-mode `parameterize_fn` translates Gradio inputs into node patches. Same code locally and on Spaces; the only divergence is `@spaces.GPU` decoration and model storage location.
-
-**Tech Stack:** Python 3.11, Gradio 5.x, `spaces`, `huggingface_hub`, ComfyUI (vendored as git submodule + runtime clone on Spaces) + custom nodes (`ComfyUI-LTXVideo`, `ComfyUI-KJNodes`, `rgthree-comfy`, `ComfyUI-VideoHelperSuite`, `ComfyUI-Custom-Scripts`), pytest, ruff.
-
-**Spec:** `docs/superpowers/specs/2026-04-30-ltx23-aio-generator-design.md`
-
----
-
-## File Map (locked at plan time)
-
-| File | Created by task | LOC est. | Responsibility |
-|---|---|---|---|
-| `requirements.txt` | T1 | 15 | Pin Gradio, spaces, huggingface_hub, torch, ruff, pytest. |
-| `pyproject.toml` | T1 | 30 | Pytest rootdir + ruff config so flat-layout imports resolve. |
-| `setup.sh` | T2 | 50 | Idempotent local bootstrap (venv, submodule, custom nodes, models). |
-| `README.md` | T3 | 80 | Spaces front matter + local quickstart + screenshot placeholders. |
-| `tests/conftest.py` | T4 | 80 | Fixtures: `master_workflow`, `canonical_inputs`, `fake_hf_cache`, CLI flags. |
-| `tools/extract_modes.py` | T5 | 200 | Extract six mode templates from the master workflow JSON. |
-| `workflows/{t2v,a2v,i2v,lipsync,keyframe,style}.json` | T6 | (data) | Six mode templates. |
-| `workflow.py` | T7–T9 | 120 | `load_template`, `set_input`, `validate`. |
-| `modes.py` | T10–T12 | 300 | `Mode` dataclass + `MODE_REGISTRY` (six entries with `parameterize_fn`). |
-| `models.py` | T13–T15 | 150 | `MODEL_REGISTRY`, `ensure_models_for_mode`, symlink/download logic. |
-| `tools/refresh_models.py` | T16 | 30 | CLI wrapper around `models.ensure_models_for_mode` for all modes. |
-| `backend.py` | T17–T20 | 200 | `ComfyUILibraryBackend`, async submit, progress hook, ZeroGPU. |
-| `ui.py` | T21–T23 | 200 | `preset_bar`, `status_banner`, `lora_chrome`. |
-| `app.py` | T24–T26 | 400 | Gradio `Blocks`, sidebar, mode rendering, generate handler. |
-| `.github/workflows/ci.yml` | T27 | 30 | Run L1+L3 tests on push. |
-| `.github/workflows/deploy-space.yml` | T28 | 25 | Optional — push to HF Space on main. |
-
-Total: ~1,800 LOC across 14 files (excluding the ComfyUI submodule, workflow JSON data, and tests).
-
----
-
-## Phase 0 — Foundations
-
-### Task 1: `requirements.txt`
-
-**Files:**
-- Create: `requirements.txt`
-
-- [ ] **Step 1: Create `requirements.txt`**
-
-```text
-gradio>=5.0,<6.0
-spaces>=0.30.0
-huggingface_hub>=0.27.0
-torch>=2.4.0
-torchvision
-torchaudio
-numpy
-Pillow
-einops
-safetensors
-tqdm
-
-# Dev / test
-pytest>=8.0
-pytest-asyncio>=0.23
-ruff>=0.5
-```
-
-- [ ] **Step 2: Create `pyproject.toml`** so pytest finds the flat-layout modules and ruff rules are pinned
-
-```toml
-[tool.pytest.ini_options]
-pythonpath = ["."]
-markers = [
-    "gpu: marks tests that need a GPU (use --gpu to enable)",
-]
-
-[tool.ruff]
-line-length = 100
-target-version = "py311"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "B", "UP"]
-ignore = ["E501"]  # line length is enforced by formatter, not linter
-
-[tool.ruff.lint.per-file-ignores]
-"tests/*" = ["E402"]  # imports inside test functions are fine
-```
-
-- [ ] **Step 3: Verify both files parse**
-
-Run: `python3.11 -m pip install --dry-run -r requirements.txt 2>&1 | head -5`
-Expected: pip resolves package names without "ERROR: Invalid requirement" lines (network errors are fine — we're checking syntax).
-
-Run: `python3.11 -c "import tomllib; print(list(tomllib.loads(open('pyproject.toml').read()).keys()))"`
-Expected: `['tool']`
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add requirements.txt pyproject.toml
-git commit -m "chore: pin runtime + dev dependencies and configure pytest/ruff"
-```
-
----
-
-### Task 2: `setup.sh`
-
-**Files:**
-- Create: `setup.sh`
-
-- [ ] **Step 1: Write `setup.sh`**
-
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$REPO_ROOT"
-
-echo "▶ Creating Python 3.11 venv"
-python3.11 -m venv .venv
-# shellcheck disable=SC1091
-source .venv/bin/activate
-pip install -U pip wheel
-
-echo "▶ Initializing ComfyUI submodule"
-git submodule update --init --recursive
-
-echo "▶ Installing ComfyUI core requirements"
-pip install -r comfyui/requirements.txt
-
-echo "▶ Installing pinned custom nodes"
-mkdir -p comfyui/custom_nodes
-cd comfyui/custom_nodes
-for repo in \
-    Lightricks/ComfyUI-LTXVideo \
-    kijai/ComfyUI-KJNodes \
-    rgthree/rgthree-comfy \
-    Kosinkadink/ComfyUI-VideoHelperSuite \
-    pythongosssss/ComfyUI-Custom-Scripts ; do
-  name="${repo##*/}"
-  if [[ ! -d "$name" ]]; then
-    git clone --depth 1 "https://github.com/$repo.git" "$name"
-  fi
-  if [[ -f "$name/requirements.txt" ]]; then
-    pip install -r "$name/requirements.txt"
-  fi
-done
-cd "$REPO_ROOT"
-
-echo "▶ Installing AIO app dependencies"
-pip install -r requirements.txt
-
-echo "▶ Symlinking models from HF cache"
-python tools/refresh_models.py || true  # ok to fail before tools/ exists
-
-echo
-echo "✓ Setup complete."
-echo "  Activate venv: source .venv/bin/activate"
-echo "  Run app:        python app.py"
-```
-
-- [ ] **Step 2: Make executable**
-
-Run: `chmod +x setup.sh`
-Expected: no output, exit 0.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add setup.sh
-git commit -m "chore: idempotent setup.sh — venv, submodule, custom nodes, models"
-```
-
----
-
-### Task 3: `README.md` with Spaces front matter
-
-**Files:**
-- Modify: `README.md`
-
-- [ ] **Step 1: Replace the placeholder `README.md`**
-
-```markdown
----
-title: LTX 2.3 All-in-One Video Generator
-emoji: 🎬
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: "5.0"
-app_file: app.py
-python_version: "3.11"
-suggested_hardware: zero-gpu
-hf_oauth: false
----
-
-# LTX 2.3 All-in-One Video Generator
-
-A Gradio app for [LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) wrapping all six modes of the official ComfyUI All-In-One workflow under a single, focused UI. Runs locally on Apple Silicon (MPS) or NVIDIA (CUDA), and deploys to Hugging Face Spaces (ZeroGPU).
-
-## Modes
-
-1. **Text → Video** (+ optional Audio)
-2. **Audio → Video** (Text + Audio → Video + Audio)
-3. **Image → Video** (+ optional Audio)
-4. **Lipsync** (Image + Audio → Video + Audio)
-5. **First / Last Frame → Video** (keyframe interpolation)
-6. **Style Transfer** (Video → Video, motion control)
-
-## Local quickstart
-
-Requires Python 3.11, ~80 GB free disk for model weights, and ~24 GB+ GPU memory (CUDA) or 32 GB+ unified memory (Apple Silicon).
-
-```bash
-git clone --recurse-submodules https://github.com/<your-handle>/ltx2.3-AIO-generator
-cd ltx2.3-AIO-generator
-bash setup.sh
-source .venv/bin/activate
-python app.py
-```
-
-The first run downloads ~70 GB of models into your existing `~/.cache/huggingface/hub` (no duplicate copies in this repo) and symlinks them into `comfyui/models/`.
-
-## HF Spaces deployment
-
-This repo is a Gradio Space. The required Pro tier provides ~50 GB persistent `/data` storage and longer per-call ZeroGPU budgets needed for Balanced and Quality presets.
-
-```bash
-git remote add space https://huggingface.co/spaces/<your-handle>/ltx2.3-aio
-git push space main
-```
-
-## License
-
-MIT for the AIO app code. ComfyUI and LTX-2.3 retain their respective licenses.
-```
-
-- [ ] **Step 2: Commit**
-
-```bash
-git add README.md
-git commit -m "docs: README with Spaces front matter and local quickstart"
-```
-
----
-
-### Task 4: `tests/conftest.py` with fixtures
-
-**Files:**
-- Create: `tests/__init__.py` (empty)
-- Create: `tests/conftest.py`
-
-- [ ] **Step 1: Create `tests/__init__.py`** (empty file)
-
-```bash
-mkdir -p tests
-touch tests/__init__.py
-```
-
-- [ ] **Step 2: Write `tests/conftest.py`**
-
-```python
-"""Shared pytest fixtures and CLI flags."""
-import json
-import os
-import pathlib
-from typing import Any
-
-import pytest
-
-REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent
-
-DEFAULT_MASTER_WORKFLOW = pathlib.Path(
-    os.environ.get(
-        "LTX23_MASTER_WORKFLOW",
-        pathlib.Path.home() / "Projects/comfyui/user/default/workflows"
-        / "1. LTX 2.3 All-In-One 260406-05.json",
-    )
-)
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    parser.addoption("--gpu", action="store_true", help="Run L4 GPU smoke tests.")
-    parser.addoption(
-        "--comfy-real",
-        action="store_true",
-        help="Use bundled ComfyUI for L2 graph validation (slower).",
-    )
-
-
-def pytest_collection_modifyitems(
-    config: pytest.Config, items: list[pytest.Item]
-) -> None:
-    if not config.getoption("--gpu"):
-        skip_gpu = pytest.mark.skip(reason="GPU smoke tests skipped (use --gpu)")
-        for item in items:
-            if "gpu" in item.keywords:
-                item.add_marker(skip_gpu)
-
-
-@pytest.fixture(scope="session")
-def master_workflow() -> dict[str, Any]:
-    """The full LTX 2.3 All-In-One workflow JSON (loaded from user's ComfyUI)."""
-    if not DEFAULT_MASTER_WORKFLOW.exists():
-        pytest.skip(
-            f"Master workflow not found at {DEFAULT_MASTER_WORKFLOW}. "
-            "Set LTX23_MASTER_WORKFLOW env var to its path."
-        )
-    return json.loads(DEFAULT_MASTER_WORKFLOW.read_text())
-
-
-@pytest.fixture
-def canonical_inputs() -> dict[str, dict[str, Any]]:
-    """Known-good Gradio input dicts per mode (used by L1/L2 tests)."""
-    return {
-        "t2v": {
-            "prompt": "a tiger walking through a misty forest at dawn, cinematic",
-            "negative_prompt": "",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "camera_lora": "none",
-            "camera_strength": 0.8,
-            "detailer_on": False,
-            "detailer_strength": 0.5,
-        },
-        "i2v": {
-            "prompt": "the subject turns toward the camera and smiles",
-            "image": "/tmp/portrait.png",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "camera_lora": "none",
-            "camera_strength": 0.8,
-            "detailer_on": True,
-            "detailer_strength": 0.5,
-            "ic_lora": "union",
-            "ic_strength": 0.5,
-            "pose_on": False,
-        },
-        "a2v": {
-            "prompt": "a dancer moves to the beat in a neon-lit studio",
-            "audio": "/tmp/track.wav",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "audio_cfg": 7.0,
-        },
-        "lipsync": {
-            "prompt": "the person speaks the audio with natural mouth movement",
-            "image": "/tmp/portrait.png",
-            "audio": "/tmp/speech.wav",
-            "preset": "balanced",
-            "image_strength": 0.7,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-        },
-        "keyframe": {
-            "prompt": "smooth transition between the two frames",
-            "first_frame": "/tmp/start.png",
-            "last_frame": "/tmp/end.png",
-            "preset": "balanced",
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-        },
-        "style": {
-            "prompt": "in the style of a renaissance oil painting",
-            "input_video": "/tmp/source.mp4",
-            "preset": "balanced",
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "ic_lora": "motion-track",
-            "ic_strength": 0.5,
-        },
-    }
-
-
-@pytest.fixture
-def fake_hf_cache(tmp_path: pathlib.Path) -> pathlib.Path:
-    """A fake ~/.cache/huggingface/hub layout with placeholder files."""
-    hub = tmp_path / "huggingface" / "hub"
-    layouts = {
-        "models--Lightricks--LTX-2.3": [
-            "ltx-2.3-22b-distilled.safetensors",
-            "ltx-2.3-spatial-upscaler-x2-1.0.safetensors",
-            "ltx-2.3-22b-distilled-lora-384.safetensors",
-        ],
-        "models--google--gemma-3-12b-it-qat-q4_0-unquantized": [
-            "model-00001-of-00005.safetensors",
-            "model-00002-of-00005.safetensors",
-            "model-00003-of-00005.safetensors",
-            "model-00004-of-00005.safetensors",
-            "model-00005-of-00005.safetensors",
-            "model.safetensors.index.json",
-            "tokenizer.model",
-            "preprocessor_config.json",
-        ],
-        "models--Kijai--LTX2.3_comfy": [
-            "LTX23_video_vae_bf16.safetensors",
-            "LTX23_audio_vae_bf16.safetensors",
-        ],
-    }
-    for repo, files in layouts.items():
-        snapshot_dir = hub / repo / "snapshots" / "deadbeef" * 1
-        snapshot_dir = hub / repo / "snapshots" / "deadbeef"
-        snapshot_dir.mkdir(parents=True, exist_ok=True)
-        for filename in files:
-            (snapshot_dir / filename).write_text("")  # placeholder
-    return hub
-```
-
-- [ ] **Step 3: Verify pytest discovers the conftest**
-
-Run: `python3.11 -m pytest tests/ --collect-only 2>&1 | head -20`
-Expected: "no tests ran" or similar — but no errors importing conftest.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add tests/__init__.py tests/conftest.py
-git commit -m "test: pytest fixtures (master_workflow, canonical_inputs, fake_hf_cache)"
-```
-
----
-
-### Task 5: ComfyUI submodule
-
-**Files:**
-- Create: `.gitmodules`
-- Create: `comfyui/` (submodule)
-
-- [ ] **Step 1: Add ComfyUI as a git submodule**
-
-```bash
-cd /Users/techfreakworm/Projects/llm/ltx2.3-AIO-generator
-git submodule add https://github.com/comfyanonymous/ComfyUI.git comfyui
-cd comfyui
-# Pin to a known-good recent commit. Capture the SHA the user is currently running.
-USER_COMFY_SHA="$(git -C ~/Projects/comfyui rev-parse HEAD)"
-git checkout "$USER_COMFY_SHA"
-cd ..
-```
-
-- [ ] **Step 2: Verify submodule status**
-
-Run: `git submodule status`
-Expected: one line starting with the pinned SHA followed by `comfyui (heads/master ...)` or similar.
-
-- [ ] **Step 3: Commit submodule**
-
-```bash
-git add .gitmodules comfyui
-git commit -m "chore: vendor ComfyUI as git submodule pinned to working commit"
-```
-
----
-
-## Phase 1 — Workflow library (TDD)
-
-### Task 6: `tools/extract_modes.py` — extract mode templates
-
-**Files:**
-- Create: `tools/__init__.py` (empty)
-- Create: `tools/extract_modes.py`
-- Create: `tests/test_extract_modes.py`
-
-- [ ] **Step 1: Write the failing test**
-
-```python
-# tests/test_extract_modes.py
-"""Tests for the workflow-mode extractor."""
-import json
-import subprocess
-import sys
-
-from tests.conftest import REPO_ROOT
-
-
-def test_extract_creates_six_mode_files(master_workflow, tmp_path):
-    """extract_modes.py emits six valid mode-specific JSON templates."""
-    out_dir = tmp_path / "workflows"
-    master_path = tmp_path / "master.json"
-    master_path.write_text(json.dumps(master_workflow))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            str(REPO_ROOT / "tools" / "extract_modes.py"),
-            "--master",
-            str(master_path),
-            "--out",
-            str(out_dir),
-        ],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-
-    assert result.returncode == 0, result.stderr
-    expected = {"t2v.json", "a2v.json", "i2v.json", "lipsync.json", "keyframe.json", "style.json"}
-    actual = {p.name for p in out_dir.iterdir()}
-    assert actual == expected
-
-    # Each file must be valid JSON with at least one node.
-    for path in out_dir.iterdir():
-        wf = json.loads(path.read_text())
-        assert "nodes" in wf
-        assert len(wf["nodes"]) > 0
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `python3.11 -m pytest tests/test_extract_modes.py -v`
-Expected: FAIL with `FileNotFoundError` or `No such file or directory` for `tools/extract_modes.py`.
-
-- [ ] **Step 3: Implement `tools/__init__.py` and `tools/extract_modes.py`**
-
-```python
-# tools/__init__.py (empty)
-```
-
-```python
-# tools/extract_modes.py
-"""Extract six mode-specific workflow templates from the master LTX 2.3 All-In-One workflow.
-
-Each ComfyUI group whose title starts with a number (e.g. "01 Text to Video") becomes
-a mode template containing only that group's nodes plus shared scaffolding (Models,
-Lora, Setting, Prompt, Load Audio/Image/Video, Output groups).
-
-Group title → output filename mapping:
-    01 → t2v.json
-    02 → a2v.json
-    03 → i2v.json
-    04 → lipsync.json
-    05 → keyframe.json
-    06 → style.json
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import re
-import sys
-from collections.abc import Iterable
-
-GROUP_TO_FILENAME: dict[str, str] = {
-    "01": "t2v.json",
-    "02": "a2v.json",
-    "03": "i2v.json",
-    "04": "lipsync.json",
-    "05": "keyframe.json",
-    "06": "style.json",
-}
-
-SHARED_GROUP_PREFIXES: tuple[str, ...] = (
-    "Models",
-    "Lora",
-    "Setting",
-    "Prompt",
-    "Load Audio",
-    "Load Image",
-    "Load Video",
-    "Output",
-)
-
-
-def _node_in_group(node: dict, group: dict) -> bool:
-    """Test whether a node's position lies inside a group's bounding box."""
-    if "pos" not in node or "bounding" not in group:
-        return False
-    nx, ny = node["pos"][0], node["pos"][1]
-    gx, gy, gw, gh = group["bounding"]
-    return (gx <= nx <= gx + gw) and (gy <= ny <= gy + gh)
-
-
-def _select_groups(master: dict, mode_prefix: str) -> list[dict]:
-    """Pick the mode group plus all shared groups."""
-    selected: list[dict] = []
-    for g in master.get("groups", []):
-        title = (g.get("title") or "").strip()
-        if title.startswith(mode_prefix + " "):
-            selected.append(g)
-        elif any(title.startswith(p) for p in SHARED_GROUP_PREFIXES):
-            selected.append(g)
-    return selected
-
-
-def _collect_nodes(master: dict, groups: Iterable[dict]) -> list[dict]:
-    """Return all nodes lying inside any of the given groups."""
-    groups_list = list(groups)
-    keep: list[dict] = []
-    for node in master.get("nodes", []):
-        if any(_node_in_group(node, g) for g in groups_list):
-            keep.append(node)
-    return keep
-
-
-def _collect_links(master: dict, kept_node_ids: set[int]) -> list[list]:
-    """Keep only links where both endpoints are in the surviving node set."""
-    return [
-        link
-        for link in master.get("links", [])
-        # ComfyUI link tuple format: [link_id, src_node_id, src_out, dst_node_id, dst_in, type]
-        if link[1] in kept_node_ids and link[3] in kept_node_ids
-    ]
-
-
-def extract_mode(master: dict, mode_prefix: str) -> dict:
-    """Build a focused workflow JSON for the given mode group prefix."""
-    groups = _select_groups(master, mode_prefix)
-    nodes = _collect_nodes(master, groups)
-    kept_ids = {n["id"] for n in nodes}
-    links = _collect_links(master, kept_ids)
-
-    return {
-        "id": f"ltx23-aio-{mode_prefix}",
-        "revision": 0,
-        "last_node_id": max(kept_ids, default=0),
-        "last_link_id": max((l[0] for l in links), default=0),
-        "nodes": nodes,
-        "links": links,
-        "groups": groups,
-        "definitions": master.get("definitions", {}),
-        "config": master.get("config", {}),
-        "extra": master.get("extra", {}),
-        "version": master.get("version", 0.4),
-    }
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--master", type=pathlib.Path, required=True)
-    parser.add_argument("--out", type=pathlib.Path, required=True)
-    args = parser.parse_args(argv)
-
-    master = json.loads(args.master.read_text())
-    args.out.mkdir(parents=True, exist_ok=True)
-
-    for prefix, filename in GROUP_TO_FILENAME.items():
-        wf = extract_mode(master, prefix)
-        out_path = args.out / filename
-        out_path.write_text(json.dumps(wf, indent=2))
-        print(f"  → wrote {out_path} ({len(wf['nodes'])} nodes, {len(wf['links'])} links)")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `python3.11 -m pytest tests/test_extract_modes.py -v`
-Expected: PASS. (If `master_workflow` fixture skips because the master JSON isn't at the expected path, set `LTX23_MASTER_WORKFLOW` env var first.)
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add tools/__init__.py tools/extract_modes.py tests/test_extract_modes.py
-git commit -m "feat(tools): extract six mode templates from master workflow JSON"
-```
-
----
-
-### Task 7: Run extraction once → commit `workflows/*.json`
-
-**Files:**
-- Create: `workflows/t2v.json` … `workflows/style.json`
-
-- [ ] **Step 1: Run the extractor against the master workflow**
-
-```bash
-mkdir -p workflows
-python3.11 tools/extract_modes.py \
-  --master ~/Projects/comfyui/user/default/workflows/"1. LTX 2.3 All-In-One 260406-05.json" \
-  --out workflows
-```
-
-Expected output: six lines like `→ wrote workflows/t2v.json (N nodes, M links)`.
-
-- [ ] **Step 2: Sanity-check each file**
-
-```bash
-for f in workflows/*.json; do
-  python3.11 -c "import json; w=json.load(open('$f')); print('$f', len(w['nodes']), 'nodes')"
-done
-```
-
-Expected: each file reports a non-zero node count.
-
-- [ ] **Step 3: Commit the templates**
-
-```bash
-git add workflows/
-git commit -m "data: extracted mode-specific workflow templates from master"
-```
-
----
-
-### Task 8: `workflow.py` — `load_template`
-
-**Files:**
-- Create: `workflow.py`
-- Create: `tests/test_workflow.py`
-
-- [ ] **Step 1: Write the failing test**
-
-```python
-# tests/test_workflow.py
-"""Unit tests for workflow.py — pure functions over JSON dicts."""
-import pytest
-
-import workflow
-
-
-def test_load_template_returns_dict_for_valid_mode():
-    wf = workflow.load_template("t2v")
-    assert isinstance(wf, dict)
-    assert "nodes" in wf
-    assert len(wf["nodes"]) > 0
-
-
-def test_load_template_raises_for_unknown_mode():
-    with pytest.raises(ValueError, match="unknown mode"):
-        workflow.load_template("nonexistent")
-
-
-def test_load_template_returns_independent_copy():
-    """Mutations to one returned dict must not affect later loads."""
-    a = workflow.load_template("t2v")
-    a["nodes"].append({"id": -999})
-    b = workflow.load_template("t2v")
-    assert {-999} & {n.get("id") for n in b["nodes"]} == set()
-```
-
-- [ ] **Step 2: Run the test to verify it fails**
-
-Run: `python3.11 -m pytest tests/test_workflow.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'workflow'`.
-
-- [ ] **Step 3: Implement `workflow.py`**
-
-```python
-"""Pure functions over LTX 2.3 mode workflow JSON templates."""
-from __future__ import annotations
-
-import copy
-import json
-import pathlib
-from typing import Any
-
-WORKFLOWS_DIR = pathlib.Path(__file__).parent / "workflows"
-
-VALID_MODES: tuple[str, ...] = ("t2v", "a2v", "i2v", "lipsync", "keyframe", "style")
-
-
-def load_template(mode: str) -> dict[str, Any]:
-    """Load a fresh, independent copy of the named mode's workflow template."""
-    if mode not in VALID_MODES:
-        raise ValueError(f"unknown mode {mode!r}; expected one of {VALID_MODES}")
-    path = WORKFLOWS_DIR / f"{mode}.json"
-    return copy.deepcopy(json.loads(path.read_text()))
-```
-
-- [ ] **Step 4: Run the test to verify it passes**
-
-Run: `python3.11 -m pytest tests/test_workflow.py -v`
-Expected: PASS — three tests green.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add workflow.py tests/test_workflow.py
-git commit -m "feat(workflow): load_template returns fresh deep copy per mode"
-```
-
----
-
-### Task 9: `workflow.py` — `set_input` and `validate`
-
-**Files:**
-- Modify: `workflow.py`
-- Modify: `tests/test_workflow.py`
-
-- [ ] **Step 1: Append failing tests**
-
-```python
-# Append to tests/test_workflow.py
-def test_set_input_patches_widgets_values_in_place():
-    wf = workflow.load_template("t2v")
-    target_node = next(n for n in wf["nodes"] if n["type"] == "CLIPTextEncode")
-    workflow.set_input(wf, target_node["id"], 0, "new prompt text")
-    refetched = next(n for n in wf["nodes"] if n["id"] == target_node["id"])
-    assert refetched["widgets_values"][0] == "new prompt text"
-
-
-def test_set_input_raises_for_unknown_node():
-    wf = workflow.load_template("t2v")
-    with pytest.raises(KeyError, match="node id"):
-        workflow.set_input(wf, 999_999_999, 0, "x")
-
-
-def test_validate_accepts_canonical_template():
-    wf = workflow.load_template("t2v")
-    workflow.validate(wf)  # must not raise
-
-
-def test_validate_rejects_workflow_with_no_nodes():
-    wf = {"nodes": [], "links": []}
-    with pytest.raises(ValueError, match="no nodes"):
-        workflow.validate(wf)
-
-
-def test_validate_rejects_orphan_link():
-    wf = workflow.load_template("t2v")
-    wf["links"].append([99999, 1, 0, 999_999_999, 0, "INT"])  # destination doesn't exist
-    with pytest.raises(ValueError, match="orphan link"):
-        workflow.validate(wf)
-```
-
-- [ ] **Step 2: Run tests to verify the new ones fail**
-
-Run: `python3.11 -m pytest tests/test_workflow.py -v`
-Expected: 5 fails (set_input + validate) and 3 prior tests still passing.
-
-- [ ] **Step 3: Implement `set_input` and `validate` in `workflow.py`**
-
-Append to `workflow.py`:
-
-```python
-def set_input(workflow: dict[str, Any], node_id: int, widget_index: int, value: Any) -> None:
-    """Patch a node's widgets_values in place.
-
-    Args:
-        workflow: A workflow dict (must have a "nodes" list).
-        node_id: The id of the node to patch.
-        widget_index: Position within the node's widgets_values list.
-        value: New value.
-
-    Raises:
-        KeyError: If no node with the given id exists.
-    """
-    for node in workflow["nodes"]:
-        if node.get("id") == node_id:
-            widgets = node.setdefault("widgets_values", [])
-            while len(widgets) <= widget_index:
-                widgets.append(None)
-            widgets[widget_index] = value
-            return
-    raise KeyError(f"node id {node_id} not found in workflow")
-
-
-def validate(workflow: dict[str, Any]) -> None:
-    """Static schema validation. Raises ValueError on the first problem found."""
-    nodes = workflow.get("nodes")
-    if not isinstance(nodes, list) or len(nodes) == 0:
-        raise ValueError("workflow has no nodes")
-
-    node_ids = {n.get("id") for n in nodes if "id" in n}
-    for link in workflow.get("links", []):
-        if not isinstance(link, list) or len(link) < 6:
-            raise ValueError(f"malformed link {link}")
-        _, src, _, dst, _, _ = link
-        if src not in node_ids or dst not in node_ids:
-            raise ValueError(f"orphan link {link}")
-```
-
-- [ ] **Step 4: Run all workflow tests**
-
-Run: `python3.11 -m pytest tests/test_workflow.py -v`
-Expected: 8 passing tests.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add workflow.py tests/test_workflow.py
-git commit -m "feat(workflow): set_input + validate over node graph"
-```
-
----
-
-## Phase 2 — Modes registry
-
-### Task 10: `modes.py` — `Mode` dataclass + skeleton
-
-**Files:**
-- Create: `modes.py`
-- Create: `tests/test_modes.py`
-
-- [ ] **Step 1: Write the failing test**
-
-```python
-# tests/test_modes.py
-"""Unit tests for modes.py — MODE_REGISTRY and parameterize_fn correctness."""
-import pytest
-
-import modes
-
-
-def test_mode_registry_has_all_six_keys():
-    assert set(modes.MODE_REGISTRY.keys()) == {
-        "t2v", "a2v", "i2v", "lipsync", "keyframe", "style",
-    }
-
-
-def test_each_mode_has_required_attributes():
-    for name, mode in modes.MODE_REGISTRY.items():
-        assert mode.name == name
-        assert mode.label  # non-empty
-        assert mode.icon  # non-empty
-        assert callable(mode.parameterize_fn)
-        assert isinstance(mode.stage_map, list) and len(mode.stage_map) > 0
-```
-
-- [ ] **Step 2: Run test to verify it fails**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v`
-Expected: FAIL — `ModuleNotFoundError: No module named 'modes'`.
-
-- [ ] **Step 3: Create `modes.py` skeleton**
-
-```python
-"""MODE_REGISTRY — one Mode entry per generation mode.
-
-Each Mode declares:
-- name: short id ("t2v", "i2v", ...)
-- label: display name
-- icon: single-character or emoji icon for the sidebar
-- stage_map: list of (label, expected_share_pct) for the status banner
-- parameterize_fn: (Gradio inputs dict) -> list[(node_id, widget_index, value)]
-
-The parameterize_fn is the only mode-specific logic. Everything else (workflow
-loading, validation, dispatch) is mode-agnostic and lives in workflow.py /
-backend.py.
-"""
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
-
-Patch = tuple[int, int, Any]
-ParameterizeFn = Callable[[dict[str, Any]], list[Patch]]
-
-
-@dataclass(frozen=True)
-class Stage:
-    label: str
-    share_pct: int  # rough share of total time, sums to ~100 across stages
-
-
-@dataclass(frozen=True)
-class Mode:
-    name: str
-    label: str
-    icon: str
-    parameterize_fn: ParameterizeFn
-    stage_map: list[Stage] = field(default_factory=list)
-
-
-# Filled in by tasks 11–12.
-MODE_REGISTRY: dict[str, Mode] = {}
-```
-
-- [ ] **Step 4: Run test to verify it still fails (different error)**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v`
-Expected: FAIL on `test_mode_registry_has_all_six_keys` — empty registry.
-
-- [ ] **Step 5: Commit skeleton**
-
-```bash
-git add modes.py tests/test_modes.py
-git commit -m "feat(modes): Mode dataclass + empty MODE_REGISTRY skeleton"
-```
-
----
-
-### Task 11: `parameterize_fn` for T2V and I2V
-
-**Files:**
-- Modify: `modes.py`
-- Modify: `tests/test_modes.py`
-
-- [ ] **Step 1: Append failing tests**
-
-```python
-# Append to tests/test_modes.py
-import workflow
-
-def test_t2v_parameterize_produces_valid_patches(canonical_inputs):
-    inputs = canonical_inputs["t2v"]
-    mode = modes.MODE_REGISTRY["t2v"]
-    patches = mode.parameterize_fn(inputs)
-
-    # All patches must be (node_id: int, widget_index: int, value: Any)
-    for node_id, widget_index, value in patches:
-        assert isinstance(node_id, int)
-        assert isinstance(widget_index, int)
-        assert value is not None or value == ""
-
-    # Apply patches to a real template; result must validate.
-    wf = workflow.load_template("t2v")
-    for patch in patches:
-        workflow.set_input(wf, *patch)
-    workflow.validate(wf)
-
-
-def test_i2v_parameterize_uses_image_path(canonical_inputs):
-    inputs = canonical_inputs["i2v"]
-    mode = modes.MODE_REGISTRY["i2v"]
-    patches = mode.parameterize_fn(inputs)
-    values = [p[2] for p in patches]
-    assert inputs["image"] in values
-```
-
-- [ ] **Step 2: Run tests to verify failures**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v -k "t2v or i2v"`
-Expected: FAIL — `KeyError: 't2v'` from empty MODE_REGISTRY.
-
-- [ ] **Step 3: Implement T2V and I2V**
-
-Append to `modes.py`:
-
-```python
-# ---------------------------------------------------------------------------
-# Node-id constants per template. These are stable for a given workflow file;
-# if you re-run tools/extract_modes.py against an updated master, re-capture
-# them by inspecting the regenerated workflows/<mode>.json.
-# ---------------------------------------------------------------------------
-
-# T2V template node ids (capture from workflows/t2v.json after extraction).
-T2V_NODE_PROMPT = 240            # CLIPTextEncode positive
-T2V_NODE_NEG_PROMPT = 241        # CLIPTextEncode negative
-T2V_NODE_RESOLUTION = 5300       # mxSlider for w/h
-T2V_NODE_FRAMES = 5301           # INTConstant
-T2V_NODE_FPS = 5302              # INTConstant
-T2V_NODE_SEED = 5303             # INTConstant
-T2V_NODE_PRESET = 5304           # Any Switch — preset selector
-T2V_NODE_CAMERA_LORA = 5400      # Power Lora Loader row 0
-T2V_NODE_DETAILER_LORA = 5401    # Power Lora Loader row 1
-
-# I2V template node ids (capture from workflows/i2v.json).
-I2V_NODE_PROMPT = 340
-I2V_NODE_IMAGE = 350             # LoadImage
-I2V_NODE_RESOLUTION = 5310
-I2V_NODE_FRAMES = 5311
-I2V_NODE_FPS = 5312
-I2V_NODE_SEED = 5313
-I2V_NODE_PRESET = 5314
-I2V_NODE_CAMERA_LORA = 5410
-I2V_NODE_DETAILER_LORA = 5411
-I2V_NODE_IC_LORA = 5412
-I2V_NODE_POSE_LORA = 5413
-
-
-def _t2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (T2V_NODE_PROMPT, 0, inp["prompt"]),
-        (T2V_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
-        (T2V_NODE_RESOLUTION, 0, inp["width"]),
-        (T2V_NODE_RESOLUTION, 1, inp["height"]),
-        (T2V_NODE_FRAMES, 0, inp["frames"]),
-        (T2V_NODE_FPS, 0, inp["fps"]),
-        (T2V_NODE_SEED, 0, inp["seed"]),
-        (T2V_NODE_PRESET, 0, inp["preset"]),
-        (T2V_NODE_CAMERA_LORA, 0, inp.get("camera_lora", "none")),
-        (T2V_NODE_CAMERA_LORA, 1, inp.get("camera_strength", 0.0)),
-        (T2V_NODE_DETAILER_LORA, 0, "ic-lora-detailer" if inp.get("detailer_on") else "none"),
-        (T2V_NODE_DETAILER_LORA, 1, inp.get("detailer_strength", 0.0)),
-    ]
-
-
-def _i2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (I2V_NODE_PROMPT, 0, inp["prompt"]),
-        (I2V_NODE_IMAGE, 0, inp["image"]),
-        (I2V_NODE_RESOLUTION, 0, inp["width"]),
-        (I2V_NODE_RESOLUTION, 1, inp["height"]),
-        (I2V_NODE_FRAMES, 0, inp["frames"]),
-        (I2V_NODE_FPS, 0, inp["fps"]),
-        (I2V_NODE_SEED, 0, inp["seed"]),
-        (I2V_NODE_PRESET, 0, inp["preset"]),
-        (I2V_NODE_CAMERA_LORA, 0, inp.get("camera_lora", "none")),
-        (I2V_NODE_CAMERA_LORA, 1, inp.get("camera_strength", 0.0)),
-        (I2V_NODE_DETAILER_LORA, 0, "ic-lora-detailer" if inp.get("detailer_on") else "none"),
-        (I2V_NODE_DETAILER_LORA, 1, inp.get("detailer_strength", 0.0)),
-        (I2V_NODE_IC_LORA, 0, f"ic-lora-{inp.get('ic_lora', 'union')}"),
-        (I2V_NODE_IC_LORA, 1, inp.get("ic_strength", 0.0)),
-        (I2V_NODE_POSE_LORA, 0, "ic-lora-pose-control" if inp.get("pose_on") else "none"),
-        (I2V_NODE_POSE_LORA, 1, inp.get("pose_strength", 0.0)),
-    ]
-
-
-_T2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Diffusion (Stage 1)", 60),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-
-_I2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode image", 3),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 20),
-    Stage("Decode video", 10),
-]
-
-MODE_REGISTRY["t2v"] = Mode(
-    name="t2v", label="Text → Video", icon="📝",
-    parameterize_fn=_t2v_parameterize, stage_map=_T2V_STAGES,
-)
-MODE_REGISTRY["i2v"] = Mode(
-    name="i2v", label="Image → Video", icon="🖼",
-    parameterize_fn=_i2v_parameterize, stage_map=_I2V_STAGES,
-)
-```
-
-> **Note:** the node-id constants (e.g. `T2V_NODE_PROMPT = 240`) are placeholders to be replaced by the actual ids from `workflows/t2v.json`. After Task 7 generates the templates, capture the real ids by running:
-> ```bash
-> python3.11 -c "import json; w=json.load(open('workflows/t2v.json')); [print(n['id'], n['type'], n.get('title')) for n in w['nodes'] if n['type'] in ('CLIPTextEncode','mxSlider','INTConstant','Power Lora Loader (rgthree)','Any Switch (rgthree)')]"
-> ```
-> and replace each constant with the matching node id. This step is part of Step 4.
-
-- [ ] **Step 4: Capture real node ids and update constants**
-
-Run the inspection command above for both `t2v.json` and `i2v.json`. Replace the constants with the real ids. Re-read the test in Step 1 — it must still pass.
-
-- [ ] **Step 5: Run T2V/I2V tests**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v -k "t2v or i2v"`
-Expected: PASS for both T2V and I2V tests; existing skeleton tests still pass.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add modes.py tests/test_modes.py
-git commit -m "feat(modes): T2V + I2V parameterize_fn with stage maps"
-```
-
----
-
-### Task 12: `parameterize_fn` for A2V, Lipsync, Keyframe, Style
-
-**Files:**
-- Modify: `modes.py`
-- Modify: `tests/test_modes.py`
-
-- [ ] **Step 1: Append failing tests**
-
-```python
-# Append to tests/test_modes.py
-@pytest.mark.parametrize("mode_name", ["a2v", "lipsync", "keyframe", "style"])
-def test_remaining_modes_parameterize_validates(mode_name, canonical_inputs):
-    inputs = canonical_inputs[mode_name]
-    mode = modes.MODE_REGISTRY[mode_name]
-    patches = mode.parameterize_fn(inputs)
-    assert len(patches) > 0
-
-    wf = workflow.load_template(mode_name)
-    for patch in patches:
-        workflow.set_input(wf, *patch)
-    workflow.validate(wf)
-
-
-def test_a2v_parameterize_passes_audio_path(canonical_inputs):
-    patches = modes.MODE_REGISTRY["a2v"].parameterize_fn(canonical_inputs["a2v"])
-    assert canonical_inputs["a2v"]["audio"] in [p[2] for p in patches]
-
-
-def test_lipsync_parameterize_passes_image_and_audio(canonical_inputs):
-    patches = modes.MODE_REGISTRY["lipsync"].parameterize_fn(canonical_inputs["lipsync"])
-    values = [p[2] for p in patches]
-    assert canonical_inputs["lipsync"]["image"] in values
-    assert canonical_inputs["lipsync"]["audio"] in values
-
-
-def test_keyframe_parameterize_passes_two_frames(canonical_inputs):
-    patches = modes.MODE_REGISTRY["keyframe"].parameterize_fn(canonical_inputs["keyframe"])
-    values = [p[2] for p in patches]
-    assert canonical_inputs["keyframe"]["first_frame"] in values
-    assert canonical_inputs["keyframe"]["last_frame"] in values
-
-
-def test_style_parameterize_passes_input_video(canonical_inputs):
-    patches = modes.MODE_REGISTRY["style"].parameterize_fn(canonical_inputs["style"])
-    assert canonical_inputs["style"]["input_video"] in [p[2] for p in patches]
-```
-
-- [ ] **Step 2: Run tests to verify failures**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v`
-Expected: 5 fails on the new tests (KeyError for missing modes).
-
-- [ ] **Step 3: Implement A2V, Lipsync, Keyframe, Style**
-
-Append to `modes.py` (with node-id constants captured from each `workflows/<mode>.json` per the inspection technique in Task 11):
-
-```python
-# A2V template node ids
-A2V_NODE_PROMPT = ...           # capture from workflows/a2v.json
-A2V_NODE_AUDIO = ...            # VHS_LoadAudioUpload
-A2V_NODE_RESOLUTION = ...
-A2V_NODE_FRAMES = ...
-A2V_NODE_FPS = ...
-A2V_NODE_SEED = ...
-A2V_NODE_PRESET = ...
-A2V_NODE_AUDIO_CFG = ...
-
-# Lipsync template node ids
-LIPSYNC_NODE_PROMPT = ...
-LIPSYNC_NODE_IMAGE = ...
-LIPSYNC_NODE_AUDIO = ...
-LIPSYNC_NODE_IMAGE_STRENGTH = ...
-LIPSYNC_NODE_FRAMES = ...
-LIPSYNC_NODE_FPS = ...
-LIPSYNC_NODE_SEED = ...
-LIPSYNC_NODE_PRESET = ...
-
-# Keyframe template node ids
-KEYFRAME_NODE_PROMPT = ...
-KEYFRAME_NODE_FIRST = ...
-KEYFRAME_NODE_LAST = ...
-KEYFRAME_NODE_FRAMES = ...
-KEYFRAME_NODE_FPS = ...
-KEYFRAME_NODE_SEED = ...
-KEYFRAME_NODE_PRESET = ...
-
-# Style template node ids
-STYLE_NODE_PROMPT = ...
-STYLE_NODE_VIDEO = ...
-STYLE_NODE_IC_LORA = ...
-STYLE_NODE_FRAMES = ...
-STYLE_NODE_FPS = ...
-STYLE_NODE_SEED = ...
-STYLE_NODE_PRESET = ...
-
-
-def _a2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (A2V_NODE_PROMPT, 0, inp["prompt"]),
-        (A2V_NODE_AUDIO, 0, inp["audio"]),
-        (A2V_NODE_RESOLUTION, 0, inp["width"]),
-        (A2V_NODE_RESOLUTION, 1, inp["height"]),
-        (A2V_NODE_FRAMES, 0, inp["frames"]),
-        (A2V_NODE_FPS, 0, inp["fps"]),
-        (A2V_NODE_SEED, 0, inp["seed"]),
-        (A2V_NODE_PRESET, 0, inp["preset"]),
-        (A2V_NODE_AUDIO_CFG, 0, inp.get("audio_cfg", 7.0)),
-    ]
-
-
-def _lipsync_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (LIPSYNC_NODE_PROMPT, 0, inp["prompt"]),
-        (LIPSYNC_NODE_IMAGE, 0, inp["image"]),
-        (LIPSYNC_NODE_AUDIO, 0, inp["audio"]),
-        (LIPSYNC_NODE_IMAGE_STRENGTH, 0, inp.get("image_strength", 0.7)),
-        (LIPSYNC_NODE_FRAMES, 0, inp["frames"]),
-        (LIPSYNC_NODE_FPS, 0, inp["fps"]),
-        (LIPSYNC_NODE_SEED, 0, inp["seed"]),
-        (LIPSYNC_NODE_PRESET, 0, inp["preset"]),
-    ]
-
-
-def _keyframe_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (KEYFRAME_NODE_PROMPT, 0, inp["prompt"]),
-        (KEYFRAME_NODE_FIRST, 0, inp["first_frame"]),
-        (KEYFRAME_NODE_LAST, 0, inp["last_frame"]),
-        (KEYFRAME_NODE_FRAMES, 0, inp["frames"]),
-        (KEYFRAME_NODE_FPS, 0, inp["fps"]),
-        (KEYFRAME_NODE_SEED, 0, inp["seed"]),
-        (KEYFRAME_NODE_PRESET, 0, inp["preset"]),
-    ]
-
-
-def _style_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return [
-        (STYLE_NODE_PROMPT, 0, inp["prompt"]),
-        (STYLE_NODE_VIDEO, 0, inp["input_video"]),
-        (STYLE_NODE_IC_LORA, 0, f"ic-lora-{inp.get('ic_lora', 'motion-track')}"),
-        (STYLE_NODE_IC_LORA, 1, inp.get("ic_strength", 0.5)),
-        (STYLE_NODE_FRAMES, 0, inp["frames"]),
-        (STYLE_NODE_FPS, 0, inp["fps"]),
-        (STYLE_NODE_SEED, 0, inp["seed"]),
-        (STYLE_NODE_PRESET, 0, inp["preset"]),
-    ]
-
-
-_A2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode audio", 5),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-_LIPSYNC_STAGES = _A2V_STAGES + []
-_KEYFRAME_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode keyframes", 5),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-_STYLE_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode source video", 10),
-    Stage("Diffusion", 70),
-    Stage("Decode video", 15),
-]
-
-
-MODE_REGISTRY["a2v"] = Mode(
-    name="a2v", label="Audio → Video", icon="🎵",
-    parameterize_fn=_a2v_parameterize, stage_map=_A2V_STAGES,
-)
-MODE_REGISTRY["lipsync"] = Mode(
-    name="lipsync", label="Lipsync", icon="🗣",
-    parameterize_fn=_lipsync_parameterize, stage_map=_LIPSYNC_STAGES,
-)
-MODE_REGISTRY["keyframe"] = Mode(
-    name="keyframe", label="First / Last Frame", icon="🎞",
-    parameterize_fn=_keyframe_parameterize, stage_map=_KEYFRAME_STAGES,
-)
-MODE_REGISTRY["style"] = Mode(
-    name="style", label="Style Transfer", icon="🎨",
-    parameterize_fn=_style_parameterize, stage_map=_STYLE_STAGES,
-)
-```
-
-- [ ] **Step 4: Capture real node ids for the four new modes**
-
-Run the inspection command from Task 11 against `workflows/a2v.json`, `workflows/lipsync.json`, `workflows/keyframe.json`, `workflows/style.json`. Replace the `...` placeholders.
-
-- [ ] **Step 5: Run all mode tests**
-
-Run: `python3.11 -m pytest tests/test_modes.py -v`
-Expected: all tests pass for all six modes.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add modes.py tests/test_modes.py
-git commit -m "feat(modes): A2V + Lipsync + Keyframe + Style parameterize_fn"
-```
-
----
-
-## Phase 3 — Models
-
-### Task 13: `models.py` — `MODEL_REGISTRY`
-
-**Files:**
-- Create: `models.py`
-- Create: `tests/test_models.py`
-
-- [ ] **Step 1: Write the failing test**
-
-```python
-# tests/test_models.py
-"""Unit tests for models.py — MODEL_REGISTRY and ensure_models_for_mode."""
-import models
-
-
-def test_model_registry_resolves_known_files():
-    assert models.MODEL_REGISTRY["ltx-2.3-22b-distilled.safetensors"].repo_id == "Lightricks/LTX-2.3"
-    assert models.MODEL_REGISTRY["ltx-2.3-22b-distilled.safetensors"].subfolder == ""
-
-
-def test_model_registry_includes_gemma_shards():
-    for i in range(1, 6):
-        key = f"model-{i:05d}-of-00005.safetensors"
-        assert key in models.MODEL_REGISTRY
-        assert "gemma-3-12b-it" in models.MODEL_REGISTRY[key].repo_id
-```
-
-- [ ] **Step 2: Run test to verify failure**
-
-Run: `python3.11 -m pytest tests/test_models.py -v`
-Expected: `ModuleNotFoundError: No module named 'models'`.
-
-- [ ] **Step 3: Implement `MODEL_REGISTRY`**
-
-```python
-# models.py
-"""Model file registry: maps filename → (HuggingFace repo, subfolder).
-
-Lookups are by filename only — the same filename in two different repos is not
-supported. If that ever happens we'll qualify by ComfyUI loader-type.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class ModelEntry:
-    repo_id: str
-    subfolder: str = ""
-    comfy_type: str = "checkpoints"  # ComfyUI models/<comfy_type>/ subdirectory
-
-
-MODEL_REGISTRY: dict[str, ModelEntry] = {
-    # Main LTX 2.3 transformer + LoRAs + upscalers
-    "ltx-2.3-22b-distilled.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="checkpoints"
-    ),
-    "ltx-2.3-22b-dev.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="checkpoints"
-    ),
-    "ltx-2.3-spatial-upscaler-x2-1.0.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="upscale_models"
-    ),
-    "ltx-2.3-22b-distilled-lora-384.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="loras"
-    ),
-    # Gemma 3 12B (5 shards + tokenizer/preprocessor)
-    **{
-        f"model-{i:05d}-of-00005.safetensors": ModelEntry(
-            "google/gemma-3-12b-it-qat-q4_0-unquantized",
-            comfy_type="text_encoders",
-            subfolder="gemma-3-12b-it",
-        )
-        for i in range(1, 6)
-    },
-    "model.safetensors.index.json": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    "tokenizer.model": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    "preprocessor_config.json": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    # Kijai's LTX 2.3 ComfyUI assets
-    "LTX23_video_vae_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", comfy_type="vae"
-    ),
-    "LTX23_audio_vae_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", comfy_type="vae"
-    ),
-    "ltx-2.3_text_projection_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", comfy_type="text_encoders"
-    ),
-    # IC-LoRAs
-    "ltx-2.3-22b-ic-lora-union-control-ref0.5.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control", comfy_type="loras"
-    ),
-    "ltx-2.3-22b-ic-lora-motion-track-control-ref0.5.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3-22b-IC-LoRA-Motion-Track-Control", comfy_type="loras"
-    ),
-    "ltx-2-19b-ic-lora-detailer.safetensors": ModelEntry(
-        "Lightricks/LTX-2-19b-IC-LoRA-Detailer", comfy_type="loras"
-    ),
-    "ltx-2-19b-ic-lora-pose-control.safetensors": ModelEntry(
-        "Lightricks/LTX-2-19b-IC-LoRA-Pose-Control", comfy_type="loras"
-    ),
-    # Camera-control LoRAs (one repo each)
-    **{
-        f"ltx-2-19b-lora-camera-control-{movement}.safetensors": ModelEntry(
-            f"Lightricks/LTX-2-19b-LoRA-Camera-Control-{movement.replace('-', '-').title()}",
-            comfy_type="loras",
-        )
-        for movement in (
-            "static",
-            "dolly-in",
-            "dolly-out",
-            "dolly-left",
-            "dolly-right",
-            "jib-up",
-            "jib-down",
-        )
-    },
-}
-```
-
-- [ ] **Step 4: Run test to verify pass**
-
-Run: `python3.11 -m pytest tests/test_models.py -v`
-Expected: 2 tests pass.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add models.py tests/test_models.py
-git commit -m "feat(models): MODEL_REGISTRY mapping filenames to HF repos"
-```
-
----
-
-### Task 14: `models.py` — `walk_workflow_for_models`
-
-**Files:**
-- Modify: `models.py`
-- Modify: `tests/test_models.py`
-
-- [ ] **Step 1: Append failing tests**
-
-```python
-# Append to tests/test_models.py
-import workflow
-
-def test_walk_workflow_for_models_finds_t2v_loaders():
-    wf = workflow.load_template("t2v")
-    needed = models.walk_workflow_for_models(wf)
-    # T2V needs at minimum the distilled transformer and gemma shards
-    assert "ltx-2.3-22b-distilled.safetensors" in needed
-    assert any(name.startswith("model-") and name.endswith(".safetensors") for name in needed)
-```
-
-- [ ] **Step 2: Run test to verify failure**
-
-Run: `python3.11 -m pytest tests/test_models.py::test_walk_workflow_for_models_finds_t2v_loaders -v`
-Expected: `AttributeError: module 'models' has no attribute 'walk_workflow_for_models'`.
-
-- [ ] **Step 3: Implement `walk_workflow_for_models`**
-
-Append to `models.py`:
-
-```python
-LOADER_NODE_TYPES: tuple[str, ...] = (
-    "CheckpointLoaderSimple",
-    "UNETLoader",
-    "UnetLoaderGGUF",
-    "VAELoader",
-    "VAELoaderKJ",
-    "LoraLoader",
-    "Power Lora Loader (rgthree)",
-    "LTXVGemmaCLIPModelLoader",
-    "LatentUpscaleModelLoader",
-    "DualCLIPLoader",
-)
-
-
-def walk_workflow_for_models(workflow: dict) -> set[str]:
-    """Return the set of model filenames referenced by loader nodes in the workflow.
-
-    Pulls filenames from nodes whose `type` matches a known loader. Filenames are
-    typically in `widgets_values[0]` (CheckpointLoaderSimple) or in nested rows
-    (Power Lora Loader). Falls back to scanning all string-valued widget entries
-    for `*.safetensors` / `*.gguf`.
-    """
-    needed: set[str] = set()
-    for node in workflow.get("nodes", []):
-        if node.get("type") not in LOADER_NODE_TYPES:
-            continue
-        widgets = node.get("widgets_values") or []
-        for value in _flatten_widget_values(widgets):
-            if isinstance(value, str) and (
-                value.endswith(".safetensors") or value.endswith(".gguf")
-                or value == "tokenizer.model" or value.endswith(".json")
-            ):
-                needed.add(value)
-    return needed
-
-
-def _flatten_widget_values(values):
-    for v in values:
-        if isinstance(v, (list, tuple)):
-            yield from _flatten_widget_values(v)
-        elif isinstance(v, dict):
-            yield from _flatten_widget_values(list(v.values()))
-        else:
-            yield v
-```
-
-- [ ] **Step 4: Run all model tests**
-
-Run: `python3.11 -m pytest tests/test_models.py -v`
-Expected: 3 tests pass.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add models.py tests/test_models.py
-git commit -m "feat(models): walk_workflow_for_models scans loader nodes"
-```
-
----
-
-### Task 15: `models.py` — `ensure_models_for_mode`
-
-**Files:**
-- Modify: `models.py`
-- Modify: `tests/test_models.py`
-
-- [ ] **Step 1: Append failing test**
-
-```python
-# Append to tests/test_models.py
-import pathlib
-
-def test_ensure_models_creates_symlinks_local(tmp_path, monkeypatch, fake_hf_cache):
-    """In local mode, ensure_models creates symlinks from comfy/models → HF cache."""
-    monkeypatch.setenv("HF_HUB_CACHE", str(fake_hf_cache))
-    monkeypatch.setattr(models, "_on_spaces", lambda: False)
-
-    comfy_models = tmp_path / "comfyui" / "models"
-    monkeypatch.setattr(models, "_comfy_models_dir", lambda: comfy_models)
-
-    needed = {
-        "ltx-2.3-22b-distilled.safetensors",
-        "model-00001-of-00005.safetensors",
-    }
-    events = list(models.ensure_models(needed))
-
-    # Each requested file should now have a symlink in comfyui/models/<type>/
-    assert (comfy_models / "checkpoints" / "ltx-2.3-22b-distilled.safetensors").is_symlink()
-    assert (comfy_models / "text_encoders" / "gemma-3-12b-it"
-            / "model-00001-of-00005.safetensors").is_symlink()
-    # No DownloadEvents because all files were already in cache
-    assert all(e.mb_done == e.mb_total for e in events)
-```
-
-- [ ] **Step 2: Run test to verify failure**
-
-Run: `python3.11 -m pytest tests/test_models.py::test_ensure_models_creates_symlinks_local -v`
-Expected: `AttributeError: module 'models' has no attribute 'ensure_models'`.
-
-- [ ] **Step 3: Implement `ensure_models`**
-
-Append to `models.py`:
-
-```python
-import os
-from collections.abc import Iterator
-from dataclasses import dataclass
-
-from huggingface_hub import hf_hub_download
-
-
-@dataclass
-class DownloadEvent:
-    filename: str
-    mb_done: float
-    mb_total: float
-
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-def _comfy_models_dir() -> pathlib.Path:
-    raw = os.environ.get("COMFY_MODELS_DIR")
-    if raw:
-        return pathlib.Path(raw)
-    if _on_spaces():
-        return pathlib.Path("/data/models")
-    return pathlib.Path(__file__).parent / "comfyui" / "models"
-
-
-def ensure_models(filenames: set[str]) -> Iterator[DownloadEvent]:
-    """Ensure each requested model is materialized in comfyui/models/<type>/.
-
-    Local mode: hf_hub_download into the user's HF cache; symlink to comfyui/models/.
-    Spaces mode: hf_hub_download with cache_dir=/data; comfyui/models/ symlinks
-    point into /data.
-
-    Yields DownloadEvent on each file (mb_done==mb_total when already cached).
-    """
-    comfy_models = _comfy_models_dir()
-    cache_dir = pathlib.Path(os.environ.get("HF_HUB_CACHE", pathlib.Path.home() / ".cache" / "huggingface" / "hub"))
-
-    for filename in filenames:
-        if filename not in MODEL_REGISTRY:
-            raise KeyError(f"unknown model file {filename!r} — add it to MODEL_REGISTRY")
-        entry = MODEL_REGISTRY[filename]
-
-        # Resolve source: hf_hub_download returns the cache path (or downloads).
-        try:
-            source = pathlib.Path(
-                hf_hub_download(
-                    repo_id=entry.repo_id,
-                    filename=filename,
-                    cache_dir=str(cache_dir),
-                    local_dir=None,
-                )
-            )
-            size_mb = source.stat().st_size / 1024 / 1024
-            yield DownloadEvent(filename, size_mb, size_mb)
-        except Exception:
-            # Fall back to scanning the cache for a placeholder file (test mode).
-            candidates = list(cache_dir.rglob(filename))
-            if not candidates:
-                raise
-            source = candidates[0]
-            yield DownloadEvent(filename, 0.0, 0.0)
-
-        # Build symlink target inside comfy_models
-        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
-
-        if dest.is_symlink() or dest.exists():
-            dest.unlink()
-        dest.symlink_to(source)
-
-
-def ensure_models_for_mode(mode: str) -> Iterator[DownloadEvent]:
-    """Convenience: walk a mode's workflow and ensure all referenced models exist."""
-    import workflow as workflow_module  # local import to avoid cycle at import time
-    wf = workflow_module.load_template(mode)
-    needed = walk_workflow_for_models(wf)
-    yield from ensure_models(needed)
-```
-
-- [ ] **Step 4: Run all model tests**
-
-Run: `python3.11 -m pytest tests/test_models.py -v`
-Expected: 4 tests pass.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add models.py tests/test_models.py
-git commit -m "feat(models): ensure_models — local symlinks + Spaces /data downloads"
-```
-
----
-
-### Task 16: `tools/refresh_models.py`
-
-**Files:**
-- Create: `tools/refresh_models.py`
-
-- [ ] **Step 1: Implement `tools/refresh_models.py`**
-
-```python
-"""Materialize all LTX 2.3 model files for every mode by walking each template."""
-from __future__ import annotations
-
-import sys
-
-import models
-from workflow import VALID_MODES
-
-
-def main() -> int:
-    needed: set[str] = set()
-    for mode in VALID_MODES:
-        try:
-            from workflow import load_template
-            wf = load_template(mode)
-            needed.update(models.walk_workflow_for_models(wf))
-        except FileNotFoundError:
-            print(f"  ⚠ workflows/{mode}.json missing — run tools/extract_modes.py first")
-    if not needed:
-        print("Nothing to do.")
-        return 0
-    print(f"Materializing {len(needed)} model files...")
-    for event in models.ensure_models(needed):
-        marker = "✓" if event.mb_done >= event.mb_total else "↓"
-        print(f"  {marker} {event.filename}  {event.mb_done:.1f}/{event.mb_total:.1f} MB")
-    print("Done.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
-```
-
-- [ ] **Step 2: Smoke-run the script**
-
-Run: `python3.11 tools/refresh_models.py 2>&1 | head -40`
-Expected: lists 30+ files, downloads any missing (or skips if already cached). Symlinks materialize in `comfyui/models/`.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add tools/refresh_models.py
-git commit -m "feat(tools): refresh_models materializes every required model"
-```
-
----
-
-## Phase 4 — Backend
-
-### Task 17: `backend.py` — skeleton + ComfyUI loading
-
-**Files:**
-- Create: `backend.py`
-- Create: `tests/test_backend.py`
-
-- [ ] **Step 1: Write the failing test**
-
-```python
-# tests/test_backend.py
-"""Backend tests — most are smoke / structural since the real work is GPU."""
-import pytest
-
-import backend
-
-
-def test_backend_class_exists():
-    assert hasattr(backend, "ComfyUILibraryBackend")
-
-
-def test_progress_event_dataclasses_exist():
-    assert hasattr(backend, "DownloadEvent")
-    assert hasattr(backend, "ProgressEvent")
-    assert hasattr(backend, "OutputEvent")
-    assert hasattr(backend, "ErrorEvent")
-```
-
-- [ ] **Step 2: Run test to verify failure**
-
-Run: `python3.11 -m pytest tests/test_backend.py -v`
-Expected: `ModuleNotFoundError: No module named 'backend'`.
-
-- [ ] **Step 3: Implement skeleton**
-
-```python
-# backend.py
-"""ComfyUI library-mode backend.
-
-Single-process, single-implementation. The @spaces.GPU decorator is the only
-divergence between local and HF Spaces deployment.
-"""
-from __future__ import annotations
-
-import asyncio
-import os
-import pathlib
-import sys
-from collections.abc import AsyncIterator
-from dataclasses import dataclass, field
-from typing import Any, Optional
-
-import models
-
-
-@dataclass
-class DownloadEvent:
-    filename: str
-    mb_done: float
-    mb_total: float
-
-
-@dataclass
-class ProgressEvent:
-    stage: int
-    stage_label: str
-    step: int
-    total_steps: int
-
-
-@dataclass
-class OutputEvent:
-    video_path: str
-    audio_path: Optional[str] = None
-    meta: dict = field(default_factory=dict)
-
-
-@dataclass
-class ErrorEvent:
-    category: str  # "oom" | "zerogpu_timeout" | "execution" | "interrupt"
-    message: str
-    stage: Optional[int] = None
-    traceback: str = ""
-
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-def _comfy_dir() -> pathlib.Path:
-    if _on_spaces():
-        return pathlib.Path("/data/comfyui")
-    return pathlib.Path(__file__).parent / "comfyui"
-
-
-class ComfyUILibraryBackend:
-    """Wraps comfy.execution.PromptExecutor for in-process workflow execution."""
-
-    def __init__(self) -> None:
-        self._comfy_dir = _comfy_dir()
-        if not self._comfy_dir.exists():
-            raise RuntimeError(
-                f"ComfyUI not found at {self._comfy_dir}. "
-                f"Local: run `bash setup.sh`. Spaces: see app.py:_bootstrap()."
-            )
-        if str(self._comfy_dir) not in sys.path:
-            sys.path.insert(0, str(self._comfy_dir))
-
-        # Defer comfy imports until the path is set up.
-        # NOTE: ComfyUI ships PromptExecutor in the top-level `execution.py`
-        # module, NOT under `comfy.execution`. Same for `nodes`. Both must be
-        # imported AFTER the sys.path insert above.
-        import asyncio
-
-        import comfy.cli_args  # noqa: F401 — side-effect: registers CLI flags
-        import execution  # top-level module — provides PromptExecutor
-        import nodes  # top-level module — provides init_extra_nodes (async)
-
-        # init_extra_nodes is an async function in modern ComfyUI; run it once.
-        asyncio.run(nodes.init_extra_nodes())  # discover custom_nodes/
-        self._executor = execution.PromptExecutor(server_instance=None)
-
-    def __repr__(self) -> str:
-        return f"ComfyUILibraryBackend(comfy_dir={self._comfy_dir!r})"
-```
-
-- [ ] **Step 4: Run skeleton tests**
-
-Run: `python3.11 -m pytest tests/test_backend.py -v`
-Expected: 2 tests pass (the structural ones — instantiation needs comfyui/ to exist, which it will after Task 5).
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add backend.py tests/test_backend.py
-git commit -m "feat(backend): ComfyUILibraryBackend skeleton + event dataclasses"
-```
-
----
-
-### Task 18: `backend.py` — `submit()` async generator
-
-**Files:**
-- Modify: `backend.py`
-
-- [ ] **Step 1: Append `submit()` and `_run_in_thread`**
-
-```python
-# Append to backend.py
-import threading
-import traceback as tb_mod
-from collections.abc import Iterable
-
-import torch
-
-
-class ComfyUILibraryBackend:  # extending — shown in full above; appending methods only
-
-    async def submit(
-        self, mode: str, workflow: dict, gpu_duration: int = 120
-    ) -> AsyncIterator[Any]:
-        """Run a workflow end-to-end. Yields Download/Progress/Output/Error events."""
-        # Pre-flight: ensure all model files exist.
-        try:
-            needed = models.walk_workflow_for_models(workflow)
-            for download_event in models.ensure_models(needed):
-                yield download_event
-        except Exception as e:
-            yield ErrorEvent(category="download", message=str(e), traceback=tb_mod.format_exc())
-            return
-
-        # Run the inference in a worker thread; pass progress events through a queue.
-        queue: asyncio.Queue = asyncio.Queue()
-        loop = asyncio.get_running_loop()
-
-        def _push(event: Any) -> None:
-            asyncio.run_coroutine_threadsafe(queue.put(event), loop)
-
-        def _hook(value: int, total: int, _preview=None) -> None:
-            _push(ProgressEvent(stage=0, stage_label="diffusion",
-                                step=int(value), total_steps=int(total)))
-
-        def _worker() -> None:
-            import comfy.utils
-            saved_hook = getattr(comfy.utils, "PROGRESS_BAR_HOOK", None)
-            try:
-                # Use the public setter; it writes the same global the
-                # ProgressBar class reads, but is the documented API.
-                comfy.utils.set_progress_bar_global_hook(_hook)
-                self._executor.execute(
-                    workflow,
-                    prompt_id="ltx23-aio",
-                    extra_data={"client_id": "ltx23-aio"},
-                    execute_outputs=[],
-                )
-                # PromptExecutor writes output files via VHS_VideoCombine; we read its
-                # history to find the most recent saved video.
-                outputs = list(self._executor.outputs.values())
-                video_path = _first_video_path(outputs) or ""
-                _push(OutputEvent(video_path=video_path))
-            except Exception as exc:
-                _push(ErrorEvent(category=_classify(exc), message=str(exc),
-                                 traceback=tb_mod.format_exc()))
-            finally:
-                comfy.utils.set_progress_bar_global_hook(saved_hook)
-                _free_memory()
-                _push(None)  # sentinel: stop the consumer
-
-        if _on_spaces():
-            import spaces
-            execute = spaces.GPU(duration=gpu_duration)(_worker)
-            thread = threading.Thread(target=execute, daemon=True)
-        else:
-            thread = threading.Thread(target=_worker, daemon=True)
-        thread.start()
-
-        while True:
-            event = await queue.get()
-            if event is None:
-                return
-            yield event
-
-
-def _classify(exc: Exception) -> str:
-    name = type(exc).__name__.lower()
-    if "outofmemory" in name or "cuda out of memory" in str(exc).lower():
-        return "oom"
-    if "interrupt" in name:
-        return "interrupt"
-    return "execution"
-
-
-def _free_memory() -> None:
-    try:
-        import comfy.model_management as mm
-        mm.unload_all_models()
-    except Exception:
-        pass
-    try:
-        if torch.backends.mps.is_available():
-            torch.mps.empty_cache()
-    except Exception:
-        pass
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-    except Exception:
-        pass
-
-
-def _first_video_path(outputs: Iterable) -> Optional[str]:
-    """Find the first .mp4 path emitted by VHS_VideoCombine in PromptExecutor outputs."""
-    for output in outputs:
-        if not isinstance(output, dict):
-            continue
-        for value in output.values():
-            if isinstance(value, list):
-                for item in value:
-                    if isinstance(item, dict) and "filename" in item:
-                        fn = item["filename"]
-                        if fn.endswith((".mp4", ".webm", ".mov")):
-                            return item.get("fullpath", fn)
-    return None
-```
-
-- [ ] **Step 2: Add an interrupt method**
-
-Append to `ComfyUILibraryBackend`:
-
-```python
-    def interrupt(self) -> None:
-        """Cancel the currently running workflow (if any)."""
-        try:
-            import comfy.model_management as mm
-            mm.interrupt_current_processing()
-        except Exception:
-            pass
-```
-
-- [ ] **Step 3: Sanity-check the file imports cleanly**
-
-Run: `python3.11 -c "import backend; print(backend.ComfyUILibraryBackend.__doc__)"`
-Expected: prints the docstring (or fails with `RuntimeError: ComfyUI not found` — which means the path is wired but ComfyUI is missing; that's a Task-5 concern).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add backend.py
-git commit -m "feat(backend): submit() async generator with progress hooks + ZeroGPU"
-```
-
----
-
-## Phase 5 — UI components
-
-### Task 19: `ui.py` — `preset_bar` + `status_banner`
-
-**Files:**
-- Create: `ui.py`
-
-- [ ] **Step 1: Implement `preset_bar` and `status_banner`**
-
-```python
-# ui.py
-"""Reusable Gradio components shared across modes."""
-from __future__ import annotations
-
-import gradio as gr
-
-
-def preset_bar(label: str = "Preset") -> gr.Radio:
-    """Fast / Balanced / Quality radio. Use as a single component."""
-    return gr.Radio(
-        choices=["Fast", "Balanced", "Quality"],
-        value="Balanced",
-        label=label,
-        container=True,
-        info="Fast: distilled 8 steps · Balanced: two-stage 30+4 · Quality: HQ res_2s sampler",
-    )
-
-
-def status_banner() -> gr.HTML:
-    """Status banner: stage chips + progress + memory."""
-    return gr.HTML(
-        value=_render_idle(),
-        elem_classes=["status-banner"],
-    )
-
-
-def _render_idle() -> str:
-    return (
-        '<div class="status-card status-idle">'
-        '<div class="status-row"><span class="status-dot"></span>'
-        '<span class="status-label">Idle</span></div></div>'
-    )
-
-
-def render_status(
-    stage_index: int,
-    stage_label: str,
-    step: int,
-    total_steps: int,
-    elapsed_s: float,
-    eta_s: float,
-    memory_text: str = "",
-) -> str:
-    """Render a status banner HTML string for the current event."""
-    pct = 0 if total_steps <= 0 else int(100 * step / total_steps)
-    return (
-        f'<div class="status-card">'
-        f'  <div class="status-row">'
-        f'    <span class="status-stage">Stage {stage_index} · {stage_label}</span>'
-        f'    <span class="status-meta">Step {step}/{total_steps} · '
-        f'      {_fmt_secs(elapsed_s)} elapsed · ~{_fmt_secs(eta_s)} remaining</span>'
-        f'  </div>'
-        f'  <div class="status-bar"><div class="status-fill" style="width:{pct}%"></div></div>'
-        f'  <div class="status-mem">{memory_text}</div>'
-        f'</div>'
-    )
-
-
-def _fmt_secs(secs: float) -> str:
-    secs = int(max(0, secs))
-    if secs < 60:
-        return f"{secs}s"
-    return f"{secs // 60}m {secs % 60}s"
-```
-
-- [ ] **Step 2: Smoke-import**
-
-Run: `python3.11 -c "import ui; print(ui.render_status(2, 'Diffusion', 18, 30, 60, 100, 'MPS · 47 GB free'))"`
-Expected: a multi-line HTML string is printed.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add ui.py
-git commit -m "feat(ui): preset_bar + status_banner components"
-```
-
----
-
-### Task 20: `ui.py` — `lora_chrome` (categorized)
-
-**Files:**
-- Modify: `ui.py`
-
-- [ ] **Step 1: Append `lora_chrome`**
-
-```python
-# Append to ui.py
-from dataclasses import dataclass
-
-
-CAMERA_LORAS: list[str] = [
-    "none", "static", "dolly-in", "dolly-out", "dolly-left", "dolly-right",
-    "jib-up", "jib-down",
-]
-
-IC_LORAS_BY_MODE: dict[str, list[str]] = {
-    "t2v": [],
-    "a2v": [],
-    "i2v": ["union", "pose-control"],
-    "lipsync": ["pose-control"],
-    "keyframe": ["union"],
-    "style": ["motion-track", "union"],
-}
-
-
-@dataclass
-class LoRAComponents:
-    camera_lora: gr.Dropdown
-    camera_strength: gr.Slider
-    detailer_on: gr.Checkbox
-    detailer_strength: gr.Slider
-    ic_lora: gr.Dropdown | None
-    ic_strength: gr.Slider | None
-    pose_on: gr.Checkbox | None
-
-
-def lora_chrome(mode: str) -> LoRAComponents:
-    """Categorized LoRA controls for a given mode (camera + detailer + IC + pose).
-
-    Only LoRAs relevant to the mode are surfaced. Distilled LoRA is auto-applied
-    by the workflow when the Fast preset is chosen — not exposed here.
-    """
-    with gr.Group():
-        gr.Markdown("**📷 Camera Movement**")
-        camera_lora = gr.Dropdown(
-            choices=CAMERA_LORAS, value="none", label="Camera",
-            info="Mutually exclusive — pick one camera direction or none.",
-        )
-        camera_strength = gr.Slider(
-            minimum=0.0, maximum=1.5, value=0.8, step=0.05,
-            label="Camera strength", visible=True,
-        )
-
-    with gr.Group():
-        gr.Markdown("**✨ Detailer**")
-        detailer_on = gr.Checkbox(label="Apply IC-LoRA-Detailer", value=False)
-        detailer_strength = gr.Slider(
-            minimum=0.0, maximum=1.0, value=0.5, step=0.05, label="Detailer strength",
-        )
-
-    ic_lora = ic_strength = pose_on = None
-    ic_options = IC_LORAS_BY_MODE.get(mode, [])
-    if ic_options:
-        with gr.Group():
-            gr.Markdown("**🎯 Image Conditioning**")
-            ic_lora = gr.Dropdown(
-                choices=["none"] + ic_options,
-                value=ic_options[0] if ic_options else "none",
-                label="IC-LoRA",
-            )
-            ic_strength = gr.Slider(
-                minimum=0.0, maximum=1.0, value=0.5, step=0.05, label="IC strength",
-            )
-
-    if mode in ("i2v", "lipsync"):
-        with gr.Group():
-            gr.Markdown("**🚶 Pose Control**")
-            pose_on = gr.Checkbox(label="Apply IC-LoRA-Pose-Control", value=False)
-
-    return LoRAComponents(
-        camera_lora=camera_lora,
-        camera_strength=camera_strength,
-        detailer_on=detailer_on,
-        detailer_strength=detailer_strength,
-        ic_lora=ic_lora,
-        ic_strength=ic_strength,
-        pose_on=pose_on,
-    )
-```
-
-- [ ] **Step 2: Smoke-import**
-
-Run: `python3.11 -c "import ui; print(ui.IC_LORAS_BY_MODE)"`
-Expected: prints the IC LoRA mapping dict.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add ui.py
-git commit -m "feat(ui): categorized lora_chrome — camera dropdown, detailer, IC, pose"
-```
-
----
-
-## Phase 6 — Gradio app
-
-### Task 21: `app.py` — bootstrap + sidebar shell
-
-**Files:**
-- Create: `app.py`
-
-- [ ] **Step 1: Write `app.py` shell**
-
-```python
-# app.py
-"""LTX 2.3 All-in-One — Gradio entry point."""
-from __future__ import annotations
-
-import os
-import pathlib
-import sys
-
-import gradio as gr
-
-import modes
-import ui
-
-
-# ---------------------------------------------------------------------------
-# Bootstrap — runs once on cold start.
-# ---------------------------------------------------------------------------
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-COMFYUI_REPO = "https://github.com/comfyanonymous/ComfyUI.git"
-# Pinned to the same commit the local git submodule uses (set in Task 5).
-# Override via env var only when intentionally testing a different ComfyUI version.
-COMFYUI_COMMIT = os.environ.get(
-    "LTX23_AIO_COMFYUI_COMMIT",
-    "eb0686bbb60c83e44c3a3e4f7defd0f589cfef10",
-)
-
-CUSTOM_NODES_PINNED: list[tuple[str, str]] = [
-    ("https://github.com/Lightricks/ComfyUI-LTXVideo.git", "main"),
-    ("https://github.com/kijai/ComfyUI-KJNodes.git", "main"),
-    ("https://github.com/rgthree/rgthree-comfy.git", "main"),
-    ("https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git", "main"),
-    ("https://github.com/pythongosssss/ComfyUI-Custom-Scripts.git", "main"),
-]
-
-
-def _git_clone(url: str, dst: pathlib.Path, ref: str) -> None:
-    import subprocess
-    subprocess.check_call(["git", "clone", "--depth", "1", "--branch", ref, url, str(dst)])
-
-
-def _bootstrap() -> None:
-    on_spaces = _on_spaces()
-    comfy_dir = pathlib.Path("/data/comfyui" if on_spaces else "comfyui")
-
-    if on_spaces and not comfy_dir.exists():
-        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:
-            name = node_url.rstrip(".git").rsplit("/", 1)[-1]
-            _git_clone(node_url, comfy_dir / "custom_nodes" / name, ref=node_ref)
-        # Install custom node deps
-        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)])
-
-    if str(comfy_dir) not in sys.path:
-        sys.path.insert(0, str(comfy_dir))
-    os.environ.setdefault(
-        "COMFY_MODELS_DIR",
-        str(pathlib.Path("/data/models") if on_spaces else (comfy_dir / "models")),
-    )
-
-
-_bootstrap()
-
-
-# ---------------------------------------------------------------------------
-# Gradio app
-# ---------------------------------------------------------------------------
-
-def build_app() -> gr.Blocks:
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="LTX 2.3 All-in-One",
-        css=_CUSTOM_CSS,
-    ) as app:
-        gr.Markdown("# ⚡ LTX 2.3 All-in-One")
-        with gr.Row():
-            with gr.Column(scale=1, min_width=200):
-                _render_sidebar()
-            with gr.Column(scale=4):
-                _render_mode_panels()
-    return app
-
-
-def _render_sidebar() -> None:
-    gr.Markdown("### Modes")
-    for name, mode in modes.MODE_REGISTRY.items():
-        gr.Markdown(f"- {mode.icon} {mode.label}")
-    gr.Markdown("---\n### Models")
-    gr.Button("Unload all models", variant="secondary")
-
-
-def _render_mode_panels() -> None:
-    with gr.Tabs():
-        for name, mode in modes.MODE_REGISTRY.items():
-            with gr.Tab(label=f"{mode.icon} {mode.label}"):
-                gr.Markdown(f"## {mode.label}")
-                gr.Markdown(f"_(Mode `{name}` form goes here — built in Task 22.)_")
-
-
-_CUSTOM_CSS = """
-.status-card { padding: 14px 16px; border-radius: 10px; background: rgba(255,255,255,0.04); border: 1px solid rgba(255,255,255,0.08); }
-.status-row { display: flex; gap: 14px; align-items: center; margin-bottom: 8px; }
-.status-stage { font-weight: 600; }
-.status-meta { font-size: 12px; opacity: 0.75; }
-.status-bar { height: 6px; background: rgba(255,255,255,0.08); border-radius: 99px; overflow: hidden; }
-.status-fill { height: 100%; background: linear-gradient(90deg,#6ea8fe,#8de9fe); transition: width .3s; }
-.status-mem { font-size: 11px; opacity: 0.6; margin-top: 6px; font-family: ui-monospace, monospace; }
-"""
-
-
-if __name__ == "__main__":
-    app = build_app()
-    app.launch(server_name="0.0.0.0", server_port=7860)
-```
-
-- [ ] **Step 2: Run the shell**
-
-Run: `python3.11 app.py 2>&1 | head -10` — Ctrl-C after a few seconds.
-Expected: "Running on local URL: http://0.0.0.0:7860". Open the URL; you see the sidebar with mode names and tabs at the top, both empty.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(app): Gradio shell with sidebar nav and empty mode tabs"
-```
-
----
-
-### Task 22: `app.py` — per-mode forms
-
-**Files:**
-- Modify: `app.py`
-
-- [ ] **Step 1: Replace `_render_mode_panels` with per-mode forms**
-
-```python
-# Replace the existing _render_mode_panels and add helpers
-def _render_mode_panels() -> dict[str, dict]:
-    """Render one form per mode. Returns the component handles keyed by mode."""
-    handles: dict[str, dict] = {}
-    with gr.Tabs() as tabs:
-        for name, mode in modes.MODE_REGISTRY.items():
-            with gr.Tab(label=f"{mode.icon} {mode.label}"):
-                handles[name] = _render_one_mode(name)
-    return handles
-
-
-def _render_one_mode(name: str) -> dict:
-    """Render a per-mode form. Returns component handles for the generate handler."""
-    mode = modes.MODE_REGISTRY[name]
-    handles: dict = {"mode": name}
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            handles["prompt"] = gr.Textbox(label="Prompt", lines=4, placeholder="Describe the shot...")
-
-            # Mode-specific media inputs
-            if name == "i2v":
-                handles["image"] = gr.Image(label="Source image", type="filepath")
-            elif name == "a2v":
-                handles["audio"] = gr.Audio(label="Source audio", type="filepath")
-            elif name == "lipsync":
-                handles["image"] = gr.Image(label="Portrait", type="filepath")
-                handles["audio"] = gr.Audio(label="Speech audio", type="filepath")
-            elif name == "keyframe":
-                handles["first_frame"] = gr.Image(label="First frame", type="filepath")
-                handles["last_frame"] = gr.Image(label="Last frame", type="filepath")
-            elif name == "style":
-                handles["input_video"] = gr.Video(label="Source video")
-
-            handles["preset"] = ui.preset_bar()
-            with gr.Row():
-                handles["width"] = gr.Slider(256, 1280, value=512, step=32, label="Width")
-                handles["height"] = gr.Slider(256, 1280, value=768, step=32, label="Height")
-            with gr.Row():
-                handles["frames"] = gr.Slider(9, 121, value=81, step=8, label="Frames (8k+1)")
-                handles["fps"] = gr.Slider(8, 30, value=24, step=1, label="FPS")
-            handles["seed"] = gr.Number(label="Seed", value=42, precision=0)
-
-            with gr.Accordion("Advanced ▾", open=False):
-                handles["lora"] = ui.lora_chrome(name)
-                handles["negative_prompt"] = gr.Textbox(label="Negative prompt", lines=2)
-
-            handles["generate_btn"] = gr.Button("▶ Generate", variant="primary", size="lg")
-
-        with gr.Column(scale=2):
-            handles["status"] = ui.status_banner()
-            handles["video_out"] = gr.Video(label="Output", autoplay=True)
-            handles["history"] = gr.Markdown("")
-
-    return handles
-```
-
-- [ ] **Step 2: Wire `_render_mode_panels` return into `build_app`**
-
-Modify `build_app` to capture the handles:
-
-```python
-def build_app() -> gr.Blocks:
-    with gr.Blocks(theme=gr.themes.Soft(), title="LTX 2.3 All-in-One", css=_CUSTOM_CSS) as app:
-        gr.Markdown("# ⚡ LTX 2.3 All-in-One")
-        with gr.Row():
-            with gr.Column(scale=1, min_width=200):
-                _render_sidebar()
-            with gr.Column(scale=4):
-                handles = _render_mode_panels()
-        # Generate-handler wiring deferred to Task 23.
-    return app
-```
-
-- [ ] **Step 3: Run the app**
-
-Run: `python3.11 app.py` — Ctrl-C after testing.
-Expected: each tab now shows the mode-specific form with media inputs, preset bar, sliders, advanced accordion, generate button, status banner, and video output. Buttons don't do anything yet.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(app): per-mode forms with media inputs, presets, advanced accordion"
-```
-
----
-
-### Task 23: `app.py` — generate handler
-
-**Files:**
-- Modify: `app.py`
-
-- [ ] **Step 1: Implement `on_generate` and wire it**
-
-```python
-# Append to app.py — after _render_one_mode
-
-import time
-from typing import Any
-
-import workflow as wf_module
-import backend as backend_module
-
-_BACKEND: backend_module.ComfyUILibraryBackend | None = None
-
-
-def _get_backend() -> backend_module.ComfyUILibraryBackend:
-    global _BACKEND
-    if _BACKEND is None:
-        _BACKEND = backend_module.ComfyUILibraryBackend()
-    return _BACKEND
-
-
-PRESET_DURATION = {"Fast": 60, "Balanced": 120, "Quality": 300}
-
-
-async def _on_generate(mode_name: str, **inputs: Any):
-    """Generate handler — async generator yielding (status_html, video_path)."""
-    mode = modes.MODE_REGISTRY[mode_name]
-
-    # Translate UI inputs into the parameterize_fn input dict.
-    params: dict[str, Any] = {
-        "prompt": inputs.get("prompt", ""),
-        "negative_prompt": inputs.get("negative_prompt", ""),
-        "preset": inputs.get("preset", "Balanced").lower(),
-        "width": int(inputs.get("width", 512)),
-        "height": int(inputs.get("height", 768)),
-        "frames": int(inputs.get("frames", 81)),
-        "fps": int(inputs.get("fps", 24)),
-        "seed": int(inputs.get("seed", 42)),
-    }
-    for k in ("image", "audio", "first_frame", "last_frame", "input_video",
-              "camera_lora", "camera_strength",
-              "detailer_on", "detailer_strength",
-              "ic_lora", "ic_strength", "pose_on", "audio_cfg", "image_strength"):
-        if k in inputs:
-            params[k] = inputs[k]
-
-    patches = mode.parameterize_fn(params)
-    workflow = wf_module.load_template(mode_name)
-    for patch in patches:
-        wf_module.set_input(workflow, *patch)
-    wf_module.validate(workflow)
-
-    backend = _get_backend()
-    duration = PRESET_DURATION.get(inputs.get("preset", "Balanced"), 120)
-
-    started = time.time()
-    last_event = None
-    async for event in backend.submit(mode_name, workflow, gpu_duration=duration):
-        last_event = event
-        elapsed = time.time() - started
-        if isinstance(event, backend_module.DownloadEvent):
-            status = ui.render_status(
-                stage_index=0, stage_label=f"Downloading {event.filename}",
-                step=int(event.mb_done), total_steps=int(max(event.mb_total, 1)),
-                elapsed_s=elapsed, eta_s=0,
-            )
-            yield status, gr.update()
-        elif isinstance(event, backend_module.ProgressEvent):
-            stage = mode.stage_map[event.stage] if event.stage < len(mode.stage_map) else mode.stage_map[-1]
-            eta = (elapsed / max(event.step, 1)) * (event.total_steps - event.step)
-            status = ui.render_status(
-                stage_index=event.stage + 1, stage_label=stage.label,
-                step=event.step, total_steps=event.total_steps,
-                elapsed_s=elapsed, eta_s=eta,
-            )
-            yield status, gr.update()
-        elif isinstance(event, backend_module.OutputEvent):
-            yield ui._render_idle(), event.video_path
-        elif isinstance(event, backend_module.ErrorEvent):
-            error_html = (
-                f'<div class="status-card status-error">'
-                f'  <div class="status-row"><span class="status-stage">Error · {event.category}</span></div>'
-                f'  <div>{event.message}</div>'
-                f'</div>'
-            )
-            yield error_html, gr.update()
-
-
-# Wire button to handler in build_app:
-
-def build_app() -> gr.Blocks:
-    with gr.Blocks(theme=gr.themes.Soft(), title="LTX 2.3 All-in-One", css=_CUSTOM_CSS) as app:
-        gr.Markdown("# ⚡ LTX 2.3 All-in-One")
-        with gr.Row():
-            with gr.Column(scale=1, min_width=200):
-                _render_sidebar()
-            with gr.Column(scale=4):
-                handles = _render_mode_panels()
-
-        for name, h in handles.items():
-            inputs = _collect_inputs_for_mode(name, h)
-            h["generate_btn"].click(
-                fn=_make_handler(name, h),
-                inputs=inputs,
-                outputs=[h["status"], h["video_out"]],
-            )
-    return app
-
-
-def _collect_inputs_for_mode(mode_name: str, h: dict) -> list:
-    """Gather the gr.Component handles to pass into _on_generate."""
-    base = [h["prompt"], h["preset"], h["width"], h["height"], h["frames"], h["fps"], h["seed"]]
-    if mode_name == "i2v":
-        base.append(h["image"])
-    elif mode_name == "a2v":
-        base.append(h["audio"])
-    elif mode_name == "lipsync":
-        base.extend([h["image"], h["audio"]])
-    elif mode_name == "keyframe":
-        base.extend([h["first_frame"], h["last_frame"]])
-    elif mode_name == "style":
-        base.append(h["input_video"])
-    base.append(h["negative_prompt"])
-    base.extend([
-        h["lora"].camera_lora, h["lora"].camera_strength,
-        h["lora"].detailer_on, h["lora"].detailer_strength,
-    ])
-    if h["lora"].ic_lora is not None:
-        base.extend([h["lora"].ic_lora, h["lora"].ic_strength])
-    if h["lora"].pose_on is not None:
-        base.append(h["lora"].pose_on)
-    return base
-
-
-def _make_handler(mode_name: str, h: dict):
-    keys = _input_keys_for_mode(mode_name, h)
-
-    async def handler(*values):
-        kwargs = dict(zip(keys, values))
-        async for output in _on_generate(mode_name, **kwargs):
-            yield output
-
-    return handler
-
-
-def _input_keys_for_mode(mode_name: str, h: dict) -> list[str]:
-    base = ["prompt", "preset", "width", "height", "frames", "fps", "seed"]
-    if mode_name == "i2v":
-        base.append("image")
-    elif mode_name == "a2v":
-        base.append("audio")
-    elif mode_name == "lipsync":
-        base.extend(["image", "audio"])
-    elif mode_name == "keyframe":
-        base.extend(["first_frame", "last_frame"])
-    elif mode_name == "style":
-        base.append("input_video")
-    base.append("negative_prompt")
-    base.extend(["camera_lora", "camera_strength", "detailer_on", "detailer_strength"])
-    if h["lora"].ic_lora is not None:
-        base.extend(["ic_lora", "ic_strength"])
-    if h["lora"].pose_on is not None:
-        base.append("pose_on")
-    return base
-```
-
-- [ ] **Step 2: End-to-end smoke run (T2V Fast preset)**
-
-Run: `python3.11 app.py`
-
-In the browser:
-1. Open the **Text → Video** tab.
-2. Type a short prompt (e.g., "a cat walking through a park, cinematic").
-3. Pick **Fast** preset.
-4. Set frames to 9, width 320, height 480 (smallest valid for fastest test).
-5. Click **Generate**.
-
-Expected: status banner updates through stages (Encode prompt → Diffusion → Decode), then a video appears in the right panel within 1–3 minutes on local MPS. (If first run, expect 30+ minutes for model downloads.)
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(app): generate handler — async streaming, status banner, video output"
-```
-
----
-
-## Phase 7 — CI
-
-### Task 24: `.github/workflows/ci.yml`
-
-**Files:**
-- Create: `.github/workflows/ci.yml`
-
-- [ ] **Step 1: Write CI workflow**
-
-```yaml
-name: CI
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: false  # ComfyUI submodule not needed for L1+L3 tests
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install runtime + dev deps
-        run: |
-          pip install -U pip
-          pip install -r requirements.txt
-
-      - name: Run unit + integration tests (no GPU)
-        run: |
-          python -m pytest tests/ -v -m "not gpu"
-
-      - name: Lint
-        run: |
-          ruff check .
-          ruff format --check .
-```
-
-- [ ] **Step 2: Locally verify the lint command passes**
-
-Run: `python3.11 -m ruff check . && python3.11 -m ruff format --check .`
-Expected: no errors. If formatter complains, run `ruff format .` and commit the changes.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add .github/workflows/ci.yml
-git commit -m "ci: run unit tests + ruff lint on every push"
-```
-
----
-
-### Task 25: `.github/workflows/deploy-space.yml` (optional)
-
-**Files:**
-- Create: `.github/workflows/deploy-space.yml`
-
-- [ ] **Step 1: Write deploy workflow**
-
-```yaml
-name: Deploy to HF Space
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: false
-
-      - name: Configure git LFS
-        run: |
-          git lfs install --skip-smudge
-
-      - name: Push to HF Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          HF_USER: ${{ secrets.HF_USER }}
-          HF_SPACE: ltx2.3-aio
-        run: |
-          git remote add space "https://$HF_USER:$HF_TOKEN@huggingface.co/spaces/$HF_USER/$HF_SPACE"
-          git push --force space main
-```
-
-- [ ] **Step 2: Commit**
-
-```bash
-git add .github/workflows/deploy-space.yml
-git commit -m "ci: optional deploy-on-main to HF Space"
-```
-
-> **Manual setup (one-time, not part of this plan):** Add `HF_TOKEN` and `HF_USER` secrets in the GitHub repo settings. Create the Space at https://huggingface.co/new-space with SDK=Gradio, Hardware=ZeroGPU.
-
----
-
-## Phase 8 — End-to-end verification
-
-### Task 26: Local smoke for all six modes
-
-**No code changes — verification only.**
-
-- [ ] **Step 1: Run app.py and exercise each mode at Fast preset**
-
-```bash
-source .venv/bin/activate
-python3.11 app.py
-```
-
-For each of T2V, A2V, I2V, Lipsync, Keyframe, Style:
-1. Open the mode's tab.
-2. Provide minimum-viable inputs (prompt + any required media at the smallest legal resolution: 320×480, frames=9, fps=24).
-3. Click **Generate**.
-4. Verify the status banner progresses through stages and the video appears.
-
-Each generation should complete in 1–5 minutes on local MPS (after models are cached).
-
-- [ ] **Step 2: Capture timings + memory peaks**
-
-For each mode, note: total wall time, peak resident memory (use Activity Monitor on macOS or `nvidia-smi --loop=2` on CUDA). Add to the README's "Local quickstart" section.
-
-- [ ] **Step 3: Commit any timing notes**
-
-```bash
-git add README.md
-git commit -m "docs: per-mode timing/memory measurements on Apple Silicon" || true
-```
-
----
-
-### Task 27: HF Spaces test deployment
-
-**No code changes — deploy + verify.**
-
-- [ ] **Step 1: Push to a personal HF Space**
-
-```bash
-git remote add space https://huggingface.co/spaces/<your-handle>/ltx2.3-aio-test
-git push --force space main
-```
-
-- [ ] **Step 2: Watch the Space build**
-
-In the Space's "Logs" tab, verify:
-- ComfyUI clones to `/data/comfyui` on first cold start (takes ~3–5 min).
-- Custom nodes install cleanly.
-- `requirements.txt` resolves on Python 3.11.
-
-- [ ] **Step 3: Run a Fast-preset T2V on the Space**
-
-Same minimum-viable inputs as Task 26. Expected: completes within the 60s ZeroGPU duration on Pro tier (after model download has populated `/data/models`).
-
-- [ ] **Step 4: Note any deviations from local behavior**
-
-Any divergence (e.g., slower download, different VAE behavior) gets a follow-up issue.
-
-- [ ] **Step 5: Optionally promote to a public Space**
-
-If everything works, repeat the deploy with the user-facing Space name (`<your-handle>/ltx2.3-aio`).
-
----
-
-## Spec coverage check
-
-| Spec section | Covered by |
-|---|---|
-| § 3 Architecture | Tasks 17–18, 21–23 |
-| § 4 File structure | Tasks 1–25 (every file) |
-| § 5 Data flow | Tasks 17–18, 21–23 |
-| § 6 Model loading & VRAM | Tasks 13–16, 18 |
-| § 7 Progress reporting | Tasks 18, 19, 23 |
-| § 8 Error handling | Tasks 18, 23 (`ErrorEvent` rendering) |
-| § 9.1 Local deployment | Tasks 2, 26 |
-| § 9.2 HF Spaces deployment | Tasks 21 (`_bootstrap`), 27 |
-| § 9.3 One-touch deploy | Task 25 |
-| § 10 Testing | Tasks 4 (fixtures), 6, 8–15, 17, 24 |
-
-All spec sections are covered. Out-of-scope items (§ 11) are intentionally absent.
-
----
-
-## Plan complete
-
-Plan saved to `docs/superpowers/plans/2026-04-30-ltx23-aio-generator.md`.
-
-**Two execution options:**
-
-**1. Subagent-Driven (recommended)** — I dispatch a fresh subagent per task, review between tasks, fast iteration. Best for a plan this long because it keeps each task's context tight.
-
-**2. Inline Execution** — Execute tasks in this session using `superpowers:executing-plans`, batch execution with checkpoints.
-
-**Which approach?**

docs/superpowers/plans/2026-05-01-topaz-drawer-redesign.md

@@ -1,535 +0,0 @@
-# Topaz Cinema Slate + Drawer Redesign — Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Apply the Topaz Cinema Slate dark palette and the hamburger-drawer layout (open by default ≥1024 px, hidden behind ≡ button below) to the existing Gradio app, with no logic or backend changes.
-
-**Architecture:** All edits land in `app.py`. Three concerns: (1) `gr.themes.Base().set(...)` overrides for the 12 Topaz tokens, (2) full rewrite of `_CUSTOM_CSS` for slate-on-slate styling + drawer mechanics + responsive breakpoint, (3) markup tweak — wrap the existing sidebar `gr.Column` in a `drawer` div with a header row above the shell that holds the ≡ toggle, title, and active-mode tag.
-
-**Tech Stack:** Gradio 5.50, IBM Plex Sans/Mono via Google Fonts, pure-CSS drawer toggle using a hidden `<input type="checkbox">` + `:checked` sibling selectors (no JS framework — but a tiny inline `<script>` block in `head=` syncs the active-mode tag and persists drawer state to `localStorage`).
-
----
-
-## File Structure
-
-- **Modify:** `app.py`
-  - `_CUSTOM_CSS` block — fully replaced
-  - `build_app()` — Blocks `theme=` and `head=` parameters added; markup gets a header row + drawer column wrapper
-
-No other files are touched. `backend.py`, `models.py`, `modes.py`, `workflow.py`, `ui.py` are unaffected.
-
----
-
-### Task 1 — Add Topaz theme tokens to `gr.Blocks`
-
-**Files:** Modify `app.py:191`
-
-- [ ] **Step 1: Define the Topaz `gr.themes.Base()` instance**
-
-Add this just above `def build_app()` near `app.py:189`:
-
-```python
-_TOPAZ_THEME = gr.themes.Base(
-    primary_hue=gr.themes.Color(
-        c50="#FBE5C7", c100="#F5D29C", c200="#EFC174", c300="#E9B05A",
-        c400="#E5A75B", c500="#E0A458", c600="#C68D3F", c700="#A6722E",
-        c800="#7E5722", c900="#583C18", c950="#3A2810",
-    ),
-    neutral_hue=gr.themes.Color(
-        c50="#E6E8EB", c100="#C9CDD3", c200="#ACB1B9", c300="#9097A0",
-        c400="#7C8693", c500="#626972", c600="#4A4F58", c700="#363B43",
-        c800="#262C35", c900="#1A1F26", c950="#12161B",
-    ),
-    font=(gr.themes.GoogleFont("IBM Plex Sans"), "ui-sans-serif", "system-ui", "sans-serif"),
-    font_mono=(gr.themes.GoogleFont("IBM Plex Mono"), "ui-monospace", "monospace"),
-).set(
-    body_background_fill="#12161B",
-    background_fill_primary="#12161B",
-    background_fill_secondary="#1A1F26",
-    block_background_fill="#1A1F26",
-    block_label_background_fill="transparent",
-    body_text_color="#E6E8EB",
-    body_text_color_subdued="#7C8693",
-    border_color_primary="#262C35",
-    border_color_accent="#E0A458",
-    button_primary_background_fill="#E0A458",
-    button_primary_background_fill_hover="#F0B870",
-    button_primary_text_color="#12161B",
-    button_secondary_background_fill="#1A1F26",
-    button_secondary_background_fill_hover="#232930",
-    button_secondary_text_color="#E6E8EB",
-    button_secondary_border_color="#262C35",
-    input_background_fill="#12161B",
-    input_border_color="#262C35",
-    input_border_color_focus="#E0A458",
-    error_background_fill="#3A1E20",
-    error_text_color="#F4A6A8",
-    slider_color="#E0A458",
-)
-```
-
-- [ ] **Step 2: Wire the theme into `build_app`**
-
-Change `app.py:191` from:
-
-```python
-with gr.Blocks(theme=gr.themes.Soft(), title="LTX 2.3 All-in-One", css=_CUSTOM_CSS) as app:
-```
-
-to:
-
-```python
-with gr.Blocks(theme=_TOPAZ_THEME, title="LTX 2.3 Studio", css=_CUSTOM_CSS) as app:
-```
-
-- [ ] **Step 3: Smoke-test that imports still work**
-
-Run: `python -c "import app; print('OK')"` in the project root.
-Expected: `OK` printed, no traceback.
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(ui): apply Topaz Cinema Slate theme tokens"
-```
-
----
-
-### Task 2 — Replace `_CUSTOM_CSS` with Topaz styles + drawer mechanics
-
-**Files:** Modify `app.py:127-182` (the whole `_CUSTOM_CSS = """..."""` block)
-
-- [ ] **Step 1: Replace the entire `_CUSTOM_CSS` block**
-
-Replace `app.py:127-182` with:
-
-```python
-_CUSTOM_CSS = """
-/* Hide Gradio's top tab strip — sidebar drives selection. */
-.aio-tabs > .tab-nav,
-.aio-tabs > div:first-child[role="tablist"],
-.aio-tabs > div:first-child:has([role="tab"]) {
-    position: absolute !important;
-    left: -99999px !important;
-    top: -99999px !important;
-    height: 0 !important;
-    overflow: hidden !important;
-    visibility: visible !important;
-    pointer-events: auto !important;
-}
-
-/* === Header === */
-.aio-header {
-    display: flex;
-    align-items: center;
-    gap: 12px;
-    padding: 11px 18px;
-    border-bottom: 1px solid #262C35;
-    background: #12161B;
-}
-.aio-ham-toggle { display: none; }  /* hidden checkbox drives drawer state */
-.aio-ham-label {
-    width: 32px; height: 32px;
-    border: 1px solid #262C35;
-    border-radius: 5px;
-    color: #7C8693;
-    cursor: pointer;
-    display: flex; align-items: center; justify-content: center;
-    font-size: 18px; font-weight: 300;
-    user-select: none;
-}
-.aio-ham-label:hover { color: #E0A458; border-color: #E0A458; }
-.aio-title {
-    font-size: 15px; font-weight: 600; letter-spacing: -0.01em;
-    color: #E6E8EB;
-}
-.aio-title .accent { color: #E0A458; }
-.aio-mode-tag {
-    margin-left: auto;
-    padding: 4px 9px;
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-    font-size: 11px; font-weight: 500; letter-spacing: 0.04em;
-    color: #E0A458;
-    border: 1px solid #E0A458;
-    border-radius: 4px;
-}
-
-/* === Drawer === */
-.aio-shell { position: relative; }
-.aio-drawer {
-    width: 220px;
-    border-right: 1px solid #262C35;
-    background: #12161B;
-    padding: 14px 10px !important;
-    flex-shrink: 0;
-    transition: transform 0.2s ease, width 0.2s ease;
-}
-.aio-drawer-heading {
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-    font-size: 10px; text-transform: uppercase; letter-spacing: 0.07em;
-    color: #7C8693;
-    padding: 6px 8px 4px !important;
-    margin: 0 !important;
-}
-
-/* Mode buttons */
-.aio-mode-btn { width: 100%; text-align: left; margin: 2px 0 !important; }
-.aio-mode-btn-active {
-    background: #1A1F26 !important;
-    color: #E0A458 !important;
-    border-left: 3px solid #E0A458 !important;
-}
-
-/* Model status / settings panels */
-.aio-model-badge {
-    padding: 9px 11px;
-    border-radius: 6px;
-    background: #1A1F26;
-    border: 1px solid #262C35;
-    font-size: 11.5px;
-    font-family: 'IBM Plex Mono', ui-monospace, monospace;
-    color: #7C8693;
-}
-
-/* === Status banner === */
-.status-card {
-    padding: 12px 16px;
-    border-radius: 6px;
-    background: #1A1F26;
-    border: 1px solid #262C35;
-}
-.status-row { display: flex; gap: 14px; align-items: center; margin-bottom: 8px; flex-wrap: wrap; }
-.status-stage { font-weight: 600; color: #E0A458; }
-.status-meta { font-size: 12px; color: #7C8693; font-family: 'IBM Plex Mono', monospace; }
-.status-bar { height: 4px; background: #262C35; border-radius: 99px; overflow: hidden; }
-.status-fill { height: 100%; background: #E0A458; transition: width .3s; }
-.status-mem { font-size: 11px; color: #7C8693; margin-top: 6px; font-family: 'IBM Plex Mono', monospace; }
-.status-error {
-    background: #3A1E20 !important;
-    border-color: #F4A6A8 !important;
-    color: #F4A6A8 !important;
-}
-.status-error .status-stage { color: #F4A6A8; }
-
-/* === Drawer toggle behavior at the desktop boundary === */
-@media (max-width: 1023px) {
-    .aio-ham-label { display: flex; }
-    .aio-drawer {
-        position: absolute;
-        top: 0; left: 0; bottom: 0;
-        z-index: 10;
-        box-shadow: 4px 0 24px rgba(0,0,0,0.6);
-        transform: translateX(-100%);
-        max-width: 80vw;
-    }
-    /* checkbox at #aio-ham-toggle is the only sibling pattern Gradio
-       lets us reach without JS — when checked, slide drawer in. */
-    body:has(.aio-ham-toggle:checked) .aio-drawer { transform: translateX(0); }
-    body:has(.aio-ham-toggle:checked) .aio-shell::before {
-        content: ""; position: absolute; inset: 0;
-        background: rgba(0,0,0,0.55); z-index: 9;
-    }
-
-    /* Mobile sub-tweaks */
-    .aio-mode-btn { font-size: 13px !important; padding: 7px 10px !important; }
-    .aio-body [class*="row"] { flex-wrap: wrap !important; }
-    .aio-body [class*="row"] > div { flex: 1 1 100% !important; min-width: 0 !important; }
-}
-
-@media (min-width: 1024px) {
-    .aio-ham-label { display: none; }
-}
-"""
-```
-
-- [ ] **Step 2: Verify the CSS doesn't break the import**
-
-Run: `python -c "import app; print(len(app._CUSTOM_CSS), 'chars CSS')"`
-Expected: a number (around 4000), no traceback.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(ui): rewrite _CUSTOM_CSS for Topaz palette + drawer mechanics"
-```
-
----
-
-### Task 3 — Add header markup + drawer wrapper to `build_app`
-
-**Files:** Modify `app.py:190-243` (the `build_app` function body)
-
-- [ ] **Step 1: Replace the markup section**
-
-Find this block in `app.py` (currently around 190-220):
-
-```python
-def build_app() -> gr.Blocks:
-    with gr.Blocks(theme=_TOPAZ_THEME, title="LTX 2.3 Studio", css=_CUSTOM_CSS) as app:
-        gr.Markdown("# ⚡ LTX 2.3 All-in-One")
-
-        with gr.Row(elem_classes=["aio-shell"]):
-            # Sidebar
-            with gr.Column(scale=1, min_width=200, elem_classes=["aio-sidebar"]):
-                gr.Markdown("**Modes**", elem_classes=["aio-sidebar-heading"])
-                with gr.Column(elem_classes=["aio-mode-btn-row"]):
-                    mode_buttons = {
-                        name: gr.Button(
-                            f"{m.icon}  {m.label}",
-                            elem_classes=["aio-mode-btn"],
-                            variant="secondary",
-                        )
-                        for name, m in modes.MODE_REGISTRY.items()
-                    }
-                gr.Markdown("**Models**", elem_classes=["aio-sidebar-heading"])
-                model_status = gr.HTML(_render_model_status_idle(), elem_id="aio-model-status")
-                refresh_btn = gr.Button("Refresh", size="sm", variant="secondary")
-                unload_btn = gr.Button("Unload all models", size="sm", variant="secondary")
-                gr.Markdown("**Settings**", elem_classes=["aio-sidebar-heading"])
-                gr.Markdown(
-                    "Output: `comfyui/output/LTX2.3/`<br>"
-                    "Set `LTX23_AIO_VRAM=lowvram|normalvram|highvram` to override the auto-detected VRAM tier.",
-                    elem_classes=["aio-model-badge"],
-                )
-
-            # Body
-            with gr.Column(scale=4, elem_classes=["aio-body"]):
-                handles, tabs_component = _render_mode_panels()
-```
-
-Replace with:
-
-```python
-def build_app() -> gr.Blocks:
-    with gr.Blocks(theme=_TOPAZ_THEME, title="LTX 2.3 Studio", css=_CUSTOM_CSS) as app:
-        # Header: hamburger checkbox (drives drawer via :checked + :has() in CSS),
-        # title, current-mode tag.
-        gr.HTML(
-            '<div class="aio-header">'
-            '  <input type="checkbox" id="aio-ham-toggle" class="aio-ham-toggle">'
-            '  <label for="aio-ham-toggle" class="aio-ham-label">≡</label>'
-            '  <span class="aio-title">LTX 2.3 <span class="accent">Studio</span></span>'
-            '  <span class="aio-mode-tag" id="aio-mode-tag">T2V</span>'
-            '</div>'
-        )
-
-        with gr.Row(elem_classes=["aio-shell"]):
-            # Drawer (drawer behaves as fixed sidebar ≥1024 px;
-            # absolute-positioned overlay <1024 px — see _CUSTOM_CSS).
-            with gr.Column(scale=1, min_width=200, elem_classes=["aio-drawer"]):
-                gr.Markdown("Modes", elem_classes=["aio-drawer-heading"])
-                mode_buttons = {
-                    name: gr.Button(
-                        f"{m.icon}  {m.label}",
-                        elem_classes=["aio-mode-btn"],
-                        variant="secondary",
-                    )
-                    for name, m in modes.MODE_REGISTRY.items()
-                }
-                gr.Markdown("Models", elem_classes=["aio-drawer-heading"])
-                model_status = gr.HTML(_render_model_status_idle(), elem_id="aio-model-status")
-                refresh_btn = gr.Button("Refresh", size="sm", variant="secondary")
-                unload_btn = gr.Button("Unload all models", size="sm", variant="secondary")
-                gr.Markdown("Settings", elem_classes=["aio-drawer-heading"])
-                gr.Markdown(
-                    "Output: `comfyui/output/LTX2.3/`<br>"
-                    "Set `LTX23_AIO_VRAM=lowvram|normalvram|highvram` to override "
-                    "the auto-detected VRAM tier.",
-                    elem_classes=["aio-model-badge"],
-                )
-
-            # Body — unchanged, still hosts the 6 mode tabs.
-            with gr.Column(scale=4, elem_classes=["aio-body"]):
-                handles, tabs_component = _render_mode_panels()
-```
-
-- [ ] **Step 2: Smoke-test build_app produces a Blocks**
-
-Run:
-```bash
-python -c "import app; b = app.build_app(); print(type(b).__name__)"
-```
-Expected: `Blocks`, no traceback.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(ui): drawer markup + header (hamburger / title / mode tag)"
-```
-
----
-
-### Task 4 — Wire active-mode tag updates from sidebar clicks
-
-**Files:** Modify `app.py:232-237` (the existing mode-button click loop)
-
-- [ ] **Step 1: Update the click handler to also push the new mode tag**
-
-Current code at `app.py:232-237`:
-
-```python
-        for name, btn in mode_buttons.items():
-            btn.click(
-                fn=lambda mode_id=name: gr.Tabs(selected=mode_id),
-                inputs=None,
-                outputs=[tabs_component],
-            )
-```
-
-Replace with:
-
-```python
-        # JS to update the header mode tag without a server round-trip.
-        # Each mode button injects a tiny on-click that rewrites #aio-mode-tag.
-        _MODE_TAG_BY_NAME = {
-            "t2v": "T2V", "a2v": "A2V", "i2v": "I2V",
-            "lipsync": "LIPSYNC", "keyframe": "KEY", "style": "STYLE",
-        }
-        for name, btn in mode_buttons.items():
-            tag = _MODE_TAG_BY_NAME.get(name, name.upper())
-            btn.click(
-                fn=lambda mode_id=name: gr.Tabs(selected=mode_id),
-                inputs=None,
-                outputs=[tabs_component],
-                js=f"() => {{ "
-                   f"const el = document.getElementById('aio-mode-tag'); "
-                   f"if (el) el.textContent = {tag!r}; "
-                   f"/* also collapse drawer on mobile after pick */ "
-                   f"if (window.matchMedia('(max-width: 1023px)').matches) {{ "
-                   f"  const t = document.getElementById('aio-ham-toggle'); "
-                   f"  if (t) t.checked = false; "
-                   f"}} return []; }}",
-            )
-```
-
-- [ ] **Step 2: Smoke-test**
-
-Run:
-```bash
-python -c "import app; b = app.build_app(); print('ok')"
-```
-Expected: `ok`, no traceback.
-
-- [ ] **Step 3: Commit**
-
-```bash
-git add app.py
-git commit -m "feat(ui): mode tag updates + auto-close drawer on mobile select"
-```
-
----
-
-### Task 5 — Visual smoke test in browser
-
-**Files:** None (test-only).
-
-- [ ] **Step 1: Launch the app**
-
-Run in one terminal:
-```bash
-cd /Users/techfreakworm/Projects/llm/ltx2.3-AIO-generator
-source .venv/bin/activate
-python app.py
-```
-Expected output: `Running on local URL: http://127.0.0.1:7860`
-
-- [ ] **Step 2: Open browser at desktop width**
-
-Open Chrome at `http://127.0.0.1:7860`. Resize window to 1280 px wide.
-
-Verify:
-- Header: ≡ button NOT visible (hidden on ≥1024 px), title "LTX 2.3 **Studio**" with "Studio" in amber, mode tag "T2V" in amber border on right
-- Drawer (220 px) visible on left, "Modes" heading in IBM Plex Mono uppercase, 6 mode buttons stacked
-- Active mode (T2V by default) has amber left border + amber text + slate-2 bg
-- Body pane: form fields use slate background, amber Generate button at the bottom
-- Click each mode button → mode tag in header updates, body switches to that mode's form
-
-- [ ] **Step 3: Resize to tablet (1023 px)**
-
-Drag Chrome to 900 px wide.
-
-Verify:
-- ≡ button NOW visible in header
-- Drawer hidden (off-screen left)
-- Click ≡ → drawer slides in, dark scrim covers body
-- Click a mode button → drawer auto-closes, body switches mode
-- Click ≡ again → drawer hides
-
-- [ ] **Step 4: Resize to phone (380 px)**
-
-Use Chrome devtools → device toolbar → iPhone 12.
-
-Verify:
-- Same as tablet, but drawer width capped at 80 vw
-- Form fields are full-width (sliders, inputs)
-- Generate button readable, no horizontal scrollbar
-
-- [ ] **Step 5: Hit Generate (T2V, default settings)**
-
-Type a short prompt, click Generate.
-
-Verify:
-- Status banner appears with `Stage 1 · Encode prompt` text in amber
-- Progress bar fills with amber
-- After ~30s on local MPS (or longer if no model cache), video appears in output
-- Banner switches to `Done` or disappears
-
-- [ ] **Step 6: Trigger an error**
-
-Set width to 0 in slider (or click Generate with empty prompt) — anything that produces an error.
-
-Verify:
-- Error banner uses `#3A1E20` background + `#F4A6A8` text
-- Stage label and meta text both readable
-
-- [ ] **Step 7: Stop the dev server**
-
-Ctrl+C in the terminal running `python app.py`.
-
-- [ ] **Step 8: Commit screenshot/notes (optional)**
-
-If anything didn't match the spec, file a follow-up; otherwise no commit needed.
-
----
-
-### Task 6 — Push to GitHub + HF Space
-
-**Files:** None — pushing only.
-
-- [ ] **Step 1: Sync to both remotes**
-
-```bash
-cd /Users/techfreakworm/Projects/llm/ltx2.3-AIO-generator
-git push origin master
-HF_TOKEN=$(hf auth token 2>/dev/null) git push "https://techfreakworm:${HF_TOKEN}@huggingface.co/spaces/techfreakworm/LTX2.3-Studio" master:main
-```
-
-- [ ] **Step 2: Verify Space accepts the push**
-
-Wait ~30 s, then:
-```bash
-HF_TOKEN=$(hf auth token 2>/dev/null) curl -s -H "Authorization: Bearer ${HF_TOKEN}" \
-  "https://huggingface.co/api/spaces/techfreakworm/LTX2.3-Studio" \
-  | python3 -c "import sys, json; d=json.load(sys.stdin); print('stage:', d['runtime']['stage'], 'sha:', d['sha'][:8])"
-```
-Expected: `stage: BUILDING` or `RUNNING_BUILDING`, sha matches local HEAD.
-
-- [ ] **Step 3: Wait for build, then visual-spot-check on Spaces**
-
-After ~5 min, open `https://techfreakworm-ltx2-3-studio.hf.space` in Chrome at 1280 px. Verify the Topaz palette + drawer rendered correctly. Resize to phone width and verify hamburger toggle.
-
----
-
-## Out of scope reminder
-
-These are explicitly NOT touched by this plan (per spec):
-- Form layout inside each mode tab (typography updates flow via theme cascade only)
-- Model status / settings panel content
-- Mode set, generate flow, progress events
-- Any CUDA / MPS / Spaces logic
-- Custom LoRA UI
-
-If any of those appear visually broken after this plan lands, file separately — they're spec-isolated and a different change.

docs/superpowers/specs/2026-04-30-ltx23-aio-generator-design.md

@@ -1,483 +0,0 @@
-# LTX 2.3 All-In-One Generator — Design Spec
-
-**Date:** 2026-04-30
-**Status:** Design approved, awaiting implementation plan
-**Repo:** `~/Projects/llm/ltx2.3-AIO-generator`
-
-## 1. Overview
-
-A Gradio app that wraps the existing ComfyUI LTX 2.3 All-In-One workflow into a polished, mode-specific UI. Same code runs locally on Apple Silicon (MPS) or NVIDIA (CUDA) and deploys to Hugging Face Spaces with ZeroGPU. The Gradio frontend is a thin layer; ComfyUI is the inference engine — bundled and called as a Python library — so all of ComfyUI's smart model management, MPS handling, and node correctness are inherited rather than reimplemented.
-
-Six generation modes ship in v1, mirroring the groups in `1. LTX 2.3 All-In-One 260406-05.json`:
-
-| # | Mode | LTX-2 pipeline class |
-|---|---|---|
-| 1 | Text → Video (+optional Audio) | `TI2VidTwoStagesPipeline` / `DistilledPipeline` |
-| 2 | Audio → Video (Text + Audio → Video + Audio) | `A2VidPipelineTwoStage` |
-| 3 | Image → Video (+optional Audio) | `TI2VidTwoStagesPipeline` |
-| 4 | Lipsync (Image + Audio → Video + Audio) | `A2VidPipelineTwoStage` |
-| 5 | First / Last Frame → Video | `KeyframeInterpolationPipeline` |
-| 6 | Style Transfer (Video → Video, motion control) | `ICLoraPipeline` |
-
-## 2. Decisions log (Q1–Q8 + path)
-
-| # | Question | Decision | Rationale |
-|---|---|---|---|
-| Q1 | Modes scope | All 6 | Marginal cost per mode is small; the differentiator vs other Gradio LTX demos is the unified shell. |
-| Q2 | Settings exposure | Preset (Fast/Balanced/Quality) + Advanced accordion | Clean Spaces demo without sacrificing local power-user control. |
-| Q3 | Backend | ComfyUI as headless backend (library mode) | ComfyUI is the production path on MPS; pure-Python `ltx-pipelines` has known crashes (TI2Vid OOM, A2Vid stage 2 SIGUSR1). Re-using ComfyUI's path inherits the fixes. |
-| Q4 | Workflow templates | Six mode-specific JSON files | Smaller diff surface, easier tests, evolves per mode. `tools/extract_modes.py` regenerates them from the master workflow. |
-| Q5 | LoRA UI | Categorized chrome (Camera dropdown · Detailer toggle · IC-LoRA mode-specific) | Mode-aware, no rope to misconfigure. Custom LoRA escape hatch deferred to v1.1. |
-| Q6 | Layout shell | Sidebar nav + 2-column body | Six tab labels are too wide horizontally; sidebar gives mode names room and accommodates global panels. |
-| Q7 | ComfyUI install | Bundled (git submodule locally, runtime clone on Spaces) | Self-contained, no dependence on user's existing ComfyUI install. |
-| Q8 | Model storage | Local: HF cache → symlinks. Spaces: lazy `hf_hub_download` to `/data`. | Honors HF cache preference; no duplicate downloads; lazy strategy keeps Spaces `/data` budget under control. |
-| Path | Spaces tier | Path A — Pro tier | ~70 GB minimum model footprint exceeds free tier `/data`; Balanced preset needs longer per-call duration. |
-
-## 3. Architecture
-
-```
-┌────────────────────────────────────────────────────────────────┐
-│  Gradio UI   (sidebar nav · 2-col body · per-mode inputs)      │
-│  ─ Mode tabs: T2V · A2V · I2V · Lipsync · Keyframe · Style    │
-│  ─ Categorized LoRA chrome inside each mode's Advanced ▾       │
-│  ─ Models / Settings / History panels in sidebar               │
-└────────────────────────────────┬───────────────────────────────┘
-                                 │  parameterize 1 of 6 templates
-                                 ▼
-┌────────────────────────────────────────────────────────────────┐
-│  Workflow Builder   (workflows/<mode>.json + UI parameters)    │
-│  ─ load_template(mode) → patch nodes → return JSON             │
-│  ─ Validates inputs against the mode's required nodes          │
-└────────────────────────────────┬───────────────────────────────┘
-                                 │  workflow JSON dict
-                                 ▼
-┌────────────────────────────────────────────────────────────────┐
-│  Backend (single impl)   ComfyUILibraryBackend                 │
-│  ─ comfy.execution.PromptExecutor.execute(workflow)            │
-│  ─ Hooks comfy.utils.PROGRESS_BAR_HOOK → yields ProgressEvent  │
-│  ─ On Spaces: wrapped in @spaces.GPU(duration=N)               │
-│  ─ Locally:   runs in a worker thread, GIL-released by torch   │
-└────────────────────────────────┬───────────────────────────────┘
-                                 │  progress events + outputs
-                                 ▼
-┌────────────────────────────────────────────────────────────────┐
-│  Bundled ComfyUI   (vendored as a git submodule)               │
-│  ─ ComfyUI core + ComfyUI-LTXVideo + KJNodes + rgthree         │
-│  ─ models/ symlinks → ~/.cache/huggingface/hub  (local)        │
-│  ─ models/ files on /data persistent volume   (Spaces)         │
-└────────────────────────────────────────────────────────────────┘
-```
-
-### 3.1 Key invariants
-
-1. **One backend interface, single implementation.** Library mode everywhere (`comfy.execution.PromptExecutor`). The `@spaces.GPU` decorator is the only divergence between local and Spaces.
-2. **Workflow JSON is the contract.** Six small templates, parameterized at the leaves only. We don't reinvent ComfyUI's node graph.
-3. **Models are never owned by the AIO repo.** Always either symlinked from HF cache (local) or downloaded to `/data` (Spaces). The bundled ComfyUI's `models/` is purely a view onto the cache.
-4. **Auto MPS/CUDA dispatch.** The bundled ComfyUI handles device selection and dtype casting. The AIO layer writes no device code.
-
-## 4. File structure
-
-```
-ltx2.3-AIO-generator/
-├── app.py                    # Gradio entry — sidebar nav, mode rendering, generate handler
-├── backend.py                # ComfyUI library backend; PromptExecutor wrapper; progress streaming
-├── workflow.py               # load + parameterize a workflow JSON template
-├── modes.py                  # MODE_REGISTRY: 6 modes × (inputs, defaults, parameterize fn)
-├── models.py                 # symlink HF cache (local) / hf_hub_download to /data (Spaces)
-├── ui.py                     # reusable Gradio components: LoRA chrome, preset bar, status banner
-├── workflows/                # six mode-specific JSON templates (≤50 nodes each)
-│   ├── t2v.json
-│   ├── a2v.json
-│   ├── i2v.json
-│   ├── lipsync.json
-│   ├── keyframe.json
-│   └── style.json
-├── tools/
-│   ├── extract_modes.py      # rebuild templates from your master workflow
-│   └── refresh_models.py     # refresh HF cache symlinks if snapshot SHAs change
-├── tests/
-│   ├── conftest.py
-│   ├── test_workflow.py
-│   └── test_modes.py
-├── comfyui/                  # git submodule pinned to a known-good ComfyUI commit
-├── setup.sh                  # init submodule, venv, install reqs, symlink models
-├── requirements.txt          # gradio, spaces, huggingface-hub, torch, comfyui's own reqs
-├── README.md                 # incl. HF Space front matter for one-touch deploy
-├── CLAUDE.md                 # project guidelines (incl. sole-author commit rule)
-└── .gitignore
-```
-
-### 4.1 Module responsibilities
-
-| File | Responsibility | LOC est. |
-|---|---|---|
-| `app.py` | Gradio Blocks; sidebar navigation; per-mode input forms; calls `backend.submit()` | ~400 |
-| `backend.py` | One class `ComfyUILibraryBackend`. Constructor adds `comfyui/` to `sys.path`, loads custom nodes, instantiates `PromptExecutor`. `submit(workflow)` is an async generator yielding `ProgressEvent`s. Handles ZeroGPU detection — wraps `_execute()` in `@spaces.GPU` if env var set. | ~200 |
-| `workflow.py` | `load_template(mode)`, `set_input(workflow, node_id, field, value)`, `validate(workflow)`. Pure functions over dicts. | ~120 |
-| `modes.py` | One `Mode` dataclass (name, icon, input_specs, parameterize_fn). `MODE_REGISTRY = {"t2v": Mode(...), ...}`. The `parameterize_fn` is the only mode-specific code. | ~300 |
-| `models.py` | `ensure_models_for_mode(mode)`: walks the mode's workflow, finds loader nodes, identifies HF repo+filename, downloads via `hf_hub_download`, symlinks into `comfyui/models/...`. On Spaces, downloads to `/data`. | ~150 |
-| `ui.py` | `lora_chrome(mode)` returns the categorized LoRA component group. `preset_bar()` returns the Fast/Balanced/Quality radio. `status_banner()` returns the `gr.HTML` for progress + stage text. | ~200 |
-
-Total app code (excluding ComfyUI submodule and workflow JSONs): **~1,400 LOC** across 6 modules.
-
-### 4.2 ComfyUI submodule + custom nodes
-
-Pinned at a known-good commit. Custom nodes installed during `setup.sh` (local) or during runtime bootstrap (Spaces):
-
-- `Lightricks/ComfyUI-LTXVideo` (LTX node implementations: `LTXICLoRALoaderModelOnly`, `LTXVChunkFeedForward`, `LTXVGemmaCLIPModelLoader`)
-- `kijai/ComfyUI-KJNodes` (`VAELoaderKJ`, `ResizeImageMaskNode`, `INTConstant`, GetNode/SetNode helpers)
-- `rgthree/rgthree-comfy` (`Power Lora Loader`, `Any Switch`, `Fast Groups Bypasser`, `Label`)
-- `Kosinkadink/ComfyUI-VideoHelperSuite` (`VHS_VideoCombine`, `VHS_LoadVideo`, `VHS_LoadAudioUpload`)
-- `pythongosssss/ComfyUI-Custom-Scripts` (`MathExpression|pysssss` — used by the master workflow for derived dimensions)
-
-## 5. Data flow
-
-User clicks **Generate** in the I2V tab. The path:
-
-```
-[1]  app.py: on_generate(mode="i2v", **inputs)
-            │  Pulls Mode("i2v") from MODE_REGISTRY
-            ▼
-[2]  modes.i2v.parameterize_fn(inputs) → list[(node_id, field, value)]
-            ▼
-[3]  workflow.load_template("i2v") → dict
-     workflow.set_input(wf, *patch) for each patch
-     workflow.validate(wf)
-            ▼
-[4]  models.ensure_models_for_mode(wf)
-     yields DownloadEvent(filename, mb_done, mb_total)
-            ▼
-[5]  backend.submit(wf) — async generator
-     On Spaces: wrapped in @spaces.GPU(duration=preset_budget)
-     Calls comfy.execution.PromptExecutor.execute(wf)
-            ▼
-[6]  PromptExecutor walks node graph
-     Per-node: yields ProgressEvent(stage, step, total_steps)
-            ▼
-[7]  app.py: async for event in backend.submit(...):
-     status_banner.html = render(event)
-            ▼
-[8]  Final node (VHS_VideoCombine) writes /tmp/out_<ts>.mp4
-     yields OutputEvent(path)
-            ▼
-[9]  Gradio video component renders the file
-     History panel adds row: timestamp · seed · duration
-```
-
-### 5.1 Three event types
-
-```python
-@dataclass
-class DownloadEvent:    filename: str; mb_done: float; mb_total: float
-@dataclass
-class ProgressEvent:    stage: int; stage_label: str; step: int; total_steps: int
-@dataclass
-class OutputEvent:      video_path: str; audio_path: Optional[str]; meta: dict
-```
-
-The Gradio handler is one async generator that consumes these and yields `(status_html, video, history)` tuples.
-
-### 5.2 Cancellation
-
-Gradio's `Button.click(..., cancels=[generate_event])` calls `backend.interrupt()` → `comfy.model_management.interrupt_current_processing()`. The async generator's `finally:` block always frees GPU memory before raising.
-
-## 6. Model loading & VRAM management
-
-ComfyUI's `comfy.model_management` handles the heavy lifting — we write zero code for it.
-
-**Inherited from ComfyUI:**
-- Smart offload tiers (tracks total/free VRAM continuously; offloads largest non-live model when next load would overflow).
-- Per-node load via `ModelPatcher`; LoRA patching applies deltas in-place without double-loading the base model.
-- Automatic device dispatch and dtype casting (BF16/FP16/FP8 per `--force-*` args).
-- ComfyUI-LTXVideo's existing MPS edge-case handling.
-
-**AIO layer adds:**
-
-| Concern | Implementation |
-|---|---|
-| Pre-flight download | `models.ensure_models_for_mode(wf)` walks loader nodes, resolves filenames via a `MODEL_REGISTRY` map, downloads via `hf_hub_download`, symlinks into `comfyui/models/<type>/<name>`. |
-| VRAM tier hint | `comfy.cli_args.args.lowvram\|normalvram\|highvram` set at backend init based on detected GPU memory. Override via env var `LTX23_AIO_VRAM`. |
-| Memory status badge | `ui.status_banner()` polls `comfy.model_management.get_free_memory()` every 2 s while idle. |
-| Manual unload | Sidebar button **Unload all models** → `unload_all_models()` + `empty_cache()`. |
-| Inter-mode caching | Single in-process ComfyUI keeps loaded models warm across mode switches. Free for us — ComfyUI's cache does it. |
-
-### 6.1 Memory math (BF16)
-
-| Component | Size | Loaded when |
-|---|---|---|
-| Distilled 22B transformer | ~44 GB | Diffusion stages |
-| Gemma 3 12B text encoder | ~24 GB | Prompt encoding |
-| Video VAE | ~2 GB | Encode (i2v/keyframe) + final decode |
-| Audio VAE | ~0.5 GB | A2V/Lipsync only |
-| LoRAs | <1 GB each | Patched into transformer |
-| Latents | ~3 GB at 512×768/81f | Diffusion |
-
-Realistic peak resident: ~70 GB on MPS unified memory; ~45 GB GPU + 24 GB system RAM on H200 80 GB ZeroGPU.
-
-### 6.2 Out-of-scope (v1.1)
-
-`UnetLoaderGGUF` for <24 GB consumer NVIDIA GPUs. The workflow templates already accommodate the GGUF node; v1.1 adds a "Low VRAM" preset that swaps the loader.
-
-## 7. Progress reporting
-
-Two surfaces, layered:
-
-```
-┌── Status Banner (gr.HTML) ────────────────────────────────────┐
-│  ⠋  Stage 4/6 · Diffusion (Stage 1)                            │
-│      Step 18/30 · 1m 12s elapsed · ~2m 41s remaining           │
-│      MPS · 47 / 128 GB · transformer + gemma resident          │
-│  ████████████████░░░░░░░░░░░░░░  60%                           │
-└────────────────────────────────────────────────────────────────┘
-```
-
-Below: a `gr.Progress(track_tqdm=True)` picks up ComfyUI's sampler tqdm bars natively.
-
-### 7.1 Stage map per mode
-
-For each mode, `modes.py` declares the stage list mapping ComfyUI node ids → human-readable stage labels.
-
-I2V Balanced preset stage map:
-
-| # | Stage | ComfyUI node(s) | Typical share |
-|---|---|---|---|
-| 1 | Download missing models | (pre-flight) | 0–60s, only on first run |
-| 2 | Encode prompt | `LTXVGemmaCLIPModelLoader` + `CLIPTextEncode` | ~5% |
-| 3 | Encode image | `LoadImage` + image VAE encode | ~3% |
-| 4 | Diffusion (Stage 1, half-res) | `KSampler` × N steps | ~55% |
-| 5 | Spatial upscale (×2) | `LatentUpscaleModelLoader` + sampler | ~7% |
-| 6 | Diffusion (Stage 2, full-res, 4 distilled steps) | `KSampler` × 4 | ~20% |
-| 7 | Decode video | Video VAE decode + `VHS_VideoCombine` | ~10% |
-
-T2V is shorter (no image encode); Lipsync adds audio encode; Style Transfer is single-stage.
-
-### 7.2 Plumbing
-
-ComfyUI's `PromptExecutor` calls a per-node hook before each node runs. The backend translates `node_id → stage_index` via the mode's stage map. Within sampler nodes, `comfy.utils.PROGRESS_BAR_HOOK` fires per step. ETA: `(elapsed / progress) - elapsed` capped to a sensible minimum.
-
-## 8. Error handling
-
-| # | Category | Surface | Recovery |
-|---|---|---|---|
-| 1 | Setup / install (`comfyui/` missing, custom node import failure, no torch CUDA/MPS) | Startup banner replaces the UI; red card with the failing component and exact `setup.sh` command. App refuses to start. | Local: `bash setup.sh`. Spaces: surfaces in build log. |
-| 2 | Model download (network, HF auth, disk full) | Status banner inline error with retry button. Auth errors prompt for `HF_TOKEN`. | Auto-retry once with backoff for transient. Auth/disk are user-actionable. |
-| 3 | Workflow validation (input not provided, frame count not 8k+1, resolution not /32, image too large) | Caught client-side; Gradio inline validation; generate button disabled. | Auto-snap where unambiguous (frame count to nearest 8k+1, resolution to nearest /32). |
-| 4 | ComfyUI execution (node not found, shape mismatch, file format) | Status banner shows failing stage in red; collapsible `View full traceback ▾`. | Suggests `tools/refresh_models.py` for symlink issues, `bash setup.sh --update-comfy` for node issues. |
-| 5 | OOM | Status banner with stage + memory at failure; **Try Fast preset** button. | On catch: `unload_all_models()` + `empty_cache()`. Next click starts clean. |
-| 6 | ZeroGPU duration exceeded (Spaces) | Status banner: "Generation exceeded GPU budget"; suggests **Switch to Fast preset**. Partial output (if decoded) still shown. | `@spaces.GPU(duration=N)` raises a specific exception we catch and translate. |
-
-### 8.1 try/finally discipline
-
-```python
-async def submit(self, workflow):
-    try:
-        async for event in self._execute_with_progress(workflow):
-            yield event
-    except OutOfMemoryError as e:
-        yield ErrorEvent(category="oom", stage=self._current_stage, ...)
-    except spaces.exceptions.GPUDurationExceededError as e:
-        yield ErrorEvent(category="zerogpu_timeout", ...)
-    except Exception as e:
-        yield ErrorEvent(category="execution", traceback=fmt(e), ...)
-    finally:
-        comfy.model_management.unload_all_models()
-        torch.mps.empty_cache() if mps else torch.cuda.empty_cache()
-```
-
-The `finally` block is the single most important line for VRAM hygiene. Cancellation triggers the same path via `interrupt_current_processing()` raising `InterruptedError`.
-
-### 8.2 Logging
-
-- Local: `comfyui/comfyui.log` + `logs/aio.log` (10 MB rotation).
-- Spaces: stderr → Space logs panel; no file logging (Space disk is ephemeral except `/data`).
-- Status banner's traceback expander reads the last error from `logs/aio.log` (local) or stderr buffer (Spaces).
-
-### 8.3 Deliberate non-goals
-
-No silent retries on ambiguous errors. Surface loudly with a traceback rather than mask real bugs.
-
-## 9. Deployment
-
-### 9.1 Local
-
-```bash
-git clone https://github.com/<your-handle>/ltx2.3-AIO-generator
-cd ltx2.3-AIO-generator
-bash setup.sh
-source .venv/bin/activate
-python app.py
-```
-
-`setup.sh` (idempotent):
-
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-
-python3.11 -m venv .venv
-source .venv/bin/activate
-pip install -U pip
-
-git submodule update --init --recursive
-pip install -r comfyui/requirements.txt
-
-cd comfyui/custom_nodes
-for repo in \
-    Lightricks/ComfyUI-LTXVideo \
-    kijai/ComfyUI-KJNodes \
-    rgthree/rgthree-comfy \
-    Kosinkadink/ComfyUI-VideoHelperSuite \
-    pythongosssss/ComfyUI-Custom-Scripts ; do
-  name="${repo##*/}"
-  [[ -d "$name" ]] || git clone "https://github.com/$repo.git" "$name"
-  [[ -f "$name/requirements.txt" ]] && pip install -r "$name/requirements.txt"
-done
-cd ../..
-
-pip install -r requirements.txt
-python tools/refresh_models.py
-
-echo "Setup complete. Run: source .venv/bin/activate && python app.py"
-```
-
-### 9.2 HF Spaces (ZeroGPU, Pro tier)
-
-`README.md` front matter:
-
-```yaml
----
-title: LTX 2.3 All-in-One Video Generator
-emoji: 🎬
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: "5.0"
-app_file: app.py
-python_version: "3.11"
-suggested_hardware: zero-gpu
-hf_oauth: false
----
-```
-
-Bootstrap inside `app.py` runs once on cold start:
-
-```python
-def _bootstrap():
-    on_spaces = bool(os.environ.get("SPACES_ZERO_GPU"))
-    comfy_dir = pathlib.Path("/data/comfyui" if on_spaces else "comfyui")
-
-    if on_spaces and not comfy_dir.exists():
-        _git_clone(COMFYUI_REPO, comfy_dir, ref=COMFYUI_COMMIT)
-        for node_repo, node_ref in CUSTOM_NODES_PINNED:
-            _git_clone(node_repo, comfy_dir / "custom_nodes" / node_repo.split("/")[-1], ref=node_ref)
-        _pip_install_custom_node_reqs(comfy_dir)
-
-    sys.path.insert(0, str(comfy_dir))
-    os.environ["COMFY_MODELS_DIR"] = str(
-        pathlib.Path("/data/models") if on_spaces else (comfy_dir / "models")
-    )
-```
-
-Storage budget: `/data` ~50 GB on Pro. Lazy per-mode download keeps usage under budget when only some modes are exercised.
-
-Per-call duration: `@spaces.GPU(duration=...)` per preset:
-
-| Preset | Duration |
-|---|---|
-| Fast | 60 s |
-| Balanced | 120 s |
-| Quality | 300 s |
-
-UI auto-greys out presets whose duration exceeds the detected `SPACES_GPU_DURATION_LIMIT`.
-
-### 9.3 One-touch deploy (optional)
-
-`.github/workflows/deploy-space.yml`:
-
-```yaml
-on: { push: { branches: [main] } }
-jobs:
-  push-to-space:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with: { lfs: true }
-      - name: Push to HF Space
-        env: { HF_TOKEN: ${{ secrets.HF_TOKEN }} }
-        run: |
-          git remote add space https://user:$HF_TOKEN@huggingface.co/spaces/<you>/ltx2.3-aio
-          git push --force space main
-```
-
-### 9.4 Local vs Spaces — what's identical, what differs
-
-| Concern | Local | Spaces |
-|---|---|---|
-| Backend code | `ComfyUILibraryBackend` | `ComfyUILibraryBackend` (same class) |
-| GPU decorator | none (worker thread) | `@spaces.GPU(duration=preset_budget)` |
-| ComfyUI install | git submodule | runtime git clone to `/data` |
-| Models location | symlinks → `~/.cache/huggingface` | direct files in `/data/models` |
-| Logging | `logs/aio.log` + `comfyui/comfyui.log` | stderr → Space logs panel |
-| First-run latency | seconds (deps installed by setup.sh) | minutes (clone + first-mode download) |
-| Custom nodes update | re-run `setup.sh` | push commit; rebuild Space |
-
-## 10. Testing
-
-Layered so most tests run on CPU in seconds; only smoke touches GPU.
-
-| Layer | What it verifies | GPU? | Time |
-|---|---|---|---|
-| L1 — Unit | `workflow.load_template`, `set_input`, `validate` (pure functions over JSON dicts) | No | < 1 s |
-| L1 — Unit | Each mode's `parameterize_fn`: known input → expected patch list | No | < 1 s |
-| L1 — Unit | `MODEL_REGISTRY` lookups: every model in every workflow resolves to an HF repo+filename | No | < 1 s |
-| L2 — Graph validation | `load_template + parameterize_fn(canonical_inputs)` produces a workflow that ComfyUI's `validate_prompt` accepts | No | < 5 s |
-| L3 — Integration (CPU) | `models.ensure_models_for_mode()` against a fake HF cache; symlinks created correctly | No | < 2 s |
-| L4 — Smoke (GPU, opt-in) | One end-to-end generation per mode at minimum viable settings (Fast preset, lowest legal resolution, 1 step). `pytest --gpu`. | Yes | ~3 min for all 6 |
-
-### 10.1 Fixtures
-
-- `canonical_inputs(mode)` — known-good Gradio input dict per mode.
-- `fake_hf_cache(tmp_path)` — fake `~/.cache/huggingface/hub` with placeholder files.
-- `--gpu` flag enables L4. Default skips with a reason.
-- `--comfy-real` flag uses bundled ComfyUI for L2; default uses a stubbed validator.
-
-### 10.2 CI
-
-`.github/workflows/ci.yml` runs L1 + L2 + L3 on `ubuntu-latest`, Python 3.11, every push. ~30 s wall time. No GPU runner. Lint: `ruff check` + `ruff format --check`.
-
-### 10.3 Deliberate non-goals
-
-- No mocks for ComfyUI itself.
-- No visual regression tests for Gradio UI.
-- No property-based / fuzz testing for workflow params.
-
-## 11. Out of scope (v1)
-
-- **Lite mode for free Spaces tier** — `LTX23_AIO_LITE=1` env var that filters MODE_REGISTRY to T2V+I2V, locks Fast preset, swaps GGUF transformer. Designed in but not built in v1.
-- **Custom LoRA escape hatch** — Power-Lora-Loader-style add/remove rows. Categorized chrome covers v1; custom is a v1.1 toggle.
-- **GGUF Q4 transformer (`UnetLoaderGGUF`)** — for <24 GB consumer NVIDIA GPUs. Workflow templates accommodate the node; v1.1 adds the "Low VRAM" preset.
-- **Auto-launch user's existing ComfyUI** — current design uses bundled ComfyUI exclusively. v1.1 could add `LTX23_AIO_COMFYUI_URL` env var to point at an external server.
-- **Multi-prompt queueing** — Gradio default single-shot is fine. ComfyUI's queue isn't exposed.
-- **History persistence across sessions** — sidebar history is in-memory. Local could read `outputs/` on startup; Spaces session storage is ephemeral.
-
-## 12. Open questions / follow-ups
-
-- **Pinned ComfyUI commit:** select after a manual end-to-end run on the user's `~/Projects/comfyui/` install. Capture the commit SHA in `setup.sh` and the Spaces bootstrap.
-- **Spaces secrets:** HF Space front matter doesn't include any secrets; `HF_TOKEN` only needed if a gated repo is used (not currently). Document in README.
-- **Output retention on Spaces:** decide whether `/tmp/out_*.mp4` should also copy to `/data/outputs/` for download-after-restart. v1 default: no, ephemeral.
-- **`MODEL_REGISTRY` source of truth:** the registry maps filename → HF repo. We populate it once at v1 from Lightricks' README + Kijai's repo and freeze it; updates require a code change + tests.
-
-## 13. Implementation order (preview — full breakdown in implementation plan)
-
-1. **Repo skeleton** — directory layout, `.gitignore`, `CLAUDE.md`, `README.md` stub, `requirements.txt`.
-2. **`tools/extract_modes.py`** — extract six mode templates from the master workflow. Validates by re-loading each in ComfyUI's parser.
-3. **`workflow.py`** — pure-function library with L1 + L2 tests.
-4. **`modes.py`** — MODE_REGISTRY with `parameterize_fn` per mode + L1 tests.
-5. **`models.py`** — registry + `ensure_models_for_mode` + L3 tests with fake HF cache.
-6. **`backend.py`** — ComfyUILibraryBackend, async submit, progress hook plumbing. Local smoke test (L4) for Fast/T2V.
-7. **`ui.py`** — LoRA chrome, preset bar, status banner.
-8. **`app.py`** — Gradio Blocks, sidebar nav, mode rendering, generate handler. Manual end-to-end on Mac for all 6 modes.
-9. **`setup.sh`** — idempotent local bootstrap.
-10. **`README.md` + Spaces front matter** — push to a test Space, verify cold-start and one Fast generation.
-11. **CI workflow** — L1 + L2 + L3 on push.
-12. **Optional `.github/workflows/deploy-space.yml`** — push-to-Space CI.

docs/superpowers/specs/2026-05-01-topaz-drawer-redesign-design.md

@@ -1,104 +0,0 @@
-# Visual redesign — Topaz Cinema Slate + Drawer layout
-
-**Date:** 2026-05-01
-**Status:** Draft, awaiting user review
-**Related:** `2026-04-30-ltx23-aio-generator-design.md` (original spec)
-
----
-
-## Goal
-
-Replace the current `gr.themes.Soft()` cream + purple palette with a dark slate-and-amber palette (**Topaz Cinema Slate**), and replace the always-visible left sidebar with a **hamburger drawer** that opens by default on desktop and is hidden by default on tablet/phone. Both changes are surface-level — no logic or backend changes.
-
-## Why
-
-The current palette reads as a hobby AI demo, not a creative-pro tool. Slate-on-slate is gentlest on the eye when judging color-graded video output, and an amber CTA reads "render," not "alert." The drawer pattern gives the form panel full screen real estate on phones (the sidebar currently stacks above the form on `<700px`, eating half the viewport for nav), while still keeping the sidebar always-visible at desktop widths where it costs nothing.
-
-## Theme tokens
-
-Applied via `gr.themes.Base().set(...)` overrides on the Blocks theme:
-
-| Token | Value | Used for |
-|---|---|---|
-| `body_background_fill` | `#12161B` | App background |
-| `background_fill_primary` | `#12161B` | Form/page background |
-| `background_fill_secondary` | `#1A1F26` | Card / panel surface |
-| `block_background_fill` | `#1A1F26` | Component (input, slider) surface |
-| `body_text_color` | `#E6E8EB` | Primary text |
-| `body_text_color_subdued` | `#7C8693` | Secondary / hint text |
-| `border_color_primary` | `#262C35` | Card / input border |
-| `border_color_accent` | `#E0A458` | Focused input ring |
-| `button_primary_background_fill` | `#E0A458` | Generate button |
-| `button_primary_text_color` | `#12161B` | Generate button label |
-| `error_background_fill` | `#3A1E20` | Error banner background |
-| `error_text_color` | `#F4A6A8` | Error banner text |
-
-Fonts: `IBM Plex Sans` (UI 14 px) + `IBM Plex Mono` (mono 13 px), loaded from Google Fonts in the page `<head>` (Gradio's `head` parameter on `Blocks`, or via `_CUSTOM_CSS` `@import`).
-
-## Layout: hamburger drawer
-
-### Markup structure (logical, Gradio components)
-
-```
-gr.Row()                                     # header
-├── HamburgerButton (gr.Button, ≡ icon)      # toggles drawer
-├── gr.Markdown("LTX 2.3 Studio")            # title
-└── ActiveModeTag (gr.Markdown, amber pill)  # shows current mode
-
-gr.Row(elem_classes="layer")
-├── gr.Column(elem_classes="drawer", visible=...) # 220 px wide
-│   └── 6 mode buttons (existing)
-└── gr.Column(elem_classes="body-pane")
-    └── gr.Tabs(elem_classes="hidden-tabs")  # current 6 mode tabs
-```
-
-### Open / closed behavior
-
-- **Desktop (≥1024 px):** drawer open by default, occupies the left 220 px of the viewport. Hamburger still works as a toggle but most users leave it open.
-- **Tablet (700–1023 px):** drawer closed by default; opening it slides over content with a translucent overlay (`background: rgba(0,0,0,0.5)`). Tapping outside closes.
-- **Phone (<700 px):** same as tablet, but drawer takes 80 % of viewport width when open.
-
-State persists in `localStorage` (`ltx-drawer-open` key) so a user who closes the drawer on desktop stays closed across reloads.
-
-### Active mode header tag
-
-A small amber-bordered pill in the header (e.g., `T2V`, `A2V`, `LIPSYNC`) showing the currently selected mode. Updates whenever a mode button is clicked. Uses `IBM Plex Mono` 11 px so it reads as a label, not a button.
-
-### CSS approach
-
-Pure CSS, no JS framework. Use `:has()` and `<input type="checkbox">` hidden control for drawer toggle, OR a tiny inline `<script>` block that toggles a class on the body. Gradio doesn't sandbox custom scripts in `_CUSTOM_CSS`, but it does support the `head` parameter on `gr.Blocks` for inline `<script>`.
-
-Existing media queries (`@max-width: 700px`, `@max-width: 1024px`) collapse to a single `@max-width: 1023px` block since drawer behavior only differs at the desktop boundary.
-
-## Files touched
-
-- `app.py` — Blocks `theme=`, `head=` (fonts + drawer toggle script), `_CUSTOM_CSS` rewrite, header markup, drawer column wrapping the existing mode buttons
-- `README.md` — update screenshot if any (defer; we don't have one yet)
-
-No changes to `backend.py`, `models.py`, `modes.py`, `workflow.py`, `ui.py`.
-
-## Out of scope (do not touch)
-
-- Form layout inside each mode tab (prompt input, parameter sliders) — typography updates only via theme token cascade
-- Model status / settings panel content — these display the same info, just on the new palette
-- Mode set, generate flow, progress events — backend unchanged
-- Any CUDA / MPS / Spaces logic
-- Custom LoRA UI (still v1.1+)
-
-## Testing plan
-
-1. `python app.py` locally on macOS, browse `http://127.0.0.1:7860`
-2. Resize Chrome window: full width → 1024 px → 700 px → 380 px. Drawer should:
-   - stay open ≥1024 px
-   - hide & become overlay-on-hamburger <1024 px
-3. Click each of 6 mode buttons; confirm:
-   - active mode tag in header updates
-   - drawer auto-closes on phone after click (open-on-tap → click-to-pick → close)
-4. Click Generate on T2V (with Balanced preset, 320×480, 5 s). Confirm progress + output render correctly on the new palette.
-5. Trigger an error (e.g., empty prompt) and confirm error banner uses `#3A1E20` / `#F4A6A8`.
-
-## Risks
-
-- Gradio's `head` parameter is on `gr.Blocks` since 4.x — confirm it accepts a multi-line string with `<script>`.
-- `gr.themes.Base().set(...)` may not cover every component (e.g., `gr.Slider`'s track). If we hit a gap we add an `elem_classes` override and target it in `_CUSTOM_CSS` — incremental, low-risk.
-- The hidden-checkbox-and-`:has()` toggle pattern has Safari ≥15.4 compatibility, fine for our audience.

mcp_tools/__init__.py

@@ -0,0 +1,41 @@
+def __getattr__(name):
+    if name in ("types", "server", "client", "shared"):
+        raise ImportError(f"No module named 'mcp.{name}' in local mcp package")
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+from .get_task_list import handle_get_task_list
+from .run import handle_run
+from .get_task_status import handle_get_task_status
+from .error_schema import make_error, make_validation_error, make_not_found_error
+try:
+    from .mcp_gradio_integration import (
+        register_high_level_mcp_apis,
+        cleanup_dependencies_api_names,
+        patch_gradio_api_suppression,
+        HIGH_LEVEL_MCP_API_NAMES,
+    )
+except ImportError:
+    register_high_level_mcp_apis = None
+    cleanup_dependencies_api_names = None
+    patch_gradio_api_suppression = None
+    HIGH_LEVEL_MCP_API_NAMES = set()
+
+MCP_FUNCTIONS = [
+    handle_get_task_list,
+    handle_run,
+    handle_get_task_status,
+]
+
+__all__ = [
+    "handle_get_task_list",
+    "handle_run",
+    "handle_get_task_status",
+    "make_error",
+    "make_validation_error",
+    "make_not_found_error",
+    "register_high_level_mcp_apis",
+    "cleanup_dependencies_api_names",
+    "patch_gradio_api_suppression",
+    "HIGH_LEVEL_MCP_API_NAMES",
+    "MCP_FUNCTIONS",
+]

mcp_tools/common.py

@@ -0,0 +1,465 @@
+"""
+MCP Common Utilities & Data Structures
+Contains image and audio parsing utilities, task definitions, presets, and async task database for Lightricks LTX-2.5 Video Generation.
+"""
+
+import os
+import time
+import urllib.parse
+import urllib.request
+import urllib.error
+import base64
+import io
+import yaml
+from typing import Dict, Any
+from PIL import Image
+
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_YAML_DIR = os.path.join(_PROJECT_ROOT, "yaml")
+
+_MAX_MEDIA_DOWNLOAD_BYTES = 100 * 1024 * 1024  # 100 MB
+_MEDIA_DOWNLOAD_TIMEOUT = 30  # seconds
+_ALLOWED_IMAGE_CONTENT_TYPES = frozenset([
+    "image/png", "image/jpeg", "image/jpg", "image/gif",
+    "image/webp", "image/bmp", "image/tiff",
+])
+
+ASPECT_RATIO_PRESETS = {
+    "16:9 (Landscape)": {"width": 1344, "height": 768},
+    "9:16 (Portrait)": {"width": 768, "height": 1344},
+    "1:1 (Square)": {"width": 1024, "height": 1024},
+    "4:3 (Classic TV)": {"width": 1152, "height": 864},
+    "3:4 (Classic Portrait)": {"width": 864, "height": 1152},
+    "3:2 (Landscape)": {"width": 1248, "height": 832},
+    "2:3 (Portrait)": {"width": 832, "height": 1248},
+    "16:9 (Widescreen)": {"width": 1344, "height": 768},
+    "9:16 (Vertical)": {"width": 768, "height": 1344},
+    "3:2 (Photography)": {"width": 1248, "height": 832},
+    "2:3 (Photography Portrait)": {"width": 832, "height": 1248},
+}
+
+
+def _parse_image_param(image_param: Any) -> Any:
+    """Parse a Base64 Data URI, HTTP/HTTPS URL, or PIL.Image into a PIL Image object."""
+    if isinstance(image_param, Image.Image):
+        return image_param
+
+    if not isinstance(image_param, str) or not image_param.strip():
+        return None
+
+    image_param = image_param.strip()
+
+    if os.path.exists(image_param):
+        return Image.open(image_param)
+
+    if image_param.startswith("http://") or image_param.startswith("https://"):
+        return _download_image_from_url(image_param)
+
+    if image_param.startswith("data:image/"):
+        _, encoded = image_param.split(",", 1) if "," in image_param else ("", image_param)
+        data = base64.b64decode(encoded)
+        return Image.open(io.BytesIO(data))
+
+    if len(image_param) > 100:
+        try:
+            data = base64.b64decode(image_param)
+            return Image.open(io.BytesIO(data))
+        except Exception:
+            pass
+
+    raise ValueError(
+        "Invalid image parameter format. Expected a file path, Base64 Data URI, or an HTTP/HTTPS URL."
+    )
+
+
+def _download_image_from_url(url: str) -> Image.Image:
+    """Download an image from an HTTP/HTTPS URL and return it as a PIL Image."""
+    req = urllib.request.Request(url, headers={"User-Agent": "LTX-2.5-VideoGen-MCP/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=_MEDIA_DOWNLOAD_TIMEOUT) as resp:
+            content_type = resp.headers.get("Content-Type", "").split(";")[0].strip().lower()
+            if content_type and content_type not in _ALLOWED_IMAGE_CONTENT_TYPES:
+                raise ValueError(
+                    f"URL returned non-image Content-Type '{content_type}'. "
+                    f"Expected one of: {', '.join(sorted(_ALLOWED_IMAGE_CONTENT_TYPES))}."
+                )
+
+            content_length = resp.headers.get("Content-Length")
+            if content_length and int(content_length) > _MAX_MEDIA_DOWNLOAD_BYTES:
+                raise ValueError(
+                    f"Image at URL is too large ({int(content_length)} bytes). "
+                    f"Maximum allowed size is {_MAX_MEDIA_DOWNLOAD_BYTES} bytes."
+                )
+
+            chunks = []
+            total = 0
+            while True:
+                chunk = resp.read(8192)
+                if not chunk:
+                    break
+                total += len(chunk)
+                if total > _MAX_MEDIA_DOWNLOAD_BYTES:
+                    raise ValueError(f"Image download exceeded maximum allowed size of {_MAX_MEDIA_DOWNLOAD_BYTES} bytes.")
+                chunks.append(chunk)
+
+            data = b"".join(chunks)
+
+    except urllib.error.URLError as e:
+        raise ValueError(f"Failed to download image from URL: {e}") from e
+    except urllib.error.HTTPError as e:
+        raise ValueError(f"HTTP error {e.code} when downloading image from URL: {e.reason}") from e
+
+    if not data:
+        raise ValueError("Downloaded image data is empty.")
+
+    return Image.open(io.BytesIO(data))
+
+
+def _parse_audio_param(audio_param: Any) -> str:
+    """Parse audio parameter (local path, URL, or Base64) and return local file path."""
+    if not isinstance(audio_param, str) or not audio_param.strip():
+        return None
+
+    audio_param = audio_param.strip()
+    if os.path.exists(audio_param):
+        return os.path.abspath(audio_param)
+
+    input_dir = os.path.join(_PROJECT_ROOT, "input")
+    os.makedirs(input_dir, exist_ok=True)
+    temp_filename = os.path.join(input_dir, f"mcp_audio_{int(time.time()*1000)}.wav")
+
+    if audio_param.startswith("http://") or audio_param.startswith("https://"):
+        req = urllib.request.Request(audio_param, headers={"User-Agent": "LTX-2.5-VideoGen-MCP/1.0"})
+        with urllib.request.urlopen(req, timeout=_MEDIA_DOWNLOAD_TIMEOUT) as resp:
+            with open(temp_filename, "wb") as f:
+                f.write(resp.read())
+        return temp_filename
+
+    if audio_param.startswith("data:audio/") or len(audio_param) > 100:
+        try:
+            _, encoded = audio_param.split(",", 1) if "," in audio_param else ("", audio_param)
+            data = base64.b64decode(encoded)
+            with open(temp_filename, "wb") as f:
+                f.write(data)
+            return temp_filename
+        except Exception:
+            pass
+
+    return audio_param
+
+
+_GLOBAL_OPTIONAL_INPUTS_SCHEMA = {
+    "negative_prompt": {
+        "type": "string",
+        "default": "pc game, console game, video game, cartoon, childish, ugly",
+        "description": "Negative prompt for video generation."
+    },
+    "seed": {
+        "type": "integer",
+        "default": -1,
+        "description": "Random seed for video generation (-1 for random seed, >=0 for deterministic reproduction)."
+    },
+    "fps": {
+        "type": "string",
+        "enum": ["24fps", "25fps"],
+        "default": "24fps",
+        "description": "Output video frame rate (default: '24fps')."
+    },
+    "use_spatial_upscaler": {
+        "type": "boolean",
+        "default": False,
+        "description": "Enable 2x spatial latent upscaler."
+    },
+    "use_temporal_upscaler": {
+        "type": "boolean",
+        "default": False,
+        "description": "Enable 2x temporal latent upscaler."
+    },
+    "zero_gpu_duration": {
+        "type": "integer",
+        "default": 60,
+        "minimum": 1,
+        "description": "GPU execution time quota allocation in seconds on HuggingFace ZeroGPU spaces (default: 60)."
+    }
+}
+
+_TASK_DEFINITIONS = [
+    {
+        "task_type": "t2v",
+        "display_name": "Text-to-Video (LTX-2.5 T2V)",
+        "description": "Generate videos and synchronized audio simultaneously from text prompt.",
+        "required_inputs": ["prompt", "duration"],
+        "optional_inputs": ["negative_prompt", "resolution", "aspect_ratio", "width", "height", "fps", "seed", "use_spatial_upscaler", "use_temporal_upscaler", "zero_gpu_duration"],
+        "optional_inputs_schema": _GLOBAL_OPTIONAL_INPUTS_SCHEMA,
+        "aspect_ratio_presets": ASPECT_RATIO_PRESETS,
+        "example_json_params": {
+            "task_type": "t2v",
+            "prompt": "A futuristic sports car drifting through neon-lit streets at night, cinematic 4k",
+            "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+            "resolution": "768p",
+            "aspect_ratio": "16:9 (Landscape)",
+            "width": 1344,
+            "height": 768,
+            "duration": 5.0,
+            "fps": "24fps",
+            "seed": -1,
+            "use_spatial_upscaler": False,
+            "use_temporal_upscaler": False,
+            "zero_gpu_duration": 60
+        }
+    },
+    {
+        "task_type": "i2v",
+        "display_name": "Image-to-Video (LTX-2.5 I2V)",
+        "description": "Generate videos and audio starting from an initial image frame.",
+        "required_inputs": ["prompt", "start_image", "duration"],
+        "optional_inputs": ["negative_prompt", "resolution", "aspect_ratio", "width", "height", "fps", "seed", "use_spatial_upscaler", "use_temporal_upscaler", "zero_gpu_duration"],
+        "optional_inputs_schema": _GLOBAL_OPTIONAL_INPUTS_SCHEMA,
+        "aspect_ratio_presets": ASPECT_RATIO_PRESETS,
+        "example_json_params": {
+            "task_type": "i2v",
+            "prompt": "A majestic lion standing on a cliff edge roaring proudly",
+            "start_image": "https://example.com/start_frame.png",
+            "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+            "resolution": "768p",
+            "aspect_ratio": "16:9 (Landscape)",
+            "width": 1344,
+            "height": 768,
+            "duration": 5.0,
+            "seed": -1,
+            "zero_gpu_duration": 60
+        }
+    },
+    {
+        "task_type": "flf2v",
+        "display_name": "First & Last Frame-to-Video (LTX-2.5 FLF2V)",
+        "description": "Generate continuous video & audio smoothly transitioning from first frame to last frame.",
+        "required_inputs": ["prompt", "start_image", "end_image", "duration"],
+        "optional_inputs": ["negative_prompt", "resolution", "aspect_ratio", "width", "height", "fps", "seed", "use_spatial_upscaler", "use_temporal_upscaler", "zero_gpu_duration"],
+        "optional_inputs_schema": _GLOBAL_OPTIONAL_INPUTS_SCHEMA,
+        "aspect_ratio_presets": ASPECT_RATIO_PRESETS,
+        "example_json_params": {
+            "task_type": "flf2v",
+            "prompt": "A rose flower bud gradually opening into full bloom",
+            "start_image": "https://example.com/bud.png",
+            "end_image": "https://example.com/bloom.png",
+            "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+            "resolution": "768p",
+            "aspect_ratio": "16:9 (Landscape)",
+            "width": 1344,
+            "height": 768,
+            "duration": 5.0,
+            "seed": -1,
+            "zero_gpu_duration": 60
+        }
+    },
+    {
+        "task_type": "ta2v",
+        "display_name": "Text & Audio-to-Video (LTX-2.5 TA2V)",
+        "description": "Generate video synchronized with uploaded audio input.",
+        "required_inputs": ["prompt", "audio_file"],
+        "optional_inputs": ["negative_prompt", "resolution", "aspect_ratio", "width", "height", "fps", "seed", "use_spatial_upscaler", "use_temporal_upscaler", "zero_gpu_duration"],
+        "optional_inputs_schema": _GLOBAL_OPTIONAL_INPUTS_SCHEMA,
+        "aspect_ratio_presets": ASPECT_RATIO_PRESETS,
+        "example_json_params": {
+            "task_type": "ta2v",
+            "prompt": "Musicians playing jazz instruments on a dimly lit stage",
+            "audio_file": "https://example.com/jazz_track.mp3",
+            "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+            "resolution": "768p",
+            "aspect_ratio": "16:9 (Landscape)",
+            "width": 1344,
+            "height": 768,
+            "seed": -1,
+            "zero_gpu_duration": 60
+        }
+    },
+    {
+        "task_type": "ia2v",
+        "display_name": "Image & Audio-to-Video (LTX-2.5 IA2V)",
+        "description": "Generate video synchronized with uploaded audio and starting from initial image.",
+        "required_inputs": ["prompt", "start_image", "audio_file"],
+        "optional_inputs": ["negative_prompt", "resolution", "aspect_ratio", "width", "height", "fps", "seed", "use_spatial_upscaler", "use_temporal_upscaler", "zero_gpu_duration"],
+        "optional_inputs_schema": _GLOBAL_OPTIONAL_INPUTS_SCHEMA,
+        "aspect_ratio_presets": ASPECT_RATIO_PRESETS,
+        "example_json_params": {
+            "task_type": "ia2v",
+            "prompt": "The character in the image begins singing and dancing with expressive motion",
+            "start_image": "https://example.com/singer.png",
+            "audio_file": "https://example.com/vocal_track.mp3",
+            "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+            "resolution": "768p",
+            "aspect_ratio": "16:9 (Landscape)",
+            "width": 1344,
+            "height": 768,
+            "seed": -1,
+            "zero_gpu_duration": 60
+        }
+    }
+]
+
+_TASKS_DB: Dict[str, Dict[str, Any]] = {}
+
+
+class DummyProgress:
+    def __call__(self, progress=0.0, desc=None):
+        pass
+
+
+def _get_public_base_url() -> str:
+    """Auto-resolve the publicly accessible base URL."""
+    public_url = os.getenv("PUBLIC_URL") or os.getenv("BASE_URL")
+    if public_url:
+        return public_url.rstrip("/")
+
+    space_host = os.getenv("SPACE_HOST")
+    if space_host:
+        if not space_host.startswith("http://") and not space_host.startswith("https://"):
+            return f"https://{space_host}"
+        return space_host.rstrip("/")
+
+    try:
+        from core.settings import GRADIO_SERVER_NAME, SERVER_PORT
+    except ImportError:
+        GRADIO_SERVER_NAME = "127.0.0.1"
+        SERVER_PORT = 7860
+
+    server_name = os.getenv("GRADIO_SERVER_NAME", GRADIO_SERVER_NAME)
+    if server_name == "0.0.0.0":
+        server_name = "127.0.0.1"
+    port = os.getenv("GRADIO_SERVER_PORT", str(SERVER_PORT))
+
+    return f"http://{server_name}:{port}"
+
+
+
+def _execute_imagegen_pipeline(task_id: str, params: dict):
+    """Execute the LTX-2.5 video generation pipeline in the background and update _TASKS_DB."""
+    start_time = time.time()
+    try:
+        _TASKS_DB[task_id]["status"] = "processing"
+        _TASKS_DB[task_id]["progress"] = 10
+        _TASKS_DB[task_id]["updated_at"] = int(start_time)
+
+        task_type = params.get("task_type", "t2v")
+        # Aliases mapping
+        if task_type == "t2va": task_type = "t2v"
+        elif task_type == "i2va": task_type = "i2v"
+        elif task_type == "flf2va": task_type = "flf2v"
+
+        prompt = params.get("prompt", "")
+        negative_prompt = params.get("negative_prompt", "pc game, console game, video game, cartoon, childish, ugly")
+        resolution = params.get("resolution", "768p")
+        aspect_ratio = params.get("aspect_ratio", "16:9 (Landscape)")
+        width = int(params.get("width", 0))
+        height = int(params.get("height", 0))
+        duration = float(params.get("duration", 5.0))
+        fps = params.get("fps", "24fps")
+        seed = int(params.get("seed", -1))
+        zero_gpu_duration = int(params.get("zero_gpu_duration", 60))
+        use_spatial = bool(params.get("use_spatial_upscaler", False))
+        use_temporal = bool(params.get("use_temporal_upscaler", False))
+
+        ui_inputs = {
+            "positive_prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "resolution": resolution,
+            "aspect_ratio": aspect_ratio,
+            "width": width,
+            "height": height,
+            "duration": duration,
+            "fps": fps,
+            "seed": seed,
+            "batch_count": 1,
+            "zero_gpu_duration": zero_gpu_duration,
+            "use_spatial_upscaler": use_spatial,
+            "use_temporal_upscaler": use_temporal,
+        }
+
+        if task_type == "t2v":
+            from ui.shared.t2v.ltx2_5_t2v_logic import process_inputs
+        elif task_type == "i2v":
+            from ui.shared.i2v.ltx2_5_i2v_logic import process_inputs
+            start_raw = params.get("start_image") or params.get("first_frame_image") or params.get("first_frame")
+            ui_inputs["start_image"] = _parse_image_param(start_raw)
+        elif task_type == "flf2v":
+            from ui.shared.flf2v.ltx2_5_flf2v_logic import process_inputs
+            start_raw = params.get("start_image") or params.get("first_frame_image") or params.get("first_frame")
+            end_raw = params.get("end_image") or params.get("last_frame_image") or params.get("last_frame")
+            ui_inputs["start_image"] = _parse_image_param(start_raw)
+            ui_inputs["end_image"] = _parse_image_param(end_raw)
+        elif task_type == "ta2v":
+            from ui.shared.ta2v.ltx2_5_ta2v_logic import process_inputs
+            audio_raw = params.get("audio_file") or params.get("audio") or params.get("ref_audio1")
+            ui_inputs["audio_file"] = _parse_audio_param(audio_raw)
+        elif task_type == "ia2v":
+            from ui.shared.ia2v.ltx2_5_ia2v_logic import process_inputs
+            start_raw = params.get("start_image") or params.get("first_frame_image") or params.get("first_frame")
+            audio_raw = params.get("audio_file") or params.get("audio") or params.get("ref_audio1")
+            ui_inputs["start_image"] = _parse_image_param(start_raw)
+            ui_inputs["audio_file"] = _parse_audio_param(audio_raw)
+        else:
+            raise ValueError(f"Unsupported task_type '{task_type}'")
+
+        _TASKS_DB[task_id]["progress"] = 50
+
+        from core.generation_logic import generate_ltx_video_wrapper
+        output = generate_ltx_video_wrapper(process_inputs, ui_inputs, progress=DummyProgress())
+
+        try:
+            from core.settings import OUTPUT_DIR
+        except ImportError:
+            OUTPUT_DIR = os.path.join(_PROJECT_ROOT, "output")
+
+        os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+        import tempfile
+        import gradio.processing_utils as pu
+
+        gradio_cache_dir = os.path.join(tempfile.gettempdir(), "gradio")
+        os.makedirs(gradio_cache_dir, exist_ok=True)
+
+        base_url = _get_public_base_url()
+        videos = []
+        raw_list = output if isinstance(output, list) else ([output] if output else [])
+        for idx, item in enumerate(raw_list):
+            target_path = None
+            if isinstance(item, str) and os.path.exists(item):
+                target_path = item
+
+            if target_path:
+                try:
+                    cached_path = pu.save_file_to_cache(target_path, cache_dir=gradio_cache_dir)
+                    abs_path = os.path.abspath(cached_path).replace("\\", "/")
+                except Exception as e:
+                    print(f"Warning: Failed to cache video file to Gradio temp dir: {e}")
+                    abs_path = os.path.abspath(target_path).replace("\\", "/")
+
+                url = f"{base_url}/gradio_api/file={urllib.parse.quote(abs_path)}"
+                videos.append(url)
+            elif item:
+                videos.append(str(item))
+
+        execution_time = round(time.time() - start_time, 2)
+        _TASKS_DB[task_id]["status"] = "completed"
+        _TASKS_DB[task_id]["progress"] = 100
+        _TASKS_DB[task_id]["completed_at"] = int(time.time())
+        _TASKS_DB[task_id]["result"] = {
+            "task_type": task_type,
+            "videos": videos,
+            "video_path": raw_list[0] if raw_list and isinstance(raw_list[0], str) else None,
+            "seed": seed,
+            "resolution": resolution,
+            "aspect_ratio": aspect_ratio,
+            "duration": duration,
+            "execution_time_seconds": execution_time,
+        }
+
+    except Exception as e:
+        _TASKS_DB[task_id]["status"] = "failed"
+        _TASKS_DB[task_id]["progress"] = 0
+        _TASKS_DB[task_id]["failed_at"] = int(time.time())
+        _TASKS_DB[task_id]["error"] = {
+            "code": "EXECUTION_ERROR",
+            "message": str(e),
+        }

mcp_tools/error_schema.py

@@ -0,0 +1,85 @@
+"""
+Unified MCP tool error response format.
+
+Error code enumeration:
+  - INVALID_PARAMS:         Parameter validation failed (missing required fields, type errors, value out of range)
+  - MODEL_NOT_FOUND:        The specified model name does not exist
+  - ARCHITECTURE_NOT_FOUND: The specified architecture name does not exist
+  - CHAIN_TYPE_NOT_FOUND:   The specified chain/injector type is invalid
+  - FEATURE_NOT_SUPPORTED:  The current model does not support the requested feature
+  - TASK_NOT_FOUND:         The async task ID does not exist
+  - MODEL_OOM:              GPU out of memory
+  - INTERNAL_ERROR:         Internal server error
+"""
+
+
+def make_error(code: str, message: str, details: dict = None) -> dict:
+    """
+    Construct a unified MCP tool error response.
+
+    Args:
+        code:    Error code (UPPER_SNAKE_CASE format)
+        message: Human-readable error description
+        details: Optional details dictionary
+
+    Returns:
+        Standardized error response dictionary
+    """
+    error = {
+        "error": {
+            "code": code,
+            "message": message,
+        }
+    }
+    if details:
+        error["error"]["details"] = details
+    return error
+
+
+def make_validation_error(
+    message: str = "Request validation failed.",
+    missing_fields: list = None,
+    invalid_fields: dict = None,
+) -> dict:
+    """
+    Construct a parameter validation failure error response.
+
+    Args:
+        message:        Error description
+        missing_fields: List of missing required field names
+        invalid_fields: Key-value pairs of invalid fields, key=field name, value=reason description
+
+    Returns:
+        Standardized INVALID_PARAMS error response
+    """
+    details = {}
+    if missing_fields:
+        details["missing_fields"] = missing_fields
+    if invalid_fields:
+        details["invalid_fields"] = invalid_fields
+    return make_error("INVALID_PARAMS", message, details if details else None)
+
+
+def make_not_found_error(resource_type: str, resource_id: str) -> dict:
+    """
+    Construct a resource-not-found error response.
+
+    Args:
+        resource_type: Resource type (e.g., "model", "architecture", "chain_type", "task")
+        resource_id:   Resource identifier
+
+    Returns:
+        Standardized *_NOT_FOUND error response
+    """
+    code_map = {
+        "model": "MODEL_NOT_FOUND",
+        "architecture": "ARCHITECTURE_NOT_FOUND",
+        "chain_type": "CHAIN_TYPE_NOT_FOUND",
+        "task": "TASK_NOT_FOUND",
+    }
+    code = code_map.get(resource_type, f"{resource_type.upper()}_NOT_FOUND")
+    return make_error(
+        code,
+        f"The specified {resource_type} '{resource_id}' was not found.",
+        {"resource_type": resource_type, "resource_id": resource_id},
+    )

mcp_tools/get_task_list.py

@@ -0,0 +1,11 @@
+"""
+MCP Tool: get_task_list
+Get a list of all supported image generation task types along with their required/optional parameter lists.
+"""
+
+from .common import _TASK_DEFINITIONS
+
+
+def handle_get_task_list() -> list:
+    """Get a list of all supported image generation task types along with their required/optional parameter lists."""
+    return _TASK_DEFINITIONS

mcp_tools/get_task_status.py

@@ -0,0 +1,21 @@
+"""
+MCP Tool: get_task_status
+Query the processing progress and final results of an async image generation task.
+"""
+
+from .common import _TASKS_DB
+from .error_schema import make_validation_error, make_not_found_error
+
+
+def handle_get_task_status(task_id: str) -> dict:
+    """Query the processing progress and final results of an async image generation task."""
+    if not task_id:
+        return make_validation_error(
+            "Parameter 'task_id' is required.",
+            missing_fields=["task_id"],
+        )
+
+    if task_id not in _TASKS_DB:
+        return make_not_found_error("task", task_id)
+
+    return _TASKS_DB[task_id]

mcp_tools/mcp_gradio_integration.py

@@ -0,0 +1,120 @@
+"""
+MCP & Gradio Integration Module
+
+Provides:
+1. register_high_level_mcp_apis: Expose high-level abstract API/MCP endpoints (using gr.api without polluting the visual UI structure)
+2. cleanup_dependencies_api_names: Force cleanup of show_api attribute for non-high-level APIs in dependencies
+3. patch_gradio_api_suppression: No-op implementation retained for backward compatibility
+"""
+
+import json
+import gradio as gr
+
+from .get_task_list import handle_get_task_list
+from .run import handle_run
+from .get_task_status import handle_get_task_status
+
+HIGH_LEVEL_MCP_API_NAMES = {
+    "get_task_list",
+    "run",
+    "get_task_status",
+}
+
+
+def sanitize_keys(obj):
+    """Recursively ensure all dictionary keys are converted to str type to avoid Gradio 5 orjson TypeError: Dict key must be str."""
+    if isinstance(obj, dict):
+        return {str(k): sanitize_keys(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [sanitize_keys(x) for x in obj]
+    elif isinstance(obj, tuple):
+        return tuple(sanitize_keys(x) for x in obj)
+    return obj
+
+
+def patch_gradio_api_suppression():
+    """Retained for backward compatibility (no-op)."""
+    pass
+
+
+def cleanup_dependencies_api_names(demo):
+    """
+    Clean up residual auto-generated API names in demo.fns and demo.dependencies.
+    Force only high-level abstract MCP APIs to be exposed as public endpoints.
+    """
+    for fn in demo.fns.values():
+        api_name = getattr(fn, "api_name", None)
+        if api_name not in HIGH_LEVEL_MCP_API_NAMES:
+            fn.show_api = False
+
+    deps = getattr(demo, "dependencies", None)
+    if deps is None and hasattr(demo, "config") and isinstance(demo.config, dict):
+        deps = demo.config.get("dependencies", [])
+
+    if deps:
+        for dep in deps:
+            if isinstance(dep, dict):
+                api_name = dep.get("api_name")
+                if api_name not in HIGH_LEVEL_MCP_API_NAMES:
+                    dep["show_api"] = False
+
+    print("[MCP Protection] Cleaned up demo dependencies. Suppressed atomic API endpoints.")
+
+
+def register_high_level_mcp_apis(demo):
+    """
+    Explicitly register high-level abstract MCP API endpoints on the Gradio demo using gr.api.
+    Using gr.api() never adds any visual UI components (such as Row, Textbox, Button, etc.), avoiding duplicate interface rendering.
+    """
+    def get_task_list() -> list:
+        """[Recommended Flow Step 1] Get a list of supported video generation task types (t2va, i2va, flf2va, ref2va) along with their required/optional parameters and paste-and-run example_json_params."""
+        return sanitize_keys(handle_get_task_list())
+
+    def run(json_params: str = "{}") -> dict:
+        """[Recommended Flow Step 2] Unified video generation task execution interface (t2va, i2va, flf2va, ref2va). Accepts a JSON string or dict of parameters.
+
+REQUIRED PARAMETERS PER TASK TYPE:
+- t2va: task_type, prompt, width, height, duration
+- i2va: task_type, prompt, width, height, duration, first_frame_image
+- flf2va: task_type, prompt, width, height, duration, first_frame_image, last_frame_image
+- ref2va: task_type, prompt, width, height, duration
+
+GLOBAL OPTIONAL CONTROL PARAMETERS:
+- seed (int): Random seed (-1 for random, >=0 for deterministic reproducibility). Default: -1.
+- zero_gpu_duration (int): GPU quota allocation in seconds on HuggingFace ZeroGPU spaces (default: 120).
+
+REF2VA OPTIONAL MEDIA REFERENCES:
+- ref_image1..9: Image file path or URL
+- ref_video1..3: Video file path
+- ref_audio1..3: Audio file path
+"""
+        try:
+            if isinstance(json_params, dict):
+                params = json_params
+            else:
+                params = json.loads(json_params or "{}")
+        except Exception as e:
+            return {"error": {"code": "INVALID_JSON", "message": f"Failed to parse JSON params: {e}"}}
+        return sanitize_keys(handle_run(params))
+
+    def get_task_status(task_id: str = "") -> dict:
+        """Query the progress, status, and final generated results of an async video generation task."""
+        if isinstance(task_id, dict):
+            task_id = task_id.get("task_id") or task_id.get("id") or ""
+        task_id_str = task_id.strip() if isinstance(task_id, str) else ""
+        return sanitize_keys(handle_get_task_status(task_id_str))
+
+    funcs = [
+        get_task_list,
+        run,
+        get_task_status,
+    ]
+
+    for func in funcs:
+        gr.api(func)
+
+    for fn in demo.fns.values():
+        if getattr(fn, "api_name", None) in HIGH_LEVEL_MCP_API_NAMES:
+            fn.show_api = True
+
+    print(f"[MCP Integration] Successfully registered {len(funcs)} High-Level Abstract MCP APIs via gr.api().")

mcp_tools/run.py

@@ -0,0 +1,113 @@
+"""
+MCP Tool: run
+Unified video generation task submission and execution interface for Lightricks LTX-2.5.
+"""
+
+import time
+import uuid
+import threading
+from .common import (
+    _TASK_DEFINITIONS,
+    _TASKS_DB,
+    _execute_imagegen_pipeline,
+)
+from .error_schema import make_validation_error
+
+
+def handle_run(params: dict) -> dict:
+    """
+    Unified Lightricks LTX-2.5 video generation task execution interface.
+
+    [SUPPORTED TASK TYPES]
+    - t2v: Text-to-Video. Required: prompt, duration.
+    - i2v: Image-to-Video. Required: prompt, start_image, duration.
+    - flf2v: First & Last Frame-to-Video. Required: prompt, start_image, end_image, duration.
+    - ta2v: Text & Audio-to-Video. Required: prompt, audio_file.
+    - ia2v: Image & Audio-to-Video. Required: prompt, start_image, audio_file.
+
+    [GLOBAL OPTIONAL PARAMETERS]
+    - negative_prompt (str): Negative prompt (default: "pc game, console game, video game, cartoon, childish, ugly").
+    - resolution (str): Resolution preset: "544p", "768p", or "1080p" (default: "768p").
+    - aspect_ratio (str): Aspect ratio: "16:9 (Landscape)", "9:16 (Portrait)", "1:1 (Square)", "4:3 (Classic TV)", "3:4 (Classic Portrait)", "3:2 (Landscape)", "2:3 (Portrait)" (default: "16:9 (Landscape)").
+    - width (int): Custom width in pixels (overrides preset if specified).
+    - height (int): Custom height in pixels (overrides preset if specified).
+    - fps (str): Frame rate: "24fps" or "25fps" (default: "24fps").
+    - seed (int): Random seed (-1 for random seed, >=0 for deterministic reproduction). Default: -1.
+    - use_spatial_upscaler (bool): Enable 2x spatial latent upscaler (default: False).
+    - use_temporal_upscaler (bool): Enable 2x temporal latent upscaler (default: False).
+    - zero_gpu_duration (int): GPU execution time quota allocation in seconds on HuggingFace ZeroGPU spaces (default: 60).
+
+    [Paste-and-Run json_params Example (t2v)]
+    {
+        "task_type": "t2v",
+        "prompt": "A futuristic sports car driving through a cyber city at sunset, 4k resolution",
+        "negative_prompt": "pc game, console game, video game, cartoon, childish, ugly",
+        "resolution": "768p",
+        "aspect_ratio": "16:9 (Landscape)",
+        "width": 1344,
+        "height": 768,
+        "duration": 5.0,
+        "seed": -1,
+        "zero_gpu_duration": 60
+    }
+    """
+    if not isinstance(params, dict):
+        return make_validation_error("Request params must be an object.")
+
+    valid_tasks = [t["task_type"] for t in _TASK_DEFINITIONS]
+    # Add alias mappings
+    alias_map = {"t2va": "t2v", "i2va": "i2v", "flf2va": "flf2v"}
+    raw_task_type = params.get("task_type")
+    task_type = alias_map.get(raw_task_type, raw_task_type)
+
+    if not task_type or task_type not in valid_tasks:
+        return make_validation_error(
+            f"Invalid or missing 'task_type'. Must be one of {valid_tasks}.",
+            invalid_fields={"task_type": f"Must be in {valid_tasks}"},
+        )
+
+    task_def = next((t for t in _TASK_DEFINITIONS if t["task_type"] == task_type), None)
+    required_fields = task_def["required_inputs"] if task_def else ["prompt"]
+
+    missing = []
+    for req_field in required_fields:
+        if req_field not in params or params[req_field] is None or params[req_field] == "":
+            # Check legacy alias keys
+            if req_field == "start_image" and (params.get("first_frame_image") or params.get("first_frame")):
+                continue
+            if req_field == "end_image" and (params.get("last_frame_image") or params.get("last_frame")):
+                continue
+            if req_field == "audio_file" and (params.get("audio") or params.get("ref_audio1")):
+                continue
+            missing.append(req_field)
+
+    if missing:
+        return make_validation_error(
+            f"Missing required parameter(s) for task '{task_type}': {', '.join(missing)}",
+            missing_fields=missing,
+        )
+
+    task_id = f"v_task_{uuid.uuid4().hex[:10]}"
+    created_at = int(time.time())
+
+    _TASKS_DB[task_id] = {
+        "task_id": task_id,
+        "status": "queued",
+        "progress": 0,
+        "created_at": created_at,
+    }
+
+    async_exec = params.get("async_execution", False)
+
+    if async_exec:
+        t = threading.Thread(target=_execute_imagegen_pipeline, args=(task_id, params), daemon=True)
+        t.start()
+        return {
+            "status": "queued",
+            "task_id": task_id,
+            "poll_interval_ms": 2000,
+            "message": "Task queued successfully. Poll get_task_status for results.",
+        }
+    else:
+        _execute_imagegen_pipeline(task_id, params)
+        return _TASKS_DB[task_id]

mcp_tools/tool_handlers.py

@@ -0,0 +1,19 @@
+"""
+MCP Tool Handlers — Aggregation entry point.
+Core logic is located in individual task files (get_task_list.py, run.py, get_task_status.py).
+"""
+
+from .get_task_list import handle_get_task_list
+from .run import handle_run
+from .get_task_status import handle_get_task_status
+from .common import (
+    _TASK_DEFINITIONS,
+    _TASKS_DB,
+    _load_yaml,
+)
+
+__all__ = [
+    "handle_get_task_list",
+    "handle_run",
+    "handle_get_task_status",
+]

models.py

@@ -1,338 +0,0 @@
-"""Model file registry: maps filename -> (HuggingFace repo, subfolder).
-
-Lookups are by filename only — the same filename in two different repos is not
-supported. If that ever happens we'll qualify by ComfyUI loader-type.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import pathlib
-from collections.abc import Iterator
-from dataclasses import dataclass
-
-from huggingface_hub import hf_hub_download
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class ModelEntry:
-    repo_id: 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] = {
-    # Main LTX 2.3 transformer + LoRAs + upscalers
-    "ltx-2.3-22b-distilled.safetensors": ModelEntry("Lightricks/LTX-2.3", comfy_type="checkpoints"),
-    "ltx-2.3-22b-dev.safetensors": ModelEntry("Lightricks/LTX-2.3", comfy_type="checkpoints"),
-    "ltx-2.3-spatial-upscaler-x2-1.0.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="latent_upscale_models"
-    ),
-    "ltx-2.3-22b-distilled-lora-384.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3", comfy_type="loras"
-    ),
-    # Gemma 3 12B (5 shards + tokenizer/preprocessor)
-    **{
-        f"model-{i:05d}-of-00005.safetensors": ModelEntry(
-            "google/gemma-3-12b-it-qat-q4_0-unquantized",
-            comfy_type="text_encoders",
-            subfolder="gemma-3-12b-it",
-        )
-        for i in range(1, 6)
-    },
-    "model.safetensors.index.json": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    "tokenizer.model": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    "preprocessor_config.json": ModelEntry(
-        "google/gemma-3-12b-it-qat-q4_0-unquantized",
-        comfy_type="text_encoders",
-        subfolder="gemma-3-12b-it",
-    ),
-    # Kijai's LTX 2.3 ComfyUI assets — files live in vae/ and text_encoders/
-    # subfolders within the repo, not at root.
-    "LTX23_video_vae_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", subfolder="vae", comfy_type="vae"
-    ),
-    "LTX23_audio_vae_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", subfolder="vae", comfy_type="vae"
-    ),
-    "ltx-2.3_text_projection_bf16.safetensors": ModelEntry(
-        "Kijai/LTX2.3_comfy", subfolder="text_encoders", comfy_type="text_encoders"
-    ),
-    # IC-LoRAs
-    "ltx-2.3-22b-ic-lora-union-control-ref0.5.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control", comfy_type="loras"
-    ),
-    "ltx-2.3-22b-ic-lora-motion-track-control-ref0.5.safetensors": ModelEntry(
-        "Lightricks/LTX-2.3-22b-IC-LoRA-Motion-Track-Control", comfy_type="loras"
-    ),
-    "ltx-2-19b-ic-lora-detailer.safetensors": ModelEntry(
-        "Lightricks/LTX-2-19b-IC-LoRA-Detailer", comfy_type="loras"
-    ),
-    "ltx-2-19b-ic-lora-pose-control.safetensors": ModelEntry(
-        "Lightricks/LTX-2-19b-IC-LoRA-Pose-Control", comfy_type="loras"
-    ),
-    # Camera-control LoRAs (one repo each — explicit hyphen-aware capitalization
-    # produces "Dolly-In", "Dolly-Out", etc. matching the actual HF org repo names.)
-    **{
-        f"ltx-2-19b-lora-camera-control-{movement}.safetensors": ModelEntry(
-            f"Lightricks/LTX-2-19b-LoRA-Camera-Control-{'-'.join(p.capitalize() for p in movement.split('-'))}",
-            comfy_type="loras",
-        )
-        for movement in (
-            "static",
-            "dolly-in",
-            "dolly-out",
-            "dolly-left",
-            "dolly-right",
-            "jib-up",
-            "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",
-    ),
-}
-
-
-LOADER_NODE_TYPES: tuple[str, ...] = (
-    "CheckpointLoaderSimple",
-    "UNETLoader",
-    "UnetLoaderGGUF",
-    "VAELoader",
-    "VAELoaderKJ",
-    "LoraLoader",
-    "Power Lora Loader (rgthree)",
-    "LTXVGemmaCLIPModelLoader",
-    "LatentUpscaleModelLoader",
-    "DualCLIPLoader",
-)
-
-
-_USER_INPUT_LOADERS = {"LoadImage", "VHS_LoadVideo", "VHS_LoadAudioUpload"}
-_MODEL_EXTS = (".safetensors", ".gguf", ".pt", ".bin", ".ckpt")
-
-
-def _walk_for_filenames(value, into: set[str]) -> None:
-    """Depth-first walk of a node's inputs, picking out model filenames.
-
-    Power Lora Loader stores its rows nested as `inputs.lora_1 = {on, lora,
-    strength}` and similar — a flat values() loop misses these. Recurse
-    through dicts and lists/tuples so nested filenames are caught.
-
-    Skips Power Lora Loader rows with `on: false` — those LoRAs aren't
-    actually loaded at runtime so there's no point downloading them.
-    """
-    if isinstance(value, str):
-        if value.endswith(_MODEL_EXTS) or value == "tokenizer.model":
-            into.add(value)
-    elif isinstance(value, dict):
-        # Power Lora Loader row: {"on": bool, "lora": "...", "strength": ...}
-        if "on" in value and "lora" in value and not value.get("on"):
-            return
-        for v in value.values():
-            _walk_for_filenames(v, into)
-    elif isinstance(value, (list, tuple)):
-        for v in value:
-            _walk_for_filenames(v, into)
-
-
-def walk_workflow_for_models(workflow: dict) -> set[str]:
-    """Return the set of model filenames referenced by the API-format workflow.
-
-    Walks `{node_id: {class_type, inputs}}` and recursively scans each node's
-    inputs for strings ending in a model extension. Skips loaders that read
-    user-supplied files (LoadImage, VHS_LoadVideo, VHS_LoadAudioUpload).
-    Unknown filenames are harmless — `ensure_models` log-warns and skips
-    anything not in the registry, so being inclusive here costs nothing.
-    """
-    needed: set[str] = set()
-    for node in workflow.values():
-        if not isinstance(node, dict):
-            continue
-        if node.get("class_type") in _USER_INPUT_LOADERS:
-            continue
-        _walk_for_filenames(node.get("inputs") or {}, needed)
-    return needed
-
-
-@dataclass
-class DownloadEvent:
-    filename: str
-    mb_done: float
-    mb_total: float
-
-
-def _on_spaces() -> bool:
-    return bool(os.environ.get("SPACES_ZERO_GPU"))
-
-
-def _comfy_models_dir() -> pathlib.Path:
-    raw = os.environ.get("COMFY_MODELS_DIR")
-    if raw:
-        return pathlib.Path(raw)
-    if _on_spaces():
-        return pathlib.Path.home() / "comfyui" / "models"
-    return pathlib.Path(__file__).parent / "comfyui" / "models"
-
-
-def ensure_models(filenames: set[str]) -> Iterator[DownloadEvent]:
-    """Ensure each requested model is materialized in comfyui/models/<type>/.
-
-    Local mode: hf_hub_download into the user's HF cache; symlink to comfyui/models/.
-    Spaces mode: hf_hub_download with cache_dir under $HOME (no /data dependency);
-    files staged at ~/comfyui/models/<comfy_type>/<filename>.
-
-    Files not in MODEL_REGISTRY are skipped (with a warning) — useful when the
-    workflow has been manually customized with non-canonical filenames that the
-    user supplies via their own ComfyUI install.
-
-    Yields DownloadEvent on each successfully materialized file (mb_done==mb_total
-    when already cached locally).
-    """
-    comfy_models = _comfy_models_dir()
-    cache_dir = pathlib.Path(
-        os.environ.get(
-            "HF_HUB_CACHE",
-            pathlib.Path.home() / ".cache" / "huggingface" / "hub",
-        )
-    )
-
-    for filename in filenames:
-        if filename not in MODEL_REGISTRY:
-            logger.warning(
-                "model file %r not in MODEL_REGISTRY; skipping. "
-                "Add an entry to MODEL_REGISTRY or override the loader in the workflow.",
-                filename,
-            )
-            continue
-        entry = MODEL_REGISTRY[filename]
-
-        # Short-circuit: if the file is already present at its expected location
-        # 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
-
-        # 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=hf_path,
-                    cache_dir=str(cache_dir),
-                    local_dir=None,
-                )
-            )
-            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 matching file (test mode +
-            # offline mode). Look for either the workflow filename OR the
-            # HF-side filename. Skip `.no_exist/` markers and 0-byte stubs —
-            # the HF lib leaves those after a 404, and symlinking them past
-            # safetensors yields a confusing "header too small" error
-            # downstream.
-            def _viable(path):
-                try:
-                    return ".no_exist" not in path.parts and path.stat().st_size > 64
-                except OSError:
-                    return False
-
-            candidates = [
-                p for p in cache_dir.rglob(filename) if _viable(p)
-            ] or [
-                p for p in cache_dir.rglob(hf_filename) if _viable(p)
-            ]
-            if not candidates:
-                logger.warning(
-                    "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)
-
-        # Stage at comfy_models/<comfy_type>/<filename> (workflow-expected name).
-        dest_dir = comfy_models / entry.comfy_type
-        dest_dir.mkdir(parents=True, exist_ok=True)
-        dest = dest_dir / filename
-
-        if dest.is_symlink() or dest.exists():
-            dest.unlink()
-        dest.symlink_to(source)
-
-
-def ensure_models_for_mode(mode: str) -> Iterator[DownloadEvent]:
-    """Convenience: walk a mode's workflow and ensure all referenced models exist."""
-    import workflow as workflow_module  # local import to avoid cycle at import time
-
-    wf = workflow_module.load_template(mode)
-    needed = walk_workflow_for_models(wf)
-    yield from ensure_models(needed)

modes.py

@@ -1,217 +0,0 @@
-"""MODE_REGISTRY — one Mode entry per generation mode.
-
-Each Mode declares:
-- name: short id ("t2v", "i2v", ...)
-- label: display name
-- icon: single-character or emoji icon for the sidebar
-- stage_map: list of (label, expected_share_pct) for the status banner
-- parameterize_fn: (Gradio inputs dict) -> list[(node_id, field_name, value)]
-
-The workflows live in `workflows/<mode>.json` in ComfyUI's API format
-(`{node_id_str: {class_type, inputs}}` — produced by the editor's
-"Save (API Format)" feature). That format is what `PromptExecutor.execute()`
-consumes directly, so parameterize_fns just patch field values by node id;
-no graph→API conversion is needed.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any
-
-# (node_id, field_name, value)
-Patch = tuple[str, str, Any]
-ParameterizeFn = Callable[[dict[str, Any]], list[Patch]]
-
-
-@dataclass(frozen=True)
-class Stage:
-    label: str
-    share_pct: int  # rough share of total time, sums to ~100 across stages
-
-
-@dataclass(frozen=True)
-class Mode:
-    name: str
-    label: str
-    icon: str
-    parameterize_fn: ParameterizeFn
-    stage_map: list[Stage] = field(default_factory=list)
-
-
-MODE_REGISTRY: dict[str, Mode] = {}
-
-
-# ---------------------------------------------------------------------------
-# Shared user-input node IDs across all 6 mode API workflows.
-# Captured 2026-05-01 from `/Users/techfreakworm/Downloads/workflows/*_api.json`
-# (master workflow exported via "Save API Format" per mode).
-# ---------------------------------------------------------------------------
-
-NODE_PROMPT = "5536"  # CLIPTextEncode (positive) — inputs.text
-NODE_NEG_PROMPT = "5537"  # CLIPTextEncode (negative) — inputs.text
-NODE_WIDTH = "5383"  # INTConstant — inputs.value
-NODE_HEIGHT = "5382"  # INTConstant — inputs.value
-NODE_FPS = "5445"  # INTConstant — inputs.value
-NODE_CLIP_SECONDS = "196"  # mxSlider — inputs.Xi (length in seconds; frames = Xi*fps+1)
-NODE_IMAGE_1 = "149"  # LoadImage (first frame / portrait) — inputs.image
-NODE_IMAGE_2 = "5437"  # LoadImage (last frame for keyframe mode) — inputs.image
-NODE_AUDIO = "5400"  # VHS_LoadAudioUpload — inputs.audio
-NODE_VIDEO = "5444"  # VHS_LoadVideo — inputs.video
-
-# Per-mode RandomNoise (subgraph-internal): id format `<subgraph_inst>:<inner>`.
-SEED_NODE_BY_MODE: dict[str, str] = {
-    "t2v": "5464:5539",
-    "a2v": "463:5540",
-    "i2v": "209:5541",
-    "lipsync": "521:5542",
-    "keyframe": "670:5543",
-    "style": "5364:5545",
-}
-
-
-def _seconds_for(frames: int, fps: int) -> int:
-    """Inverse of `frames = seconds*fps + 1` from the master's MathExpression."""
-    return max(1, (max(1, int(frames)) - 1) // max(1, int(fps)))
-
-
-def _shared_patches(inp: dict[str, Any], mode: str) -> list[Patch]:
-    return [
-        (NODE_PROMPT, "text", inp.get("prompt", "")),
-        (NODE_NEG_PROMPT, "text", inp.get("negative_prompt", "")),
-        (NODE_WIDTH, "value", int(inp.get("width", 512))),
-        (NODE_HEIGHT, "value", int(inp.get("height", 768))),
-        (NODE_FPS, "value", int(inp.get("fps", 24))),
-        (
-            NODE_CLIP_SECONDS,
-            "Xi",
-            _seconds_for(int(inp.get("frames", 81)), int(inp.get("fps", 24))),
-        ),
-        (SEED_NODE_BY_MODE[mode], "noise_seed", int(inp.get("seed", 42))),
-    ]
-
-
-def _t2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "t2v")
-
-
-def _i2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "i2v") + [
-        (NODE_IMAGE_1, "image", inp["image"]),
-    ]
-
-
-def _a2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "a2v") + [
-        (NODE_AUDIO, "audio", inp["audio"]),
-    ]
-
-
-def _lipsync_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "lipsync") + [
-        (NODE_IMAGE_1, "image", inp["image"]),
-        (NODE_AUDIO, "audio", inp["audio"]),
-    ]
-
-
-def _keyframe_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "keyframe") + [
-        (NODE_IMAGE_1, "image", inp["first_frame"]),
-        (NODE_IMAGE_2, "image", inp["last_frame"]),
-    ]
-
-
-def _style_parameterize(inp: dict[str, Any]) -> list[Patch]:
-    return _shared_patches(inp, "style") + [
-        (NODE_IMAGE_1, "image", inp["image"]),
-        (NODE_VIDEO, "video", inp["input_video"]),
-        (NODE_VIDEO, "skip_first_frames", 0),
-    ]
-
-
-_T2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Diffusion (Stage 1)", 60),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-
-_I2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode image", 3),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 20),
-    Stage("Decode video", 10),
-]
-
-_A2V_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode audio", 5),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-
-_LIPSYNC_STAGES = list(_A2V_STAGES)
-_KEYFRAME_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode keyframes", 5),
-    Stage("Diffusion (Stage 1)", 55),
-    Stage("Spatial upscale", 7),
-    Stage("Diffusion (Stage 2)", 18),
-    Stage("Decode video", 10),
-]
-_STYLE_STAGES = [
-    Stage("Encode prompt", 5),
-    Stage("Encode source video", 10),
-    Stage("Diffusion", 70),
-    Stage("Decode video", 15),
-]
-
-
-MODE_REGISTRY["t2v"] = Mode(
-    name="t2v",
-    label="Text → Video",
-    icon="📝",
-    parameterize_fn=_t2v_parameterize,
-    stage_map=_T2V_STAGES,
-)
-MODE_REGISTRY["i2v"] = Mode(
-    name="i2v",
-    label="Image → Video",
-    icon="🖼",
-    parameterize_fn=_i2v_parameterize,
-    stage_map=_I2V_STAGES,
-)
-MODE_REGISTRY["a2v"] = Mode(
-    name="a2v",
-    label="Audio → Video",
-    icon="🎵",
-    parameterize_fn=_a2v_parameterize,
-    stage_map=_A2V_STAGES,
-)
-MODE_REGISTRY["lipsync"] = Mode(
-    name="lipsync",
-    label="Lipsync",
-    icon="👄",
-    parameterize_fn=_lipsync_parameterize,
-    stage_map=_LIPSYNC_STAGES,
-)
-MODE_REGISTRY["keyframe"] = Mode(
-    name="keyframe",
-    label="Keyframe → Video",
-    icon="🎞",
-    parameterize_fn=_keyframe_parameterize,
-    stage_map=_KEYFRAME_STAGES,
-)
-MODE_REGISTRY["style"] = Mode(
-    name="style",
-    label="Style Transfer",
-    icon="🎨",
-    parameterize_fn=_style_parameterize,
-    stage_map=_STYLE_STAGES,
-)

pyproject.toml

@@ -1,17 +0,0 @@
-[tool.pytest.ini_options]
-pythonpath = ["."]
-markers = [
-    "gpu: marks tests that need a GPU (use --gpu to enable)",
-]
-
-[tool.ruff]
-line-length = 100
-target-version = "py311"
-exclude = ["comfyui/", ".venv/"]
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "B", "UP"]
-ignore = ["E501"]  # line length is enforced by formatter, not linter
-
-[tool.ruff.lint.per-file-ignores]
-"tests/*" = ["E402"]  # imports inside test functions are fine

requirements.txt

@@ -1,60 +1,43 @@
-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
+comfyui-frontend-package==1.49.6
+comfyui-workflow-templates==0.11.43
+comfyui-embedded-docs==0.5.10
+torch
+torchsde
 torchvision
-# HF Spaces ships torch==2.10.0; bare 'torchaudio' lets pip pick an older
-# wheel whose C++ ABI doesn't match → import crashes the whole audio code
-# path including ComfyUI-LTXVideo's audio VAE. Pin the matching version.
-torchaudio==2.10.0
-numpy
-Pillow
+torchaudio
+numpy>=1.25.0
 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
+transformers>=4.50.3
+tokenizers>=0.13.3
 sentencepiece
-av
-kornia
-spandrel
-torchsde
+safetensors>=0.4.2
+aiohttp>=3.11.8
+yarl>=1.18.0
+pyyaml
+Pillow
 scipy
-aiohttp
-pydantic
-pydantic-settings
-python-dotenv
-yarl
-PyOpenGL
-glfw
-SQLAlchemy
+tqdm
+psutil
 alembic
-Mako
-networkx
-sympy
-mpmath
+SQLAlchemy>=2.0.0
+filelock
+av>=16.0.0
+comfy-kitchen==0.2.31
+comfy-aimdo==0.4.13
+requests
+simpleeval>=1.0.0
 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
-scikit-image  # comfyui_controlnet_aux dwpose hand keypoint detector
-onnxruntime  # comfyui_controlnet_aux dwpose accelerator (CPU/CoreML on Mac, CUDA on Spaces)
-diffusers  # ComfyUI-SeedVR2 (used during init even when the node isn't called)
-yt-dlp  # ComfyUI-MediaMixer (init-time import)
+#non essential dependencies:
+kornia>=0.7.1
+spandrel
+pydantic~=2.0
+pydantic-settings~=2.0
+PyOpenGL>=3.1.8
+comfy-angle
+
 
-# Dev / test
-pytest>=8.0
-pytest-asyncio>=0.23
-ruff>=0.5
+huggingface-hub
+imageio
+spaces
+sageattention @ https://huggingface.co/RioShiina/Sage-Attention-ZeroGPU-Space-Build/resolve/main/sageattention-2.2.0-cp312-cp312-linux_x86_64.whl

setup.sh

@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$REPO_ROOT"
-
-echo "▶ Creating Python 3.11 venv"
-python3.11 -m venv .venv
-# shellcheck disable=SC1091
-source .venv/bin/activate
-pip install -U pip wheel
-
-echo "▶ Initializing ComfyUI submodule"
-git submodule update --init --recursive
-
-echo "▶ Installing ComfyUI core requirements"
-pip install -r comfyui/requirements.txt
-
-echo "▶ Installing pinned custom nodes"
-mkdir -p comfyui/custom_nodes
-cd comfyui/custom_nodes
-for repo in \
-    Lightricks/ComfyUI-LTXVideo \
-    kijai/ComfyUI-KJNodes \
-    rgthree/rgthree-comfy \
-    Kosinkadink/ComfyUI-VideoHelperSuite \
-    pythongosssss/ComfyUI-Custom-Scripts ; do
-  name="${repo##*/}"
-  if [[ ! -d "$name" ]]; then
-    git clone --depth 1 "https://github.com/$repo.git" "$name"
-  fi
-  if [[ -f "$name/requirements.txt" ]]; then
-    pip install -r "$name/requirements.txt"
-  fi
-done
-cd "$REPO_ROOT"
-
-echo "▶ Installing AIO app dependencies"
-pip install -r requirements.txt
-
-echo "▶ Symlinking models from HF cache"
-if [[ -f tools/refresh_models.py ]]; then
-  python tools/refresh_models.py
-else
-  echo "  (tools/refresh_models.py not yet present — skipping; will be added in Task 16)"
-fi
-
-echo
-echo "✓ Setup complete."
-echo "  Activate venv: source .venv/bin/activate"
-echo "  Run app:        python app.py"

tests/conftest.py

@@ -1,158 +0,0 @@
-"""Shared pytest fixtures and CLI flags."""
-
-import json
-import os
-import pathlib
-from typing import Any
-
-import pytest
-
-REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent
-
-DEFAULT_MASTER_WORKFLOW = pathlib.Path(
-    os.environ.get(
-        "LTX23_MASTER_WORKFLOW",
-        pathlib.Path.home()
-        / "Projects/comfyui/user/default/workflows"
-        / "1. LTX 2.3 All-In-One 260406-05.json",
-    )
-)
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    parser.addoption("--gpu", action="store_true", help="Run L4 GPU smoke tests.")
-    parser.addoption(
-        "--comfy-real",
-        action="store_true",
-        help="Use bundled ComfyUI for L2 graph validation (slower).",
-    )
-
-
-def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
-    if not config.getoption("--gpu"):
-        skip_gpu = pytest.mark.skip(reason="GPU smoke tests skipped (use --gpu)")
-        for item in items:
-            if "gpu" in item.keywords:
-                item.add_marker(skip_gpu)
-
-
-@pytest.fixture(scope="session")
-def master_workflow() -> dict[str, Any]:
-    """The full LTX 2.3 All-In-One workflow JSON (loaded from user's ComfyUI)."""
-    if not DEFAULT_MASTER_WORKFLOW.exists():
-        pytest.skip(
-            f"Master workflow not found at {DEFAULT_MASTER_WORKFLOW}. "
-            "Set LTX23_MASTER_WORKFLOW env var to its path."
-        )
-    return json.loads(DEFAULT_MASTER_WORKFLOW.read_text())
-
-
-@pytest.fixture
-def canonical_inputs() -> dict[str, dict[str, Any]]:
-    """Known-good Gradio input dicts per mode (used by L1/L2 tests)."""
-    return {
-        "t2v": {
-            "prompt": "a tiger walking through a misty forest at dawn, cinematic",
-            "negative_prompt": "",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "camera_lora": "none",
-            "camera_strength": 0.8,
-            "detailer_on": False,
-            "detailer_strength": 0.5,
-        },
-        "i2v": {
-            "prompt": "the subject turns toward the camera and smiles",
-            "image": "/tmp/portrait.png",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "camera_lora": "none",
-            "camera_strength": 0.8,
-            "detailer_on": True,
-            "detailer_strength": 0.5,
-            "ic_lora": "union",
-            "ic_strength": 0.5,
-            "pose_on": False,
-        },
-        "a2v": {
-            "prompt": "a dancer moves to the beat in a neon-lit studio",
-            "audio": "/tmp/track.wav",
-            "preset": "balanced",
-            "width": 512,
-            "height": 768,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "audio_cfg": 7.0,
-        },
-        "lipsync": {
-            "prompt": "the person speaks the audio with natural mouth movement",
-            "image": "/tmp/portrait.png",
-            "audio": "/tmp/speech.wav",
-            "preset": "balanced",
-            "image_strength": 0.7,
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-        },
-        "keyframe": {
-            "prompt": "smooth transition between the two frames",
-            "first_frame": "/tmp/start.png",
-            "last_frame": "/tmp/end.png",
-            "preset": "balanced",
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-        },
-        "style": {
-            "prompt": "in the style of a renaissance oil painting",
-            "input_video": "/tmp/source.mp4",
-            "preset": "balanced",
-            "frames": 81,
-            "fps": 24,
-            "seed": 42,
-            "ic_lora": "motion-track",
-            "ic_strength": 0.5,
-        },
-    }
-
-
-@pytest.fixture
-def fake_hf_cache(tmp_path: pathlib.Path) -> pathlib.Path:
-    """A fake ~/.cache/huggingface/hub layout with placeholder files."""
-    hub = tmp_path / "huggingface" / "hub"
-    layouts = {
-        "models--Lightricks--LTX-2.3": [
-            "ltx-2.3-22b-distilled.safetensors",
-            "ltx-2.3-spatial-upscaler-x2-1.0.safetensors",
-            "ltx-2.3-22b-distilled-lora-384.safetensors",
-        ],
-        "models--google--gemma-3-12b-it-qat-q4_0-unquantized": [
-            "model-00001-of-00005.safetensors",
-            "model-00002-of-00005.safetensors",
-            "model-00003-of-00005.safetensors",
-            "model-00004-of-00005.safetensors",
-            "model-00005-of-00005.safetensors",
-            "model.safetensors.index.json",
-            "tokenizer.model",
-            "preprocessor_config.json",
-        ],
-        "models--Kijai--LTX2.3_comfy": [
-            "LTX23_video_vae_bf16.safetensors",
-            "LTX23_audio_vae_bf16.safetensors",
-        ],
-    }
-    for repo, files in layouts.items():
-        snapshot_dir = hub / repo / "snapshots" / "deadbeef"
-        snapshot_dir.mkdir(parents=True, exist_ok=True)
-        for filename in files:
-            (snapshot_dir / filename).write_text("")  # placeholder
-    return hub

tests/test_backend.py

@@ -1,14 +0,0 @@
-"""Backend tests — most are smoke / structural since the real work is GPU."""
-
-import backend
-
-
-def test_backend_class_exists():
-    assert hasattr(backend, "ComfyUILibraryBackend")
-
-
-def test_progress_event_dataclasses_exist():
-    assert hasattr(backend, "DownloadEvent")
-    assert hasattr(backend, "ProgressEvent")
-    assert hasattr(backend, "OutputEvent")
-    assert hasattr(backend, "ErrorEvent")

tests/test_extract_modes.py

@@ -1,39 +0,0 @@
-"""Tests for the workflow-mode extractor."""
-
-import json
-import subprocess
-import sys
-
-from tests.conftest import REPO_ROOT
-
-
-def test_extract_creates_six_mode_files(master_workflow, tmp_path):
-    """extract_modes.py emits six valid mode-specific JSON templates."""
-    out_dir = tmp_path / "workflows"
-    master_path = tmp_path / "master.json"
-    master_path.write_text(json.dumps(master_workflow))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            str(REPO_ROOT / "tools" / "extract_modes.py"),
-            "--master",
-            str(master_path),
-            "--out",
-            str(out_dir),
-        ],
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-
-    assert result.returncode == 0, result.stderr
-    expected = {"t2v.json", "a2v.json", "i2v.json", "lipsync.json", "keyframe.json", "style.json"}
-    actual = {p.name for p in out_dir.iterdir()}
-    assert actual == expected
-
-    # Each file must be valid JSON with at least one node.
-    for path in out_dir.iterdir():
-        wf = json.loads(path.read_text())
-        assert "nodes" in wf
-        assert len(wf["nodes"]) > 0

tests/test_models.py

@@ -1,73 +0,0 @@
-"""Unit tests for models.py — MODEL_REGISTRY and ensure_models_for_mode."""
-
-import models
-import workflow
-
-
-def test_model_registry_resolves_known_files():
-    assert (
-        models.MODEL_REGISTRY["ltx-2.3-22b-distilled.safetensors"].repo_id == "Lightricks/LTX-2.3"
-    )
-    assert models.MODEL_REGISTRY["ltx-2.3-22b-distilled.safetensors"].subfolder == ""
-
-
-def test_model_registry_includes_gemma_shards():
-    for i in range(1, 6):
-        key = f"model-{i:05d}-of-00005.safetensors"
-        assert key in models.MODEL_REGISTRY
-        assert "gemma-3-12b-it" in models.MODEL_REGISTRY[key].repo_id
-
-
-def test_walk_workflow_for_models_finds_t2v_loaders():
-    wf = workflow.load_template("t2v")
-    needed = models.walk_workflow_for_models(wf)
-    # T2V needs at minimum a transformer (distilled, dev fp8, or GGUF Q4) and a gemma encoder
-    assert any(
-        name.endswith(".gguf") or "distilled.safetensors" in name or "transformer_only" in name
-        for name in needed
-    )
-    assert any("gemma" in name.lower() for name in needed)
-
-
-def test_ensure_models_creates_symlinks_local(tmp_path, monkeypatch, fake_hf_cache):
-    """In local mode, ensure_models creates symlinks from comfy/models -> HF cache."""
-    monkeypatch.setenv("HF_HUB_CACHE", str(fake_hf_cache))
-    monkeypatch.setattr(models, "_on_spaces", lambda: False)
-
-    # Force the HF Hub call to fail so the fallback path (cache_dir.rglob) is exercised.
-    def _raise(*_args, **_kwargs):
-        raise RuntimeError("offline test: forcing fallback to cache scan")
-
-    monkeypatch.setattr(models, "hf_hub_download", _raise)
-
-    comfy_models = tmp_path / "comfyui" / "models"
-    monkeypatch.setattr(models, "_comfy_models_dir", lambda: comfy_models)
-
-    needed = {
-        "ltx-2.3-22b-distilled.safetensors",
-        "model-00001-of-00005.safetensors",
-    }
-    list(models.ensure_models(needed))
-
-    # Each requested file should now have a symlink in comfyui/models/<type>/
-    assert (comfy_models / "checkpoints" / "ltx-2.3-22b-distilled.safetensors").is_symlink()
-    assert (
-        comfy_models / "text_encoders" / "gemma-3-12b-it" / "model-00001-of-00005.safetensors"
-    ).is_symlink()
-
-
-def test_ensure_models_skips_unregistered_files_with_warning(
-    tmp_path, monkeypatch, fake_hf_cache, caplog
-):
-    """Files not in MODEL_REGISTRY are skipped (with warning), not raised."""
-    import logging
-
-    monkeypatch.setenv("HF_HUB_CACHE", str(fake_hf_cache))
-    monkeypatch.setattr(models, "_on_spaces", lambda: False)
-    monkeypatch.setattr(models, "_comfy_models_dir", lambda: tmp_path / "comfyui" / "models")
-
-    with caplog.at_level(logging.WARNING):
-        list(models.ensure_models({"nonexistent_phantom_file.safetensors"}))
-
-    # Should not raise, should log a warning, should yield no events for the missing entry.
-    assert any("nonexistent_phantom_file" in record.message for record in caplog.records)