diff --git a/experiments/ltx2-lora/README.md b/experiments/ltx2-lora/README.md
new file mode 100644
index 0000000..745a3da
--- /dev/null
+++ b/experiments/ltx2-lora/README.md
@@ -0,0 +1,85 @@
+# LTX-2.3 LoRA training — proven pipeline (Blackwell / sm120 / cu128)
+
+End-to-end LoRA fine-tuning of **LTX-2.3-22B** on the RTX PRO 6000, verified 2026-07-13. LoRAs train
+in bf16/int8 and **apply to our NVFP4 22B at inference**.
+
+## One command (orchestrated)
+
+```bash
+~/dev/LTX-2/.venv/bin/python make_video_lora.py <clips_dir> <style_name> \
+    [--rank 32] [--steps 1000] [--bucket 768x512x49] [--with-audio] [--gpu 1] [--no-caption] [--no-wire]
+```
+
+`make_video_lora.py` runs the whole chain — **caption → preprocess → fix-conditions → config → train →
+wire into ComfyUI** — and is **resumable** (each stage skips if its output exists). Point it at a folder
+of clips; get a `<style>.safetensors` LoRA symlinked into ComfyUI `loras/` plus a ready
+`LTX-2.3_T2V_<style>_LoRA` workflow (fp4 base + `LoraLoaderModelOnly`). If `<clips_dir>/dataset.json`
+(list of `{video_path, caption}`) exists or `--no-caption` is set, captioning is skipped and it's used.
+
+Work dir defaults to `/mnt/data/video-lora/<style>/`. The manual stages below are what it automates.
+
+## Gradio app (train + generate + compare in the browser)
+
+```bash
+~/dev/LTX-2/.venv/bin/python experiments/ltx2-lora/app.py     # UI on http://protolabs:7862
+```
+
+**Train tab** — upload clips (or point at a folder), set style/rank/steps/bucket, streams the pipeline log.
+**Generate & Compare tab** — pick any trained LoRA from the dropdown (↻ refresh), enter a prompt, **Generate**
+a video and see it inline, or **Compare vs base** to A/B base-vs-LoRA at the same seed side-by-side. Talks to
+ComfyUI on :8188 (must be up); needs `base_api.json` seeded once by any fp4 T2V run in the UI.
+
+---
+
+## Manual pipeline (what the orchestrator runs)
+
+## Verified on Blackwell
+- Trainer: `~/dev/LTX-2/packages/ltx-trainer` (`.venv`, torch 2.9.1+cu128). Arch-agnostic loader reads
+  the arch from the checkpoint's `config` metadata → the **22B (AVTransformer3DModel, 48 layers) trains
+  with no special-casing**.
+- `int8-quanto` quantization **works on sm120** (block-by-block; skips patchify/proj_out like our fp4 policy).
+- Base model to train on: `ltx-2.3-22b-distilled-1.1.safetensors` (bf16, 43 GB). Text encoder:
+  `/mnt/models/gemma-3-12b`.
+- Footprint (int8, rank 16): **~22 GB** → fits GPU1 alongside an idle ComfyUI. ~1 s/step.
+- LoRA output = standard PEFT format (`diffusion_model.…lora_A/B`, rank 16), 205 MB. Loads via
+  ComfyUI `LoraLoaderModelOnly` onto the **fp4 base** and measurably changes output (strength 0 vs 1
+  = different bytes at fixed seed).
+
+## Pipeline
+
+```bash
+cd ~/dev/LTX-2/packages/ltx-trainer
+PY=~/dev/LTX-2/.venv/bin/python
+
+# 1. dataset.json — list of {video_path, caption}. LTX likes long captions w/ audio description.
+
+# 2. preprocess: VAE-encode videos → latents + Gemma text embeddings
+CUDA_VISIBLE_DEVICES=1 $PY scripts/process_dataset.py dataset.json \
+  --resolution-buckets "768x448x25" \
+  --model-path /mnt/data/models-cold/LTX-2.3/ltx-2.3-22b-distilled-1.1.safetensors \
+  --text-encoder-path /mnt/models/gemma-3-12b \
+  --video-column video_path \
+  --output-dir <preprocessed>
+#  ⚠️ GOTCHA: text embeddings land NEXT TO the source clips as <clip>.pt, NOT in
+#     <preprocessed>/conditions/. The trainer's PrecomputedDataset expects
+#     <preprocessed>/conditions/<relpath>/<name>.pt mirroring <preprocessed>/latents/<relpath>/.
+#     Move them: cp <src_dir>/*.pt <preprocessed>/conditions/<relpath>/
+
+# 3. train (config = toy_smoke.yaml here; edit paths/steps/rank/target for real runs)
+CUDA_VISIBLE_DEVICES=1 $PY scripts/train.py <config>.yaml --disable-progress-bars
+#  → checkpoints/lora_weights_step_NNNNN.safetensors
+
+# 4. use in ComfyUI: symlink into models/loras/, add LoraLoaderModelOnly between the
+#    CheckpointLoaderSimple MODEL output and the guider, on the NVFP4 base.
+```
+
+## Config notes (`toy_smoke.yaml`)
+- `with_audio: false` unless you also preprocess `--with-audio` (needs audio_latents/). Toy run was video-only.
+- `quantization: int8-quanto` + `optimizer_type: adamw8bit` to co-reside with ComfyUI. Drop to bf16 +
+  free GPU1 for max fidelity.
+- `validation.interval: null` for smoke (validation gens are slow + reload Gemma). Enable for real runs.
+- rank 16 (low-vram) / 32 (standard). target_modules `to_k/to_q/to_v/to_out.0` match video+audio attn.
+
+## Next (real LoRA)
+Pick a concept → gather 20-50 style-consistent clips → caption (`caption_videos.py`, qwen_omni) →
+preprocess → train ~1-2k steps → validate. The smoke proved every stage runs on this box.
diff --git a/experiments/ltx2-lora/app.py b/experiments/ltx2-lora/app.py
new file mode 100644
index 0000000..caafaf4
--- /dev/null
+++ b/experiments/ltx2-lora/app.py
@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""Gradio UI for LTX-2.3 video LoRAs: TRAIN one from clips, then GENERATE + COMPARE videos
+with it against the NVFP4 base — all in the browser.
+
+  Train tab:            clips (upload/folder) -> caption→preprocess→train→wire -> LoRA in ComfyUI
+  Generate & Compare:   pick a LoRA, prompt -> video; or A/B base-vs-LoRA (same seed) side by side
+
+Talks to ComfyUI on :8188 (must be up). Run:
+  ~/dev/LTX-2/.venv/bin/python experiments/ltx2-lora/app.py     (UI on :7862)
+"""
+import gradio as gr, subprocess, os, shutil, signal, json, time, urllib.request
+from pathlib import Path
+
+HERE = Path(__file__).parent
+ORCH = HERE / "make_video_lora.py"
+PY = str(Path.home() / "dev/LTX-2/.venv/bin/python")
+COMFY = "http://127.0.0.1:8188"
+OUT = "/mnt/data/ltx-out"
+LORA_DIR = Path.home() / "dev/ComfyUI/models/loras"
+BASE_API = "/mnt/data/ltx-out/base_api.json"   # ComfyUI's own serialized fp4 T2V graph
+BUCKETS = ["768x512x49", "960x544x49", "768x448x25", "512x320x25", "1280x704x49"]
+_proc = {"p": None}
+
+# ------------------------------- TRAIN -------------------------------
+def train(mode, uploads, folder, style, rank, steps, bucket, with_audio, auto_caption, gpu):
+    if not style or not style.strip():
+        yield "❌ provide a style / LoRA name"; return
+    style = style.strip().replace(" ", "_")
+    work = Path(f"/mnt/data/video-lora/{style}")
+    if mode == "Upload clips":
+        if not uploads:
+            yield "❌ upload at least one clip"; return
+        clips = work / "raw"; clips.mkdir(parents=True, exist_ok=True)
+        for f in uploads:
+            shutil.copy2(f, clips / Path(f).name)
+        clips_dir = str(clips)
+    else:
+        if not folder or not os.path.isdir(folder):
+            yield f"❌ not a folder on the box: {folder}"; return
+        clips_dir = folder
+    cmd = [PY, str(ORCH), clips_dir, style, "--rank", str(int(rank)), "--steps", str(int(steps)),
+           "--bucket", bucket, "--gpu", str(int(gpu))]
+    if with_audio: cmd.append("--with-audio")
+    if not auto_caption: cmd.append("--no-caption")
+    log = "$ " + " ".join(cmd) + "\n\n"; yield log
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                         text=True, bufsize=1, preexec_fn=os.setsid)
+    _proc["p"] = p
+    for line in p.stdout:
+        log += line; yield log
+    p.wait(); _proc["p"] = None
+    log += (f"\n\n✅ DONE — '{style}' LoRA trained + wired. Switch to **Generate & Compare**, hit "
+            f"↻ Refresh, pick `{style}.safetensors`." if p.returncode == 0
+            else f"\n\n❌ exited {p.returncode} — see log above.")
+    yield log
+
+def stop():
+    p = _proc.get("p")
+    if p and p.poll() is None:
+        os.killpg(os.getpgid(p.pid), signal.SIGTERM); return "🛑 stop sent."
+    return "nothing running."
+
+# --------------------------- GENERATE ---------------------------
+def list_loras():
+    return ["(none / base)"] + sorted(f.name for f in LORA_DIR.glob("*.safetensors")) if LORA_DIR.exists() else ["(none / base)"]
+
+def _upload_image(path):
+    """POST an image to ComfyUI /upload/image; return the stored filename for LoadImage."""
+    import mimetypes, uuid
+    data = open(path, "rb").read()
+    name = f"ref_{uuid.uuid4().hex[:12]}{Path(path).suffix or '.png'}"
+    boundary = "----lorastudio" + uuid.uuid4().hex
+    ct = mimetypes.guess_type(path)[0] or "image/png"
+    body = (f"--{boundary}\r\nContent-Disposition: form-data; name=\"image\"; filename=\"{name}\"\r\n"
+            f"Content-Type: {ct}\r\n\r\n").encode() + data + \
+           (f"\r\n--{boundary}\r\nContent-Disposition: form-data; name=\"overwrite\"\r\n\r\ntrue\r\n"
+            f"--{boundary}--\r\n").encode()
+    req = urllib.request.Request(f"{COMFY}/upload/image", body,
+                                 {"Content-Type": f"multipart/form-data; boundary={boundary}"})
+    return json.load(urllib.request.urlopen(req)).get("name", name)
+
+def _build(prompt, seed, lora, strength, w, h, ref_image=None, ref_strength=0.7):
+    api = json.load(open(BASE_API)); api.pop("4823", None)          # distilled-only
+    if prompt.strip():
+        api["2483"]["inputs"]["text"] = prompt
+    api["4832"]["inputs"]["noise_seed"] = int(seed)
+    api["3059"]["inputs"]["width"] = int(w); api["3059"]["inputs"]["height"] = int(h)
+    # reference image (I2V first-frame conditioning): flip bypass off + feed the image
+    if ref_image and "2004" in api and "4977" in api:
+        fname = _upload_image(ref_image)
+        api["2004"]["inputs"]["image"] = fname
+        api["4977"]["inputs"]["value"] = False                      # bypass off -> I2V
+        if "3159" in api:
+            api["3159"]["inputs"]["strength"] = float(ref_strength)
+    if lora and lora != "(none / base)":
+        ckpt = next(n for n, v in api.items() if v["class_type"] == "CheckpointLoaderSimple")
+        guiders = [(n, inp) for n, v in api.items() for inp, val in v["inputs"].items()
+                   if isinstance(val, list) and val[0] == ckpt and val[1] == 0 and "Guider" in v["class_type"]]
+        api["9001"] = {"class_type": "LoraLoaderModelOnly",
+                       "inputs": {"model": [ckpt, 0], "lora_name": lora, "strength_model": float(strength)}}
+        for gid, inp in guiders:
+            api[gid]["inputs"][inp] = ["9001", 0]
+    return api
+
+def _run(api):
+    pid = json.load(urllib.request.urlopen(urllib.request.Request(
+        f"{COMFY}/prompt", json.dumps({"prompt": api}).encode(), {"Content-Type": "application/json"})))["prompt_id"]
+    t0 = time.time()
+    while time.time() - t0 < 420:
+        time.sleep(2)
+        h = json.load(urllib.request.urlopen(f"{COMFY}/history/{pid}"))
+        if pid in h and h[pid].get("status", {}).get("completed"):
+            for _nid, o in h[pid].get("outputs", {}).items():
+                for k in ("videos", "gifs", "images"):
+                    for f in o.get(k, []):
+                        return f"{OUT}/{f.get('subfolder','')}/{f['filename']}".replace("//", "/")
+            return None
+    return None
+
+def _check_base():
+    if not os.path.exists(BASE_API):
+        return "⚠️ No base T2V graph yet — run one LTX-2.3 T2V in ComfyUI once (seeds base_api.json), then retry."
+    return None
+
+def generate(prompt, lora, strength, seed, w, h, ref_image, ref_strength):
+    err = _check_base()
+    if err: return None, err
+    try:
+        v = _run(_build(prompt, seed, lora, strength, w, h, ref_image, ref_strength))
+        mode = "I2V" if ref_image else "T2V"
+        return v, (f"✅ {mode} · {lora} @ str {strength}, seed {seed}" if v else "❌ no output (check ComfyUI log)")
+    except Exception as e:
+        return None, f"❌ {e}"
+
+def compare(prompt, lora, strength, seed, w, h, ref_image, ref_strength):
+    err = _check_base()
+    if err: return None, None, err
+    if not lora or lora == "(none / base)":
+        return None, None, "pick a LoRA to compare against base"
+    try:
+        base = _run(_build(prompt, seed, "(none / base)", 0, w, h, ref_image, ref_strength))
+        withl = _run(_build(prompt, seed, lora, strength, w, h, ref_image, ref_strength))
+        mode = "I2V" if ref_image else "T2V"
+        return base, withl, f"✅ {mode}, same seed {seed}: base vs {lora}@{strength}"
+    except Exception as e:
+        return None, None, f"❌ {e}"
+
+# ------------------------------- UI -------------------------------
+with gr.Blocks(title="LTX-2.3 Video LoRA Studio") as demo:
+    gr.Markdown("# 🎬 LTX-2.3 Video LoRA Studio\nTrain a LoRA from clips, then generate + A/B it on the **NVFP4 22B** base.")
+    with gr.Tab("Train"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                mode = gr.Radio(["Upload clips", "Folder on box"], value="Upload clips", label="Clip source")
+                uploads = gr.File(file_count="multiple", label="Clips", file_types=[".mp4", ".mov", ".webm", ".mkv"])
+                folder = gr.Textbox(label="…or a folder path on the box", visible=False, placeholder="/mnt/data/my-clips")
+                style = gr.Textbox(label="Style / LoRA name", placeholder="e.g. neon_noir")
+                with gr.Row():
+                    rank = gr.Slider(8, 128, value=32, step=8, label="LoRA rank")
+                    steps = gr.Number(value=1000, label="Steps", precision=0)
+                bucket = gr.Dropdown(BUCKETS, value="768x512x49", label="Resolution bucket (W×H×Frames)")
+                with gr.Row():
+                    with_audio = gr.Checkbox(False, label="Train audio branch")
+                    auto_caption = gr.Checkbox(True, label="Auto-caption")
+                    gpu = gr.Number(value=1, label="GPU", precision=0)
+                with gr.Row():
+                    btn = gr.Button("Train LoRA", variant="primary"); stopb = gr.Button("Stop")
+            with gr.Column(scale=2):
+                tout = gr.Textbox(label="Pipeline log", lines=30, max_lines=30, autoscroll=True)
+        mode.change(lambda m: (gr.update(visible=m == "Upload clips"), gr.update(visible=m == "Folder on box")),
+                    mode, [uploads, folder])
+        btn.click(train, [mode, uploads, folder, style, rank, steps, bucket, with_audio, auto_caption, gpu], tout)
+        stopb.click(stop, None, tout)
+
+    with gr.Tab("Generate & Compare"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                g_prompt = gr.Textbox(label="Prompt", lines=4,
+                                      value="cinematic, a lone figure walks down a rain-slicked neon street at night")
+                with gr.Row():
+                    g_lora = gr.Dropdown(list_loras(), value="(none / base)", label="LoRA")
+                    g_refresh = gr.Button("↻", scale=0)
+                with gr.Row():
+                    g_strength = gr.Slider(0.0, 2.0, value=1.0, step=0.05, label="LoRA strength")
+                    g_seed = gr.Number(value=42, label="Seed", precision=0)
+                with gr.Row():
+                    g_w = gr.Number(value=768, label="Width", precision=0)
+                    g_h = gr.Number(value=448, label="Height", precision=0)
+                g_ref = gr.Image(type="filepath", label="Reference image (first frame — optional → I2V)", height=180)
+                g_refstr = gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="First-frame strength (I2V anchor)")
+                with gr.Row():
+                    g_gen = gr.Button("Generate", variant="primary")
+                    g_cmp = gr.Button("Compare vs base")
+                g_status = gr.Markdown()
+            with gr.Column(scale=2):
+                g_video = gr.Video(label="Output", autoplay=True)
+                with gr.Row():
+                    g_base = gr.Video(label="Base (no LoRA)", autoplay=True)
+                    g_with = gr.Video(label="With LoRA", autoplay=True)
+        g_refresh.click(lambda: gr.update(choices=list_loras()), None, g_lora)
+        g_gen.click(generate, [g_prompt, g_lora, g_strength, g_seed, g_w, g_h, g_ref, g_refstr], [g_video, g_status])
+        g_cmp.click(compare, [g_prompt, g_lora, g_strength, g_seed, g_w, g_h, g_ref, g_refstr], [g_base, g_with, g_status])
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7862, show_error=True)
diff --git a/experiments/ltx2-lora/make_video_lora.py b/experiments/ltx2-lora/make_video_lora.py
new file mode 100644
index 0000000..2f6de20
--- /dev/null
+++ b/experiments/ltx2-lora/make_video_lora.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""One-command LTX-2.3-22B video LoRA orchestrator: clips folder -> usable LoRA on the fp4 base.
+
+Stages (each skipped if its output already exists — resumable):
+  1. caption   clips -> dataset.json   (caption_videos.py / qwen_omni; auto speech+scene)
+  2. preprocess dataset -> latents + conditions (process_dataset.py: 22B audio/vae + Gemma)
+  3. fix       relocate text embeds into conditions/ mirroring latents/  (the known gotcha)
+  4. config    emit training YAML from toy_smoke.yaml, overriding paths/rank/steps
+  5. train     train.py -> LoRA .safetensors
+  6. wire      symlink LoRA into ComfyUI loras/ + emit a T2V workflow with LoraLoaderModelOnly
+
+Run with the LTX-2 trainer venv:
+  ~/dev/LTX-2/.venv/bin/python make_video_lora.py <clips_dir> <style_name> \
+      [--rank 32] [--steps 1000] [--bucket 768x512x49] [--with-audio] [--gpu 1] \
+      [--no-caption] [--no-wire]
+
+If <clips_dir>/dataset.json exists (or --no-caption), captioning is skipped and that file is used.
+"""
+import argparse, json, os, subprocess, sys, shutil, glob
+from pathlib import Path
+
+TRAINER = Path.home() / "dev/LTX-2/packages/ltx-trainer"
+PY = str(Path.home() / "dev/LTX-2/.venv/bin/python")
+MODEL = "/mnt/data/models-cold/LTX-2.3/ltx-2.3-22b-distilled-1.1.safetensors"
+GEMMA = "/mnt/models/gemma-3-12b"
+COMFY = Path.home() / "dev/ComfyUI"
+TEMPLATE = Path(__file__).parent / "toy_smoke.yaml"
+BASE_API = "/mnt/data/ltx-out/base_api.json"   # ComfyUI's own serialized fp4 T2V graph
+
+
+def sh(cmd, env=None, cwd=None):
+    print(f"\n$ {' '.join(str(c) for c in cmd)}\n", flush=True)
+    subprocess.run([str(c) for c in cmd], check=True, env=env, cwd=cwd)
+
+
+def stage_caption(clips_dir, ds_json, do_caption):
+    if ds_json.exists():
+        print(f"[caption] using existing {ds_json}"); return
+    if not do_caption:
+        sys.exit(f"[caption] no {ds_json} and --no-caption set — provide a dataset.json "
+                 '(list of {"video_path","caption"}) or drop --no-caption.')
+    sh([PY, TRAINER / "scripts/caption_videos.py", clips_dir, "--output", ds_json], cwd=TRAINER)
+
+
+def stage_preprocess(ds_json, pre, bucket, with_audio, gpu):
+    if (pre / "latents").exists() and any((pre / "latents").rglob("*.pt")):
+        print(f"[preprocess] latents exist in {pre}, skipping"); return
+    env = {**os.environ, "CUDA_VISIBLE_DEVICES": str(gpu)}
+    cmd = [PY, TRAINER / "scripts/process_dataset.py", ds_json,
+           "--resolution-buckets", bucket, "--model-path", MODEL,
+           "--text-encoder-path", GEMMA, "--video-column", "video_path", "--output-dir", pre]
+    if with_audio:
+        cmd.append("--with-audio")
+    sh(cmd, env=env, cwd=TRAINER)
+
+
+def stage_fix_conditions(clips_dir, pre):
+    """process_dataset writes text embeds next to the source clip as <stem>.pt, NOT into
+    conditions/. Mirror the latents/ tree into conditions/ by matching basename."""
+    cond = pre / "conditions"
+    latents = list((pre / "latents").rglob("*.pt"))
+    made = 0
+    for lat in latents:
+        rel = lat.relative_to(pre / "latents")           # e.g. clips/foo.pt
+        dst = cond / rel
+        if dst.exists():
+            continue
+        # find the embed: <clips_dir>/**/<stem>.pt (saved next to source video)
+        matches = list(Path(clips_dir).rglob(lat.name))
+        embed = next((m for m in matches if m.parent != (pre / "latents" / rel.parent)), None)
+        if embed is None:
+            print(f"[fix] WARN no embed found for {rel} (looked for {lat.name} under {clips_dir})")
+            continue
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(embed, dst); made += 1
+    print(f"[fix] conditions/: {made} embeds relocated, {len(latents)} latents total")
+    n_cond = len(list(cond.rglob('*.pt'))) if cond.exists() else 0
+    if n_cond < len(latents):
+        sys.exit(f"[fix] conditions ({n_cond}) < latents ({len(latents)}) — training will fail to pair. "
+                 "Check that captions produced embeds for every clip.")
+
+
+def stage_config(pre, style, rank, steps, with_audio, out_dir, cfg_path):
+    import yaml
+    cfg = yaml.safe_load(open(TEMPLATE))
+    cfg["model"]["model_path"] = MODEL
+    cfg["model"]["text_encoder_path"] = GEMMA
+    cfg["lora"]["rank"] = rank; cfg["lora"]["alpha"] = rank
+    cfg["training_strategy"]["with_audio"] = with_audio
+    cfg["optimization"]["steps"] = steps
+    cfg["acceleration"]["quantization"] = "int8-quanto"     # fit alongside ComfyUI
+    cfg["data"]["preprocessed_data_root"] = str(pre)
+    cfg["validation"]["interval"] = max(steps // 4, 100)    # watch it learn on real runs
+    cfg["validation"]["skip_initial_validation"] = True
+    cfg["checkpoints"]["interval"] = max(steps // 4, 100)
+    cfg["output_dir"] = str(out_dir)
+    cfg["hub"]["push_to_hub"] = False; cfg["wandb"]["enabled"] = False
+    yaml.safe_dump(cfg, open(cfg_path, "w"), sort_keys=False)
+    print(f"[config] wrote {cfg_path} (rank {rank}, {steps} steps, audio={with_audio})")
+
+
+def stage_train(cfg_path, out_dir, gpu):
+    ckpts = sorted(glob.glob(str(out_dir / "checkpoints" / "lora_weights_step_*.safetensors")))
+    if ckpts:
+        print(f"[train] checkpoint exists ({Path(ckpts[-1]).name}), skipping train"); return ckpts[-1]
+    env = {**os.environ, "CUDA_VISIBLE_DEVICES": str(gpu)}
+    sh([PY, TRAINER / "scripts/train.py", cfg_path, "--disable-progress-bars"], env=env, cwd=TRAINER)
+    ckpts = sorted(glob.glob(str(out_dir / "checkpoints" / "lora_weights_step_*.safetensors")))
+    if not ckpts:
+        sys.exit("[train] no LoRA checkpoint produced")
+    return ckpts[-1]
+
+
+def stage_wire(lora_path, style):
+    loras = COMFY / "models/loras"; loras.mkdir(parents=True, exist_ok=True)
+    link = loras / f"{style}.safetensors"
+    if link.exists() or link.is_symlink():
+        link.unlink()
+    link.symlink_to(lora_path)
+    print(f"[wire] symlinked LoRA -> {link}")
+    # emit a T2V workflow (API format) with LoraLoaderModelOnly on the fp4 base, if base_api exists
+    if not os.path.exists(BASE_API):
+        print(f"[wire] {BASE_API} not found — skip workflow gen (run one fp4 T2V in the UI first to seed it). "
+              f"Manually: add LoraLoaderModelOnly(lora_name={style}.safetensors) between the checkpoint MODEL and the guider.")
+        return
+    api = json.load(open(BASE_API)); api.pop("4823", None)   # distilled-only
+    # find the guider that consumes the checkpoint MODEL (slot 0) on the distilled path
+    ckpt_id = next((n for n, v in api.items() if v["class_type"] == "CheckpointLoaderSimple"), None)
+    guiders = [(n, inp) for n, v in api.items() for inp, val in v["inputs"].items()
+               if isinstance(val, list) and val[0] == ckpt_id and val[1] == 0 and "Guider" in v["class_type"]]
+    api["9001"] = {"class_type": "LoraLoaderModelOnly",
+                   "inputs": {"model": [ckpt_id, 0], "lora_name": f"{style}.safetensors", "strength_model": 1.0}}
+    for gid, inp in guiders:
+        api[gid]["inputs"][inp] = ["9001", 0]
+    out = COMFY / "user/default/workflows" / f"LTX-2.3_T2V_{style}_LoRA.json"
+    json.dump(api, open(out, "w"), indent=1)
+    print(f"[wire] wrote workflow (API) {out} — load via 'Open' or POST to /prompt")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("clips_dir"); ap.add_argument("style")
+    ap.add_argument("--rank", type=int, default=32)
+    ap.add_argument("--steps", type=int, default=1000)
+    ap.add_argument("--bucket", default="768x512x49", help="WxHxFrames (H,W div 32; frames%%8==1)")
+    ap.add_argument("--with-audio", action="store_true")
+    ap.add_argument("--gpu", type=int, default=1)
+    ap.add_argument("--no-caption", action="store_true")
+    ap.add_argument("--no-wire", action="store_true")
+    ap.add_argument("--work", default=None, help="work dir (default /mnt/data/video-lora/<style>)")
+    a = ap.parse_args()
+
+    work = Path(a.work or f"/mnt/data/video-lora/{a.style}")
+    work.mkdir(parents=True, exist_ok=True)
+    ds_json = work / "dataset.json"
+    pre = work / "preprocessed"
+    cfg_path = work / "config.yaml"
+    out_dir = work / "lora-out"
+    print(f"=== make_video_lora: style={a.style} | clips={a.clips_dir} | work={work} ===")
+
+    stage_caption(a.clips_dir, ds_json, not a.no_caption)
+    stage_preprocess(ds_json, pre, a.bucket, a.with_audio, a.gpu)
+    stage_fix_conditions(a.clips_dir, pre)
+    stage_config(pre, a.style, a.rank, a.steps, a.with_audio, out_dir, cfg_path)
+    lora = stage_train(cfg_path, out_dir, a.gpu)
+    print(f"\n✅ LoRA: {lora}")
+    if not a.no_wire:
+        stage_wire(lora, a.style)
+    print(f"\n=== done: '{a.style}' LoRA ready. Load LTX-2.3_T2V_{a.style}_LoRA in ComfyUI (or add "
+          f"LoraLoaderModelOnly {a.style}.safetensors) and generate. ===")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/experiments/ltx2-lora/toy_smoke.yaml b/experiments/ltx2-lora/toy_smoke.yaml
new file mode 100644
index 0000000..a407926
--- /dev/null
+++ b/experiments/ltx2-lora/toy_smoke.yaml
@@ -0,0 +1,88 @@
+model:
+  model_path: /mnt/data/models-cold/LTX-2.3/ltx-2.3-22b-distilled-1.1.safetensors
+  text_encoder_path: /mnt/models/gemma-3-12b
+  training_mode: lora
+  load_checkpoint: null
+lora:
+  rank: 16
+  alpha: 16
+  dropout: 0.0
+  target_modules:
+  - to_k
+  - to_q
+  - to_v
+  - to_out.0
+training_strategy:
+  name: text_to_video
+  first_frame_conditioning_p: 0.5
+  with_audio: false
+  audio_latents_dir: audio_latents
+optimization:
+  learning_rate: 1e-4
+  steps: 50
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  max_grad_norm: 1.0
+  optimizer_type: adamw8bit
+  scheduler_type: linear
+  scheduler_params: {}
+  enable_gradient_checkpointing: true
+acceleration:
+  mixed_precision_mode: bf16
+  quantization: int8-quanto
+  load_text_encoder_in_8bit: false
+data:
+  preprocessed_data_root: /mnt/data/ltx2-lora/preprocessed
+  num_dataloader_workers: 1
+validation:
+  prompts:
+  - A woman with long brown hair sits at a wooden desk in a cozy home office, typing
+    on a laptop while occasionally glancing at notes beside her. Soft natural light
+    streams through a large window, casting warm shadows across the room. She pauses
+    to take a sip from a ceramic mug, then continues working with focused concentration.
+    The audio captures the gentle clicking of keyboard keys, the soft rustle of papers,
+    and ambient room tone with occasional distant bird chirps from outside.
+  - A chef in a white uniform stands in a professional kitchen, carefully plating
+    a gourmet dish with precise movements. Steam rises from freshly cooked vegetables
+    as he arranges them with tweezers. The stainless steel surfaces gleam under bright
+    overhead lights, and various pots simmer on the stove behind him. The audio features
+    the sizzling of pans, the clinking of utensils against plates, and the ambient
+    hum of kitchen ventilation.
+  negative_prompt: worst quality, inconsistent motion, blurry, jittery, distorted
+  images: null
+  video_dims:
+  - 576
+  - 576
+  - 89
+  frame_rate: 25.0
+  seed: 42
+  inference_steps: 30
+  interval: null
+  videos_per_prompt: 1
+  guidance_scale: 4.0
+  stg_scale: 1.0
+  stg_blocks:
+  - 29
+  stg_mode: stg_av
+  generate_audio: true
+  skip_initial_validation: true
+checkpoints:
+  interval: 25
+  keep_last_n: -1
+  precision: bfloat16
+flow_matching:
+  timestep_sampling_mode: shifted_logit_normal
+  timestep_sampling_params: {}
+hub:
+  push_to_hub: false
+  hub_model_id: null
+wandb:
+  enabled: false
+  project: ltx-2-trainer
+  entity: null
+  tags:
+  - ltx2
+  - lora
+  log_validation_videos: true
+seed: 42
+output_dir: /mnt/data/ltx2-lora/outputs/toy-smoke
diff --git a/experiments/ltx2-nvfp4/BLOG.md b/experiments/ltx2-nvfp4/BLOG.md
new file mode 100644
index 0000000..8176dec
--- /dev/null
+++ b/experiments/ltx2-nvfp4/BLOG.md
@@ -0,0 +1,68 @@
+# Quantizing LTX-2.3 22B to NVFP4 on Blackwell (and the cu130 trap everyone hits)
+
+Lightricks ships an fp4 checkpoint for **LTX-2 19B**, but the newer, better **LTX-2.3 22B is bf16 only**. If you
+have a Blackwell card (RTX PRO 6000, RTX 50-series) that means leaving the 4-bit TensorCores idle on your best
+video model. So we quantized it ourselves — and reverse-engineered Lightricks' exact mixed-precision policy in
+the process.
+
+## The result
+
+A 22.9 GB NVFP4 checkpoint (down from 46.1 GB), running the DiT at **1.57× the speed of bf16** and **−38% peak
+VRAM**, with the distilled decode path **visually indistinguishable** from bf16.
+
+| 960×544, 8-step distilled | bf16 | NVFP4 | Δ |
+|---|---|---|---|
+| Disk | 46.1 GB | 22.9 GB | 2.0× |
+| DiT step | 2.85 s/it | 1.82 s/it | 1.57× |
+| Peak VRAM | ~60 GB | ~37 GB | −38% |
+| Cold load + first clip | 39.2 s | 19.0 s | 2.1× |
+
+(Reproduced across 2 runs each. Speedup is on the DiT denoising loop; the bf16 VAE decode is unchanged, so
+whole-pipeline gain is smaller on very short clips.)
+
+## The trap: cu130 or bust
+
+The single biggest source of "NVFP4 is slower than fp8" confusion in the LTX community is the CUDA version.
+NVFP4 only hits the fast path on **torch built with CUDA 13**. On cu128 it silently falls back to a slow path
+and runs **~2× slower than fp8** — ComfyUI even warns you (`You need pytorch with cu130 or higher to use
+optimized CUDA operations`) but it's easy to miss. Same sm120/cu130 story we hit on the vLLM side. One
+force-reinstall fixes it:
+
+```bash
+pip install --force-reinstall --no-cache-dir torch==2.11.0 torchvision torchaudio \
+  --index-url https://download.pytorch.org/whl/cu130
+```
+
+## The method: mirror Lightricks, don't guess
+
+There's no turnkey "quantize an LTX checkpoint" node. But `comfy_kitchen` (shipped with ComfyUI-LTXVideo)
+exposes the exact primitive the official fp4 was built with — `TensorCoreNVFP4Layout.quantize`. The trick is
+matching two things so ComfyUI's loader recognizes the result:
+
+1. **The tensor format.** Each fp4 weight is three tensors: `W` (uint8 packed), `W_scale` (fp8-e4m3 per-block),
+   `W_scale_2` (fp32 per-tensor). Using `comfy_kitchen`'s own serializer guarantees this.
+2. **The `_quantization_metadata` header.** This is the actual load trigger. Without it the loader treats the
+   packed uint8 as a regular weight and dies on a shape mismatch (`[4096,2048]` vs `[4096,4096]`). It's a JSON
+   map of `{module_path: {"format": "nvfp4"}}` in the safetensors header.
+
+And **which** layers to quantize? We diffed the shipped 19B fp4 against its bf16 and recovered the policy: fp4
+the transformer-block Linears, but **keep block 0, the last 5 blocks, all gating projections, and the entire
+VAE/vocoder in bf16**. Classic first/last-layer precision retention — the bf16 blocks absorb the ~9%
+per-tensor error of the 4-bit middle. We applied the identical policy to the 22B.
+
+## The honest caveat: distilled decode only
+
+The 2.3 workflow has two decode branches. On the fp4 model, the **distilled decode is clean**, but the **full
+decode shows mild added artifacting**. Not surprising — the DiT is where the 4-bit lives, and the full VAE
+decoder is more sensitive to it. Default to distilled decode and it's a clean win.
+
+## Reproduce
+
+The converter is ~100 lines, runs in ~40 s on one Blackwell card, and is in
+[`protoLabsAI/lab`](https://github.com/protoLabsAI) under `experiments/ltx2-nvfp4/`. The checkpoint is on
+[HuggingFace](https://huggingface.co/protoLabsAI).
+
+---
+
+*Part of the protoLabs quant + serving lab — parity-verified low-bit models and the Blackwell serving findings
+that make them run. LTX-2.3 · NVFP4 · sm120 · cu130.*
diff --git a/experiments/ltx2-nvfp4/LICENSE b/experiments/ltx2-nvfp4/LICENSE
new file mode 100644
index 0000000..82c330b
--- /dev/null
+++ b/experiments/ltx2-nvfp4/LICENSE
@@ -0,0 +1,349 @@
+                         LTX-2 Community License Agreement
+                           License date: January 5, 2026
+
+
+By using or distributing any portion or element of LTX-2, you agree
+to be bound by this Agreement.
+
+   1. Definitions.
+
+      "Agreement" means the terms and conditions for the license, use,
+      reproduction, and distribution of LTX-2 and the Complementary
+      Materials, as specified in this document.
+
+      "Control" means the direct or indirect ownership of fifty percent
+      (50%) or more of the voting securities or other ownership
+      interests, or the power to direct the management and policies of
+      such Entity through voting rights, contract, or otherwise.
+
+      "Data" means a collection of information and/or content extracted
+      from the dataset used with LTX-2, including to train, pretrain,
+      or otherwise evaluate LTX-2. The Data is not licensed under this
+      Agreement.
+
+      "Derivatives of LTX-2" means all modifications to LTX-2, works
+      based on LTX-2, or any other model which is created or initialized
+      by transfer of patterns of the weights, parameters, activations or
+      output of LTX-2, to the other model, in order to cause the other
+      model to perform similarly to LTX-2, including – but not limited
+      to - distillation methods entailing the use of intermediate data
+      representations or methods based on the generation of synthetic
+      data by LTX-2 for training the other model. For clarity, Derivatives
+      of LTX-2 include: (i) any fine-tuned or adapted weights, parameters,
+      or checkpoints derived from LTX-2; (ii) derivative model architectures
+      that incorporate or are based upon LTX-2's architecture; and
+      (iii) any modified or extended versions of the Complementary
+      Materials. All intellectual property rights in Derivatives of LTX-2
+      shall be subject to the terms of this Agreement, and you may not
+      claim exclusive ownership rights in any Derivatives of LTX-2 that
+      would restrict the rights granted herein.
+      "Entity" means any individual, corporation, partnership, limited
+      liability company, or other legal entity. For purposes of this
+      Agreement, an Entity shall be deemed to include, on an aggregative
+      basis, all subsidiaries, affiliates, and other companies under
+      common Control with such Entity. When determining whether an Entity
+      meets any threshold under this Agreement (including revenue
+      thresholds), all subsidiaries, affiliates, and companies under
+      common Control shall be considered collectively.
+      "Harm" includes but is not limited to physical, mental,
+      psychological, financial and reputational damage, pain, or loss.
+      "Licensor" or "Lightricks" means the owner that is granting the
+      license under this Agreement. For the purposes of this Agreement,
+      the Licensor is Lightricks Ltd.
+      "LTX-2" means the large language models, text/image/video/audio/3D
+      generation models, and multimodal large language models and their
+      software and algorithms, including trained model weights, parameters
+      (including optimizer states), machine-learning model code,
+      inference-enabling code, training-enabling code, fine-tuning
+      enabling code, accompanying source code, scripts, documentation,
+      tutorials, examples, and all other elements of the foregoing
+      distributed and made publicly available by Lightricks (including,
+      for example, at https://github.com/Lightricks/LTX-2) for the LTX-2
+      model released on January 5, 2026. This license is applicable to
+      all LTX-2 versions released since January 5, 2026, and all future
+      releases of LTX-2 under this license.
+      "Output" means the results of operating LTX-2 as embodied in
+      informational content resulting therefrom.
+      "you" (or "your") means an individual or legal Entity licensing
+      LTX-2 in accordance with this Agreement and/or making use of LTX-2
+      for whichever purpose and in any field of use, including usage of
+      LTX-2 in an end-use application - e.g. chatbot, translator, image
+      generator.
+   2. Grant of License. Subject to the terms and conditions of this
+      Agreement, you are granted a non-exclusive, worldwide,
+      non-transferable and royalty-free limited license under Licensor's
+      intellectual property or other rights owned by Licensor embodied
+      in LTX-2 to use, reproduce, prepare, distribute, publicly display,
+      publicly perform, sublicense, copy, create derivative works of,
+      and make modifications to LTX-2, for any purpose, subject to the
+      restrictions set forth in Attachment A; provided however, that
+      Entities with annual revenues of at least $10,000,000 (the
+      "Commercial Entities") are required to obtain a paid commercial
+      use license in order to use LTX-2 and Derivatives of LTX-2,
+      subject to the terms and provisions of a different license (the
+      "Commercial Use Agreement"), as will be provided by the Licensor.
+      Commercial Entities interested in such a commercial license are
+      required to contact Licensor. Any commercial use of LTX-2 or
+      Derivatives of LTX-2 by the Commercial Entities not in accordance
+      with this Agreement and/or the Commercial Use Agreement is strictly
+      prohibited and shall be deemed a material breach of this Agreement.
+      Such material breach will be subject, in addition to any license
+      fees owed to Licensor for the period such Commercial Entity used
+      LTX-2 (as will be determined by Licensor), to liquidated damages,
+      which will be paid to Licensor immediately upon demand, in an
+      amount equal to double the amount that would otherwise have been
+      paid by you for the relevant period of time. Such amount reflects
+      a reasonable estimation of the losses and administrative costs
+      incurred due to such breach. You agree and understand that this
+      remedy does not limit the Licensor's right to pursue other remedies
+      available at law or equity.
+   3. Distribution and Redistribution. You may host for third parties
+      remote access purposes (e.g. software-as-a-service), reproduce
+      and distribute copies of LTX-2 or Derivatives of LTX-2 thereof in
+      any medium, with or without modifications, provided that you meet
+      the following conditions:
+      (a) Use-based restrictions as referenced in paragraph 4 and all
+          provisions of Attachment A MUST be included as an enforceable
+          provision by you in any type of legal agreement (e.g. a
+          license) governing the use and/or distribution of LTX-2 or
+          Derivatives of LTX-2, and you shall give notice to subsequent
+          users you distribute to, that LTX-2 or Derivatives of LTX-2
+          are subject to paragraph 4 and Attachment A in their entirety,
+          including all use restrictions and acceptable use policies;
+      (b) You must provide any third party recipients of LTX-2 or
+          Derivatives of LTX-2 a copy of this Agreement, including all
+          attachments and use policies. Any Derivative of LTX-2 (as
+          defined in Section 1, including but not limited to fine-tuned
+          weights, modified training code, models trained on Outputs, or
+          any other derivative) must be distributed exclusively under
+          the terms of this Agreement with a complete copy of this
+          license included;
+      (c) You must cause any modified files to carry prominent notices
+          stating that you changed the files;
+      (d) You must retain all copyright, patent, trademark, and
+          attribution notices excluding those notices that do not
+          pertain to any part of LTX-2, Derivatives of LTX-2.
+      You may add your own copyright statement to your modifications and
+      may provide additional or different license terms and conditions -
+      respecting paragraph 3(a) - for use, reproduction, or distribution
+      of your modifications, or for any such Derivatives of LTX-2 as a
+      whole, provided your use, reproduction, and distribution of LTX-2
+      otherwise complies with the conditions stated in this Agreement,
+      and you provide a complete copy of this Agreement with any such
+      use, reproduction and distribution of LTX-2 and any Derivatives
+      thereof.
+   4. Use-based restrictions. The restrictions set forth in Attachment A
+      are considered Use-based restrictions. Therefore, you cannot use
+      LTX-2 and the Derivatives of LTX-2 in violation of the specified
+      restricted uses. You may use LTX-2 subject to this Agreement,
+      including only for lawful purposes and in accordance with the
+      Agreement. "Use" may include creating any content with, fine-tuning,
+      updating, running, training, evaluating and/or re-parametrizing
+      LTX-2. You shall require all of your users who use LTX-2 or a
+      Derivative of LTX-2 to comply with the terms of this paragraph 4.
+   5. The Output You Generate. Except as set forth herein, Licensor
+      claims no rights in the Output you generate using LTX-2. You are
+      accountable for input you insert into LTX-2, the Output you
+      generate and its subsequent uses. No use of the Output can
+      contravene any provision as stated in the Agreement.
+   6. Updates and Runtime Restrictions. To the maximum extent permitted
+      by law, Licensor reserves the right to restrict (remotely or
+      otherwise) usage of LTX-2 in violation of this Agreement, update
+      LTX-2 through electronic means, or modify the Output of LTX-2
+      based on updates. You shall undertake reasonable efforts to use
+      the latest version of LTX-2. Any use of the non-current version
+      of LTX-2 is done solely at your risk.
+   7. Export Controls and Sanctions Compliance. You acknowledge that
+      LTX-2, Derivatives of LTX-2 may be subject to export control laws
+      and regulations, including but not limited to the U.S. Export
+      Administration Regulations and sanctions programs administered by
+      the Office of Foreign Assets Control (OFAC). You represent and
+      warrant that you and any users of LTX-2 are not (i) located in,
+      organized under the laws of, or ordinarily resident in any country
+      or territory subject to comprehensive sanctions; (ii) identified
+      on any U.S. government restricted party list, including the
+      Specially Designated Nationals and Blocked Persons List; or
+      (iii) otherwise prohibited from receiving LTX-2 under applicable
+      law. You shall not export, re-export, or transfer LTX-2, directly
+      or indirectly, in violation of any applicable export control or
+      sanctions laws or regulations. You agree to comply with all
+      applicable trade control laws and shall indemnify and hold
+      Licensor harmless from any claims arising from your failure to
+      comply with such laws.
+   8. Trademarks and related. Nothing in this Agreement permits you to
+      make use of Licensor's trademarks, trade names, logos or to
+      otherwise suggest endorsement or misrepresent the relationship
+      between the parties; and any rights not expressly granted herein
+      are reserved by the Licensor.
+
+   9. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides LTX-2 on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or
+      conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS
+      FOR A PARTICULAR PURPOSE. You are solely responsible for
+      determining the appropriateness of using or redistributing LTX-2
+      and Derivatives of LTX-2 and assume any risks associated with
+      your exercise of permissions under this Agreement.
+
+   10. Limitation of Liability. In no event and under no legal theory,
+       whether in tort (including negligence), contract, or otherwise,
+       unless required by applicable law (such as deliberate and grossly
+       negligent acts) or agreed to in writing, shall Licensor be liable
+       to you for damages, including any direct, indirect, special,
+       incidental, or consequential damages of any character arising as
+       a result of this Agreement or out of the use or inability to use
+       LTX-2 (including but not limited to damages for loss of goodwill,
+       work stoppage, computer failure or malfunction, or any and all
+       other commercial damages or losses), even if Licensor has been
+       advised of the possibility of such damages.
+
+   11. Accepting Warranty or Additional Liability. While redistributing
+       LTX-2 and Derivatives of LTX-2, you may, provided you do not
+       violate the terms of this Agreement, choose to offer and charge
+       a fee for, acceptance of support, warranty, indemnity, or other
+       liability obligations. However, in accepting such obligations,
+       you may act only on your own behalf and on your sole
+       responsibility, not on behalf of Licensor, and only if you agree
+       to indemnify, defend, and hold Licensor harmless for any liability
+       incurred by, or claims asserted against Licensor, by reason of
+       your accepting any such warranty or additional liability.
+
+   12. Governing Law. This Agreement and all relations, disputes, claims
+       and other matters arising hereunder (including non-contractual
+       disputes or claims) will be governed exclusively by, and construed
+       exclusively in accordance with, the laws of the State of New York.
+       To the extent permitted by law, choice of laws rules and the
+       United Nations Convention on Contracts for the International Sale
+       of Goods will not apply. For the purposes of adjudicating any
+       action or proceeding to enforce the terms of this Agreement, you
+       hereby irrevocably consent to the exclusive jurisdiction of, and
+       venue in, the federal and state courts located in the County of
+       New York within the State of New York. The prevailing party in
+       any claim or dispute between the parties under this Agreement
+       will be entitled to reimbursement of its reasonable attorneys'
+       fees and costs. You hereby waive the right to a trial by jury,
+       to participate in a class or representative action (including in
+       arbitration), or to combine individual proceedings in court or
+       in arbitration without the consent of all parties.
+   13. Term and Termination. This Agreement is effective upon your
+       acceptance and continues until terminated. Licensor may terminate
+       this Agreement immediately upon written notice to you if you
+       breach any provision of this Agreement, including but not limited
+       to violations of the use restrictions in Attachment A or
+       unauthorized commercial use. Upon termination: (a) all rights
+       granted to you under this Agreement will immediately cease;
+       (b) you must immediately cease all use of LTX-2 and Derivatives
+       of LTX-2; (c) you must delete or destroy all copies of LTX-2
+       and Derivatives of LTX-2 in your possession or control; and
+       (d) you must notify any third parties to whom you distributed
+       LTX-2 or Derivatives of LTX-2 of the termination. Sections 8-13,
+       and Section 15 shall survive termination of this Agreement.
+       Termination does not relieve you of any obligations incurred
+       prior to termination, including payment obligations under
+       Section 2. In addition, if You commence a lawsuit or other
+       proceedings (including a cross-claim or counterclaim in a lawsuit)
+       against Licensor or any person or entity alleging that LTX-2 or
+       any Output, or any portion of any of the foregoing, infringe any
+       intellectual property or other right owned or licensable by you,
+       then all licenses granted to you under this Agreement shall
+       terminate as of the date such lawsuit or other proceeding is filed.
+   14. Disputes and Arbitration. All disputes arising in connection with
+       this Agreement shall be finally settled by arbitration under the
+       Rules of Arbitration of the International Chamber of Commerce
+       ("ICC Rules"), by one (1) arbitrator appointed in accordance with
+       the ICC Rules. The seat of arbitration shall be New York, NY, USA,
+       and the proceedings shall be conducted in English. The arbitrator
+       shall be empowered to grant any relief that a court could grant.
+       Judgment on the arbitration award may be entered by any court
+       having jurisdiction thereof. Each party waives its right to a
+       trial by jury and to participate in any class or representative
+       action.
+   15. If any provision of this Agreement is held to be
+       invalid, illegal
+       or unenforceable, the remaining provisions shall be unaffected
+       thereby and remain valid as if such provision had not been set
+       forth herein.
+   END OF TERMS AND CONDITIONS
+   ATTACHMENT A: Use Restrictions
+      When using the Outputs, LTX-2 and any Derivatives thereof, you
+      will comply with the Acceptable Use Policy. In addition, you
+      agree not to use the Outputs, LTX-2 or its Derivatives in any
+      of the following ways:
+      1. In any way that violates any applicable national, federal,
+         state, local or international law or regulation;
+      2. For the purpose of exploiting, Harming or attempting to
+         exploit or Harm minors in any way;
+      3. To generate or disseminate false information and/or content
+         with the purpose of Harming others;
+      4. To generate or disseminate personal identifiable information
+         that can be used to Harm an individual;
+      5. To generate or disseminate information and/or content (e.g.
+         images, code, posts, articles), and place the information
+         and/or content in any context (e.g. bot generating tweets)
+         without expressly and intelligibly disclaiming that the
+         information and/or content is machine generated;
+      6. To defame, disparage or otherwise harass others;
+      7. To impersonate or attempt to impersonate (e.g. deepfakes)
+         others without their consent;
+      8. For fully automated decision making that adversely impacts an
+         individual's legal rights or otherwise creates or modifies a
+         binding, enforceable obligation;
+
+      9. For any use intended to or which has the effect of
+         discriminating against or Harming individuals or groups based
+         on online or offline social behavior or known or predicted
+         personal or personality characteristics;
+
+      10. To exploit any of the vulnerabilities of a specific group of
+          persons based on their age, social, physical or mental
+          characteristics, in order to materially distort the behavior
+          of a person pertaining to that group in a manner that causes
+          or is likely to cause that person or another person physical
+          or psychological Harm;
+
+      11. For any use intended to or which has the effect of
+          discriminating against individuals or groups based on legally
+          protected characteristics or categories;
+
+      12. To provide medical advice and medical results interpretation;
+
+      13. To generate or disseminate information for the purpose to be
+          used for administration of justice, law enforcement,
+          immigration or asylum processes, such as predicting an
+          individual will commit fraud/crime commitment (e.g. by text
+          profiling, drawing causal relationships between assertions
+          made in documents, indiscriminate and arbitrarily-targeted use);
+
+      14. To generate and/or disseminate malware (including – but not
+          limited to – ransomware) or any other content to be used for
+          the purpose of harming electronic systems;
+
+      15. To engage in, promote, incite, or facilitate discrimination
+          or other unlawful or harmful conduct in the provision of
+          employment, employment benefits, credit, housing, or other
+          essential goods and services;
+
+      16. To engage in, promote, incite, or facilitate the harassment,
+          abuse, threatening, or bullying of individuals or groups of
+          individuals;
+
+      17. For military, warfare, nuclear industries or applications,
+          weapons development, or any use in connection with activities
+          that may cause death, personal injury, or severe physical or
+          environmental damage;
+
+      18. For commercial use only: To train, improve, or fine-tune any
+          other machine learning model, artificial intelligence system,
+          or competing model, except for Derivatives of LTX-2 as
+          expressly permitted under this Agreement;
+
+      19. To circumvent, disable, or interfere with any technical
+          limitations, safety features, content filters, or use
+          restrictions implemented in LTX-2 by Licensor;
+
+      20. To use LTX-2 or Derivatives of LTX-2 in any product, service,
+          or application that directly competes with Licensor's
+          commercial products or services, or is designed to replace or
+          substitute Licensor's offerings in the market, without
+          obtaining a separate commercial license from Licensor.
\ No newline at end of file
diff --git a/experiments/ltx2-nvfp4/README.md b/experiments/ltx2-nvfp4/README.md
new file mode 100644
index 0000000..cc155fd
--- /dev/null
+++ b/experiments/ltx2-nvfp4/README.md
@@ -0,0 +1,117 @@
+---
+license: other
+license_name: ltx-2-community-license
+license_link: LICENSE
+base_model: Lightricks/LTX-2.3
+tags:
+  - text-to-video
+  - image-to-video
+  - video-generation
+  - nvfp4
+  - fp4
+  - quantization
+  - blackwell
+  - comfyui
+  - ltx-video
+library_name: comfyui
+pipeline_tag: text-to-video
+---
+
+# LTX-2.3-22B-distilled — NVFP4 (mixed precision)
+
+A **native NVFP4** (4-bit) quantization of [`Lightricks/LTX-2.3`](https://huggingface.co/Lightricks/LTX-2.3)
+`22b-distilled-1.1`, for **NVIDIA Blackwell** (RTX PRO 6000 / RTX 50-series, sm120) via ComfyUI.
+
+Lightricks ships an fp4 checkpoint for **LTX-2 19B** but the newer **LTX-2.3 22B is bf16-only**. This fills
+that gap: the 22B distilled model at ~half the disk and VRAM, running on Blackwell's native FP4 TensorCores.
+
+## Results (measured, honest)
+
+Single-clip, `960×544`, 8-step distilled sampler, distilled decode, RTX PRO 6000 (96 GB), vLLM-adjacent
+ComfyUI stack on **torch cu130**. Speed/VRAM reproduced across 2 runs each; quality eyeballed across 4 prompts.
+
+| Metric | bf16 (upstream) | **NVFP4 (this)** | Δ |
+|---|---|---|---|
+| Disk size | 46.1 GB | **22.9 GB** | **2.0× smaller** |
+| DiT step speed | 2.85 s/it | **1.82 s/it** | **1.57× faster** |
+| Peak runtime VRAM | ~60 GB | **~37 GB** | **−38%** |
+| Cold load + first clip | 39.2 s | **19.0 s** | **2.1× faster** |
+| Distilled-decode quality | baseline | **visually unchanged** | — |
+
+Higher resolution holds the win (fp4 `1280×704` ≈ 3.85 s/it, scaling with token count as expected).
+
+## ⚠️ You need torch built with CUDA 13 (cu130)
+
+This is the single most important thing. NVFP4 only hits the fast TensorCore path on **cu130**. On **cu128,
+fp4 silently falls back and runs ~2× *slower* than fp8** (ComfyUI logs `WARNING: You need pytorch with cu130 or
+higher to use optimized CUDA operations`). This is the field's #1 LTX-fp4 confusion. If your fp4 is slower than
+fp8, this is why.
+
+```bash
+pip install --force-reinstall --no-cache-dir torch==2.11.0 torchvision torchaudio \
+  --index-url https://download.pytorch.org/whl/cu130
+```
+
+## ⚠️ Use the distilled decode path
+
+The LTX-2.3 single-stage workflow ships **two decode branches** (a fast "distilled" decode and a "full"
+decode). On this quant, the **distilled decode is visually indistinguishable from bf16**, while the **full
+decode shows mild added artifacting**. Default to the distilled decode. (The DiT is where the fp4 lives; the
+VAE decoders are untouched bf16 — the full decoder is just more sensitive to the small DiT-linear error.)
+
+## Usage (ComfyUI)
+
+1. cu130 torch (above) + [`ComfyUI-LTXVideo`](https://github.com/Lightricks/ComfyUI-LTXVideo)
+   (provides the `comfy_kitchen` NVFP4 kernels: `scaled_mm_nvfp4`, `quantize_nvfp4`).
+2. Drop `ltx-2.3-22b-distilled-1.1-fp4.safetensors` into `ComfyUI/models/checkpoints/`.
+3. Load the `2.3/LTX-2.3_T2V_I2V_Single_Stage_Distilled_Full` example workflow, point the
+   `CheckpointLoaderSimple` at this file, keep the **distilled** decode/save branch.
+4. Text encoder: any Gemma-3-12B LTX encoder (`gemma_3_12B_it_fp8_scaled.safetensors` works well).
+
+The checkpoint carries a standard `_quantization_metadata` header, so ComfyUI's LTX loader auto-detects the
+NVFP4 layers — no flags, no config edits.
+
+## What's quantized (mixed precision)
+
+Replicates Lightricks' own 19B-fp4 layer policy exactly (reverse-engineered from their shipped checkpoint):
+
+- **NVFP4 (4-bit):** the 2-D Linear weights in `transformer_blocks` **1–42** (attention q/k/v/out + feed-forward,
+  video + audio + cross-modal). 1,176 weights.
+- **Kept bf16 (precision-sensitive):** transformer block **0** and the **last 5 blocks (43–47)**, all
+  `to_gate_logits` gates, the patchify / proj_out / adaln / caption + embeddings connectors, and the entire
+  VAE / audio-VAE / vocoder.
+
+Each fp4 weight is stored as `W` (uint8 packed) + `W_scale` (fp8-e4m3 per-block) + `W_scale_2` (fp32
+per-tensor) — byte-identical to the shipped 19B fp4 format.
+
+## Reproduce it
+
+The full converter is `quantize.py` (in this repo / `protoLabsAI/lab`). It streams the bf16 checkpoint
+tensor-by-tensor through `comfy_kitchen`'s own `TensorCoreNVFP4Layout.quantize`, so the output format is
+guaranteed loader-compatible. ~40 s on one Blackwell card.
+
+```bash
+CUDA_VISIBLE_DEVICES=0 python quantize.py \
+  --in  ltx-2.3-22b-distilled-1.1.safetensors \
+  --out ltx-2.3-22b-distilled-1.1-fp4.safetensors
+```
+
+## Limitations & honest notes
+
+- Numbers are **single-clip** on one specific Blackwell + cu130 ComfyUI config; your mileage varies with
+  resolution, length, sampler, and card.
+- Speedup is on the **DiT denoising** loop. End-to-end wall-clock also includes VAE decode (bf16, unchanged)
+  and text encoding, so the *whole-pipeline* ratio is smaller than 1.57× at short clip lengths.
+- **Full-decode** path: mild artifacting (see above). Distilled decode only.
+- FP4 is 4-bit — expect a small per-tensor error (~9% relative L1 on a quantized layer), which the first/last
+  bf16 blocks are there to absorb. If you see quality loss, widen the bf16-kept block set and re-quantize.
+
+## Attribution & license
+
+Derivative of [`Lightricks/LTX-2.3`](https://huggingface.co/Lightricks/LTX-2.3), released under the **LTX-2
+Community License** (see `LICENSE`). This quant is redistributed under the same license, including its
+Acceptable Use Policy (Attachment A) and paragraph 4 use restrictions, which pass through to you. High-revenue
+commercial entities require a separate Commercial Use Agreement from Lightricks for *use* — see the license.
+
+Quantized by [protoLabsAI](https://huggingface.co/protoLabsAI). Method + measurements:
+`protoLabsAI/lab` → `experiments/ltx2-nvfp4/`.
diff --git a/experiments/ltx2-nvfp4/measurements-multires.json b/experiments/ltx2-nvfp4/measurements-multires.json
new file mode 100644
index 0000000..e4bbafd
--- /dev/null
+++ b/experiments/ltx2-nvfp4/measurements-multires.json
@@ -0,0 +1,58 @@
+[
+ {
+  "label": "fp4_768x512",
+  "wall_s": 13.5,
+  "peak_vram_mb": 41069,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00003_.mp4"
+ },
+ {
+  "label": "fp4_1280x704",
+  "wall_s": 34.5,
+  "peak_vram_mb": 43757,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00004_.mp4"
+ },
+ {
+  "label": "bf16_768x512",
+  "wall_s": 33.2,
+  "peak_vram_mb": 63341,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00005_.mp4"
+ },
+ {
+  "label": "bf16_1280x704",
+  "wall_s": 48.3,
+  "peak_vram_mb": 65869,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00006_.mp4"
+ },
+ {
+  "label": "fp4_dog",
+  "wall_s": 48.0,
+  "peak_vram_mb": 59597,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00007_.mp4"
+ },
+ {
+  "label": "fp4_tokyo",
+  "wall_s": 36.3,
+  "peak_vram_mb": 43661,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00008_.mp4"
+ },
+ {
+  "label": "fp4_bread",
+  "wall_s": 37.5,
+  "peak_vram_mb": 43661,
+  "staged_mb": null,
+  "best_s_per_it": null,
+  "out": "output_D_00009_.mp4"
+ }
+]
\ No newline at end of file
diff --git a/experiments/ltx2-nvfp4/quantize.py b/experiments/ltx2-nvfp4/quantize.py
new file mode 100644
index 0000000..85ed9f6
--- /dev/null
+++ b/experiments/ltx2-nvfp4/quantize.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Quantize an LTX-2.3 bf16 checkpoint to NVFP4 (fp4_mixed), replicating Lightricks'
+exact layer-selection policy reverse-engineered from the shipped 19B fp4 checkpoint.
+
+Policy (matches ltx-2-19b-dev-fp4.safetensors):
+  - Quantize ONLY 2D Linear weights in model.diffusion_model.transformer_blocks
+  - KEEP block 0 and the last 5 blocks (43..47) in bf16   [first/last precision retention]
+  - KEEP all to_gate_logits gates in bf16                 [tiny, gating-sensitive]
+  - KEEP everything else in bf16: patchify/proj_out, adaln, caption/embeddings
+    connectors, VAE, audio_vae, vocoder, and all non-2D tensors.
+
+Each quantized weight K becomes three keys (comfy_kitchen serialization, verified
+identical to the shipped fp4): K (uint8 packed fp4), K_scale (fp8_e4m3 per-block),
+K_scale_2 (fp32 per-tensor). ComfyUI's LTX loader auto-detects fp4 from these sidecars.
+
+Run with ComfyUI's venv (has comfy_kitchen + torch cu130):
+  CUDA_VISIBLE_DEVICES=1 ~/dev/ComfyUI/venv/bin/python ltx23_nvfp4_quantize.py \
+      --in  /mnt/data/models-cold/LTX-2.3/ltx-2.3-22b-distilled-1.1.safetensors \
+      --out /mnt/data/models-cold/LTX-2.3/ltx-2.3-22b-distilled-1.1-fp4.safetensors
+"""
+import argparse, re, time, torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+from comfy_kitchen.tensor.nvfp4 import TensorCoreNVFP4Layout as NVFP4
+
+KEEP_BLOCKS = {0, 43, 44, 45, 46, 47}          # bf16 (matches 19B: block 0 + last 5)
+BLOCK_RE = re.compile(r"model\.diffusion_model\.transformer_blocks\.(\d+)\.")
+
+def is_quant_target(key: str, shape) -> bool:
+    if not key.endswith(".weight"):
+        return False
+    if len(shape) != 2:
+        return False
+    m = BLOCK_RE.match(key)
+    if not m:                                   # only the main transformer_blocks
+        return False
+    if int(m.group(1)) in KEEP_BLOCKS:
+        return False
+    if "to_gate_logits" in key:                 # keep gates high-precision
+        return False
+    return True
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in", dest="src", required=True)
+    ap.add_argument("--out", dest="dst", required=True)
+    ap.add_argument("--limit", type=int, default=0, help="quantize only first N targets (dry test)")
+    args = ap.parse_args()
+
+    assert torch.cuda.is_available(), "need CUDA for ck.quantize_nvfp4"
+    t0 = time.time()
+    out = {}
+    quant_layers = {}                                # module_path -> {"format":"nvfp4"}
+    n_q = n_kept = n_qbytes = 0
+    with safe_open(args.src, framework="pt", device="cpu") as f:
+        src_meta = f.metadata() or {}
+        keys = list(f.keys())
+        targets = [k for k in keys if is_quant_target(k, f.get_slice(k).get_shape())]
+        if args.limit:
+            targets = targets[:args.limit]
+        tset = set(targets)
+        print(f"{len(keys)} tensors total | {len(targets)} → NVFP4 | {len(keys)-len(targets)} → bf16 passthrough")
+        for i, k in enumerate(keys):
+            t = f.get_tensor(k)
+            if k in tset:
+                qdata, params = NVFP4.quantize(t.to("cuda"))
+                sd = NVFP4.state_dict_tensors(qdata, params)  # {"":qdata,"_scale":bs,"_scale_2":s}
+                for suf, qt in sd.items():
+                    out[k + suf] = qt.cpu().contiguous()
+                    n_qbytes += out[k + suf].numel() * out[k + suf].element_size()
+                quant_layers[k[:-len(".weight")]] = {"format": "nvfp4"}   # module path, no .weight
+                n_q += 1
+                if n_q % 200 == 0:
+                    print(f"  [{n_q}/{len(targets)}] quantized … {time.time()-t0:.0f}s", flush=True)
+            else:
+                out[k] = t.contiguous()
+                n_kept += 1
+            del t
+    # Header the ComfyUI LTX loader reads to build NVFP4 layers (the load trigger).
+    import json as _json
+    meta = {k: v for k, v in src_meta.items() if k != "encrypted_wandb_properties"}
+    meta["_quantization_metadata"] = _json.dumps({"format_version": "1.0", "layers": quant_layers})
+    meta["quant_source"] = args.src.split("/")[-1]
+    print(f"quantized {n_q} weights (~{n_qbytes/1e9:.1f} GB fp4), kept {n_kept} bf16 tensors")
+    print(f"_quantization_metadata: {len(quant_layers)} layers tagged nvfp4")
+    print(f"writing {args.dst} …")
+    save_file(out, args.dst, metadata=meta)
+    print(f"DONE in {time.time()-t0:.0f}s")
+
+if __name__ == "__main__":
+    main()
diff --git a/infra/video-bridge/README.md b/infra/video-bridge/README.md
new file mode 100644
index 0000000..8e381d5
--- /dev/null
+++ b/infra/video-bridge/README.md
@@ -0,0 +1,55 @@
+# protoLabs video bridge (stub)
+
+OpenAI `/v1/videos` async-jobs API over ComfyUI + **LTX-2.3-22B NVFP4**, co-located with
+ComfyUI on `protolabs:8188`. This is **piece 2** of [protoBanana#38](https://github.com/protoLabsAI/protoBanana/issues/38) —
+the standalone video bridge the team settled on (litellm's native `/v1/videos` router shadows
+passthrough routes, so the job layer can't live inside the gateway). protoBanana stays
+image-only; this depends on it (reuses `ComfyUIClient`, inherits the #39 cache-nonce fix).
+
+## Contract (AGREED — `protoDirector/GATEWAY_CONTRACT.md`)
+
+```
+POST /v1/videos              {model, prompt, seconds, size, negative_prompt?, seed?, extra_body?}
+                             (+ optional multipart input_reference for first-frame/I2V)
+                             -> 201 {id, object:"video", model, status:"queued", progress, created_at}
+GET  /v1/videos/{id}         -> {id, status: queued|in_progress|completed|failed, progress, error?}
+GET  /v1/videos/{id}/content -> mp4 bytes (video/mp4)
+```
+
+- **Job id survives restarts** — `job_id -> prompt_id` persisted to `JOB_STORE`; status is
+  re-derived from ComfyUI `/history` (also persistent), so a client resumes polling after a
+  bridge crash/redeploy.
+- **Bytes off local disk** — `/content` reads ComfyUI's output dir directly; `/view` fallback.
+- **LTX knobs in `extra_body`** — `fps`, `seed`, `negative_prompt` (model-agnostic surface stays clean).
+
+## Run
+
+```bash
+pip install -r requirements.txt
+uvicorn bridge:app --host 0.0.0.0 --port 8100          # needs ComfyUI up on :8188
+# smoke:
+python smoke.py
+```
+
+Env: `COMFY_URL` (`http://127.0.0.1:8188`), `COMFY_OUTPUT_DIR` (`/mnt/data/ltx-out`),
+`JOB_STORE` (`/mnt/data/ltx-out/video-bridge/jobs.json`), `MODEL_PREFIX` (`protolabs/ltx2`).
+
+## Edge routing (homelab-iac task)
+
+Route `/v1/videos*` → this bridge, everything else → the gateway unchanged. Client contract
+holds exactly as written (same base URL, key, shapes). When `sora-2`/`veo-*` become real, the
+bridge dispatches by `model`: `protolabs/ltx2-*` local, anything else proxied to the gateway's
+native `/v1/videos`.
+
+## What's stubbed / next
+
+- **`seconds` → frames** snaps to LTX's `8n+1` at `fps` (default 30). Verify the mapping matches
+  intended clip length on real requests.
+- **`input_reference` (I2V)** is accepted + uploaded, but the template is **T2V-only**; wiring
+  first-frame conditioning needs the I2V workflow variant (un-bypass the "Load Image" group).
+- **Fine progress** — currently coarse (queued 0 / in_progress null / completed 100). ComfyUI's
+  `/ws` gives per-step progress; wire it for a real 0-100.
+- **Concurrency** — single ComfyUI instance serializes; `n=1` only (per contract v1).
+
+Workflow: `workflows/ltx2-t2v.json` (distilled-decode path, Full fork removed). Injection map
+in `inject.py`.
diff --git a/infra/video-bridge/bridge.py b/infra/video-bridge/bridge.py
new file mode 100644
index 0000000..28b1e44
--- /dev/null
+++ b/infra/video-bridge/bridge.py
@@ -0,0 +1,229 @@
+"""protoLabs video bridge — OpenAI /v1/videos over ComfyUI (LTX-2.3 NVFP4).
+
+Co-located with ComfyUI on protolabs:8188 (issue protoBanana#38, piece 2). Implements
+exactly the three AGREED contract URLs so protoDirector's video runner + any `sora-2`/
+`veo-*` client hit `protolabs/ltx2-*` identically:
+
+    POST /v1/videos              {model, prompt, seconds, size, ...} -> {id, status:"queued"}
+    GET  /v1/videos/{id}         -> {id, status, progress, error?}
+    GET  /v1/videos/{id}/content -> mp4 bytes
+
+Job store is JSON-file-backed (restart-survivable job ids, #38 hard req): the job->prompt_id
+map persists, and status is re-derived from ComfyUI's /history (which also survives a bridge
+restart), so polling resumes cleanly after a crash/redeploy. mp4 bytes are read off ComfyUI's
+output dir on local disk — no multi-hundred-MB clips hauled through an extra hop.
+
+Reuses protoBanana's ComfyUIClient (the #39 cache-nonce fix comes along for free). protoBanana
+itself stays image-only; this is a separate service that depends on it.
+
+Run:  uvicorn bridge:app --host 0.0.0.0 --port 8100
+Env:  COMFY_URL (default http://127.0.0.1:8188), COMFY_OUTPUT_DIR (/mnt/data/ltx-out),
+      JOB_STORE (/mnt/data/ltx-out/video-bridge/jobs.json), MODEL_PREFIX (protolabs/ltx2)
+"""
+from __future__ import annotations
+import os, sys, json, time, uuid, asyncio, pathlib
+from typing import Any, Optional
+from fastapi import FastAPI, HTTPException, UploadFile, File, Request
+from fastapi.responses import JSONResponse, Response
+
+# co-located protoBanana checkout provides the reusable ComfyUI client
+sys.path.insert(0, os.path.expanduser("~/dev/protoBanana"))
+from protobanana.client import ComfyUIClient  # noqa: E402
+
+import inject  # noqa: E402
+
+COMFY_URL = os.environ.get("COMFY_URL", "http://127.0.0.1:8188")
+OUTPUT_DIR = pathlib.Path(os.environ.get("COMFY_OUTPUT_DIR", "/mnt/data/ltx-out"))
+JOB_STORE = pathlib.Path(os.environ.get("JOB_STORE", "/mnt/data/ltx-out/video-bridge/jobs.json"))
+MODEL_PREFIX = os.environ.get("MODEL_PREFIX", "protolabs/ltx2")
+
+app = FastAPI(title="protoLabs video bridge", version="0.1-stub")
+_client: Optional[ComfyUIClient] = None
+_lock = asyncio.Lock()
+
+
+# ---- job store (JSON-file-backed; restart-survivable) --------------------------
+def _load_jobs() -> dict[str, Any]:
+    if JOB_STORE.exists():
+        try:
+            return json.loads(JOB_STORE.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def _save_jobs(jobs: dict[str, Any]) -> None:
+    JOB_STORE.parent.mkdir(parents=True, exist_ok=True)
+    tmp = JOB_STORE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(jobs, indent=1))
+    tmp.replace(JOB_STORE)  # atomic
+
+
+async def _put(job: dict[str, Any]) -> None:
+    async with _lock:
+        jobs = _load_jobs()
+        jobs[job["id"]] = job
+        _save_jobs(jobs)
+
+
+def _get(job_id: str) -> Optional[dict[str, Any]]:
+    return _load_jobs().get(job_id)
+
+
+@app.on_event("startup")
+async def _startup() -> None:
+    global _client
+    _client = ComfyUIClient(COMFY_URL, poll_interval_s=1.0, default_timeout_s=600.0)
+
+
+@app.on_event("shutdown")
+async def _shutdown() -> None:
+    if _client:
+        await _client.aclose()
+
+
+# ---- status derivation (re-derived from ComfyUI, so it survives bridge restart) --
+async def _derive(job: dict[str, Any]) -> dict[str, Any]:
+    """Refresh a job's status/progress/out_file from ComfyUI /history + /queue."""
+    if job["status"] in ("completed", "failed"):
+        return job
+    pid = job["prompt_id"]
+    http = _client.http
+    hist = (await http.get(f"{COMFY_URL}/history/{pid}")).json()
+    entry = hist.get(pid)
+    if entry:
+        st = entry.get("status", {})
+        if st.get("completed"):
+            if st.get("status_str") == "error":
+                job.update(status="failed", progress=None,
+                           error={"message": str(st.get("messages"))[:500]})
+            else:
+                job.update(status="completed", progress=100,
+                           out_file=_find_output(entry))
+            await _put(job)
+            return job
+    # not done yet — queued vs in_progress from /queue
+    q = (await http.get(f"{COMFY_URL}/queue")).json()
+    running = any(pid == item[1] for item in q.get("queue_running", []))
+    job["status"] = "in_progress" if running else "queued"
+    job["progress"] = None if running else 0
+    return job
+
+
+def _find_output(entry: dict[str, Any]) -> Optional[dict[str, str]]:
+    for _nid, out in entry.get("outputs", {}).items():
+        for key in ("videos", "gifs", "images"):
+            for f in out.get(key) or []:
+                return {"filename": f["filename"], "subfolder": f.get("subfolder", ""),
+                        "type": f.get("type", "output")}
+    return None
+
+
+# ---- the three contract endpoints -----------------------------------------------
+@app.post("/v1/videos")
+async def create_video(request: Request,
+                       input_reference: Optional[UploadFile] = File(None)):
+    # accept both JSON and multipart (input_reference forces multipart).
+    # multipart: pull ALL contract fields from the form (not just model/prompt) so an
+    # I2V request doesn't silently drop seconds/size/seed/negative_prompt/extra_body.
+    if request.headers.get("content-type", "").startswith("application/json"):
+        body = await request.json()
+    else:
+        form = await request.form()
+        body = {k: v for k, v in form.multi_items() if k != "input_reference"}
+        # scalars that must be numeric downstream
+        for k in ("seconds", "seed"):
+            if k in body and body[k] not in (None, ""):
+                body[k] = float(body[k]) if k == "seconds" else int(body[k])
+        # extra_body arrives as a JSON string over multipart
+        if isinstance(body.get("extra_body"), str):
+            try:
+                body["extra_body"] = json.loads(body["extra_body"])
+            except json.JSONDecodeError:
+                raise HTTPException(400, "extra_body must be valid JSON")
+    prompt = body.get("prompt")
+    if not prompt:
+        raise HTTPException(400, "prompt is required")
+    model = body.get("model") or f"{MODEL_PREFIX}-distilled"
+    extra = body.get("extra_body") or {}
+
+    # NOTE (stub): input_reference (first-frame / I2V) is accepted and uploaded, but the
+    # current template is T2V-only. Wiring it needs the I2V workflow variant (un-bypass the
+    # "Load Image" group). Tracked as the next bridge task.
+    ref_name = None
+    if input_reference is not None:
+        ref_name = await _client.upload_image(await input_reference.read(),
+                                              filename=input_reference.filename or "ref.png")
+
+    wf = inject.build_workflow(
+        prompt,
+        size=body.get("size"),
+        seconds=body.get("seconds"),
+        seed=body.get("seed"),
+        negative_prompt=body.get("negative_prompt"),
+        extra_body=extra,
+    )
+    try:
+        pid = await _client.submit_prompt(wf)
+    except Exception as e:
+        raise HTTPException(502, f"ComfyUI submit failed: {e}")
+
+    job = {"id": f"vid_{uuid.uuid4().hex[:24]}", "prompt_id": pid, "model": model,
+           "status": "queued", "progress": 0, "created_at": int(time.time()),
+           "params": {"size": body.get("size"), "seconds": body.get("seconds"),
+                      "input_reference": ref_name}, "out_file": None, "error": None}
+    await _put(job)
+    return JSONResponse(_public(job), status_code=201)
+
+
+@app.get("/v1/videos/{job_id}")
+async def get_video(job_id: str):
+    job = _get(job_id)
+    if not job:
+        raise HTTPException(404, "unknown job id")
+    job = await _derive(job)
+    return _public(job)
+
+
+@app.get("/v1/videos/{job_id}/content")
+async def get_content(job_id: str):
+    job = _get(job_id)
+    if not job:
+        raise HTTPException(404, "unknown job id")
+    job = await _derive(job)
+    if job["status"] != "completed":
+        raise HTTPException(409, f"job not completed (status={job['status']})")
+    out = job.get("out_file")
+    if not out:
+        raise HTTPException(500, "completed but no output file recorded")
+    # read off local disk (co-located); fall back to ComfyUI /view
+    path = OUTPUT_DIR / out["subfolder"] / out["filename"]
+    if path.exists():
+        data = path.read_bytes()
+    else:
+        r = await _client.http.get(f"{COMFY_URL}/view",
+                                   params={"filename": out["filename"],
+                                           "subfolder": out["subfolder"], "type": out["type"]})
+        r.raise_for_status()
+        data = r.content
+    return Response(content=data, media_type="video/mp4",
+                    headers={"Content-Disposition": f'inline; filename="{out["filename"]}"'})
+
+
+def _public(job: dict[str, Any]) -> dict[str, Any]:
+    """The client-facing shape (hide prompt_id / internal fields)."""
+    out = {"id": job["id"], "object": "video", "model": job["model"],
+           "status": job["status"], "progress": job.get("progress"),
+           "created_at": job["created_at"]}
+    if job.get("error"):
+        out["error"] = job["error"]
+    return out
+
+
+@app.get("/healthz")
+async def healthz():
+    try:
+        await _client.http.get(f"{COMFY_URL}/system_stats")
+        return {"ok": True, "comfy": COMFY_URL}
+    except Exception as e:
+        raise HTTPException(503, f"comfy unreachable: {e}")
diff --git a/infra/video-bridge/inject.py b/infra/video-bridge/inject.py
new file mode 100644
index 0000000..56e3d37
--- /dev/null
+++ b/infra/video-bridge/inject.py
@@ -0,0 +1,71 @@
+"""Inject OpenAI /v1/videos request params into the LTX-2.3 T2V ComfyUI workflow.
+
+Injection map (ltx2-t2v.json, distilled-decode path):
+    prompt          -> node 2483 CLIPTextEncode.text (positive)
+    negative_prompt -> node 2612 CLIPTextEncode.text (negative)
+    size WxH        -> node 3059 EmptyLTXVLatentVideo.width/height
+    seconds         -> node 4979 PrimitiveInt.value (frames, snapped to 8n+1)
+    seed            -> node 4832 RandomNoise.noise_seed
+LTX-specific knobs (fps, etc.) arrive via extra_body and are applied where present.
+"""
+from __future__ import annotations
+import copy, json, os
+from typing import Any
+
+_TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), "workflows", "ltx2-t2v.json")
+
+# node ids in ltx2-t2v.json (ComfyUI API format)
+N_POS, N_NEG, N_LATENT, N_FRAMES, N_NOISE = "2483", "2612", "3059", "4979", "4832"
+DEFAULT_FPS = 30
+DEFAULT_NEG = "pc game, console game, video game, cartoon, childish, ugly"
+
+
+def load_template() -> dict[str, Any]:
+    return json.load(open(_TEMPLATE_PATH))
+
+
+def snap_frames(seconds: float, fps: int = DEFAULT_FPS) -> int:
+    """LTX latent length must be 8n+1. Map seconds*fps to the nearest valid count."""
+    raw = max(1, round(float(seconds) * fps))
+    n = round((raw - 1) / 8)
+    return max(9, n * 8 + 1)
+
+
+def parse_size(size: str | None) -> tuple[int, int]:
+    if not size:
+        return 1280, 704
+    w, h = size.lower().split("x")
+    return int(w), int(h)
+
+
+def build_workflow(
+    prompt: str,
+    *,
+    size: str | None = None,
+    seconds: float | str | None = None,
+    seed: int | None = None,
+    negative_prompt: str | None = None,
+    extra_body: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    extra = extra_body or {}
+    wf = copy.deepcopy(load_template())
+    fps = int(extra.get("fps", DEFAULT_FPS))
+
+    wf[N_POS]["inputs"]["text"] = prompt
+    wf[N_NEG]["inputs"]["text"] = negative_prompt or extra.get("negative_prompt") or DEFAULT_NEG
+
+    w, h = parse_size(size)
+    wf[N_LATENT]["inputs"]["width"] = w
+    wf[N_LATENT]["inputs"]["height"] = h
+
+    if seconds is not None:
+        wf[N_FRAMES]["inputs"]["value"] = snap_frames(float(seconds), fps)
+
+    # seed: explicit > extra_body.seed > leave template default.
+    # NOTE: protoBanana PR #39's per-submission SaveImage nonce defeats ComfyUI's exec
+    # cache server-side, so a fixed/absent seed no longer returns a stale cached clip.
+    s = seed if seed is not None else extra.get("seed")
+    if s is not None:
+        wf[N_NOISE]["inputs"]["noise_seed"] = int(s)
+
+    return wf
diff --git a/infra/video-bridge/requirements.txt b/infra/video-bridge/requirements.txt
new file mode 100644
index 0000000..cb31318
--- /dev/null
+++ b/infra/video-bridge/requirements.txt
@@ -0,0 +1,5 @@
+fastapi>=0.115
+uvicorn[standard]>=0.30
+httpx>=0.27
+python-multipart>=0.0.9
+# + protoBanana on PYTHONPATH (co-located checkout) for protobanana.client.ComfyUIClient
diff --git a/infra/video-bridge/smoke.py b/infra/video-bridge/smoke.py
new file mode 100644
index 0000000..0840345
--- /dev/null
+++ b/infra/video-bridge/smoke.py
@@ -0,0 +1,31 @@
+"""End-to-end smoke: POST a job, poll to completion, fetch mp4 bytes."""
+import time, sys, httpx
+BASE = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:8100"
+c = httpx.Client(timeout=30.0)
+
+r = c.post(f"{BASE}/v1/videos", json={
+    "model": "protolabs/ltx2-distilled",
+    "prompt": "a red fox trotting through fresh snow at dawn, breath visible, cinematic, soft light",
+    "seconds": 2, "size": "768x512", "seed": 123,
+})
+print("POST", r.status_code, r.json())
+r.raise_for_status()
+jid = r.json()["id"]
+
+t0 = time.time()
+while True:
+    time.sleep(2)
+    s = c.get(f"{BASE}/v1/videos/{jid}").json()
+    print(f"  [{time.time()-t0:4.0f}s] status={s['status']} progress={s.get('progress')}")
+    if s["status"] in ("completed", "failed"):
+        break
+    if time.time() - t0 > 300:
+        print("TIMEOUT"); sys.exit(1)
+
+if s["status"] == "failed":
+    print("FAILED:", s.get("error")); sys.exit(1)
+
+r = c.get(f"{BASE}/v1/videos/{jid}/content")
+print("GET /content:", r.status_code, r.headers.get("content-type"), len(r.content), "bytes")
+open("/mnt/data/ltx-out/bridge_smoke.mp4", "wb").write(r.content)
+print("saved /mnt/data/ltx-out/bridge_smoke.mp4")
diff --git a/infra/video-bridge/workflows/ltx2-t2v.json b/infra/video-bridge/workflows/ltx2-t2v.json
new file mode 100644
index 0000000..4979707
--- /dev/null
+++ b/infra/video-bridge/workflows/ltx2-t2v.json
@@ -0,0 +1,590 @@
+{
+ "1241": {
+  "inputs": {
+   "frame_rate": [
+    "4978",
+    0
+   ],
+   "positive": [
+    "2483",
+    0
+   ],
+   "negative": [
+    "2612",
+    0
+   ]
+  },
+  "class_type": "LTXVConditioning",
+  "_meta": {
+   "title": "LTXVConditioning"
+  }
+ },
+ "2004": {
+  "inputs": {
+   "image": "example.png"
+  },
+  "class_type": "LoadImage",
+  "_meta": {
+   "title": "Load Image"
+  }
+ },
+ "2483": {
+  "inputs": {
+   "text": "{{PROMPT}}",
+   "clip": [
+    "4960",
+    0
+   ]
+  },
+  "class_type": "CLIPTextEncode",
+  "_meta": {
+   "title": "CLIP Text Encode (Positive Prompt)"
+  }
+ },
+ "2612": {
+  "inputs": {
+   "text": "{{NEGATIVE}}",
+   "clip": [
+    "4960",
+    0
+   ]
+  },
+  "class_type": "CLIPTextEncode",
+  "_meta": {
+   "title": "CLIP Text Encode (Negative Prompt)"
+  }
+ },
+ "3059": {
+  "inputs": {
+   "width": 1280,
+   "height": 704,
+   "length": [
+    "4979",
+    0
+   ],
+   "batch_size": 1
+  },
+  "class_type": "EmptyLTXVLatentVideo",
+  "_meta": {
+   "title": "EmptyLTXVLatentVideo"
+  }
+ },
+ "3159": {
+  "inputs": {
+   "strength": 0.7,
+   "bypass": [
+    "4977",
+    0
+   ],
+   "vae": [
+    "3940",
+    2
+   ],
+   "image": [
+    "3336",
+    0
+   ],
+   "latent": [
+    "3059",
+    0
+   ]
+  },
+  "class_type": "LTXVImgToVideoConditionOnly",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 LTXV Img To Video Condition Only"
+  }
+ },
+ "3336": {
+  "inputs": {
+   "img_compression": 18,
+   "image": [
+    "4981",
+    0
+   ]
+  },
+  "class_type": "LTXVPreprocess",
+  "_meta": {
+   "title": "LTXV Preprocess"
+  }
+ },
+ "3940": {
+  "inputs": {
+   "ckpt_name": "ltx-2.3-22b-distilled-1.1-fp4.safetensors"
+  },
+  "class_type": "CheckpointLoaderSimple",
+  "_meta": {
+   "title": "Load Checkpoint"
+  }
+ },
+ "3980": {
+  "inputs": {
+   "frames_number": [
+    "4979",
+    0
+   ],
+   "frame_rate": [
+    "4985",
+    0
+   ],
+   "batch_size": 1,
+   "audio_vae": [
+    "4010",
+    0
+   ]
+  },
+  "class_type": "LTXVEmptyLatentAudio",
+  "_meta": {
+   "title": "LTXV Empty Latent Audio"
+  }
+ },
+ "4010": {
+  "inputs": {
+   "ckpt_name": "ltx-2.3-22b-distilled-1.1-fp4.safetensors"
+  },
+  "class_type": "LTXVAudioVAELoader",
+  "_meta": {
+   "title": "Load LTXV Audio VAE"
+  }
+ },
+ "4528": {
+  "inputs": {
+   "video_latent": [
+    "3159",
+    0
+   ],
+   "audio_latent": [
+    "3980",
+    0
+   ]
+  },
+  "class_type": "LTXVConcatAVLatent",
+  "_meta": {
+   "title": "LTXVConcatAVLatent"
+  }
+ },
+ "4802": {
+  "inputs": {
+   "noise": [
+    "4814",
+    0
+   ],
+   "guider": [
+    "4808",
+    0
+   ],
+   "sampler": [
+    "4967",
+    0
+   ],
+   "sigmas": [
+    "4966",
+    0
+   ],
+   "latent_image": [
+    "4528",
+    0
+   ]
+  },
+  "class_type": "SamplerCustomAdvanced",
+  "_meta": {
+   "title": "SamplerCustomAdvanced"
+  }
+ },
+ "4808": {
+  "inputs": {
+   "skip_blocks": "28",
+   "model": [
+    "3940",
+    0
+   ],
+   "positive": [
+    "1241",
+    0
+   ],
+   "negative": [
+    "1241",
+    1
+   ],
+   "parameters": [
+    "4964",
+    0
+   ]
+  },
+  "class_type": "MultimodalGuider",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 Multimodal Guider"
+  }
+ },
+ "4814": {
+  "inputs": {
+   "noise_seed": 42
+  },
+  "class_type": "RandomNoise",
+  "_meta": {
+   "title": "RandomNoise"
+  }
+ },
+ "4818": {
+  "inputs": {
+   "samples": [
+    "4824",
+    1
+   ],
+   "audio_vae": [
+    "4010",
+    0
+   ]
+  },
+  "class_type": "LTXVAudioVAEDecode",
+  "_meta": {
+   "title": "LTXV Audio VAE Decode"
+  }
+ },
+ "4819": {
+  "inputs": {
+   "fps": [
+    "4978",
+    0
+   ],
+   "bit_depth": 8,
+   "images": [
+    "4983",
+    0
+   ],
+   "audio": [
+    "4818",
+    0
+   ]
+  },
+  "class_type": "CreateVideo",
+  "_meta": {
+   "title": "Create Video"
+  }
+ },
+ "4824": {
+  "inputs": {
+   "av_latent": [
+    "4802",
+    0
+   ]
+  },
+  "class_type": "LTXVSeparateAVLatent",
+  "_meta": {
+   "title": "LTXVSeparateAVLatent"
+  }
+ },
+ "4828": {
+  "inputs": {
+   "cfg": 1.0,
+   "model": [
+    "3940",
+    0
+   ],
+   "positive": [
+    "1241",
+    0
+   ],
+   "negative": [
+    "1241",
+    1
+   ]
+  },
+  "class_type": "CFGGuider",
+  "_meta": {
+   "title": "CFG Guider"
+  }
+ },
+ "4829": {
+  "inputs": {
+   "noise": [
+    "4832",
+    0
+   ],
+   "guider": [
+    "4828",
+    0
+   ],
+   "sampler": [
+    "4831",
+    0
+   ],
+   "sigmas": [
+    "4971",
+    0
+   ],
+   "latent_image": [
+    "4528",
+    0
+   ]
+  },
+  "class_type": "SamplerCustomAdvanced",
+  "_meta": {
+   "title": "SamplerCustomAdvanced"
+  }
+ },
+ "4831": {
+  "inputs": {
+   "sampler_name": "euler_ancestral_cfg_pp"
+  },
+  "class_type": "KSamplerSelect",
+  "_meta": {
+   "title": "KSamplerSelect"
+  }
+ },
+ "4832": {
+  "inputs": {
+   "noise_seed": 0
+  },
+  "class_type": "RandomNoise",
+  "_meta": {
+   "title": "RandomNoise"
+  }
+ },
+ "4845": {
+  "inputs": {
+   "av_latent": [
+    "4829",
+    0
+   ]
+  },
+  "class_type": "LTXVSeparateAVLatent",
+  "_meta": {
+   "title": "LTXVSeparateAVLatent"
+  }
+ },
+ "4848": {
+  "inputs": {
+   "samples": [
+    "4845",
+    1
+   ],
+   "audio_vae": [
+    "4010",
+    0
+   ]
+  },
+  "class_type": "LTXVAudioVAEDecode",
+  "_meta": {
+   "title": "LTXV Audio VAE Decode"
+  }
+ },
+ "4849": {
+  "inputs": {
+   "fps": [
+    "4978",
+    0
+   ],
+   "bit_depth": 8,
+   "images": [
+    "4982",
+    0
+   ],
+   "audio": [
+    "4848",
+    0
+   ]
+  },
+  "class_type": "CreateVideo",
+  "_meta": {
+   "title": "Create Video"
+  }
+ },
+ "4852": {
+  "inputs": {
+   "filename_prefix": "output_D",
+   "format": "auto",
+   "codec": "auto",
+   "video": [
+    "4849",
+    0
+   ]
+  },
+  "class_type": "SaveVideo",
+  "_meta": {
+   "title": "Save Video"
+  }
+ },
+ "4960": {
+  "inputs": {
+   "text_encoder": "gemma_3_12B_it_fp8_scaled.safetensors",
+   "ckpt_name": "ltx-2.3-22b-distilled-1.1-fp4.safetensors",
+   "device": "default"
+  },
+  "class_type": "LTXAVTextEncoderLoader",
+  "_meta": {
+   "title": "LTXV Audio Text Encoder Loader"
+  }
+ },
+ "4963": {
+  "inputs": {
+   "modality": "AUDIO",
+   "cfg": 7.0,
+   "stg": 1.0,
+   "perturb_attn": true,
+   "rescale": 0.7,
+   "modality_scale": 3.0,
+   "skip_step": 0,
+   "cross_attn": true
+  },
+  "class_type": "GuiderParameters",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 Guider Parameters"
+  }
+ },
+ "4964": {
+  "inputs": {
+   "modality": "VIDEO",
+   "cfg": 3.0,
+   "stg": 1.0,
+   "perturb_attn": true,
+   "rescale": 0.9,
+   "modality_scale": 3.0,
+   "skip_step": 0,
+   "cross_attn": true,
+   "parameters": [
+    "4963",
+    0
+   ]
+  },
+  "class_type": "GuiderParameters",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 Guider Parameters"
+  }
+ },
+ "4966": {
+  "inputs": {
+   "steps": 15,
+   "max_shift": 2.05,
+   "base_shift": 0.95,
+   "stretch": true,
+   "terminal": 0.1,
+   "latent": [
+    "4528",
+    0
+   ]
+  },
+  "class_type": "LTXVScheduler",
+  "_meta": {
+   "title": "LTXVScheduler"
+  }
+ },
+ "4967": {
+  "inputs": {
+   "eta": 0.25,
+   "sampler_name": "exponential/res_2s",
+   "seed": 94,
+   "bongmath": true
+  },
+  "class_type": "ClownSampler_Beta",
+  "_meta": {
+   "title": "ClownSampler"
+  }
+ },
+ "4971": {
+  "inputs": {
+   "sigmas": "1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0"
+  },
+  "class_type": "ManualSigmas",
+  "_meta": {
+   "title": "ManualSigmas"
+  }
+ },
+ "4977": {
+  "inputs": {
+   "value": true
+  },
+  "class_type": "PrimitiveBoolean",
+  "_meta": {
+   "title": "bypass_i2v"
+  }
+ },
+ "4978": {
+  "inputs": {
+   "value": 24.0
+  },
+  "class_type": "PrimitiveFloat",
+  "_meta": {
+   "title": "fps"
+  }
+ },
+ "4979": {
+  "inputs": {
+   "value": 121
+  },
+  "class_type": "PrimitiveInt",
+  "_meta": {
+   "title": "number of frames"
+  }
+ },
+ "4981": {
+  "inputs": {
+   "resize_type": "scale longer dimension",
+   "resize_type.longer_size": 1536,
+   "scale_method": "lanczos",
+   "input": [
+    "2004",
+    0
+   ]
+  },
+  "class_type": "ResizeImageMaskNode",
+  "_meta": {
+   "title": "Resize Image/Mask"
+  }
+ },
+ "4982": {
+  "inputs": {
+   "horizontal_tiles": 2,
+   "vertical_tiles": 2,
+   "overlap": 6,
+   "last_frame_fix": false,
+   "working_device": "auto",
+   "working_dtype": "auto",
+   "vae": [
+    "3940",
+    2
+   ],
+   "latents": [
+    "4845",
+    0
+   ]
+  },
+  "class_type": "LTXVTiledVAEDecode",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 LTXV Tiled VAE Decode"
+  }
+ },
+ "4983": {
+  "inputs": {
+   "horizontal_tiles": 2,
+   "vertical_tiles": 2,
+   "overlap": 6,
+   "last_frame_fix": false,
+   "working_device": "auto",
+   "working_dtype": "auto",
+   "vae": [
+    "3940",
+    2
+   ],
+   "latents": [
+    "4824",
+    0
+   ]
+  },
+  "class_type": "LTXVTiledVAEDecode",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 LTXV Tiled VAE Decode"
+  }
+ },
+ "4985": {
+  "inputs": {
+   "a": [
+    "4978",
+    0
+   ]
+  },
+  "class_type": "LTXFloatToInt",
+  "_meta": {
+   "title": "\ud83c\udd5b\ud83c\udd63\ud83c\udd67 Float To Int"
+  }
+ }
+}
\ No newline at end of file