comfy-diffusion 2.1.1__tar.gz → 2.2.0__tar.gz

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-diffusion
-Version: 2.1.1
+Version: 2.2.0
 Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
 Author: Alejandro Quintero
 License: GPL-3.0-only

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion/audio.py

@@ -120,6 +120,37 @@ def ltxv_audio_vae_decode(vae: _LtxvAudioVaeDecoder, latent: Any) -> dict[str, A
     if getattr(latent_tensor, "is_nested", False):
         latent_tensor = latent_tensor.unbind()[-1]
 
+    first_stage_model = getattr(vae, "first_stage_model", None)
+    if first_stage_model is not None:
+        if hasattr(vae, "patcher"):
+            from ._runtime import ensure_comfyui_on_path
+
+            ensure_comfyui_on_path()
+            import comfy.model_management
+
+            memory_required = 0
+            if hasattr(vae, "memory_used_decode") and hasattr(latent_tensor, "shape"):
+                memory_required = vae.memory_used_decode(latent_tensor.shape, vae.vae_dtype)
+            comfy.model_management.load_models_gpu(
+                [vae.patcher],
+                memory_required=memory_required,
+                force_full_load=getattr(vae, "disable_offload", False),
+            )
+        if hasattr(latent_tensor, "to") and hasattr(vae, "device") and hasattr(vae, "vae_dtype"):
+            latent_tensor = latent_tensor.to(device=vae.device, dtype=vae.vae_dtype)
+        with _inference_mode_context():
+            audio = first_stage_model.decode(latent_tensor)
+        if hasattr(audio, "to"):
+            output_device = getattr(vae, "output_device", getattr(latent_tensor, "device", None))
+            if hasattr(vae, "vae_output_dtype"):
+                audio = audio.to(device=output_device, dtype=vae.vae_output_dtype(), copy=True)
+            elif output_device is not None:
+                audio = audio.to(output_device)
+        return {
+            "waveform": audio,
+            "sample_rate": int(first_stage_model.output_sample_rate),
+        }
+
     if hasattr(vae, "to"):
         vae.to("cpu")
     if hasattr(latent_tensor, "cpu"):

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion/conditioning.py

@@ -429,6 +429,213 @@ def ltxv_add_guide(
     return r[0], r[1], r[2]
 
 
+def _append_guide_attention_entry(
+    conditioning: Any,
+    pre_filter_count: int,
+    latent_shape: list[int],
+) -> Any:
+    """Append IC-LoRA guide attention metadata to conditioning."""
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+    import node_helpers
+
+    existing_entries: list[Any] = []
+    for entry in conditioning:
+        entries = entry[1].get("guide_attention_entries")
+        if entries is not None:
+            existing_entries = list(entries)
+            break
+
+    updated_entries = [
+        *existing_entries,
+        {
+            "pre_filter_count": pre_filter_count,
+            "strength": 1.0,
+            "pixel_mask": None,
+            "latent_shape": latent_shape,
+        },
+    ]
+    return node_helpers.conditioning_set_values(
+        conditioning, {"guide_attention_entries": updated_entries}
+    )
+
+
+def _ltxv_dilate_latent(
+    latent: dict[str, Any],
+    horizontal_scale: int,
+    vertical_scale: int,
+) -> dict[str, Any]:
+    if horizontal_scale == 1 and vertical_scale == 1:
+        return latent
+
+    import torch
+
+    samples = latent["samples"]
+    mask = latent.get("noise_mask", None)
+    dilated_shape = samples.shape[:3] + (
+        samples.shape[3] * vertical_scale,
+        samples.shape[4] * horizontal_scale,
+    )
+
+    dilated_samples = torch.zeros(
+        dilated_shape,
+        device=samples.device,
+        dtype=samples.dtype,
+        requires_grad=False,
+    )
+    dilated_samples[..., ::vertical_scale, ::horizontal_scale] = samples
+
+    dilated_mask_shape = (
+        dilated_samples.shape[0],
+        1,
+        dilated_samples.shape[2],
+        dilated_samples.shape[3],
+        dilated_samples.shape[4],
+    )
+    dilated_mask = torch.full(
+        dilated_mask_shape,
+        -1.0,
+        device=samples.device,
+        dtype=samples.dtype,
+        requires_grad=False,
+    )
+    dilated_mask[..., ::vertical_scale, ::horizontal_scale] = (
+        mask if mask is not None else 1.0
+    )
+    return {"samples": dilated_samples, "noise_mask": dilated_mask}
+
+
+def ltx_add_video_ic_lora_guide(
+    positive: Any,
+    negative: Any,
+    vae: Any,
+    latent: dict[str, Any],
+    image: Any,
+    frame_idx: int = 0,
+    strength: float = 1.0,
+    latent_downscale_factor: float = 1.0,
+    crop: str = "disabled",
+    use_tiled_encode: bool = False,
+    tile_size: int = 256,
+    tile_overlap: int = 64,
+) -> tuple[Any, Any, dict[str, Any]]:
+    """Inject a video IC-LoRA guide into LTXV conditioning and latent.
+
+    Mirrors Lightricks' ``LTXAddVideoICLoRAGuide`` node. This variant supports
+    downscaled reference latents, which the LTX-2.3 motion-track IC-LoRA uses
+    with ``reference_downscale_factor=2`` / reference resolution ``0.5x``.
+    """
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+
+    import comfy.utils
+    import comfy_extras.nodes_lt as nodes_lt
+    import torch
+
+    scale_factors = vae.downscale_index_formula
+    latent_image = latent["samples"]
+    noise_mask = nodes_lt.get_noise_mask(latent)
+
+    _, _, latent_length, latent_height, latent_width = latent_image.shape
+
+    time_scale_factor = scale_factors[0]
+    num_frames_to_keep = (
+        ((image.shape[0] - 1) // time_scale_factor) * time_scale_factor + 1
+    )
+    causal_fix = frame_idx == 0 or num_frames_to_keep == 1
+    if not causal_fix:
+        image = torch.cat([image[:1], image], dim=0)
+
+    images = image[
+        : ((image.shape[0] - 1) // time_scale_factor) * time_scale_factor + 1
+    ]
+    target_width = int(latent_width * scale_factors[1] / latent_downscale_factor)
+    target_height = int(latent_height * scale_factors[2] / latent_downscale_factor)
+    pixels = comfy.utils.common_upscale(
+        images.movedim(-1, 1),
+        target_width,
+        target_height,
+        "bilinear",
+        crop=crop,
+    ).movedim(1, -1)
+    encode_pixels = pixels[:, :, :, :3]
+    if use_tiled_encode:
+        guide_latent = vae.encode_tiled(
+            encode_pixels,
+            tile_x=tile_size,
+            tile_y=tile_size,
+            overlap=tile_overlap,
+        )
+    else:
+        guide_latent = vae.encode(encode_pixels)
+
+    if not causal_fix:
+        guide_latent = guide_latent[:, :, 1:, :, :]
+        image = image[1:]
+
+    guide_orig_shape = list(guide_latent.shape[2:])
+    guide_mask = None
+
+    if latent_downscale_factor > 1:
+        downscale_int = int(latent_downscale_factor)
+        if latent_width % downscale_int != 0 or latent_height % downscale_int != 0:
+            raise ValueError(
+                f"Latent spatial size {latent_width}x{latent_height} must be divisible "
+                f"by latent_downscale_factor {latent_downscale_factor}"
+            )
+
+        dilated = _ltxv_dilate_latent(
+            {"samples": guide_latent},
+            horizontal_scale=downscale_int,
+            vertical_scale=downscale_int,
+        )
+        guide_mask = dilated["noise_mask"]
+        guide_latent = dilated["samples"]
+
+    iclora_tokens_added = (
+        guide_latent.shape[2] * guide_latent.shape[3] * guide_latent.shape[4]
+    )
+
+    frame_idx, latent_idx = nodes_lt.LTXVAddGuide.get_latent_index(
+        positive,
+        latent_length,
+        len(image),
+        frame_idx,
+        scale_factors,
+    )
+    if latent_idx + guide_latent.shape[2] > latent_length:
+        raise ValueError("Conditioning frames exceed the length of the latent sequence.")
+
+    positive, negative, latent_image, noise_mask = nodes_lt.LTXVAddGuide.append_keyframe(
+        positive,
+        negative,
+        frame_idx,
+        latent_image,
+        noise_mask,
+        guide_latent,
+        strength,
+        scale_factors,
+        guide_mask=guide_mask,
+        latent_downscale_factor=latent_downscale_factor,
+        causal_fix=causal_fix,
+    )
+
+    positive = _append_guide_attention_entry(
+        positive,
+        iclora_tokens_added,
+        guide_orig_shape,
+    )
+    negative = _append_guide_attention_entry(
+        negative,
+        iclora_tokens_added,
+        guide_orig_shape,
+    )
+
+    return positive, negative, {"samples": latent_image, "noise_mask": noise_mask}
+
+
 def conditioning_zero_out(conditioning: Any) -> list[Any]:
     """Zero out conditioning tensors.
 
@@ -1976,6 +2183,7 @@ __all__ = [
     "ltxv_img_to_video",
     "ltxv_conditioning",
     "ltxv_crop_guides",
+    "ltx_add_video_ic_lora_guide",
     "conditioning_zero_out",
     "conditioning_combine",
     "conditioning_set_mask",

comfy_diffusion-2.2.0/comfy_diffusion/lora.py

@@ -0,0 +1,78 @@
+"""LoRA application helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, cast
+
+
+def apply_lora(
+    model: Any,
+    clip: Any,
+    path: str | Path,
+    strength_model: float,
+    strength_clip: float,
+) -> tuple[Any, Any]:
+    """Apply a LoRA file to a model/CLIP pair and return patched copies.
+
+    The returned pair can be passed back into ``apply_lora`` to stack
+    multiple LoRAs by chaining calls.
+    """
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+
+    import comfy.sd
+    import comfy.utils
+
+    lora_path = str(Path(path))
+    lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+    patched = comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip)
+    return cast(tuple[Any, Any], patched)
+
+
+def apply_ic_lora_model_only(
+    model: Any,
+    path: str | Path,
+    strength_model: float = 1.0,
+) -> tuple[Any, float]:
+    """Apply an IC-LoRA to a model and return its reference downscale factor.
+
+    Mirrors Lightricks' ``LTXICLoRALoaderModelOnly`` node: the LoRA is applied
+    to the diffusion model only, and ``reference_downscale_factor`` is read
+    from safetensors metadata. Missing or invalid metadata falls back to ``1.0``.
+    """
+    from ._runtime import ensure_comfyui_on_path
+
+    ensure_comfyui_on_path()
+
+    import comfy.sd
+    import comfy.utils
+
+    lora_path = str(Path(path))
+    loaded = comfy.utils.load_torch_file(
+        lora_path,
+        safe_load=True,
+        return_metadata=True,
+    )
+    lora, metadata = loaded
+
+    try:
+        latent_downscale_factor = float(metadata["reference_downscale_factor"])
+    except (KeyError, TypeError, ValueError):
+        latent_downscale_factor = 1.0
+
+    if strength_model == 0:
+        return model, latent_downscale_factor
+
+    patched_model, _ = comfy.sd.load_lora_for_models(
+        model,
+        None,
+        lora,
+        strength_model,
+        0.0,
+    )
+    return patched_model, latent_downscale_factor
+
+
+__all__ = ["apply_lora", "apply_ic_lora_model_only"]

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion/models.py

@@ -259,8 +259,8 @@ class ModelManager:
         ensure_comfyui_on_path()
 
         import folder_paths
+        from comfy import sd as comfy_sd
         from comfy import utils as comfy_utils
-        from comfy.ldm.lightricks.vae.audio_vae import AudioVAE
 
         p = Path(path)
         if p.is_absolute() and p.is_file():
@@ -274,7 +274,14 @@ class ModelManager:
         state_dict, metadata = comfy_utils.load_torch_file(
             checkpoint_path, return_metadata=True
         )
-        return AudioVAE(state_dict, metadata)
+        state_dict = comfy_utils.state_dict_prefix_replace(
+            state_dict,
+            {"audio_vae.": "autoencoder.", "vocoder.": "vocoder."},
+            filter_keys=True,
+        )
+        vae = comfy_sd.VAE(sd=state_dict, metadata=metadata)
+        vae.throw_exception_if_invalid()
+        return vae
 
     def load_ltxav_text_encoder(
         self,

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion/pipelines/video/ltx/ltx23/__init__.py

@@ -19,6 +19,9 @@ ia2v
     audio file.  The audio is VAE-encoded and injected with a zero noise mask
     so the sampler uses it as structural guidance.
     Mirrors ``video_ltx2_3_ia2v.json``.
+motion_track
+    Motion-track IC-LoRA pipeline.  Uses a rendered sparse-track control video
+    to guide object or region motion.
 
 Usage::
 
@@ -26,6 +29,7 @@ Usage::
     from comfy_diffusion.pipelines.video.ltx.ltx23.i2v import manifest, run
     from comfy_diffusion.pipelines.video.ltx.ltx23.flf2v import manifest, run
     from comfy_diffusion.pipelines.video.ltx.ltx23.ia2v import manifest, run
+    from comfy_diffusion.pipelines.video.ltx.ltx23.motion_track import manifest, run
 """
 
-__all__ = ["t2v", "i2v", "flf2v", "ia2v"]
+__all__ = ["t2v", "i2v", "flf2v", "ia2v", "motion_track"]

comfy_diffusion-2.2.0/comfy_diffusion/pipelines/video/ltx/ltx23/motion_track.py

@@ -0,0 +1,199 @@
+"""LTX-Video 2.3 motion-track IC-LoRA pipeline.
+
+This pipeline mirrors the official Lightricks
+``LTX-2.3_ICLoRA_Motion_Track_Distilled.json`` workflow. It expects a rendered
+motion-track control video: a reference video whose frames contain the colored
+spline overlays that describe sparse object or region trajectories.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from comfy_diffusion.downloader import HFModelEntry, ModelEntry
+
+__all__ = ["manifest", "run"]
+
+_HF_REPO_CKPT = "Lightricks/LTX-2.3"
+_HF_REPO_TE = "Comfy-Org/ltx-2"
+_HF_REPO_IC_LORA = "Lightricks/LTX-2.3-22b-IC-LoRA-Motion-Track-Control"
+
+_UNET_DEST = Path("checkpoints") / "ltx-2.3-22b-dev.safetensors"
+_TEXT_ENCODER_DEST = Path("text_encoders") / "gemma_3_12B_it.safetensors"
+_DISTILLED_LORA_DEST = Path("loras") / "ltx-2.3-22b-distilled-lora-384-1.1.safetensors"
+_IC_LORA_DEST = Path("loras") / "ltx-2.3-22b-ic-lora-motion-track-control-ref0.5.safetensors"
+
+_SIGMAS = "1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0"
+
+
+def manifest() -> list[ModelEntry]:
+    """Return all model files required by the motion-track IC-LoRA pipeline."""
+    return [
+        HFModelEntry(
+            repo_id=_HF_REPO_CKPT,
+            filename="ltx-2.3-22b-dev.safetensors",
+            dest=_UNET_DEST,
+        ),
+        HFModelEntry(
+            repo_id=_HF_REPO_TE,
+            filename="split_files/text_encoders/gemma_3_12B_it.safetensors",
+            dest=_TEXT_ENCODER_DEST,
+        ),
+        HFModelEntry(
+            repo_id=_HF_REPO_CKPT,
+            filename="ltx-2.3-22b-distilled-lora-384-1.1.safetensors",
+            dest=_DISTILLED_LORA_DEST,
+        ),
+        HFModelEntry(
+            repo_id=_HF_REPO_IC_LORA,
+            filename="ltx-2.3-22b-ic-lora-motion-track-control-ref0.5.safetensors",
+            dest=_IC_LORA_DEST,
+        ),
+    ]
+
+
+def run(
+    *,
+    models_dir: str | Path,
+    motion_track_video: str | Path | Any,
+    prompt: str,
+    negative_prompt: str = "pc game, console game, video game, cartoon, childish, ugly",
+    width: int = 960,
+    height: int = 544,
+    length: int = 121,
+    fps: int = 24,
+    cfg: float = 1.0,
+    seed: int = 0,
+    distilled_lora_strength: float = 0.5,
+    ic_lora_strength: float = 1.0,
+    guide_strength: float = 1.0,
+    unet_filename: str | None = None,
+    vae_filename: str | None = None,
+    audio_vae_filename: str | None = None,
+    text_encoder_filename: str | None = None,
+    distilled_lora_filename: str | None = None,
+    ic_lora_filename: str | None = None,
+    use_tiled_guide_encode: bool = False,
+    tile_size: int = 256,
+    tile_overlap: int = 64,
+) -> dict[str, Any]:
+    """Run LTX-2.3 motion-track controlled video generation.
+
+    Parameters
+    ----------
+    motion_track_video:
+        Control video as a path or a BHWC torch tensor. The frames should show
+        the colored trajectory splines expected by the LTX motion-track IC-LoRA.
+    """
+    from comfy_diffusion.audio import (
+        ltxv_audio_vae_decode,
+        ltxv_concat_av_latent,
+        ltxv_empty_latent_audio,
+        ltxv_separate_av_latent,
+    )
+    from comfy_diffusion.conditioning import (
+        encode_prompt,
+        ltx_add_video_ic_lora_guide,
+        ltxv_conditioning,
+        ltxv_crop_guides,
+    )
+    from comfy_diffusion.latent import ltxv_empty_latent_video
+    from comfy_diffusion.lora import apply_ic_lora_model_only, apply_lora
+    from comfy_diffusion.models import ModelManager
+    from comfy_diffusion.runtime import check_runtime
+    from comfy_diffusion.sampling import (
+        cfg_guider,
+        get_sampler,
+        manual_sigmas,
+        random_noise,
+        sample_custom,
+    )
+    from comfy_diffusion.vae import vae_decode_batch_tiled
+    from comfy_diffusion.video import load_video
+
+    check_result = check_runtime()
+    if check_result.get("error"):
+        raise RuntimeError(
+            f"ComfyUI runtime not available: {check_result['error']}"
+        )
+
+    models_dir = Path(models_dir)
+    mm = ModelManager(models_dir)
+
+    unet_path = Path(unet_filename) if unet_filename else models_dir / _UNET_DEST
+    te_path = (
+        Path(text_encoder_filename) if text_encoder_filename else models_dir / _TEXT_ENCODER_DEST
+    )
+    vae_path = Path(vae_filename) if vae_filename else unet_path
+    audio_vae_path = Path(audio_vae_filename) if audio_vae_filename else vae_path
+    distilled_lora_path = (
+        Path(distilled_lora_filename)
+        if distilled_lora_filename
+        else models_dir / _DISTILLED_LORA_DEST
+    )
+    ic_lora_path = (
+        Path(ic_lora_filename) if ic_lora_filename else models_dir / _IC_LORA_DEST
+    )
+
+    ckpt = mm.load_checkpoint_from_path(unet_path)
+    model = ckpt.model
+    vae = ckpt.vae if vae_filename is None else mm.load_vae(vae_path)
+    audio_vae = mm.load_ltxv_audio_vae(audio_vae_path)
+    clip = mm.load_ltxav_text_encoder(te_path, unet_path)
+
+    model, _ = apply_lora(model, clip, distilled_lora_path, distilled_lora_strength, 0.0)
+    model, latent_downscale_factor = apply_ic_lora_model_only(
+        model,
+        ic_lora_path,
+        ic_lora_strength,
+    )
+
+    if isinstance(motion_track_video, (str, Path)):
+        guide_video = load_video(motion_track_video)
+    else:
+        guide_video = motion_track_video
+
+    positive, negative = encode_prompt(clip, prompt, negative_prompt)
+    positive, negative = ltxv_conditioning(positive, negative, frame_rate=fps)
+
+    video_latent = ltxv_empty_latent_video(
+        width=width,
+        height=height,
+        length=length,
+        fps=fps,
+    )
+    positive, negative, video_latent = ltx_add_video_ic_lora_guide(
+        positive,
+        negative,
+        vae,
+        video_latent,
+        guide_video,
+        frame_idx=0,
+        strength=guide_strength,
+        latent_downscale_factor=latent_downscale_factor,
+        crop="disabled",
+        use_tiled_encode=use_tiled_guide_encode,
+        tile_size=tile_size,
+        tile_overlap=tile_overlap,
+    )
+
+    audio_latent = ltxv_empty_latent_audio(audio_vae, frames_number=length, frame_rate=fps)
+    av_latent = ltxv_concat_av_latent(video_latent, audio_latent)
+
+    guider = cfg_guider(model, positive, negative, cfg)
+    noise = random_noise(seed)
+    sigmas = manual_sigmas(_SIGMAS)
+    sampler = get_sampler("euler_ancestral_cfg_pp")
+    sampled, _ = sample_custom(noise, guider, sampler, sigmas, av_latent)
+
+    video_latent_out, audio_latent_out = ltxv_separate_av_latent(sampled)
+    positive, negative, video_latent_out = ltxv_crop_guides(
+        positive,
+        negative,
+        video_latent_out,
+    )
+    frames = vae_decode_batch_tiled(vae, video_latent_out)
+    audio = ltxv_audio_vae_decode(audio_vae, audio_latent_out)
+
+    return {"frames": frames, "audio": audio}

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comfy-diffusion
-Version: 2.1.1
+Version: 2.2.0
 Summary: ComfyUI inference engine as a standalone Python library (no server, no UI).
 Author: Alejandro Quintero
 License: GPL-3.0-only

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/comfy_diffusion.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ comfy_diffusion/pipelines/video/ltx/ltx23/__init__.py
 comfy_diffusion/pipelines/video/ltx/ltx23/flf2v.py
 comfy_diffusion/pipelines/video/ltx/ltx23/i2v.py
 comfy_diffusion/pipelines/video/ltx/ltx23/ia2v.py
+comfy_diffusion/pipelines/video/ltx/ltx23/motion_track.py
 comfy_diffusion/pipelines/video/ltx/ltx23/t2v.py
 comfy_diffusion/pipelines/video/wan/__init__.py
 comfy_diffusion/pipelines/video/wan/wan21/__init__.py
@@ -153,6 +154,7 @@ tests/test_pipelines_image_z_image_turbo.py
 tests/test_pipelines_ltx23_flf2v.py
 tests/test_pipelines_ltx23_i2v.py
 tests/test_pipelines_ltx23_ia2v.py
+tests/test_pipelines_ltx23_motion_track.py
 tests/test_pipelines_ltx23_t2v.py
 tests/test_pipelines_ltx2_audio_to_video.py
 tests/test_pipelines_ltx2_canny.py

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comfy-diffusion"
-version = "2.1.1"
+version = "2.2.0"
 description = "ComfyUI inference engine as a standalone Python library (no server, no UI)."
 readme = "README.md"
 license = { text = "GPL-3.0-only" }

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/tests/test_audio.py

@@ -146,6 +146,47 @@ def test_ltxv_audio_vae_decode_calls_vae_decode_and_returns_audio_dict() -> None
     assert vae2.calls == [fake_latent_tensor]
 
 
+def test_ltxv_audio_vae_decode_supports_comfy_vae_wrapper() -> None:
+    class FakeAudioTensor:
+        def __init__(self) -> None:
+            self.calls: list[tuple[str, Any]] = []
+
+        def movedim(self, source: int, destination: int) -> "FakeAudioTensor":
+            self.calls.append(("movedim", (source, destination)))
+            return self
+
+        def to(self, device: Any) -> "FakeAudioTensor":
+            self.calls.append(("to", device))
+            return self
+
+    class FakeFirstStageModel:
+        output_sample_rate = 48000
+
+        def __init__(self) -> None:
+            self.calls: list[Any] = []
+
+        def decode(self, latent: Any) -> FakeAudioTensor:
+            self.calls.append(latent)
+            return fake_audio
+
+    class FakeLatentTensor:
+        device = "cuda:0"
+
+    fake_audio = FakeAudioTensor()
+    fake_latent = FakeLatentTensor()
+
+    class FakeComfyVae:
+        def __init__(self) -> None:
+            self.first_stage_model = FakeFirstStageModel()
+
+    vae = FakeComfyVae()
+    result = ltxv_audio_vae_decode(vae, {"samples": fake_latent})
+
+    assert result == {"waveform": fake_audio, "sample_rate": 48000}
+    assert vae.first_stage_model.calls == [fake_latent]
+    assert fake_audio.calls == [("to", "cuda:0")]
+
+
 def test_ltxv_empty_latent_audio_signature_matches_contract() -> None:
     signature = inspect.signature(ltxv_empty_latent_audio)
     assert (

{comfy_diffusion-2.1.1 → comfy_diffusion-2.2.0}/tests/test_conditioning.py

@@ -304,6 +304,7 @@ def test_conditioning_public_api_exports_expected_entrypoints() -> None:
         "ltxv_img_to_video",
         "ltxv_conditioning",
         "ltxv_crop_guides",
+        "ltx_add_video_ic_lora_guide",
         "conditioning_zero_out",
         "conditioning_combine",
         "conditioning_set_mask",