Promote sliding window workflow fix

README.md

@@ -8,51 +8,57 @@ tags:
   - video-to-audio
   - audio-generation
   - workflow
+  - foley-lora
 ---
 
 # LTX 2.3 Foley V2A ComfyUI Workflow
 
-This repository contains a ready-to-test ComfyUI workflow for the
+This repository contains ready-to-test ComfyUI workflows for the
 [`FuzzPuppy/LTX-2.3-Foley-LoRA`](https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-LoRA)
 LoRA. The LoRA adds Foley sound effects to a silent input video using LTX-2.3:
-given a short video and a prompt describing the visible action, the workflow
+given a video and a prompt describing the visible action, the loop workflow
 generates matching non-speech, non-music sound effects and saves a new MP4.
 
-The workflow is intentionally small: it takes one short video clip, keeps the
-first `89` frames, generates matching Foley audio, and saves an MP4 with the
-source frames plus generated audio. It is meant as the fastest public ComfyUI
-test for `FuzzPuppy/LTX-2.3-Foley-LoRA`, not as a full long-video stitching
-pipeline.
+There are two workflows provided:
+1. `foley-sliding-window.json`: long-video workflow with overlapping audio windows and stitching.
+2. `ltx_23_foley_v2a.json`: original short-clip workflow.
 
-## Tutorial
+If you want run a quick short test, use `ltx_23_foley_v2a.json`. Otherwise, use `foley-sliding-window.json` so you can generate longer audio while keeping memory under control.
 
+## Tutorial
 [![Watch the tutorial: using the LTX-2.3 Foley LoRA in ComfyUI](https://img.youtube.com/vi/qnHFDlrySmw/hqdefault.jpg)](https://youtu.be/qnHFDlrySmw)
 
 [Watch the tutorial on YouTube](https://youtu.be/qnHFDlrySmw)
 
 ## What Is Included
 
-- `ltx_23_foley_v2a.json`: ComfyUI workflow.
+- `foley-sliding-window.json`: long-video workflow with overlapping audio windows and stitching.
+- `ltx_23_foley_v2a.json`: original short-clip workflow.
 - `setup_runpod_ltx_foley.sh`: one-command RunPod setup script.
 - `ltx_foley_v2a`: small helper-node package.
 - `tennis-no-sound.mp4`: default silent test video for RunPod setup.
 
-The workflow requires the `ltx_foley_v2a` helper-node package. If ComfyUI shows
-missing nodes named `LTXFoleyVideoToAudioLatent`, `LTXFoleyTrimImages`, or
-`LTXFoleyAudioVAEDecode`, the workflow JSON was loaded before these helper nodes
-were installed into `ComfyUI/custom_nodes`.
+Both workflows require the `ltx_foley_v2a` helper-node package. If ComfyUI shows
+missing nodes named `LTXFoleyForLoopOpen`, `LTXFoleyWindowSelect`,
+`LTXFoleyVideoToAudioLatent`, or `LTXFoleyAudioVAEDecode`, the workflow JSON was
+loaded before these helper nodes were installed into `ComfyUI/custom_nodes`.
 
 The helper-node package handles the workflow-specific pieces that stock ComfyUI
 does not currently cover cleanly:
 
-- freezes the uploaded video as LTX video latents while leaving matching audio
+- plans the window count from the uploaded video
+- provides a small local ComfyUI for-loop so no external loop-node pack is needed
+- splits longer videos into overlapping windows
+- freezes each source window as LTX video latents while leaving matching audio
   latents empty for Foley generation
-- trims or pads the saved video frames to the same generation window
-- decodes LTX audio VAE output into the Comfy audio tensor layout expected by
+- decodes each audio window into the Comfy audio tensor layout expected by
   current video saving nodes
+- writes each raw decoded window as a WAV before stitching so artifacts can be
+  checked before the final crossfade
+- crossfades and stitches generated audio windows into one final track
 
-Prompt text, model loading, LoRA loading, sampling, video creation, and MP4
-saving use normal ComfyUI/LTXVideo nodes.
+Prompt text, model loading, LoRA loading, video creation, and MP4 saving use
+normal ComfyUI/LTXVideo nodes.
 
 ## Fastest RunPod Test
 
@@ -64,24 +70,35 @@ https://console.runpod.io/deploy?template=cw3nka7d08&ref=k7b1cgii
 1. In RunPod, under "Additional Filters" filter CUDA versions to CUDA 12.8.
 2. Select a 48 GB GPU: A40, RTX A6000, L40/L40S, or A100.
 3. Make sure the `ComfyUI - CUDA 12.8` template is selected.
-4. The template's default volume disk is `50 GB`, which is enough for the core
-   workflow files, but tight once caches and reruns accumulate. Change the volume
-   disk to `100 GB` if you want more breathing room.
+4. The template's default volume disk is `50 GB`, which is enough for the core workflow files, but tight once caches and reruns accumulate. Change the volume disk to `100 GB` if you want more breathing room.
 5. Start the pod and open a terminal.
 6. Run:
 
 ```bash
-cd /workspace && curl -L https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-Workflow/resolve/main/setup_runpod_ltx_foley.sh -o setup_runpod_ltx_foley.sh && bash setup_runpod_ltx_foley.sh
+cd /workspace
+curl -L https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-Workflow/resolve/main/setup_runpod_ltx_foley.sh -o setup_runpod_ltx_foley.sh
+bash setup_runpod_ltx_foley.sh
+```
+
+The setup script installs the nodes and models, downloads the tennis test video as `input.mp4`, restarts ComfyUI without stopping the pod (with `--cache-classic`, see the Manual ComfyUI Install notes), and waits until the UI responds on port `8188`.
+
+By default the script installs ComfyUI `v0.27.0`. To test another ComfyUI release, set `COMFYUI_CORE_REF`:
+
+```bash
+COMFYUI_CORE_REF=v0.19.0 bash setup_runpod_ltx_foley.sh
 ```
 
-The setup script installs the nodes and models, downloads the tennis test video
-as `input.mp4`, restarts ComfyUI without stopping the pod, and waits until the UI
-responds on port `8188`.
+To install workflow files from a different Hugging Face branch, set
+`WORKFLOW_REVISION`:
+
+```bash
+WORKFLOW_REVISION=windows bash setup_runpod_ltx_foley.sh
+```
 
 After the script finishes:
 
 1. Open ComfyUI from the RunPod web UI.
-2. Under workflows, select `ltx_23_foley_v2a.json`.
+2. Under workflows, select `foley-sliding-window.json`.
 3. Hit `Run`.
 
 The default input video and prompt are already set:
@@ -103,9 +120,14 @@ It installs or refreshes:
 
 - `Lightricks/ComfyUI-LTXVideo`
 - `ltx_foley_v2a` helper nodes
+- `foley-sliding-window.json`
 - `ltx_23_foley_v2a.json`
 - `tennis-no-sound.mp4`
 
+The script also applies a small compatibility patch to the installed
+`ComfyUI-LTXVideo/pyramid_blending.py` file so current Kornia builds can import
+the node pack on fresh ComfyUI installs.
+
 It downloads these model files:
 
 - Base checkpoint:
@@ -126,19 +148,12 @@ If you are not using the RunPod script:
 1. Install or update ComfyUI.
 2. Install the official LTXVideo custom nodes:
    `https://github.com/Lightricks/ComfyUI-LTXVideo`
-3. Install the Foley helper nodes by copying or symlinking the workflow repo's
+3. Install the Foley helper nodes by placing the workflow repo's
    `ltx_foley_v2a` folder into:
-   `ComfyUI/custom_nodes/ltx_foley_v2a`
-
-   If you only downloaded the workflow JSON, run these commands from your
-   ComfyUI install directory to install the two helper-node files:
-
-   ```bash
-   mkdir -p custom_nodes/ltx_foley_v2a
-   curl -L https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-Workflow/resolve/main/ltx_foley_v2a/__init__.py -o custom_nodes/ltx_foley_v2a/__init__.py
-   curl -L https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-Workflow/resolve/main/ltx_foley_v2a/nodes.py -o custom_nodes/ltx_foley_v2a/nodes.py
-   ```
-4. Put the model files in:
+   `ComfyUI/custom_nodes/`
+4. Copy the either `foley-sliding-window.json` or `ltx_23_foley_v2a.json` into your ComfyUI user workflows folder. In a standard ComfyUI install this is:
+`ComfyUI/user/default/workflows`.
+5. Put the model files in:
    - checkpoint:
      [`ltx-2.3-22b-dev-fp8.safetensors`](https://huggingface.co/Lightricks/LTX-2.3-fp8/blob/main/ltx-2.3-22b-dev-fp8.safetensors)
      in `ComfyUI/models/checkpoints`
@@ -148,9 +163,21 @@ If you are not using the RunPod script:
    - Foley LoRA:
      [`ltx-2.3-foley-400-steps.safetensors`](https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-LoRA/blob/main/ltx-2.3-foley-400-steps.safetensors)
      in `ComfyUI/models/loras`
-5. Restart ComfyUI.
-6. Under workflows, select `ltx_23_foley_v2a.json`.
-7. Hit `Run`.
+6. Restart ComfyUI, starting it with the `--cache-classic` flag:
+
+   ```bash
+   python main.py --cache-classic
+   ```
+
+   On newer ComfyUI versions (`v0.27.0`+) the default caching mode is RAM-pressure
+   caching, which can evict node outputs in the middle of a run while the large
+   LTX models load. For `foley-sliding-window.json` that forces the window plan,
+   video decode, and model loaders to re-execute between windows, making long
+   runs much slower. `--cache-classic` keeps those outputs cached for the whole
+   run. The flag also exists on older releases such as `v0.19.0`, where it is
+   harmless.
+7. Under workflows, select `foley-sliding-window.json` or `ltx_23_foley_v2a.json`.
+8. Hit `Run`.
 
 ## Workflow Defaults
 
@@ -159,24 +186,34 @@ If you are not using the RunPod script:
 - Negative prompt: anti-music/anti-vocal prompt
 - Conditioning size: `576x576`
 - Frame window: `89` frames
+- Window overlap: `1.0` second
+- Maximum windows: `16`
+- Random ID: `42`
 - Sampling steps: `30`
 - Guidance: `4.0`
-- STG blocks: `14, 19`
+- Save window audio: `true`
+- Window audio prefix: `ltx_foley_window`
 - LoRA strength: `1.0`
 
-The workflow uses the first `89` frames of the uploaded video. Shorter videos are
-padded by repeating the last frame. The saved video is trimmed or padded to the
-same frame count so the output video duration matches the generated audio.
+Advanced sampler/STG settings are visible nodes in the loop body:
+sampler `euler_ancestral_cfg_pp`, STG scale `1.0`, rescale `0.7`, STG blocks
+`14, 19`, max shift `2.05`, base shift `0.95`, terminal `0.1`.
+
+The `foley-sliding-window.json` workflow uses the full uploaded video. Videos longer than the selected
+window are processed as overlapping windows and stitched into one generated
+audio track. Shorter videos are padded internally by repeating the last frame.
+The saved MP4 uses the source frames plus the stitched generated audio.
+Raw generated window WAVs are saved under ComfyUI's output directory in
+`ltx_foley_windows/` and their paths are listed in the manifest output.
 
 ## VRAM Notes
 
-Sampling is the VRAM peak. Start with a 48 GB GPU for the first reliable test.
+Sampling is the VRAM peak.
 If you need to reduce memory use, try these changes in order:
 
 - reduce frames from `89` to `57`, `41`, or `25`
 - reduce conditioning size from `576x576` to `448x448` or `384x384`
 - reduce sampling steps from `30` to `20`
-- lower or disable STG if quality is acceptable
 
 Frame counts should stay one more than a multiple of 8:
 
@@ -184,7 +221,49 @@ Frame counts should stay one more than a multiple of 8:
 9, 17, 25, 33, 41, 49, 57, ..., 89, ..., 257
 ```
 
-## Troubleshooting RunPod Setup
+For l`foley-sliding-window.json`, the default `max_windows` is `16` so accidental very long inputs
+fail clearly instead of running for hours. Increase it only when you expect the
+extra runtime.
+
+## Troubleshooting
+
+### Missing Nodes
+
+If ComfyUI reports missing `LTXFoley...` nodes after manual setup, verify that
+these files exist and then restart ComfyUI:
+
+```text
+ComfyUI/custom_nodes/ltx_foley_v2a/__init__.py
+ComfyUI/custom_nodes/ltx_foley_v2a/nodes.py
+```
+
+### Models Reload Or Nodes Re-Execute Between Windows
+
+If the log shows `planned N windows` repeating, or the checkpoint/text-encoder
+reloading before every window of `foley-sliding-window.json`, ComfyUI is running
+with its default RAM-pressure caching and is evicting node outputs mid-run.
+Start ComfyUI with `--cache-classic` (the RunPod script already does this). The
+generated audio is still correct either way — the re-execution only costs time.
+
+### Audio Artifacts On Some ComfyUI Versions
+
+The workflows have been tested on ComfyUI `v0.27.0` and run
+successfully there. However, on `v0.27.0` and newer ComfyUI versions generally, we have noticed that LTX-2.3 video-to-audio can produce a high-pitched squeak or audio artifacts in some generated audio.
+
+If you notice the audio artifacts on a generation, rollback to `v0.19.0` of ComfyUI.
+
+If you are using the RunPod setup you can rollback by simply:
+
+```bash
+cd /workspace
+COMFYUI_CORE_REF=v0.19.0 bash setup_runpod_ltx_foley.sh
+```
+
+Then reload `foley-sliding-window.json` and run it again.
+
+### RunPod Setup
+
+#### Restarting/Rerun
 
 If you rerun setup after a workflow or node update:
 
@@ -195,23 +274,19 @@ cd /workspace && bash setup_runpod_ltx_foley.sh
 The script will skip verified model files, refresh the workflow/helper nodes,
 and restart ComfyUI.
 
+#### Model Downloads
+
 If model downloads fail with authorization errors, accept the relevant Hugging
 Face model terms and rerun with `HF_TOKEN` set.
 
+#### Logs
+
 Logs from the script-managed ComfyUI restart are written to:
 
 ```text
 /workspace/runpod-slim/comfyui-restart.log
 ```
 
-If ComfyUI reports missing `LTXFoley...` nodes after manual setup, verify that
-these files exist and then restart ComfyUI:
-
-```text
-ComfyUI/custom_nodes/ltx_foley_v2a/__init__.py
-ComfyUI/custom_nodes/ltx_foley_v2a/nodes.py
-```
-
 ## License Scope
 
 The files in this workflow repository are released under the Apache-2.0 license.

foley-sliding-window.json

@@ -0,0 +1,1655 @@
+{
+  "last_node_id": 28,
+  "last_link_id": 47,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "LoadVideo",
+      "pos": [
+        -1600,
+        -420
+      ],
+      "size": [
+        320,
+        90
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": [
+            1
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadVideo"
+      },
+      "widgets_values": [
+        "input.mp4"
+      ]
+    },
+    {
+      "id": 2,
+      "type": "GetVideoComponents",
+      "pos": [
+        -1220,
+        -420
+      ],
+      "size": [
+        220,
+        120
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "links": [
+            2,
+            7,
+            44
+          ]
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": null
+        },
+        {
+          "name": "fps",
+          "type": "FLOAT",
+          "links": [
+            3,
+            4,
+            21,
+            45
+          ]
+        },
+        {
+          "name": "bit_depth",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "GetVideoComponents"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 3,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        -1600,
+        -160
+      ],
+      "size": [
+        360,
+        110
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            10
+          ]
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": null
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            19
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "ltx-2.3-22b-dev-fp8.safetensors"
+      ]
+    },
+    {
+      "id": 4,
+      "type": "LTXVAudioVAELoader",
+      "pos": [
+        -1600,
+        0
+      ],
+      "size": [
+        360,
+        80
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "Audio VAE",
+          "type": "VAE",
+          "links": [
+            20,
+            35
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXVAudioVAELoader"
+      },
+      "widgets_values": [
+        "ltx-2.3-22b-dev-fp8.safetensors"
+      ]
+    },
+    {
+      "id": 5,
+      "type": "LTXAVTextEncoderLoader",
+      "pos": [
+        -1600,
+        150
+      ],
+      "size": [
+        360,
+        120
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            12,
+            13
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXAVTextEncoderLoader"
+      },
+      "widgets_values": [
+        "gemma_3_12B_it_fp8_scaled.safetensors",
+        "ltx-2.3-22b-dev-fp8.safetensors",
+        "default"
+      ]
+    },
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        -1180,
+        140
+      ],
+      "size": [
+        420,
+        180
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 12
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            14
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "Two men are playing tennis. No speech is present. No music is present."
+      ],
+      "title": "Positive Prompt"
+    },
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        -1180,
+        370
+      ],
+      "size": [
+        420,
+        160
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 13
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            15
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "music, melody, song, singing, vocals, score, soundtrack, beat, rhythm bed, instrumental backing, tinny, thin, harsh, clipped, distorted, low bitrate"
+      ],
+      "title": "Negative Prompt"
+    },
+    {
+      "id": 8,
+      "type": "LTXVConditioning",
+      "pos": [
+        -700,
+        300
+      ],
+      "size": [
+        220,
+        90
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 14
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 15
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            16
+          ]
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "links": [
+            17
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXVConditioning"
+      },
+      "widgets_values": [
+        25.0
+      ]
+    },
+    {
+      "id": 9,
+      "type": "LTXFoleyWindowPlan",
+      "pos": [
+        -860,
+        -430
+      ],
+      "size": [
+        320,
+        210
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "link": 4
+        }
+      ],
+      "outputs": [
+        {
+          "name": "window_plan",
+          "type": "FOLEY_WINDOW_PLAN",
+          "links": [
+            8,
+            43
+          ]
+        },
+        {
+          "name": "window_count",
+          "type": "INT",
+          "links": [
+            6
+          ]
+        },
+        {
+          "name": "manifest",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyWindowPlan"
+      },
+      "widgets_values": [
+        25.0,
+        89,
+        1.0,
+        16
+      ]
+    },
+    {
+      "id": 10,
+      "type": "LoraLoaderModelOnly",
+      "pos": [
+        -1180,
+        -160
+      ],
+      "size": [
+        360,
+        90
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 10
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            11
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoraLoaderModelOnly"
+      },
+      "widgets_values": [
+        "ltx-2.3-foley-400-steps.safetensors",
+        1.0
+      ]
+    },
+    {
+      "id": 11,
+      "type": "LTXFoleyForLoopOpen",
+      "pos": [
+        -500,
+        -430
+      ],
+      "size": [
+        300,
+        170
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "remaining",
+          "type": "INT",
+          "link": 6
+        },
+        {
+          "name": "audio_accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "link": null,
+          "shape": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "flow_control",
+          "type": "FLOW_CONTROL",
+          "links": [
+            40
+          ]
+        },
+        {
+          "name": "remaining",
+          "type": "INT",
+          "links": [
+            9
+          ]
+        },
+        {
+          "name": "audio_accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "links": [
+            39
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyForLoopOpen"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 12,
+      "type": "LTXFoleyWindowSelect",
+      "pos": [
+        -140,
+        -430
+      ],
+      "size": [
+        320,
+        140
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 7
+        },
+        {
+          "name": "window_plan",
+          "type": "FOLEY_WINDOW_PLAN",
+          "link": 8
+        },
+        {
+          "name": "remaining",
+          "type": "INT",
+          "link": 9
+        }
+      ],
+      "outputs": [
+        {
+          "name": "window_images",
+          "type": "IMAGE",
+          "links": [
+            18
+          ]
+        },
+        {
+          "name": "window_info",
+          "type": "FOLEY_WINDOW",
+          "links": [
+            37
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyWindowSelect"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 13,
+      "type": "LTXFoleyVideoToAudioLatent",
+      "pos": [
+        -140,
+        -220
+      ],
+      "size": [
+        360,
+        340
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 18
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 16
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 17
+        },
+        {
+          "name": "video_vae",
+          "type": "VAE",
+          "link": 19
+        },
+        {
+          "name": "audio_vae",
+          "type": "VAE",
+          "link": 20
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "link": 21
+        }
+      ],
+      "outputs": [
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "links": [
+            25
+          ]
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "links": [
+            26
+          ]
+        },
+        {
+          "name": "av_latent",
+          "type": "LATENT",
+          "links": [
+            22,
+            31,
+            32
+          ]
+        },
+        {
+          "name": "preview_images",
+          "type": "IMAGE",
+          "links": null
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "links": null
+        },
+        {
+          "name": "frames",
+          "type": "INT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyVideoToAudioLatent"
+      },
+      "widgets_values": [
+        25.0,
+        576,
+        576,
+        89
+      ]
+    },
+    {
+      "id": 14,
+      "type": "ModelSamplingLTXV",
+      "pos": [
+        260,
+        -170
+      ],
+      "size": [
+        260,
+        120
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 11
+        },
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "link": 22
+        }
+      ],
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            23
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ModelSamplingLTXV"
+      },
+      "widgets_values": [
+        2.05,
+        0.95
+      ]
+    },
+    {
+      "id": 15,
+      "type": "LTXVApplySTG",
+      "pos": [
+        560,
+        -160
+      ],
+      "size": [
+        240,
+        80
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 23
+        }
+      ],
+      "outputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "links": [
+            24
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXVApplySTG"
+      },
+      "widgets_values": [
+        "14, 19"
+      ]
+    },
+    {
+      "id": 16,
+      "type": "STGGuiderNode",
+      "pos": [
+        840,
+        -180
+      ],
+      "size": [
+        240,
+        150
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 24
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 25
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 26
+        }
+      ],
+      "outputs": [
+        {
+          "name": "GUIDER",
+          "type": "GUIDER",
+          "links": [
+            28
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "STGGuiderNode"
+      },
+      "widgets_values": [
+        4.0,
+        1.0,
+        0.7
+      ]
+    },
+    {
+      "id": 17,
+      "type": "RandomNoise",
+      "pos": [
+        560,
+        -430
+      ],
+      "size": [
+        240,
+        90
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "NOISE",
+          "type": "NOISE",
+          "links": [
+            27
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "RandomNoise"
+      },
+      "widgets_values": [
+        42,
+        "fixed"
+      ]
+    },
+    {
+      "id": 18,
+      "type": "KSamplerSelect",
+      "pos": [
+        560,
+        -300
+      ],
+      "size": [
+        240,
+        80
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "SAMPLER",
+          "type": "SAMPLER",
+          "links": [
+            29
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSamplerSelect"
+      },
+      "widgets_values": [
+        "euler_ancestral_cfg_pp"
+      ]
+    },
+    {
+      "id": 19,
+      "type": "LTXVScheduler",
+      "pos": [
+        840,
+        20
+      ],
+      "size": [
+        240,
+        160
+      ],
+      "flags": {},
+      "order": 18,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "latent",
+          "type": "LATENT",
+          "link": 32
+        }
+      ],
+      "outputs": [
+        {
+          "name": "SIGMAS",
+          "type": "SIGMAS",
+          "links": [
+            30
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXVScheduler"
+      },
+      "widgets_values": [
+        30,
+        2.05,
+        0.95,
+        true,
+        0.1
+      ]
+    },
+    {
+      "id": 20,
+      "type": "SamplerCustomAdvanced",
+      "pos": [
+        1140,
+        -220
+      ],
+      "size": [
+        230,
+        130
+      ],
+      "flags": {},
+      "order": 19,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "noise",
+          "type": "NOISE",
+          "link": 27
+        },
+        {
+          "name": "guider",
+          "type": "GUIDER",
+          "link": 28
+        },
+        {
+          "name": "sampler",
+          "type": "SAMPLER",
+          "link": 29
+        },
+        {
+          "name": "sigmas",
+          "type": "SIGMAS",
+          "link": 30
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 31
+        }
+      ],
+      "outputs": [
+        {
+          "name": "output",
+          "type": "LATENT",
+          "links": [
+            33
+          ]
+        },
+        {
+          "name": "denoised_output",
+          "type": "LATENT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SamplerCustomAdvanced"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 21,
+      "type": "LTXVSeparateAVLatent",
+      "pos": [
+        1420,
+        -220
+      ],
+      "size": [
+        220,
+        80
+      ],
+      "flags": {},
+      "order": 20,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "av_latent",
+          "type": "LATENT",
+          "link": 33
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video_latent",
+          "type": "LATENT",
+          "links": null
+        },
+        {
+          "name": "audio_latent",
+          "type": "LATENT",
+          "links": [
+            34
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXVSeparateAVLatent"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 22,
+      "type": "LTXFoleyAudioVAEDecode",
+      "pos": [
+        1680,
+        -220
+      ],
+      "size": [
+        240,
+        90
+      ],
+      "flags": {},
+      "order": 21,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 34
+        },
+        {
+          "name": "audio_vae",
+          "type": "VAE",
+          "link": 35
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Audio",
+          "type": "AUDIO",
+          "links": [
+            36
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyAudioVAEDecode"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 23,
+      "type": "LTXFoleyWindowAudioSave",
+      "pos": [
+        1980,
+        -260
+      ],
+      "size": [
+        300,
+        150
+      ],
+      "flags": {},
+      "order": 22,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 36
+        },
+        {
+          "name": "window_info",
+          "type": "FOLEY_WINDOW",
+          "link": 37
+        }
+      ],
+      "outputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": null
+        },
+        {
+          "name": "window_record",
+          "type": "FOLEY_WINDOW_RECORD",
+          "links": [
+            38
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyWindowAudioSave"
+      },
+      "widgets_values": [
+        true,
+        "ltx_foley_window"
+      ]
+    },
+    {
+      "id": 24,
+      "type": "LTXFoleyAudioAccumulator",
+      "pos": [
+        2320,
+        -300
+      ],
+      "size": [
+        260,
+        120
+      ],
+      "flags": {},
+      "order": 23,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "window_record",
+          "type": "FOLEY_WINDOW_RECORD",
+          "link": 38
+        },
+        {
+          "name": "accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "link": 39
+        }
+      ],
+      "outputs": [
+        {
+          "name": "accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "links": [
+            41
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyAudioAccumulator"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 25,
+      "type": "LTXFoleyForLoopClose",
+      "pos": [
+        2660,
+        -430
+      ],
+      "size": [
+        260,
+        120
+      ],
+      "flags": {},
+      "order": 24,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "flow_control",
+          "type": "FLOW_CONTROL",
+          "link": 40
+        },
+        {
+          "name": "audio_accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "link": 41,
+          "shape": 7
+        }
+      ],
+      "outputs": [
+        {
+          "name": "audio_accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "links": [
+            42
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyForLoopClose"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 26,
+      "type": "LTXFoleyAudioStitch",
+      "pos": [
+        3020,
+        -380
+      ],
+      "size": [
+        300,
+        110
+      ],
+      "flags": {},
+      "order": 25,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "accumulation",
+          "type": "FOLEY_AUDIO_ACCUM",
+          "link": 42
+        },
+        {
+          "name": "window_plan",
+          "type": "FOLEY_WINDOW_PLAN",
+          "link": 43
+        }
+      ],
+      "outputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            46
+          ]
+        },
+        {
+          "name": "manifest",
+          "type": "STRING",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LTXFoleyAudioStitch"
+      },
+      "widgets_values": []
+    },
+    {
+      "id": 27,
+      "type": "CreateVideo",
+      "pos": [
+        3380,
+        -420
+      ],
+      "size": [
+        260,
+        140
+      ],
+      "flags": {},
+      "order": 26,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 44
+        },
+        {
+          "name": "fps",
+          "type": "FLOAT",
+          "link": 45
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 46
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": [
+            47
+          ]
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CreateVideo"
+      },
+      "widgets_values": [
+        25.0,
+        8
+      ]
+    },
+    {
+      "id": 28,
+      "type": "SaveVideo",
+      "pos": [
+        3700,
+        -420
+      ],
+      "size": [
+        260,
+        110
+      ],
+      "flags": {},
+      "order": 27,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "link": 47
+        }
+      ],
+      "outputs": [
+        {
+          "name": "video",
+          "type": "VIDEO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SaveVideo"
+      },
+      "widgets_values": [
+        "ltx_foley_loop",
+        "auto",
+        "auto"
+      ]
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      2,
+      0,
+      "VIDEO"
+    ],
+    [
+      2,
+      2,
+      0,
+      9,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      2,
+      2,
+      8,
+      2,
+      "FLOAT"
+    ],
+    [
+      4,
+      2,
+      2,
+      9,
+      1,
+      "FLOAT"
+    ],
+    [
+      6,
+      9,
+      1,
+      11,
+      0,
+      "INT"
+    ],
+    [
+      7,
+      2,
+      0,
+      12,
+      0,
+      "IMAGE"
+    ],
+    [
+      8,
+      9,
+      0,
+      12,
+      1,
+      "FOLEY_WINDOW_PLAN"
+    ],
+    [
+      9,
+      11,
+      1,
+      12,
+      2,
+      "INT"
+    ],
+    [
+      10,
+      3,
+      0,
+      10,
+      0,
+      "MODEL"
+    ],
+    [
+      11,
+      10,
+      0,
+      14,
+      0,
+      "MODEL"
+    ],
+    [
+      12,
+      5,
+      0,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      13,
+      5,
+      0,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      14,
+      6,
+      0,
+      8,
+      0,
+      "CONDITIONING"
+    ],
+    [
+      15,
+      7,
+      0,
+      8,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      16,
+      8,
+      0,
+      13,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      17,
+      8,
+      1,
+      13,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      18,
+      12,
+      0,
+      13,
+      0,
+      "IMAGE"
+    ],
+    [
+      19,
+      3,
+      2,
+      13,
+      3,
+      "VAE"
+    ],
+    [
+      20,
+      4,
+      0,
+      13,
+      4,
+      "VAE"
+    ],
+    [
+      21,
+      2,
+      2,
+      13,
+      5,
+      "FLOAT"
+    ],
+    [
+      22,
+      13,
+      2,
+      14,
+      1,
+      "LATENT"
+    ],
+    [
+      23,
+      14,
+      0,
+      15,
+      0,
+      "MODEL"
+    ],
+    [
+      24,
+      15,
+      0,
+      16,
+      0,
+      "MODEL"
+    ],
+    [
+      25,
+      13,
+      0,
+      16,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      26,
+      13,
+      1,
+      16,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      27,
+      17,
+      0,
+      20,
+      0,
+      "NOISE"
+    ],
+    [
+      28,
+      16,
+      0,
+      20,
+      1,
+      "GUIDER"
+    ],
+    [
+      29,
+      18,
+      0,
+      20,
+      2,
+      "SAMPLER"
+    ],
+    [
+      30,
+      19,
+      0,
+      20,
+      3,
+      "SIGMAS"
+    ],
+    [
+      31,
+      13,
+      2,
+      20,
+      4,
+      "LATENT"
+    ],
+    [
+      32,
+      13,
+      2,
+      19,
+      0,
+      "LATENT"
+    ],
+    [
+      33,
+      20,
+      0,
+      21,
+      0,
+      "LATENT"
+    ],
+    [
+      34,
+      21,
+      1,
+      22,
+      0,
+      "LATENT"
+    ],
+    [
+      35,
+      4,
+      0,
+      22,
+      1,
+      "VAE"
+    ],
+    [
+      36,
+      22,
+      0,
+      23,
+      0,
+      "AUDIO"
+    ],
+    [
+      37,
+      12,
+      1,
+      23,
+      1,
+      "FOLEY_WINDOW"
+    ],
+    [
+      38,
+      23,
+      1,
+      24,
+      0,
+      "FOLEY_WINDOW_RECORD"
+    ],
+    [
+      39,
+      11,
+      2,
+      24,
+      1,
+      "FOLEY_AUDIO_ACCUM"
+    ],
+    [
+      40,
+      11,
+      0,
+      25,
+      0,
+      "FLOW_CONTROL"
+    ],
+    [
+      41,
+      24,
+      0,
+      25,
+      1,
+      "FOLEY_AUDIO_ACCUM"
+    ],
+    [
+      42,
+      25,
+      0,
+      26,
+      0,
+      "FOLEY_AUDIO_ACCUM"
+    ],
+    [
+      43,
+      9,
+      0,
+      26,
+      1,
+      "FOLEY_WINDOW_PLAN"
+    ],
+    [
+      44,
+      2,
+      0,
+      27,
+      0,
+      "IMAGE"
+    ],
+    [
+      45,
+      2,
+      2,
+      27,
+      1,
+      "FLOAT"
+    ],
+    [
+      46,
+      26,
+      0,
+      27,
+      2,
+      "AUDIO"
+    ],
+    [
+      47,
+      27,
+      0,
+      28,
+      0,
+      "VIDEO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "models": [
+    {
+      "name": "ltx-2.3-22b-dev-fp8.safetensors",
+      "url": "https://huggingface.co/Lightricks/LTX-2.3-fp8/resolve/main/ltx-2.3-22b-dev-fp8.safetensors",
+      "directory": "checkpoints"
+    },
+    {
+      "name": "gemma_3_12B_it_fp8_scaled.safetensors",
+      "url": "https://huggingface.co/Comfy-Org/ltx-2/resolve/main/split_files/text_encoders/gemma_3_12B_it_fp8_scaled.safetensors",
+      "directory": "text_encoders"
+    },
+    {
+      "name": "ltx-2.3-foley-400-steps.safetensors",
+      "url": "https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-LoRA/resolve/main/ltx-2.3-foley-400-steps.safetensors",
+      "directory": "loras"
+    }
+  ],
+  "version": 0.4
+}

ltx_foley_v2a/nodes.py

@@ -1,5 +1,22 @@
 from __future__ import annotations
 
+import json
+import math
+import re
+import wave
+from pathlib import Path
+
+
+class _SmartType(str):
+    def __ne__(self, other):
+        if self == "*" or other == "*":
+            return False
+        return str.__ne__(self, other)
+
+
+ANY_TYPE = _SmartType("*")
+
+
 def _common_upscale(images, width: int, height: int):
     import comfy.utils
 
@@ -22,6 +39,438 @@ def _audio_vae_model(audio_vae):
     return getattr(audio_vae, "first_stage_model", audio_vae)
 
 
+def _window_specs(source_frames: int, fps: float, window_frames: int, overlap_seconds: float) -> list[dict[str, object]]:
+    if window_frames % 8 != 1:
+        raise ValueError("window_frames must satisfy window_frames % 8 == 1")
+    if source_frames <= 0:
+        raise ValueError("source frame count must be positive")
+    if fps <= 0:
+        raise ValueError("frame_rate must be positive")
+    if overlap_seconds < 0:
+        raise ValueError("overlap_seconds must be non-negative")
+
+    frames = window_frames
+    if source_frames <= frames:
+        return [{"index": 1, "start_frame": 0, "start_seconds": 0.0, "frames": frames, "duration": frames / fps}]
+
+    overlap_frames = max(0, round(overlap_seconds * fps))
+    overlap_frames = min(overlap_frames, frames - 8)
+    hop_frames = max(8, frames - overlap_frames)
+    last_start = max(0, source_frames - frames)
+
+    starts = list(range(0, last_start + 1, hop_frames))
+    if starts[-1] != last_start:
+        starts.append(last_start)
+
+    return [
+        {
+            "index": index,
+            "start_frame": start_frame,
+            "start_seconds": start_frame / fps,
+            "frames": frames,
+            "duration": frames / fps,
+        }
+        for index, start_frame in enumerate(starts, start=1)
+    ]
+
+
+def _slice_or_pad_frames(images, start_frame: int, frames: int):
+    import torch
+
+    if images.shape[0] == 0:
+        raise ValueError("No video frames were provided")
+    if start_frame < 0:
+        raise ValueError("start_frame must be non-negative")
+    if frames <= 0:
+        raise ValueError("frames must be positive")
+
+    source = images[start_frame : start_frame + frames]
+    if source.shape[0] == 0:
+        source = images[-1:]
+    if source.shape[0] < frames:
+        pad = source[-1:].repeat((frames - source.shape[0], 1, 1, 1))
+        source = torch.cat([source, pad], dim=0)
+    return source
+
+
+def _audio_waveform(audio: dict[str, object]):
+    waveform = audio.get("waveform")
+    if waveform is None:
+        raise ValueError("Expected AUDIO dict to contain waveform")
+    if waveform.ndim == 2:
+        waveform = waveform.unsqueeze(0)
+    elif waveform.ndim != 3:
+        raise ValueError(f"Expected audio waveform to have 2 or 3 dimensions, got shape {tuple(waveform.shape)}")
+
+    if waveform.shape[1] in (1, 2, 6):
+        return waveform
+    if waveform.shape[2] in (1, 2, 6):
+        return waveform.movedim(-1, 1)
+    raise ValueError(f"Could not infer audio channel dimension from waveform shape {tuple(waveform.shape)}")
+
+
+def _audio_stats(audio) -> dict[str, object]:
+    import torch
+
+    if audio.numel() == 0:
+        return {"samples": 0, "rms": 0.0, "peak": 0.0}
+    detached = audio.detach().float()
+    return {
+        "samples": int(detached.shape[-1]),
+        "rms": float(torch.sqrt(torch.mean(torch.square(detached))).cpu()),
+        "peak": float(torch.max(torch.abs(detached)).cpu()),
+    }
+
+
+def _accum_record_count(accumulation) -> int:
+    if isinstance(accumulation, dict):
+        return len(accumulation.get("records", []))
+    return 0
+
+
+def _loop_next_remaining(accumulation) -> int:
+    """Windows still to generate, derived from the latest accumulated record.
+
+    The loop countdown is carried inside the accumulation value instead of a
+    graph link to the loop-open node so the ephemeral loop nodes never need a
+    link back into the visible graph (see LTXFoleyForLoopClose docstring).
+    """
+    records = accumulation.get("records", []) if isinstance(accumulation, dict) else []
+    if not records:
+        raise ValueError("The sliding-window loop requires at least one accumulated window record")
+    info = records[-1]["window_info"]
+    window_count = int(info.get("window_count", info.get("planned_window_count", 0)))
+    if window_count <= 0:
+        raise ValueError("Accumulated window record does not carry a window count")
+    return window_count - int(info["spec"]["index"])
+
+
+def _safe_filename(value: str, default: str = "ltx_foley_window") -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "_", str(value)).strip("._")
+    return cleaned or default
+
+
+def _comfy_output_directory() -> Path:
+    try:
+        import folder_paths
+
+        return Path(folder_paths.get_output_directory())
+    except Exception:
+        return Path.cwd()
+
+
+def _write_audio_window(audio: dict[str, object], *, prefix: str, window_index: int) -> str:
+    import torch
+
+    sample_rate = int(audio["sample_rate"])
+    waveform = _audio_waveform(audio).detach().float().cpu()[0]
+    waveform = waveform.clamp(-1.0, 1.0)
+    pcm = (waveform.movedim(0, -1) * 32767.0).round().to(torch.int16).contiguous()
+
+    output_dir = _comfy_output_directory() / "ltx_foley_windows"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    path = output_dir / f"{_safe_filename(prefix)}_{window_index:03d}.wav"
+
+    with wave.open(str(path), "wb") as handle:
+        handle.setnchannels(int(waveform.shape[0]))
+        handle.setsampwidth(2)
+        handle.setframerate(sample_rate)
+        handle.writeframes(pcm.numpy().tobytes())
+
+    return str(path)
+
+
+def _stitch_audio_windows(
+    audio_windows: list[dict[str, object]],
+    window_specs: list[dict[str, object]],
+    output_duration: float,
+    overlap_seconds: float,
+) -> tuple[dict[str, object], list[dict[str, object]]]:
+    import torch
+
+    if not audio_windows:
+        raise ValueError("No window audio was generated")
+
+    sample_rate = int(audio_windows[0]["sample_rate"])
+    waveforms = [_audio_waveform(audio).detach().float().cpu() for audio in audio_windows]
+    channels = int(waveforms[0].shape[1])
+    total_samples = max(1, math.ceil(output_duration * sample_rate))
+    accum = torch.zeros((1, channels, total_samples), dtype=torch.float32)
+    weights = torch.zeros((1, 1, total_samples), dtype=torch.float32)
+    overlap_samples = max(1, round(overlap_seconds * sample_rate))
+
+    stats: list[dict[str, object]] = []
+    for index, (waveform, spec) in enumerate(zip(waveforms, window_specs, strict=True)):
+        current_rate = int(audio_windows[index]["sample_rate"])
+        if current_rate != sample_rate:
+            raise ValueError(f"Mismatched audio sample rate {current_rate}; expected {sample_rate}")
+        if waveform.shape[1] != channels:
+            raise ValueError(f"Mismatched audio channel count {waveform.shape[1]}; expected {channels}")
+
+        start = round(float(spec["start_seconds"]) * sample_rate)
+        if start >= total_samples:
+            continue
+        available = total_samples - start
+        waveform = waveform[:, :, :available]
+        if waveform.numel() == 0:
+            continue
+
+        window_weight = torch.ones((1, 1, waveform.shape[-1]), dtype=torch.float32)
+        if index > 0:
+            fade = min(overlap_samples, waveform.shape[-1])
+            window_weight[:, :, :fade] = torch.linspace(0.0, 1.0, fade, dtype=torch.float32).view(1, 1, -1)
+        if index < len(waveforms) - 1:
+            fade = min(overlap_samples, waveform.shape[-1])
+            fade_out = torch.linspace(1.0, 0.0, fade, dtype=torch.float32).view(1, 1, -1)
+            window_weight[:, :, -fade:] = torch.minimum(window_weight[:, :, -fade:], fade_out)
+
+        end = start + waveform.shape[-1]
+        accum[:, :, start:end] += waveform * window_weight
+        weights[:, :, start:end] += window_weight
+        stats.append({"window_index": int(spec["index"]), **_audio_stats(waveform)})
+
+    stitched = accum / torch.clamp(weights, min=1e-6)
+    return {"waveform": stitched, "sample_rate": sample_rate}, stats
+
+
+def _manifest_text(
+    *,
+    source_frames: int,
+    fps: float,
+    window_specs: list[dict[str, object]],
+    planned_window_count: int | None = None,
+    truncated_by_max_windows: bool = False,
+    audio_stats: list[dict[str, object]],
+    window_audio_paths: list[str],
+    warnings: list[str],
+) -> str:
+    payload = {
+        "version": "ltx_foley_loop",
+        "source_frames": int(source_frames),
+        "frame_rate": float(fps),
+        "source_duration": float(source_frames / fps),
+        "window_count": len(window_specs),
+        "planned_window_count": int(planned_window_count if planned_window_count is not None else len(window_specs)),
+        "truncated_by_max_windows": bool(truncated_by_max_windows),
+        "window_specs": window_specs,
+        "window_audio_stats": audio_stats,
+        "window_audio_paths": window_audio_paths,
+        "warnings": warnings,
+    }
+    return json.dumps(payload, indent=2)
+
+
+class LTXFoleyForLoopOpen:
+    """Minimal execution-inversion for-loop.
+
+    Loop mechanics are adapted from akatz-ai/ComfyUI-Execution-Inversion
+    under the MIT license, Copyright (c) 2025 akatz-ai. This node deliberately
+    only exposes the sockets needed by the Foley workflow.
+
+    This node is a pure pass-through: the visible graph body is the first loop
+    iteration. Recursion happens in _LTXFoleyLoopIterator, which clones the
+    subgraph between this node and the accumulator and seeds the clone of this
+    node with plain values via remaining/initial_value0.
+    """
+
+    CATEGORY = "LTX/Foley/Loop"
+    RETURN_TYPES = (_SmartType("FLOW_CONTROL"), "INT", "FOLEY_AUDIO_ACCUM")
+    RETURN_NAMES = ("flow_control", "remaining", "audio_accumulation")
+    FUNCTION = "open"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "remaining": ("INT", {"default": 1, "min": 0, "max": 100000, "step": 1}),
+            },
+            "optional": {"audio_accumulation": ("FOLEY_AUDIO_ACCUM",)},
+            "hidden": {"initial_value0": (ANY_TYPE,), "unique_id": "UNIQUE_ID"},
+        }
+
+    def open(self, remaining: int, **kwargs):
+        seeded = "initial_value0" in kwargs
+        if seeded:
+            remaining = kwargs["initial_value0"]
+        remaining = int(remaining)
+        print(
+            "[LTXFoley][trace] loop open "
+            f"node={kwargs.get('unique_id')} remaining={remaining} seeded={seeded} "
+            f"accum_records={_accum_record_count(kwargs.get('audio_accumulation'))}",
+            flush=True,
+        )
+        return ("stub", remaining, kwargs.get("audio_accumulation"))
+
+
+class LTXFoleyForLoopClose:
+    """Closes the sliding-window loop.
+
+    The loop-carried audio accumulation is received as a materialized value
+    (not a rawLink) and handed to the recursion as an embedded constant, and
+    the countdown is derived from the accumulation itself. The ephemeral
+    iterator node this expands must never receive graph links as inputs:
+    links attached to freshly expanded nodes bypass the per-consumer
+    execution cache, so under ComfyUI's default RAM-pressure caching an
+    evicted upstream output re-executes the entire visible sampler chain
+    (observed as a duplicated first window).
+    """
+
+    CATEGORY = "LTX/Foley/Loop"
+    RETURN_TYPES = ("FOLEY_AUDIO_ACCUM",)
+    RETURN_NAMES = ("audio_accumulation",)
+    FUNCTION = "close"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {"flow_control": (_SmartType("FLOW_CONTROL"), {"rawLink": True})},
+            "optional": {"audio_accumulation": ("FOLEY_AUDIO_ACCUM",)},
+            "hidden": {"dynprompt": "DYNPROMPT", "unique_id": "UNIQUE_ID"},
+        }
+
+    def close(self, flow_control, audio_accumulation=None, dynprompt=None, unique_id=None):
+        from comfy_execution.graph_utils import GraphBuilder, is_link
+
+        open_node = flow_control[0]
+        next_remaining = _loop_next_remaining(audio_accumulation)
+        if next_remaining <= 0:
+            print(
+                "[LTXFoley][trace] loop finished "
+                f"node={unique_id} accum_records={_accum_record_count(audio_accumulation)}",
+                flush=True,
+            )
+            return (audio_accumulation,)
+
+        anchor = dynprompt.get_node(unique_id)["inputs"].get("audio_accumulation")
+        if not is_link(anchor):
+            raise ValueError("LTXFoleyForLoopClose expects audio_accumulation to be linked from the loop body")
+        print(
+            "[LTXFoley][trace] loop close expanding "
+            f"node={unique_id} open_node={open_node} anchor={anchor[0]} next_remaining={next_remaining}",
+            flush=True,
+        )
+        graph = GraphBuilder()
+        iterator = graph.node(
+            "_LTXFoleyLoopIterator",
+            audio_accumulation=audio_accumulation,
+            open_node=open_node,
+            anchor_node=anchor[0],
+            anchor_output=anchor[1],
+        )
+        return {"result": (iterator.out(0),), "expand": graph.finalize()}
+
+
+class _LTXFoleyLoopIterator:
+    """Runs one recursion step of the sliding-window loop.
+
+    All inputs are constants (values and node-id strings). The loop body is
+    discovered by walking dynprompt links upward from the anchor (the
+    accumulator feeding the loop close), then cloning every node between the
+    loop open and the anchor. The clone's open node is seeded with plain
+    values, and the next iterator receives the cloned anchor's output — the
+    only link it ever holds, and one that points inside its own expansion.
+    """
+
+    CATEGORY = "LTX/Foley/Internal"
+    RETURN_TYPES = ("FOLEY_AUDIO_ACCUM",)
+    RETURN_NAMES = ("audio_accumulation",)
+    FUNCTION = "iterate"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "audio_accumulation": ("FOLEY_AUDIO_ACCUM",),
+                "open_node": (ANY_TYPE,),
+                "anchor_node": (ANY_TYPE,),
+                "anchor_output": ("INT", {"default": 0}),
+            },
+            "hidden": {"dynprompt": "DYNPROMPT", "unique_id": "UNIQUE_ID"},
+        }
+
+    def _explore_dependencies(self, node_id, dynprompt, upstream):
+        from comfy_execution.graph_utils import is_link
+
+        node_info = dynprompt.get_node(node_id)
+        if "inputs" not in node_info:
+            return
+        for value in node_info["inputs"].values():
+            if is_link(value):
+                parent_id = value[0]
+                if parent_id not in upstream:
+                    upstream[parent_id] = []
+                    self._explore_dependencies(parent_id, dynprompt, upstream)
+                upstream[parent_id].append(node_id)
+
+    def _collect_contained(self, node_id, upstream, contained):
+        if node_id not in upstream:
+            return
+        for child_id in upstream[node_id]:
+            if child_id not in contained:
+                contained[child_id] = True
+                self._collect_contained(child_id, upstream, contained)
+
+    def iterate(self, audio_accumulation, open_node, anchor_node, anchor_output, dynprompt=None, unique_id=None):
+        next_remaining = _loop_next_remaining(audio_accumulation)
+        if next_remaining <= 0:
+            print(
+                "[LTXFoley][trace] loop finished "
+                f"node={unique_id} accum_records={_accum_record_count(audio_accumulation)}",
+                flush=True,
+            )
+            return (audio_accumulation,)
+
+        from comfy_execution.graph_utils import GraphBuilder, is_link
+
+        upstream = {}
+        self._explore_dependencies(anchor_node, dynprompt, upstream)
+        contained = {}
+        self._collect_contained(open_node, upstream, contained)
+        contained[open_node] = True
+        contained[anchor_node] = True
+
+        graph = GraphBuilder()
+        for node_id in contained:
+            original_node = dynprompt.get_node(node_id)
+            node = graph.node(original_node["class_type"], node_id)
+            node.set_override_display_id(node_id)
+        for node_id in contained:
+            original_node = dynprompt.get_node(node_id)
+            node = graph.lookup_node(node_id)
+            for key, value in original_node["inputs"].items():
+                if is_link(value) and value[0] in contained:
+                    parent = graph.lookup_node(value[0])
+                    node.set_input(key, parent.out(value[1]))
+                else:
+                    node.set_input(key, value)
+
+        new_open = graph.lookup_node(open_node)
+        # Replace the remaining link with a plain value as well, so the clone
+        # does not pull the (possibly evicted) window-plan chain back onto the
+        # execution list.
+        new_open.set_input("remaining", next_remaining)
+        new_open.set_input("initial_value0", next_remaining)
+        new_open.set_input("audio_accumulation", audio_accumulation)
+        new_anchor = graph.lookup_node(anchor_node)
+        recurse = graph.node(
+            "_LTXFoleyLoopIterator",
+            "Recurse",
+            audio_accumulation=new_anchor.out(int(anchor_output)),
+            open_node=new_open.id,
+            anchor_node=new_anchor.id,
+            anchor_output=int(anchor_output),
+        )
+        recurse.set_override_display_id(unique_id)
+        print(
+            "[LTXFoley][trace] loop recursing "
+            f"node={unique_id} next_remaining={next_remaining} "
+            f"accum_records={_accum_record_count(audio_accumulation)} "
+            f"cloned_nodes={sorted(contained)}",
+            flush=True,
+        )
+        return {"result": (recurse.out(0),), "expand": graph.finalize()}
+
+
 class LTXFoleyVideoToAudioLatent:
     CATEGORY = "LTX/Foley"
     RETURN_TYPES = ("CONDITIONING", "CONDITIONING", "LATENT", "IMAGE", "FLOAT", "INT")
@@ -63,10 +512,7 @@ class LTXFoleyVideoToAudioLatent:
         if images.shape[0] == 0:
             raise ValueError("No video frames were provided")
 
-        source = images[:frames]
-        if source.shape[0] < frames:
-            pad = source[-1:].repeat((frames - source.shape[0], 1, 1, 1))
-            source = torch.cat([source, pad], dim=0)
+        source = _slice_or_pad_frames(images, 0, frames)
 
         resized = _common_upscale(source, width, height).clamp(0.0, 1.0)
         video_latent = video_vae.encode(resized[:, :, :, :3])
@@ -131,6 +577,208 @@ class LTXFoleyTrimImages:
         return (trimmed, float(frame_rate))
 
 
+class LTXFoleyWindowPlan:
+    CATEGORY = "LTX/Foley"
+    RETURN_TYPES = ("FOLEY_WINDOW_PLAN", "INT", "STRING")
+    RETURN_NAMES = ("window_plan", "window_count", "manifest")
+    FUNCTION = "plan"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "frame_rate": ("FLOAT", {"default": 25.0, "min": 1.0, "max": 120.0, "step": 0.01}),
+                "window_frames": ("INT", {"default": 89, "min": 9, "max": 257, "step": 8}),
+                "overlap_seconds": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.1}),
+                "max_windows": ("INT", {"default": 16, "min": 1, "max": 256, "step": 1}),
+            }
+        }
+
+    def plan(self, images, frame_rate: float, window_frames: int, overlap_seconds: float, max_windows: int):
+        fps = float(frame_rate)
+        source_frames = int(images.shape[0])
+        all_specs = _window_specs(source_frames, fps, int(window_frames), float(overlap_seconds))
+        max_windows = int(max_windows)
+        specs = all_specs[:max_windows]
+        truncated = len(specs) < len(all_specs)
+        if not specs:
+            raise ValueError("max_windows must allow at least one diagnostic window")
+        plan = {
+            "version": "ltx_foley_loop_plan",
+            "source_frames": source_frames,
+            "frame_rate": fps,
+            "source_duration": source_frames / fps,
+            "window_frames": int(window_frames),
+            "overlap_seconds": float(overlap_seconds),
+            "planned_window_count": len(all_specs),
+            "truncated_by_max_windows": truncated,
+            "window_specs": specs,
+        }
+        if truncated:
+            print(
+                "[LTXFoley] diagnostic truncation: "
+                f"planned {len(all_specs)} windows, running first {len(specs)} because max_windows={max_windows}",
+                flush=True,
+            )
+        else:
+            print(f"[LTXFoley] planned {len(specs)} windows", flush=True)
+        return (plan, len(specs), json.dumps(plan, indent=2))
+
+
+class LTXFoleyWindowSelect:
+    CATEGORY = "LTX/Foley"
+    RETURN_TYPES = ("IMAGE", "FOLEY_WINDOW")
+    RETURN_NAMES = ("window_images", "window_info")
+    FUNCTION = "select"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "window_plan": ("FOLEY_WINDOW_PLAN",),
+                "remaining": ("INT", {"default": 1, "min": 1, "max": 100000, "step": 1}),
+            },
+            "hidden": {"unique_id": "UNIQUE_ID"},
+        }
+
+    def select(self, images, window_plan: dict[str, object], remaining: int, unique_id=None):
+        specs = list(window_plan["window_specs"])
+        loop_index = len(specs) - int(remaining)
+        if loop_index < 0 or loop_index >= len(specs):
+            raise ValueError(f"Loop remaining={remaining} is outside the planned {len(specs)} windows")
+        spec = dict(specs[loop_index])
+        frames = int(window_plan.get("window_frames", spec["frames"]))
+        window_images = _slice_or_pad_frames(images, int(spec["start_frame"]), frames)
+        window_info = {
+            "spec": spec,
+            "window_count": len(specs),
+            "source_frames": int(window_plan["source_frames"]),
+            "frame_rate": float(window_plan["frame_rate"]),
+            "source_duration": float(window_plan["source_duration"]),
+            "overlap_seconds": float(window_plan["overlap_seconds"]),
+            "planned_window_count": int(window_plan.get("planned_window_count", len(specs))),
+            "truncated_by_max_windows": bool(window_plan.get("truncated_by_max_windows", False)),
+        }
+        print(
+            "[LTXFoley] selecting window "
+            f"{spec['index']}/{len(specs)} start_frame={spec['start_frame']} frames={frames} "
+            f"node={unique_id} remaining={remaining}",
+            flush=True,
+        )
+        return (window_images, window_info)
+
+
+class LTXFoleyWindowAudioSave:
+    CATEGORY = "LTX/Foley"
+    RETURN_TYPES = ("AUDIO", "FOLEY_WINDOW_RECORD")
+    RETURN_NAMES = ("audio", "window_record")
+    FUNCTION = "save"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "audio": ("AUDIO",),
+                "window_info": ("FOLEY_WINDOW",),
+                "save_audio": ("BOOLEAN", {"default": True}),
+                "filename_prefix": ("STRING", {"default": "ltx_foley_window"}),
+            }
+        }
+
+    def save(self, audio, window_info: dict[str, object], save_audio: bool, filename_prefix: str):
+        spec = dict(window_info["spec"])
+        path = ""
+        if save_audio:
+            path = _write_audio_window(audio, prefix=filename_prefix, window_index=int(spec["index"]))
+        stats = _audio_stats(_audio_waveform(audio))
+        print(
+            "[LTXFoley] window "
+            f"{spec['index']} audio samples={stats['samples']} rms={stats['rms']:.6f} "
+            f"peak={stats['peak']:.6f} path={path or '<not saved>'}",
+            flush=True,
+        )
+        return (audio, {"audio": audio, "window_info": window_info, "path": path})
+
+
+class LTXFoleyAudioAccumulator:
+    CATEGORY = "LTX/Foley/Loop"
+    RETURN_TYPES = ("FOLEY_AUDIO_ACCUM",)
+    RETURN_NAMES = ("accumulation",)
+    FUNCTION = "accumulate"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {"window_record": ("FOLEY_WINDOW_RECORD",)},
+            "optional": {"accumulation": ("FOLEY_AUDIO_ACCUM",)},
+            "hidden": {"unique_id": "UNIQUE_ID"},
+        }
+
+    def accumulate(self, window_record: dict[str, object], accumulation: dict[str, object] | None = None, unique_id=None):
+        records = [] if accumulation is None else list(accumulation.get("records", []))
+        records.append(window_record)
+        print(
+            "[LTXFoley][trace] accumulate "
+            f"node={unique_id} window={window_record['window_info']['spec']['index']} "
+            f"total_records={len(records)}",
+            flush=True,
+        )
+        return ({"records": records},)
+
+
+class LTXFoleyAudioStitch:
+    CATEGORY = "LTX/Foley"
+    RETURN_TYPES = ("AUDIO", "STRING")
+    RETURN_NAMES = ("audio", "manifest")
+    FUNCTION = "stitch"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict[str, object]:
+        return {
+            "required": {
+                "accumulation": ("FOLEY_AUDIO_ACCUM",),
+                "window_plan": ("FOLEY_WINDOW_PLAN",),
+            }
+        }
+
+    def stitch(self, accumulation: dict[str, object], window_plan: dict[str, object]):
+        records = list(accumulation.get("records", []))
+        if not records:
+            raise ValueError("No generated window audio records were provided")
+
+        records.sort(key=lambda item: int(item["window_info"]["spec"]["index"]))
+        audio_windows = [item["audio"] for item in records]
+        specs = [dict(item["window_info"]["spec"]) for item in records]
+        stitched_audio, audio_stats = _stitch_audio_windows(
+            audio_windows,
+            specs,
+            output_duration=float(window_plan["source_duration"]),
+            overlap_seconds=float(window_plan["overlap_seconds"]),
+        )
+        manifest = _manifest_text(
+            source_frames=int(window_plan["source_frames"]),
+            fps=float(window_plan["frame_rate"]),
+            window_specs=specs,
+            planned_window_count=int(window_plan.get("planned_window_count", len(specs))),
+            truncated_by_max_windows=bool(window_plan.get("truncated_by_max_windows", False)),
+            audio_stats=audio_stats,
+            window_audio_paths=[str(item.get("path", "")) for item in records],
+            warnings=(
+                [f"Diagnostic run truncated to {len(specs)} of {int(window_plan.get('planned_window_count', len(specs)))} planned windows"]
+                if bool(window_plan.get("truncated_by_max_windows", False))
+                else []
+            ),
+        )
+        print(
+            "[LTXFoley] stitched "
+            f"{len(specs)} window(s); truncated={bool(window_plan.get('truncated_by_max_windows', False))}",
+            flush=True,
+        )
+        return (stitched_audio, manifest)
+
+
 class LTXFoleyAudioVAEDecode:
     CATEGORY = "LTX/Foley"
     RETURN_TYPES = ("AUDIO",)
@@ -151,7 +799,8 @@ class LTXFoleyAudioVAEDecode:
         if audio_latent.is_nested:
             audio_latent = audio_latent.unbind()[-1]
 
-        audio = audio_vae.decode(audio_latent).to(audio_latent.device)
+        output_device = audio_latent.device
+        audio = audio_vae.decode(audio_latent).to(output_device)
         if audio.ndim == 2:
             audio = audio.unsqueeze(1)
         elif audio.ndim != 3:
@@ -169,12 +818,27 @@ class LTXFoleyAudioVAEDecode:
 
 
 NODE_CLASS_MAPPINGS = {
+    "_LTXFoleyLoopIterator": _LTXFoleyLoopIterator,
+    "LTXFoleyForLoopOpen": LTXFoleyForLoopOpen,
+    "LTXFoleyForLoopClose": LTXFoleyForLoopClose,
     "LTXFoleyVideoToAudioLatent": LTXFoleyVideoToAudioLatent,
     "LTXFoleyTrimImages": LTXFoleyTrimImages,
+    "LTXFoleyWindowPlan": LTXFoleyWindowPlan,
+    "LTXFoleyWindowSelect": LTXFoleyWindowSelect,
+    "LTXFoleyWindowAudioSave": LTXFoleyWindowAudioSave,
+    "LTXFoleyAudioAccumulator": LTXFoleyAudioAccumulator,
+    "LTXFoleyAudioStitch": LTXFoleyAudioStitch,
     "LTXFoleyAudioVAEDecode": LTXFoleyAudioVAEDecode,
 }
 NODE_DISPLAY_NAME_MAPPINGS = {
+    "LTXFoleyForLoopOpen": "LTX Foley For Loop Open",
+    "LTXFoleyForLoopClose": "LTX Foley For Loop Close",
     "LTXFoleyVideoToAudioLatent": "LTX Foley Video To Audio Latent",
     "LTXFoleyTrimImages": "LTX Foley Trim Images",
+    "LTXFoleyWindowPlan": "LTX Foley Window Plan",
+    "LTXFoleyWindowSelect": "LTX Foley Window Select",
+    "LTXFoleyWindowAudioSave": "LTX Foley Window Audio Save",
+    "LTXFoleyAudioAccumulator": "LTX Foley Audio Accumulator",
+    "LTXFoleyAudioStitch": "LTX Foley Audio Stitch",
     "LTXFoleyAudioVAEDecode": "LTX Foley Audio VAE Decode",
 }

setup_runpod_ltx_foley.sh

@@ -1,9 +1,12 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
-LTXVIDEO_REPO="${LTXVIDEO_REPO:-https://github.com/Lightricks/ComfyUI-LTXVideo.git}"
-WORKFLOW_REPO="${WORKFLOW_REPO:-FuzzPuppy/LTX-2.3-Foley-Workflow}"
-WORKFLOW_BASE_URL="${WORKFLOW_BASE_URL:-https://huggingface.co/${WORKFLOW_REPO}/resolve/main}"
+LTXVIDEO_REPO="https://github.com/Lightricks/ComfyUI-LTXVideo.git"
+LTXVIDEO_REVISION="4f45fd6c222eb06eb3e46605da62e7c889e4be5c"
+COMFYUI_CORE_REF="${COMFYUI_CORE_REF:-v0.27.0}"
+WORKFLOW_REPO="FuzzPuppy/LTX-2.3-Foley-Workflow"
+WORKFLOW_REVISION="${WORKFLOW_REVISION:-main}"
+WORKFLOW_BASE_URL="https://huggingface.co/${WORKFLOW_REPO}/resolve/${WORKFLOW_REVISION}"
 
 log() {
   printf '\n[%s] %s\n' "$(date +%H:%M:%S)" "$*"
@@ -14,12 +17,18 @@ die() {
   exit 1
 }
 
+hf_token() {
+  local token="${HF_TOKEN:-${HUGGINGFACE_TOKEN:-}}"
+  printf '%s' "$token" | tr -d '[:space:]'
+}
+
 download_file() {
   local url="$1"
   local target="$2"
-  local token="${HF_TOKEN:-${HUGGINGFACE_TOKEN:-}}"
+  local token
   local curl_args=(-fL --retry 5 --retry-delay 2)
 
+  token="$(hf_token)"
   mkdir -p "$(dirname "$target")"
   if [[ -n "$token" ]]; then
     curl_args+=(-H "Authorization: Bearer $token")
@@ -32,10 +41,11 @@ download_model_file() {
   local target_path="$2"
   local expected_sha256="$3"
   local partial_path="${target_path}.part"
-  local token="${HF_TOKEN:-${HUGGINGFACE_TOKEN:-}}"
+  local token
   local curl_args=(-fL --retry 5 --retry-delay 2 -C -)
   local attempt
 
+  token="$(hf_token)"
   if [[ -s "$target_path" ]]; then
     if printf '%s  %s\n' "$expected_sha256" "$target_path" | sha256sum -c - >/dev/null 2>&1; then
       printf 'verified: %s\n' "$target_path"
@@ -69,23 +79,12 @@ download_model_file() {
   die "Downloaded file failed SHA-256 verification: $target_path"
 }
 
-build_comfyui_args() {
-  COMFYUI_ARGS=(--listen 0.0.0.0 --port 8188 --enable-cors-header)
-
-  if [[ -s "$ARGS_FILE" ]]; then
-    local line
-    local line_args
-    while IFS= read -r line; do
-      [[ -z "$line" || "$line" == \#* ]] && continue
-      read -r -a line_args <<< "$line"
-      COMFYUI_ARGS+=("${line_args[@]}")
-    done < "$ARGS_FILE"
-  fi
-}
-
 restart_comfyui() {
   log "Restarting ComfyUI"
-  build_comfyui_args
+  # --cache-classic: the default RAM-pressure cache evicts node outputs
+  # mid-prompt while the large AV models load, which forces the sliding-window
+  # loop expansion to re-execute the entire upstream graph on every iteration.
+  local comfyui_args=(--listen 0.0.0.0 --port 8188 --enable-cors-header --cache-classic)
 
   local pid
   while IFS= read -r pid; do
@@ -107,7 +106,7 @@ restart_comfyui() {
 
   (
     cd "$COMFYUI_DIR"
-    nohup "$PYTHON_BIN" main.py "${COMFYUI_ARGS[@]}" > "$LOG_FILE" 2>&1 &
+    nohup "$PYTHON_BIN" main.py "${comfyui_args[@]}" > "$LOG_FILE" 2>&1 &
     printf '%s\n' "$!" > "$PID_FILE"
   )
 
@@ -127,13 +126,113 @@ restart_comfyui() {
   die "ComfyUI process started, but port 8188 did not become ready. Check $LOG_FILE"
 }
 
+patch_ltxvideo_kornia_import() {
+  local target="$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/pyramid_blending.py"
+  [[ -f "$target" ]] || return
+
+  "$PYTHON_BIN" - "$target" <<'PY'
+from pathlib import Path
+import sys
+
+path = Path(sys.argv[1])
+text = path.read_text(encoding="utf-8")
+old = """from kornia.geometry.transform.pyramid import (
+    PyrUp,
+    build_laplacian_pyramid,
+    build_pyramid,
+    find_next_powerof_two,
+    is_powerof_two,
+    pad,
+)
+"""
+new = """from kornia.geometry.transform.pyramid import (
+    PyrUp,
+    build_laplacian_pyramid,
+    build_pyramid,
+    find_next_powerof_two,
+    is_powerof_two,
+)
+from torch.nn.functional import pad
+"""
+if old in text:
+    path.write_text(text.replace(old, new), encoding="utf-8")
+    print(f"patched kornia pad import: {path}")
+elif "from torch.nn.functional import pad" in text:
+    print(f"kornia pad import already patched: {path}")
+else:
+    print(f"warning: expected kornia import block not found in {path}", file=sys.stderr)
+PY
+}
+
+ensure_pip() {
+  if "$PYTHON_BIN" -m pip --version >/dev/null 2>&1; then
+    return
+  fi
+
+  log "Bootstrapping pip for $PYTHON_BIN"
+  "$PYTHON_BIN" -m ensurepip --upgrade || true
+  if ! "$PYTHON_BIN" -m pip --version >/dev/null 2>&1; then
+    die "Could not run pip with $PYTHON_BIN. The RunPod Python environment is missing pip/ensurepip."
+  fi
+}
+
+pip_install() {
+  ensure_pip
+  "$PYTHON_BIN" -m pip install "$@"
+}
+
+install_comfyui_core_requirements() {
+  local requirements="$COMFYUI_DIR/requirements.txt"
+
+  [[ -f "$requirements" ]] || die "Could not find ComfyUI requirements file: $requirements"
+
+  log "Installing ComfyUI core requirements for $COMFYUI_CORE_REF"
+  pip_install --upgrade pip setuptools wheel
+  pip_install --upgrade -r "$requirements"
+}
+
+install_comfyui_core() {
+  log "Installing ComfyUI core at $COMFYUI_CORE_REF"
+  if [[ "$COMFYUI_CORE_REF" == v* ]]; then
+    git -C "$COMFYUI_DIR" fetch --force origin "refs/tags/$COMFYUI_CORE_REF:refs/tags/$COMFYUI_CORE_REF"
+  else
+    git -C "$COMFYUI_DIR" fetch --force origin "$COMFYUI_CORE_REF"
+  fi
+  if ! git -C "$COMFYUI_DIR" checkout -f "$COMFYUI_CORE_REF"; then
+    die "Could not check out ComfyUI core ref: $COMFYUI_CORE_REF"
+  fi
+
+  log "ComfyUI core resolved to $(git -C "$COMFYUI_DIR" describe --tags --always --dirty)"
+}
+
+install_ltxvideo_nodes() {
+  local target="$CUSTOM_NODES_DIR/ComfyUI-LTXVideo"
+
+  log "Installing official LTXVideo custom nodes at $LTXVIDEO_REVISION"
+  if [[ ! -d "$target/.git" ]]; then
+    rm -rf "$target"
+    git clone "$LTXVIDEO_REPO" "$target"
+  fi
+
+  if ! git -C "$target" fetch origin "$LTXVIDEO_REVISION"; then
+    git -C "$target" fetch origin
+  fi
+
+  if ! git -C "$target" checkout -f "$LTXVIDEO_REVISION"; then
+    log "Existing LTXVideo checkout could not switch revisions; re-cloning."
+    rm -rf "$target"
+    git clone "$LTXVIDEO_REPO" "$target"
+    git -C "$target" fetch origin "$LTXVIDEO_REVISION" || git -C "$target" fetch origin
+    git -C "$target" checkout -f "$LTXVIDEO_REVISION"
+  fi
+}
+
 COMFYUI_DIR="${COMFYUI_DIR:-/workspace/runpod-slim/ComfyUI}"
 [[ -f "$COMFYUI_DIR/main.py" ]] || die "Could not find ComfyUI at $COMFYUI_DIR. Use RunPod's official ComfyUI - CUDA 12.8 template or set COMFYUI_DIR=/path/to/ComfyUI."
 CUSTOM_NODES_DIR="$COMFYUI_DIR/custom_nodes"
 MODELS_DIR="$COMFYUI_DIR/models"
 INPUT_DIR="$COMFYUI_DIR/input"
 VENV_DIR="$COMFYUI_DIR/.venv-cu128"
-ARGS_FILE="/workspace/runpod-slim/comfyui_args.txt"
 LOG_FILE="/workspace/runpod-slim/comfyui-restart.log"
 PID_FILE="/workspace/runpod-slim/comfyui-restart.pid"
 PYTHON_BIN="$VENV_DIR/bin/python"
@@ -148,6 +247,8 @@ fi
 
 log "Using ComfyUI at $COMFYUI_DIR"
 log "Using Python at $PYTHON_BIN"
+log "Requested ComfyUI core ref: $COMFYUI_CORE_REF"
+log "Requested workflow revision: $WORKFLOW_REVISION"
 
 mkdir -p "$CUSTOM_NODES_DIR" "$MODELS_DIR/checkpoints" "$MODELS_DIR/loras" "$MODELS_DIR/text_encoders" "$INPUT_DIR"
 
@@ -156,36 +257,32 @@ command -v git >/dev/null 2>&1 || die "git is required. RunPod's official ComfyU
 command -v ffmpeg >/dev/null 2>&1 || die "ffmpeg is required. RunPod's official ComfyUI - CUDA 12.8 template includes it."
 command -v sha256sum >/dev/null 2>&1 || die "sha256sum is required. RunPod's official ComfyUI - CUDA 12.8 template includes it."
 
-if [[ "${UPDATE_COMFYUI:-0}" == "1" ]]; then
-  log "Updating ComfyUI"
-  git -C "$COMFYUI_DIR" pull --ff-only || log "ComfyUI git pull was skipped or failed; continuing with the installed version."
-else
-  log "Keeping the RunPod template's pinned ComfyUI install"
-fi
+install_comfyui_core
+install_comfyui_core_requirements
 
-log "Installing official LTXVideo custom nodes"
-if [[ -d "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/.git" ]]; then
-  git -C "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo" pull --ff-only || log "LTXVideo git pull was skipped or failed; continuing with the installed version."
-else
-  rm -rf "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo"
-  git clone --depth 1 "$LTXVIDEO_REPO" "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo"
-fi
+install_ltxvideo_nodes
 
 if [[ -f "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/requirements.txt" ]]; then
-  "$PYTHON_BIN" -m pip install -r "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/requirements.txt"
+  pip_install --upgrade -r "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/requirements.txt"
 fi
 if [[ -f "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/install.py" ]]; then
   "$PYTHON_BIN" "$CUSTOM_NODES_DIR/ComfyUI-LTXVideo/install.py" || log "LTXVideo install.py returned non-zero; continuing after requirements install."
 fi
+patch_ltxvideo_kornia_import
 
 log "Installing LTX Foley helper node and workflow from $WORKFLOW_REPO"
 NODE_DEST="$CUSTOM_NODES_DIR/ltx_foley_v2a"
 WORKFLOW_DEST="$COMFYUI_DIR/user/default/workflows"
 rm -rf "$NODE_DEST"
 mkdir -p "$NODE_DEST" "$WORKFLOW_DEST"
+rm -f \
+  "$WORKFLOW_DEST/ltx_23_foley_v2a_v3_loop.json" \
+  "$WORKFLOW_DEST/ltx_23_foley_v2a_legacy_audio_vae.json" \
+  "$WORKFLOW_DEST/ltx_23_foley_v2a_v1_wav_debug.json"
 download_file "$WORKFLOW_BASE_URL/ltx_foley_v2a/__init__.py" "$NODE_DEST/__init__.py"
 download_file "$WORKFLOW_BASE_URL/ltx_foley_v2a/nodes.py" "$NODE_DEST/nodes.py"
 download_file "$WORKFLOW_BASE_URL/ltx_23_foley_v2a.json" "$WORKFLOW_DEST/ltx_23_foley_v2a.json"
+download_file "$WORKFLOW_BASE_URL/foley-sliding-window.json" "$WORKFLOW_DEST/foley-sliding-window.json"
 download_file "$WORKFLOW_BASE_URL/tennis-no-sound.mp4" "$INPUT_DIR/input.mp4"
 
 log "Downloading LTX 2.3 Foley model files"
@@ -198,7 +295,7 @@ download_model_file \
   "$MODELS_DIR/text_encoders/gemma_3_12B_it_fp8_scaled.safetensors" \
   "60216ce97c01c3a8753c2dfd0a89fc76e16fbe446d1a32ef8f1b528ac8bae466"
 download_model_file \
-  "https://huggingface.co/FuzzPuppy/LTX-2.3-Foley/resolve/main/ltx-2.3-foley-400-steps.safetensors" \
+  "https://huggingface.co/FuzzPuppy/LTX-2.3-Foley-LoRA/resolve/main/ltx-2.3-foley-400-steps.safetensors" \
   "$MODELS_DIR/loras/ltx-2.3-foley-400-steps.safetensors" \
   "12b37ffff8444ac1348a8c9fb24843a6bd70e77cf4202ac39b1d056b81fa41c9"
 
@@ -209,9 +306,14 @@ cat <<EOF
 
 Next steps:
 1. Open the RunPod HTTP service on port 8188.
-2. Load workflow: user/default/workflows/ltx_23_foley_v2a.json
+2. Load workflow: user/default/workflows/foley-sliding-window.json
+   Short-clip workflow: user/default/workflows/ltx_23_foley_v2a.json
 3. Queue the workflow. The tennis test video is already installed as input.mp4 and the prompt is prefilled.
 
+This run used:
+  COMFYUI_CORE_REF=$COMFYUI_CORE_REF
+  WORKFLOW_REVISION=$WORKFLOW_REVISION
+
 If model download fails with 401/403, accept the model licenses on Hugging Face and rerun with:
   export HF_TOKEN=hf_...
   bash $0