Remove module level lora CACHE and a long module docstring.

.github/workflows/cla.yml

@@ -1,91 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, synchronize, closed]
-
-permissions:
-  actions: write
-  contents: read # 'read' is enough because signatures live in a REMOTE repo
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla-assistant:
-    runs-on: ubuntu-latest
-    steps:
-      # The CLA action normally requires every commit author in a PR to sign.
-      # We only want the PR author to sign, so we allowlist all other committers
-      # by computing them from the PR's commits and excluding the PR author.
-      - name: Build author-only allowlist
-        id: allowlist
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
-          BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
-        run: |
-          others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
-            --jq '.[] | (.author.login // empty), (.committer.login // empty)' \
-            | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
-          if [ -n "$others" ]; then
-            echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"
-          else
-            echo "allowlist=${BASE_ALLOWLIST}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: CLA Assistant
-        # Run on PR events, on "recheck" comment, or when someone posts the exact signing phrase.
-        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # PAT required to write to the centralized signatures repo.
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-        with:
-          # Where the CLA document lives (shown to contributors)
-          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
-
-          # Centralized signature storage
-          remote-organization-name: comfy-org
-          remote-repository-name: comfy-cla
-          path-to-signatures: signatures/cla.json
-          branch: main
-
-          # Only the PR author must sign: bots plus every non-author committer
-          # are allowlisted via the "Build author-only allowlist" step above.
-          # *[bot] is a catch-all for any GitHub App bot account.
-          allowlist: ${{ steps.allowlist.outputs.allowlist }}
-
-          # Custom PR comment messages
-          custom-notsigned-prcomment: |
-            🎉 Thank you for your contribution, we really appreciate it! 🎉
-
-            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
-
-            - Confirm that you own your contribution.
-            - Keep the right to reuse your own code.
-            - Grant us a copyright license to include and share it within our projects.
-
-            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
-
-            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
-
-          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
-
-          custom-allsigned-prcomment: |
-            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.

AGENTS.md

@@ -127,8 +127,6 @@
 - Do not add unnecessary `try`/`except` blocks. Use them for optional dependency,
   platform, or backend capability detection only when the program has a useful
   fallback. Prefer specific exception types when changing new code.
-- If a library version is pinned in `requirements.txt`, do not add code to
-  ComfyUI to handle older versions of that library.
 - Remove any workarounds for PyTorch versions that ComfyUI no longer officially
   supports. Deprecated workarounds include catching an exception and rerunning
   the same op with the input cast to float. If a workaround does not have a

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

README.md

@@ -229,7 +229,7 @@ Python 3.14 works but some custom nodes may have issues. The free threaded varia
 
 Python 3.13 is very well supported. If you have trouble with some custom node dependencies on 3.13 you can try 3.12
 
-torch 2.5 is minimally supported but using a newer version is extremely recommended. Some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old. If your pytorch is more than 6 months old, please update it.
+torch 2.4 and above is supported but some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old.
 
 ### Instructions:
 

comfy/ldm/ace/ace_step15.py

@@ -217,7 +217,10 @@ class AceStepAttention(nn.Module):
                 cos, sin = position_embeddings
                 query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
+        n_rep = self.num_heads // self.num_kv_heads
+        if n_rep > 1:
+            key_states = key_states.repeat_interleave(n_rep, dim=1)
+            value_states = value_states.repeat_interleave(n_rep, dim=1)
 
         attn_bias = None
         if self.sliding_window is not None and not self.is_cross_attention:
@@ -241,7 +244,7 @@ class AceStepAttention(nn.Module):
             else:
                 attn_bias = window_bias
 
-        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False, **gqa_kwargs)
+        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False)
         attn_output = self.o_proj(attn_output)
 
         return attn_output

comfy/ldm/audio/dit.py

@@ -425,16 +425,19 @@ class Attention(nn.Module):
         if n == 1 and causal:
             causal = False
 
-        gqa_kwargs = {"enable_gqa": True} if h != kv_h else {}
+        if h != kv_h:
+            # Repeat interleave kv_heads to match q_heads
+            heads_per_kv_head = h // kv_h
+            k, v = map(lambda t: t.repeat_interleave(heads_per_kv_head, dim = 1), (k, v))
 
         if self.differential:
             q, q_diff = q.unbind(dim=1)
             k, k_diff = k.unbind(dim=1)
-            out      = optimized_attention(q,      k,      v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
-            out_diff = optimized_attention(q_diff, k_diff, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
+            out      = optimized_attention(q,      k,      v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
+            out_diff = optimized_attention(q_diff, k_diff, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
             out = out - out_diff
         else:
-            out = optimized_attention(q, k, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
+            out = optimized_attention(q, k, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options)
 
         out = self.to_out(out)
 

comfy/ldm/boogu/model.py

@@ -74,8 +74,11 @@ class BooguDoubleStreamProcessor(nn.Module):
         key = key.transpose(1, 2)
         value = value.transpose(1, 2)
 
-        gqa_kwargs = {"enable_gqa": True} if attn.kv_heads < attn.heads else {}
-        hidden_states = optimized_attention_masked(query, key, value, attn.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options, **gqa_kwargs)
+        if attn.kv_heads < attn.heads:
+            key = key.repeat_interleave(attn.heads // attn.kv_heads, dim=1)
+            value = value.repeat_interleave(attn.heads // attn.kv_heads, dim=1)
+
+        hidden_states = optimized_attention_masked(query, key, value, attn.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options)
 
         # Split back to instruction/image, apply per-stream output projections, recombine.
         instruct_hidden_states = self.instruct_out(hidden_states[:, :L_instruct])

comfy/ldm/modules/attention.py

@@ -1,6 +1,5 @@
 import math
 import sys
-import inspect
 
 import torch
 import torch.nn.functional as F
@@ -15,16 +14,16 @@ from .sub_quadratic_attention import efficient_dot_product_attention
 
 from comfy import model_management
 
+TORCH_HAS_GQA = model_management.torch_version_numeric >= (2, 5)
+
 if model_management.xformers_enabled():
     import xformers
     import xformers.ops
 
 SAGE_ATTENTION_IS_AVAILABLE = False
-SAGE_ATTENTION_SUPPORTS_MASK = False
 try:
     from sageattention import sageattn
     SAGE_ATTENTION_IS_AVAILABLE = True
-    SAGE_ATTENTION_SUPPORTS_MASK = "attn_mask" in inspect.signature(sageattn).parameters
 except ImportError as e:
     if model_management.sage_attention_enabled():
         if e.name == "sageattention":
@@ -90,44 +89,6 @@ def default(val, d):
         return val
     return d
 
-def _gqa_repeat_factor(query_heads, key_heads, value_heads):
-    if key_heads != value_heads:
-        raise ValueError(f"Key/value head count mismatch for GQA: {key_heads} != {value_heads}")
-    if query_heads == key_heads:
-        return 1
-    if query_heads % key_heads != 0:
-        raise ValueError(f"Query heads must be divisible by key/value heads for GQA: {query_heads} vs {key_heads}")
-    return query_heads // key_heads
-
-def _repeat_kv_for_gqa(k, v, query_heads, head_dim):
-    n_rep = _gqa_repeat_factor(query_heads, k.shape[head_dim], v.shape[head_dim])
-    if n_rep > 1:
-        k = k.repeat_interleave(n_rep, dim=head_dim)
-        v = v.repeat_interleave(n_rep, dim=head_dim)
-    return k, v
-
-def _heads_from_dim(tensor, dim_head, name):
-    inner_dim = tensor.shape[-1]
-    if inner_dim % dim_head != 0:
-        raise ValueError(f"{name} inner dimension {inner_dim} is not divisible by head dimension {dim_head}")
-    return inner_dim // dim_head
-
-def _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, enable_gqa=False, expand_kv=True):
-    q = q.unsqueeze(3).reshape(b, -1, heads, dim_head)
-    if enable_gqa:
-        key_heads = _heads_from_dim(k, dim_head, "Key")
-        value_heads = _heads_from_dim(v, dim_head, "Value")
-    else:
-        key_heads = heads
-        value_heads = heads
-    k = k.unsqueeze(3).reshape(b, -1, key_heads, dim_head)
-    v = v.unsqueeze(3).reshape(b, -1, value_heads, dim_head)
-    if enable_gqa:
-        _gqa_repeat_factor(heads, key_heads, value_heads)
-        if expand_kv:
-            k, v = _repeat_kv_for_gqa(k, v, heads, -2)
-    return q, k, v
-
 
 # feedforward
 class GEGLU(nn.Module):
@@ -191,19 +152,28 @@ def attention_basic(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
         b, _, dim_head = q.shape
         dim_head //= heads
 
+    if kwargs.get("enable_gqa", False) and q.shape[-3] != k.shape[-3]:
+        n_rep = q.shape[-3] // k.shape[-3]
+        k = k.repeat_interleave(n_rep, dim=-3)
+        v = v.repeat_interleave(n_rep, dim=-3)
+
     scale = kwargs.get("scale", dim_head ** -0.5)
 
     h = heads
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
-        q, k, v = map(
+         q, k, v = map(
             lambda t: t.reshape(b * heads, -1, dim_head),
             (q, k, v),
         )
     else:
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        q, k, v = map(lambda t: t.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head).contiguous(), (q, k, v))
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, -1, heads, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * heads, -1, dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
 
     # force cast to fp32 to avoid overflowing
     if attn_precision == torch.float32:
@@ -261,16 +231,13 @@ def attention_sub_quad(query, key, value, heads, mask=None, attn_precision=None,
         query = query * (kwargs["scale"] * dim_head ** 0.5)
 
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            key, value = _repeat_kv_for_gqa(key, value, query.shape[-3], -3)
         query = query.reshape(b * heads, -1, dim_head)
         value = value.reshape(b * heads, -1, dim_head)
         key = key.reshape(b * heads, -1, dim_head).movedim(1, 2)
     else:
-        query, key, value = _reshape_qkv_to_heads(query, key, value, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        query = query.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
-        value = value.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
-        key = key.permute(0, 2, 3, 1).reshape(b * heads, dim_head, -1)
+        query = query.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
+        value = value.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head)
+        key = key.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 3, 1).reshape(b * heads, dim_head, -1)
 
 
     dtype = query.dtype
@@ -337,15 +304,19 @@ def attention_split(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
     scale = kwargs.get("scale", dim_head ** -0.5)
 
     if skip_reshape:
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
-        q, k, v = map(
+         q, k, v = map(
             lambda t: t.reshape(b * heads, -1, dim_head),
             (q, k, v),
         )
     else:
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
-        q, k, v = map(lambda t: t.permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head).contiguous(), (q, k, v))
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, -1, heads, dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * heads, -1, dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
 
     r1 = torch.zeros(q.shape[0], q.shape[1], v.shape[2], device=q.device, dtype=q.dtype)
 
@@ -467,7 +438,7 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
             disabled_xformers = True
 
     if disabled_xformers:
-        return attention_pytorch(q, k, v, heads, mask, skip_reshape=skip_reshape, skip_output_reshape=skip_output_reshape, **kwargs)
+        return attention_pytorch(q, k, v, heads, mask, skip_reshape=skip_reshape, **kwargs)
 
     if skip_reshape:
         # b h k d -> b k h d
@@ -475,12 +446,13 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
             lambda t: t.permute(0, 2, 1, 3),
             (q, k, v),
         )
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-2], -2)
     # actually do the reshaping
     else:
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
+        q, k, v = map(
+            lambda t: t.reshape(b, -1, heads, dim_head),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a singleton batch dimension
@@ -502,7 +474,7 @@ def attention_xformers(q, k, v, heads, mask=None, attn_precision=None, skip_resh
         mask = mask_out[..., :mask.shape[-1]]
         mask = mask.expand(b, heads, -1, -1)
 
-    out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=mask, scale=kwargs.get("scale", None))
+    out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=mask)
 
     if skip_output_reshape:
         out = out.permute(0, 2, 1, 3)
@@ -526,8 +498,10 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False), expand_kv=False)
-        q, k, v = map(lambda t: t.transpose(1, 2), (q, k, v))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a batch dimension if there isn't already one
@@ -537,7 +511,9 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
         if mask.ndim == 3:
             mask = mask.unsqueeze(1)
 
-    sdpa_keys = ("scale", "enable_gqa")
+    # Pass through extra SDPA kwargs (scale, enable_gqa) if provided
+    # enable_gqa requires PyTorch 2.5+; older versions use manual KV expansion above
+    sdpa_keys = ("scale", "enable_gqa") if TORCH_HAS_GQA else ("scale",)
     sdpa_extra = {k: v for k, v in kwargs.items() if k in sdpa_keys}
 
     if SDP_BATCH_LIMIT >= b:
@@ -565,19 +541,20 @@ def attention_pytorch(q, k, v, heads, mask=None, attn_precision=None, skip_resha
 
 @wrap_attn
 def attention_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=False, skip_output_reshape=False, **kwargs):
-    if kwargs.get("low_precision_attention", True) is False or (mask is not None and not SAGE_ATTENTION_SUPPORTS_MASK):
+    if kwargs.get("low_precision_attention", True) is False:
         return attention_pytorch(q, k, v, heads, mask=mask, skip_reshape=skip_reshape, skip_output_reshape=skip_output_reshape, **kwargs)
 
     exception_fallback = False
     if skip_reshape:
         b, _, _, dim_head = q.shape
         tensor_layout = "HND"
-        if kwargs.get("enable_gqa", False):
-            k, v = _repeat_kv_for_gqa(k, v, q.shape[-3], -3)
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head),
+            (q, k, v),
+        )
         tensor_layout = "NHD"
 
     if mask is not None:
@@ -588,12 +565,8 @@ def attention_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=
         if mask.ndim == 3:
             mask = mask.unsqueeze(1)
 
-    sage_kwargs = {"is_causal": False, "tensor_layout": tensor_layout, "sm_scale": kwargs.get("scale", None), "smooth_k": False}
-    if mask is not None:
-        sage_kwargs["attn_mask"] = mask
-
     try:
-        out = sageattn(q, k, v, **sage_kwargs)
+        out = sageattn(q, k, v, attn_mask=mask, is_causal=False, tensor_layout=tensor_layout)
     except Exception as e:
         logging.error("Error running sage attention: {}, using pytorch attention instead.".format(e))
         exception_fallback = True
@@ -643,6 +616,7 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 skip_output_reshape=skip_output_reshape,
                 **kwargs
             )
+        q_s, k_s, v_s = q, k, v
         N = q.shape[2]
         dim_head = D
     else:
@@ -668,15 +642,11 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 **kwargs
             )
 
-    if skip_reshape:
-        q_s = q
-        if kwargs.get("enable_gqa", False):
-            k_s, v_s = _repeat_kv_for_gqa(k, v, H, -3)
-        else:
-            k_s, v_s = k, v
-    else:
-        q_s, k_s, v_s = _reshape_qkv_to_heads(q, k, v, B, heads, dim_head, kwargs.get("enable_gqa", False))
-        q_s, k_s, v_s = map(lambda t: t.permute(0, 2, 1, 3).contiguous(), (q_s, k_s, v_s))
+    if not skip_reshape:
+        q_s, k_s, v_s = map(
+            lambda t: t.view(B, -1, heads, dim_head).permute(0, 2, 1, 3).contiguous(),
+            (q, k, v),
+        )
         B, H, L, D = q_s.shape
 
     try:
@@ -692,7 +662,7 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
                 q, k, v, heads,
                 mask=mask,
                 attn_precision=attn_precision,
-                skip_reshape=skip_reshape,
+                skip_reshape=False,
                 skip_output_reshape=skip_output_reshape,
                 **kwargs
             )
@@ -711,20 +681,19 @@ def attention3_sage(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
 try:
     @torch.library.custom_op("flash_attention::flash_attn", mutates_args=())
     def flash_attn_wrapper(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-                    dropout_p: float = 0.0, causal: bool = False, softmax_scale: float = -1.0) -> torch.Tensor:
-        softmax_scale_arg = None if softmax_scale == -1.0 else softmax_scale
-        return flash_attn_func(q, k, v, dropout_p=dropout_p, causal=causal, softmax_scale=softmax_scale_arg)
+                    dropout_p: float = 0.0, causal: bool = False) -> torch.Tensor:
+        return flash_attn_func(q, k, v, dropout_p=dropout_p, causal=causal)
 
 
     @flash_attn_wrapper.register_fake
-    def flash_attn_fake(q, k, v, dropout_p=0.0, causal=False, softmax_scale=-1.0):
+    def flash_attn_fake(q, k, v, dropout_p=0.0, causal=False):
         # Output shape is the same as q
         return q.new_empty(q.shape)
 except AttributeError as error:
     FLASH_ATTN_ERROR = error
 
     def flash_attn_wrapper(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor,
-                    dropout_p: float = 0.0, causal: bool = False, softmax_scale: float = -1.0) -> torch.Tensor:
+                    dropout_p: float = 0.0, causal: bool = False) -> torch.Tensor:
         assert False, f"Could not define flash_attn_wrapper: {FLASH_ATTN_ERROR}"
 
 @wrap_attn
@@ -734,8 +703,10 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
     else:
         b, _, dim_head = q.shape
         dim_head //= heads
-        q, k, v = _reshape_qkv_to_heads(q, k, v, b, heads, dim_head, kwargs.get("enable_gqa", False), expand_kv=False)
-        q, k, v = map(lambda t: t.transpose(1, 2), (q, k, v))
+        q, k, v = map(
+            lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
+            (q, k, v),
+        )
 
     if mask is not None:
         # add a batch dimension if there isn't already one
@@ -754,16 +725,10 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
             v.transpose(1, 2),
             dropout_p=0.0,
             causal=False,
-            softmax_scale=kwargs.get("scale", -1.0),
         ).transpose(1, 2)
     except Exception as e:
         logging.warning(f"Flash Attention failed, using default SDPA: {e}")
-        sdpa_extra = {}
-        if kwargs.get("enable_gqa", False):
-            sdpa_extra["enable_gqa"] = True
-        if "scale" in kwargs:
-            sdpa_extra["scale"] = kwargs["scale"]
-        out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False, **sdpa_extra)
+        out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False)
     if not skip_output_reshape:
         out = (
             out.transpose(1, 2).reshape(b, -1, heads * dim_head)
@@ -1244,3 +1209,5 @@ class SpatialVideoTransformer(SpatialTransformer):
             x = self.proj_out(x)
         out = x + x_in
         return out
+
+

comfy/ldm/omnigen/omnigen2.py

@@ -141,8 +141,11 @@ class Attention(nn.Module):
         key = key.transpose(1, 2)
         value = value.transpose(1, 2)
 
-        gqa_kwargs = {"enable_gqa": True} if self.kv_heads < self.heads else {}
-        hidden_states = optimized_attention_masked(query, key, value, self.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options, **gqa_kwargs)
+        if self.kv_heads < self.heads:
+            key = key.repeat_interleave(self.heads // self.kv_heads, dim=1)
+            value = value.repeat_interleave(self.heads // self.kv_heads, dim=1)
+
+        hidden_states = optimized_attention_masked(query, key, value, self.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options)
         hidden_states = self.to_out[0](hidden_states)
         return hidden_states
 

comfy/ops.py

@@ -174,8 +174,6 @@ def cast_modules_with_vbar(comfy_modules, dtype, device, bias_dtype, non_blockin
                     elif xfer_dest2 is not None:
                         xfer_source.prepare(xfer_dest2, stream, copy=True, commit=False)
                         return
-                    else:
-                        return
                 comfy.model_management.cast_to_gathered(xfer_source, xfer_dest, non_blocking=non_blocking, stream=stream, r2=xfer_dest2)
 
         def handle_pin(m, pin, source, dest, subset="weights", size=None):

comfy/sd.py

@@ -468,9 +468,6 @@ class CLIP:
     def decode(self, token_ids, skip_special_tokens=True):
         return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
 
-    def is_dynamic(self):
-        return self.patcher.is_dynamic()
-
 class VAE:
     def __init__(self, sd=None, device=None, config=None, dtype=None, metadata=None):
         if 'decoder.up_blocks.0.resnets.0.norm1.weight' in sd.keys(): #diffusers format
@@ -1254,8 +1251,6 @@ class VAE:
         except:
             return None
 
-    def is_dynamic(self):
-        return self.patcher.is_dynamic()
 
 class StyleModel:
     def __init__(self, model, device="cpu"):

comfy/text_encoders/gpt_oss.py

@@ -12,7 +12,7 @@ import torch.nn.functional as F
 
 import comfy.ops
 from comfy import sd1_clip
-from comfy.ldm.modules.attention import optimized_attention_for_device
+from comfy.ldm.modules.attention import TORCH_HAS_GQA, optimized_attention_for_device
 from comfy.text_encoders.llama import RMSNorm, apply_rope
 
 
@@ -110,6 +110,10 @@ def _attention_with_sinks(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, sin
     putting the sink logit in the mask at that column.
     """
 
+    if num_kv_groups > 1 and not TORCH_HAS_GQA:
+        k = k.repeat_interleave(num_kv_groups, dim=1)
+        v = v.repeat_interleave(num_kv_groups, dim=1)
+
     B, _, S_q, D = q.shape
     H_kv = k.shape[1]
     S_kv = k.shape[-2]

comfy/text_encoders/llama.py

@@ -550,8 +550,10 @@ class Attention(nn.Module):
                 xv = xv[:, :, -sliding_window:]
                 attention_mask = attention_mask[..., -sliding_window:] if attention_mask is not None else None
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
-        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True, **gqa_kwargs)
+        xk = xk.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+        xv = xv.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+
+        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True)
         return self.o_proj(output), present_key_value
 
 class MLP(nn.Module):
@@ -935,41 +937,22 @@ class BaseGenerate:
             return torch.argmax(logits, dim=-1, keepdim=True)
 
         # Sampling mode
-        if len(token_history) > 0 and (repetition_penalty != 1.0 or (presence_penalty is not None and presence_penalty != 0.0)):
-            token_ids = torch.tensor(list(set(token_history)), device=logits.device)
-            token_logits = logits[:, token_ids]
-            if repetition_penalty != 1.0:
-                token_logits = torch.where(token_logits < 0, token_logits * repetition_penalty, token_logits / repetition_penalty)
-            if presence_penalty is not None and presence_penalty != 0.0:
-                token_logits = token_logits - presence_penalty
-            logits[:, token_ids] = token_logits
+        if repetition_penalty != 1.0:
+            for i in range(logits.shape[0]):
+                for token_id in set(token_history):
+                    logits[i, token_id] *= repetition_penalty if logits[i, token_id] < 0 else 1/repetition_penalty
+
+        if presence_penalty is not None and presence_penalty != 0.0:
+            for i in range(logits.shape[0]):
+                for token_id in set(token_history):
+                    logits[i, token_id] -= presence_penalty
 
         if temperature != 1.0:
             logits = logits / temperature
 
         if top_k > 0:
-            top_k = min(top_k, logits.shape[-1])
-            logits, top_indices = torch.topk(logits, top_k)
-
-            if min_p > 0.0:
-                probs_before_filter = torch.nn.functional.softmax(logits, dim=-1)
-                top_probs, _ = probs_before_filter.max(dim=-1, keepdim=True)
-                min_threshold = min_p * top_probs
-                indices_to_remove = probs_before_filter < min_threshold
-                logits[indices_to_remove] = torch.finfo(logits.dtype).min
-
-            if top_p < 1.0:
-                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
-                cumulative_probs = torch.cumsum(torch.nn.functional.softmax(sorted_logits, dim=-1), dim=-1)
-                sorted_indices_to_remove = cumulative_probs > top_p
-                sorted_indices_to_remove[..., 0] = False
-                indices_to_remove = torch.zeros_like(logits, dtype=torch.bool)
-                indices_to_remove.scatter_(1, sorted_indices, sorted_indices_to_remove)
-                logits[indices_to_remove] = torch.finfo(logits.dtype).min
-
-            probs = torch.nn.functional.softmax(logits, dim=-1)
-            next_token = torch.multinomial(probs, num_samples=1, generator=generator)
-            return top_indices.gather(1, next_token)
+            indices_to_remove = logits < torch.topk(logits, top_k)[0][..., -1, None]
+            logits[indices_to_remove] = torch.finfo(logits.dtype).min
 
         if min_p > 0.0:
             probs_before_filter = torch.nn.functional.softmax(logits, dim=-1)

comfy/text_encoders/qwen35.py

@@ -366,8 +366,12 @@ class GatedAttention(nn.Module):
                     xv = torch.cat((past_value[:, :, :index], xv), dim=2)
                 present_key_value = (xk, xv, index + num_tokens)
 
-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
-        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True, **gqa_kwargs)
+        # Expand KV heads for GQA
+        if self.num_heads != self.num_kv_heads:
+            xk = xk.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+            xv = xv.repeat_interleave(self.num_heads // self.num_kv_heads, dim=1)
+
+        output = optimized_attention(xq, xk, xv, self.num_heads, mask=attention_mask, skip_reshape=True)
         output = output * gate.sigmoid()
 
         return self.o_proj(output), present_key_value

comfy_api/latest/_input_impl/video_types.py

@@ -1,6 +1,5 @@
 from av.container import InputContainer
 from av.subtitles.stream import SubtitleStream
-from av.video.reformatter import ColorRange
 from fractions import Fraction
 from typing import Optional
 from .._input import AudioInput, VideoInput
@@ -10,7 +9,6 @@ import itertools
 import json
 import numpy as np
 import math
-import os
 import torch
 from .._util import VideoContainer, VideoCodec, VideoComponents
 import logging
@@ -60,57 +58,6 @@ def video_stream_bit_depth(stream) -> int:
     return max(component.bits for component in stream.format.components)
 
 
-def last_decodable_audio_stream(container: InputContainer):
-    """Streams FFmpeg has no decoder for have no codec context, and decoding their
-    packets crashes the process (e.g. APAC spatial-audio track in iPhone)."""
-    stream = next(
-        (s for s in reversed(container.streams.audio) if s.codec_context is not None),
-        None,
-    )
-    if stream is None and len(container.streams.audio):
-        logging.warning("No decodable audio stream found in video; ignoring audio.")
-    return stream
-
-
-def probe_audio_params(container: InputContainer, audio_stream, max_packets: int = 200):
-    """Containers probed only up to a window (mpegts) leave audio codec parameters unset when
-    audio starts beyond it; learn them by decoding ahead. The caller must seek back afterwards.
-    Returns (sample_rate, channels), zeros when the stream never yields a decodable frame."""
-    for i, packet in enumerate(container.demux(audio_stream)):
-        try:
-            frames = packet.decode()
-        except av.error.FFmpegError:
-            return 0, 0
-        if frames:
-            return frames[0].sample_rate, frames[0].layout.nb_channels
-        if i >= max_packets:
-            break
-    return 0, 0
-
-
-def write_output_metadata(container: InputContainer, output, metadata: dict | None):
-    """Copy the source container's metadata, then overlay the caller's tags."""
-    for key, value in container.metadata.items():
-        if metadata is None or key not in metadata:
-            output.metadata[key] = value
-    if metadata is not None:
-        for key, value in metadata.items():
-            output.metadata[key] = value if isinstance(value, str) else json.dumps(value)
-
-
-def mp4_output_open_kwargs(path: str | io.BytesIO, format: VideoContainer, codec: VideoCodec) -> dict:
-    if format != VideoContainer.AUTO and format != VideoContainer.MP4:
-        raise ValueError("Only MP4 format is supported for now")
-    if codec != VideoCodec.AUTO and codec != VideoCodec.H264:
-        raise ValueError("Only H264 codec is supported for now")
-    open_kwargs = {"mode": "w", "options": {"movflags": "use_metadata_tags"}}
-    if isinstance(format, VideoContainer) and format != VideoContainer.AUTO:
-        open_kwargs["format"] = format.value
-    elif isinstance(path, io.BytesIO):
-        open_kwargs["format"] = "mp4"  # no file extension to infer the format from
-    return open_kwargs
-
-
 class VideoFromFile(VideoInput):
     """
     Class representing video input from a file.
@@ -245,10 +192,13 @@ class VideoFromFile(VideoInput):
                     return estimated_frames
 
             # 3. Last resort: decode frames and count them (streaming)
-            start_time, duration = self.get_active_trim_window()
+            if self.__start_time < 0:
+                start_time = max(self._get_raw_duration() + self.__start_time, 0)
+            else:
+                start_time = self.__start_time
             frame_count = 1
             start_pts = int(start_time / video_stream.time_base)
-            end_pts = int((start_time + duration) / video_stream.time_base)
+            end_pts = int((start_time + self.__duration) / video_stream.time_base)
             container.seek(start_pts, stream=video_stream)
             frame_iterator = (
                 container.decode(video_stream)
@@ -303,14 +253,17 @@ class VideoFromFile(VideoInput):
 
     def get_components_internal(self, container: InputContainer) -> VideoComponents:
         video_stream = self._get_first_video_stream(container)
-        start_time, duration = self.get_active_trim_window()
+        if self.__start_time < 0:
+            start_time = max(self._get_raw_duration() + self.__start_time, 0)
+        else:
+            start_time = self.__start_time
 
         # Get video frames
         frames = []
         audio_frames = []
         alphas = None
         start_pts = int(start_time / video_stream.time_base)
-        end_pts = int((start_time + duration) / video_stream.time_base)
+        end_pts = int((start_time + self.__duration) / video_stream.time_base)
 
         if start_pts != 0:
             container.seek(start_pts, stream=video_stream)
@@ -328,8 +281,8 @@ class VideoFromFile(VideoInput):
         video_done = False
         audio_done = True
 
-        audio_stream = last_decodable_audio_stream(container)
-        if audio_stream is not None:
+        if len(container.streams.audio):
+            audio_stream = container.streams.audio[-1]
             streams += [audio_stream]
             resampler = av.audio.resampler.AudioResampler(format='fltp')
             audio_done = False
@@ -345,7 +298,7 @@ class VideoFromFile(VideoInput):
                     for frame in packet.decode():
                         if frame.pts < start_pts:
                             continue
-                        if duration and frame.pts >= end_pts:
+                        if self.__duration and frame.pts >= end_pts:
                             video_done = True
                             break
 
@@ -412,7 +365,7 @@ class VideoFromFile(VideoInput):
                     map(resampler.resample, packet.decode())
                 )
                 for frame in aframes:
-                    if duration and frame.time > start_time + duration:
+                    if self.__duration and frame.time > start_time + self.__duration:
                         audio_done = True
                         break
 
@@ -434,8 +387,8 @@ class VideoFromFile(VideoInput):
 
         if len(audio_frames) > 0:
             audio_data = np.concatenate(audio_frames, axis=1)  # shape: (channels, total_samples)
-            if duration:
-                audio_data = audio_data[..., :int(duration * audio_stream.sample_rate)]
+            if self.__duration:
+                audio_data = audio_data[..., :int(self.__duration * audio_stream.sample_rate)]
 
             audio_tensor = torch.from_numpy(audio_data).unsqueeze(0)  # shape: (1, channels, total_samples)
             audio = AudioInput({
@@ -481,22 +434,33 @@ class VideoFromFile(VideoInput):
             if not reuse_streams:
                 if bit_depth is None:
                     bit_depth = source_bit_depth
-                return self._save_transcoded(container, path, format=format, codec=codec, metadata=metadata, bit_depth=bit_depth)
+                components = self.get_components_internal(container)
+                video = VideoFromComponents(components)
+                return video.save_to(
+                    path, format=format, codec=codec, metadata=metadata, bit_depth=bit_depth,
+                )
 
             streams = container.streams
 
             open_kwargs = get_open_write_kwargs(path, container_format, format)
             with av.open(path, **open_kwargs) as output_container:
-                # Add metadata before writing any streams
-                write_output_metadata(container, output_container, metadata)
+                # Copy over the original metadata
+                for key, value in container.metadata.items():
+                    if metadata is None or key not in metadata:
+                        output_container.metadata[key] = value
 
-                # Add streams to the new container. Streams with no codec context cannot be used as an output template.
+                # Add our new metadata
+                if metadata is not None:
+                    for key, value in metadata.items():
+                        if isinstance(value, str):
+                            output_container.metadata[key] = value
+                        else:
+                            output_container.metadata[key] = json.dumps(value)
+
+                # Add streams to the new container
                 stream_map = {}
                 for stream in streams:
                     if isinstance(stream, (av.VideoStream, av.AudioStream, SubtitleStream)):
-                        if stream.codec_context is None:
-                            logging.warning("Skipping %s stream %d with unsupported codec", stream.type, stream.index)
-                            continue
                         out_stream = output_container.add_stream_from_template(template=stream, opaque=True)
                         stream_map[stream] = out_stream
 
@@ -506,254 +470,6 @@ class VideoFromFile(VideoInput):
                         packet.stream = stream_map[packet.stream]
                         output_container.mux(packet)
 
-    def _save_transcoded(
-        self,
-        container: InputContainer,
-        path: str | io.BytesIO,
-        format: VideoContainer,
-        codec: VideoCodec,
-        metadata: dict | None,
-        bit_depth: int,
-    ):
-        """Re-encode to H.264/AAC one frame at a time; peak memory does not scale with video length."""
-        open_kwargs = mp4_output_open_kwargs(path, format, codec)
-        video_stream = self._get_first_video_stream(container)
-        start_time, duration = self.get_active_trim_window()
-        start_pts = int(start_time / video_stream.time_base)
-        end_pts = int((start_time + duration) / video_stream.time_base) if duration else None
-        if start_pts != 0:
-            container.seek(start_pts, stream=video_stream)
-
-        audio_stream = last_decodable_audio_stream(container)
-        pix_fmt = "yuv420p10le" if bit_depth >= 10 else "yuv420p"
-        rate = Fraction(video_stream.average_rate) if video_stream.average_rate else Fraction(1)
-
-        resampler = None
-        sample_rate = 0
-        audio_time_base = None
-        duration_cap = None
-        if audio_stream is not None:
-            sample_rate = audio_stream.codec_context.sample_rate
-            channels = audio_stream.codec_context.channels
-            if not sample_rate:
-                sample_rate, channels = probe_audio_params(container, audio_stream)
-                container.seek(start_pts, stream=video_stream)
-                if sample_rate:
-                    audio_stream.codec_context.flush_buffers()
-                else:
-                    logging.warning("Audio stream parameters could not be determined; ignoring audio.")
-                    audio_stream = None
-        if audio_stream is not None:
-            audio_time_base = Fraction(1, sample_rate)
-            layout = {1: "mono", 2: "stereo", 6: "5.1"}.get(channels, "stereo")
-            resampler = av.audio.resampler.AudioResampler(format="fltp", layout=layout, rate=sample_rate)
-            if duration:
-                duration_cap = math.ceil(duration * sample_rate)
-
-        streams = [video_stream] if audio_stream is None else [video_stream, audio_stream]
-        pts_step = max(1, int(round((1 / rate) / video_stream.time_base)))
-        video_done = False
-        audio_done = audio_stream is None
-        video_pts_offset = None
-        last_video_pts = None
-        last_video_end = None
-        # rebased pts -> true display duration: the mp4 muxer pads the last sample with 1/rate otherwise
-        video_frame_durations = {}
-        source_size = None
-        rotation_k = 0
-        rotation_filter = None
-        audio_started = False
-        samples_written = 0
-        pending_audio = []
-        # The output opens lazily on the first kept frame: it decides the geometry (90/270 rotation swaps dims),
-        # and never seeking back keeps webm/mkv leading audio intact.
-        output = None
-        out_video = None
-        out_audio = None
-
-        def audio_frame_from_ndarray(nd_planar):
-            frame = av.AudioFrame.from_ndarray(np.ascontiguousarray(nd_planar), format="fltp", layout=layout)
-            frame.sample_rate = sample_rate
-            return frame
-
-        def drain_audio(final=False):
-            # Audio may cover the pts span of the video written so far, capped by the requested duration
-            nonlocal samples_written, audio_done
-            if last_video_end is None:
-                cap = 0
-            else:
-                cap = math.ceil(last_video_end * video_stream.time_base * sample_rate)
-            if duration_cap is not None:
-                cap = min(cap, duration_cap)
-            while pending_audio and not audio_done:
-                frame = pending_audio[0]
-                if samples_written + frame.samples <= cap:
-                    frame.pts = samples_written
-                    frame.time_base = audio_time_base
-                    output.mux(out_audio.encode(frame))
-                    samples_written += frame.samples
-                    pending_audio.pop(0)
-                    continue
-                if final:
-                    keep = frame.to_ndarray()[..., :cap - samples_written]
-                    if keep.shape[-1] > 0:
-                        tail = audio_frame_from_ndarray(keep)
-                        tail.pts = samples_written
-                        tail.time_base = audio_time_base
-                        output.mux(out_audio.encode(tail))
-                        samples_written += keep.shape[-1]
-                    pending_audio.clear()
-                break
-            if duration_cap is not None and samples_written >= duration_cap:
-                audio_done = True
-            return cap
-
-        try:
-            for packet in container.demux(*streams):
-                if video_done and audio_done:
-                    break
-
-                if packet.stream == video_stream and not video_done:
-                    try:
-                        frames = packet.decode()
-                    except av.error.InvalidDataError:
-                        logging.info("pyav decode error")
-                        continue
-                    for frame in frames:
-                        if frame.pts is not None and frame.pts < start_pts:
-                            continue
-                        if end_pts is not None and frame.pts is not None and frame.pts >= end_pts:
-                            video_done = True
-                            if last_video_pts is not None:
-                                # the source continues past the window: hold the last kept frame to the window end
-                                last_video_end = max(last_video_end, end_pts - video_pts_offset)
-                            break
-                        # the source's true display duration of this frame; average_rate is not a
-                        # frame duration (sparse/VFR sources), so it is only the fallback
-                        frame_duration = frame.duration if frame.duration else pts_step
-                        if end_pts is not None and frame.pts is not None:
-                            frame_duration = min(frame_duration, end_pts - frame.pts)
-                        if output is None:
-                            rotation_k = int(round(frame.rotation // 90)) % 4 if frame.rotation else 0
-                            if rotation_k % 2:
-                                out_width, out_height = frame.height, frame.width
-                            else:
-                                out_width, out_height = frame.width, frame.height
-                            if out_width % 2 or out_height % 2:
-                                raise ValueError(f"H.264 output requires even dimensions, got {out_width}x{out_height}")
-                            source_size = (frame.width, frame.height)
-                            output = av.open(path, **open_kwargs)
-                            # Add metadata before writing any streams
-                            write_output_metadata(container, output, metadata)
-                            out_video = output.add_stream("h264", rate=rate)
-                            # no B-frames: reordering makes mp4 sample durations follow decode order,
-                            # so irregular-VFR spans and trim windows land wrong
-                            out_video.codec_context.max_b_frames = 0
-                            out_video.width = out_width
-                            out_video.height = out_height
-                            out_video.pix_fmt = pix_fmt
-                            # source pts pass through (rebased to 0), so variable frame rate survives
-                            out_video.codec_context.time_base = video_stream.time_base
-                            if audio_stream is not None:
-                                out_audio = output.add_stream("aac", rate=sample_rate, layout=layout)
-                        if (frame.width, frame.height) != source_size:
-                            # encoding would silently rescale the new geometry into the old one
-                            raise ValueError(
-                                f"Video resolution changes mid-stream "
-                                f"({source_size[0]}x{source_size[1]} -> {frame.width}x{frame.height}); cannot transcode"
-                            )
-                        if rotation_k:
-                            if rotation_filter is None:
-                                g = av.filter.Graph()
-                                g_src = g.add_buffer(width=frame.width, height=frame.height,
-                                                     format=frame.format.name, time_base=video_stream.time_base)
-                                tail = g_src
-                                for filter_name, filter_args in {1: [("transpose", "cclock")],
-                                                                 2: [("hflip", None), ("vflip", None)],
-                                                                 3: [("transpose", "clock")]}[rotation_k]:
-                                    step = g.add(filter_name, filter_args)
-                                    tail.link_to(step)
-                                    tail = step
-                                g_sink = g.add("buffersink")
-                                tail.link_to(g_sink)
-                                g.configure()
-                                rotation_filter = (g_src, g_sink)
-                            rotation_filter[0].push(frame)
-                            frame = rotation_filter[1].pull()
-                        if frame.color_range == ColorRange.JPEG:
-                            # compress full-range sources (yuvj/MJPEG) to limited range
-                            frame = frame.reformat(format=pix_fmt, src_color_range="JPEG", dst_color_range="MPEG")
-                        else:
-                            frame = frame.reformat(format=pix_fmt)
-                        if frame.pts is not None:
-                            if video_pts_offset is None:
-                                video_pts_offset = frame.pts
-                            frame.pts -= video_pts_offset
-                        if frame.pts is None or (last_video_pts is not None and frame.pts <= last_video_pts):
-                            # broken sources emit missing/backward timestamps mid-stream, which the
-                            # muxer rejects; nudge them forward by one nominal frame interval
-                            frame.pts = 0 if last_video_pts is None else last_video_pts + pts_step
-                        last_video_pts = frame.pts
-                        last_video_end = frame.pts + frame_duration
-                        video_frame_durations[frame.pts] = frame_duration
-                        # the decoded pict_type would force x264's frame types (intra-only
-                        # sources like MJPEG/ProRes would come out all-keyframe)
-                        frame.pict_type = 0
-                        for out_packet in out_video.encode(frame):
-                            out_packet.duration = video_frame_durations.pop(out_packet.pts, 0)
-                            output.mux(out_packet)
-                        drain_audio()
-
-                elif packet.stream == audio_stream and not audio_done:
-                    for resampled in itertools.chain.from_iterable(map(resampler.resample, packet.decode())):
-                        if not audio_started:
-                            if resampled.pts is None:
-                                frame_start = 0.0
-                            else:
-                                # passthrough frames keep the source stream's time base
-                                tb = resampled.time_base if resampled.time_base else audio_time_base
-                                frame_start = float(resampled.pts * tb)
-                            to_skip = max(0, int((start_time - frame_start) * sample_rate))
-                            if to_skip >= resampled.samples:
-                                continue
-                            audio_started = True
-                            if to_skip:
-                                pending_audio.append(audio_frame_from_ndarray(resampled.to_ndarray()[..., to_skip:]))
-                                continue
-                        pending_audio.append(resampled)
-                        if video_done:
-                            # the video window is complete so the cap is final, but containers
-                            # that interleave audio behind video (fragmented mp4) still owe most
-                            # of it: stop only once the demuxed audio covers the cap
-                            cap = drain_audio()
-                            if pending_audio or samples_written >= cap:
-                                drain_audio(final=True)
-                                audio_done = True
-                                break
-
-            if output is None:
-                raise ValueError(f"No decodable video frames found in file '{self.__file}'")
-            if out_audio is not None and not audio_done:
-                drain_audio(final=True)
-            window_fill = last_video_end - last_video_pts if video_done and last_video_pts is not None else 0
-            for out_packet in out_video.encode(None):
-                duration = video_frame_durations.pop(out_packet.pts, 0)
-                if out_packet.pts == last_video_pts:
-                    duration = max(duration, window_fill)
-                out_packet.duration = duration
-                output.mux(out_packet)
-            if out_audio is not None:
-                output.mux(out_audio.encode(None))
-        except BaseException:
-            if output is not None:
-                output.close()
-                if isinstance(path, (str, os.PathLike)) and os.path.exists(path):
-                    os.remove(path)
-            raise
-        else:
-            if output is not None:
-                output.close()
-
     def _get_first_video_stream(self, container: InputContainer):
         if len(container.streams.video):
             return container.streams.video[0]
@@ -801,12 +517,22 @@ class VideoFromComponents(VideoInput):
         bit_depth: int | None = None,
     ):
         """Save the video to a file path or BytesIO buffer."""
-        open_kwargs = mp4_output_open_kwargs(path, format, codec)
+        if format != VideoContainer.AUTO and format != VideoContainer.MP4:
+            raise ValueError("Only MP4 format is supported for now")
+        if codec != VideoCodec.AUTO and codec != VideoCodec.H264:
+            raise ValueError("Only H264 codec is supported for now")
         # None means "use the depth this video was created with" (CreateVideo's choice).
         if bit_depth is None:
             bit_depth = self.__bit_depth
         is_10bit = bit_depth >= 10
-        with av.open(path, **open_kwargs) as output:
+        extra_kwargs = {}
+        if isinstance(format, VideoContainer) and format != VideoContainer.AUTO:
+            extra_kwargs["format"] = format.value
+        elif isinstance(path, io.BytesIO):
+            # BytesIO has no file extension, so av.open can't infer the format.
+            # Default to mp4 since that's the only supported format anyway.
+            extra_kwargs["format"] = "mp4"
+        with av.open(path, mode='w', options={'movflags': 'use_metadata_tags'}, **extra_kwargs) as output:
             # Add metadata before writing any streams
             if metadata is not None:
                 for key, value in metadata.items():

comfy_api/latest/_io.py

@@ -1261,6 +1261,155 @@ class DynamicSlot(ComfyTypeI):
             out_dict[input_type][finalized_id] = value
             out_dict["dynamic_paths"][finalized_id] = finalize_prefix(curr_prefix, curr_prefix[-1])
 
+@comfytype(io_type="COMFY_DYNAMICGROUP_V3")
+class DynamicGroup(ComfyTypeI):
+    """A repeatable group of widget inputs (e.g. lora_name + strength stacked into N rows).
+
+    At execution time the node receives a ``list[dict]`` where each element is a row.
+
+    Example::
+
+        io.DynamicGroup.Input(
+            "loras",
+            template=[
+                io.Combo.Input("lora_name", options=folder_paths.get_filename_list("loras")),
+                io.Float.Input("strength", default=1.0, min=-100, max=100, step=0.01),
+            ],
+            min=0,
+            max=50,
+        )
+        # execute receives: loras: list[dict] = [{"lora_name": "x.safetensors", "strength": 1.0}, ...]
+    """
+
+    Type = list[dict[str, Any]]
+    _MaxRows = 100
+
+    class Input(DynamicInput):
+        def __init__(
+            self,
+            id: str,
+            template: list["Input"],
+            min: int = 0,
+            max: int = 50,
+            display_name: str = None,
+            optional: bool = False,
+            tooltip: str = None,
+            lazy: bool = None,
+            extra_dict=None,
+            group_name: str = "Group",
+        ):
+            super().__init__(id, display_name, optional, tooltip, lazy, extra_dict)
+            assert len(template) > 0, "DynamicGroup template must have at least one field."
+            for t in template:
+                assert isinstance(t, WidgetInput), (
+                    f"DynamicGroup template field '{t.id}' must be a WidgetInput subclass "
+                    f"(Combo, Float, Int, String, Boolean, Color). Got {type(t).__name__}."
+                )
+                assert not isinstance(t, DynamicInput), (
+                    f"DynamicGroup template field '{t.id}' must not be a DynamicInput. "
+                    "Nesting dynamic inputs inside DynamicGroup is not supported."
+                )
+            field_ids = [t.id for t in template]
+            assert len(field_ids) == len(set(field_ids)), (
+                f"DynamicGroup template field ids must be unique within a row. Got: {field_ids}"
+            )
+            # Reject "." in group id and template field ids: slot_id encoding uses "." as a
+            # delimiter (<group_id>.<row>.<field_id>), so any "." in these names would cause
+            # path.split(".") to produce the wrong number of segments during decoding.
+            assert "." not in id, (
+                f"DynamicGroup id must not contain '.'. Got: '{id}'"
+            )
+            for t in template:
+                assert "." not in t.id, (
+                    f"DynamicGroup template field id must not contain '.'. Got: '{t.id}'"
+                )
+            assert min >= 0, "DynamicGroup min must be >= 0."
+            assert max >= 1, "DynamicGroup max must be >= 1."
+            assert max <= DynamicGroup._MaxRows, f"DynamicGroup max must be <= {DynamicGroup._MaxRows}."
+            assert min <= max, "DynamicGroup min must be <= max."
+            self.template = template
+            self.min = min
+            self.max = max
+            self.group_name = group_name
+
+        def get_all(self) -> list["Input"]:
+            return [self] + list(self.template)
+
+        def as_dict(self):
+            return super().as_dict() | prune_dict({
+                "template": create_input_dict_v1(self.template),
+                "min": self.min,
+                "max": self.max,
+                "group_name": self.group_name,
+            })
+
+        def validate(self):
+            for t in self.template:
+                t.validate()
+
+    @staticmethod
+    def _expand_schema_for_dynamic(
+        out_dict: dict[str, Any],
+        live_inputs: dict[str, Any],
+        value: tuple[str, dict[str, Any]],
+        input_type: str,
+        curr_prefix: list[str] | None,
+    ):
+        info = value[1]
+        min_rows: int = info.get("min", 0)
+        max_rows: int = info.get("max", DynamicGroup._MaxRows)
+        template: dict[str, Any] = info.get("template", {})
+
+        # Collect all template field specs across required/optional sections
+        field_specs: list[tuple[str, tuple[str, dict[str, Any]], bool]] = []
+        for field_required_key in ("required", "optional"):
+            section = template.get(field_required_key, {})
+            is_required_field = field_required_key == "required"
+            for field_id, field_value in section.items():
+                field_specs.append((field_id, field_value, is_required_field))
+
+        # Determine how many rows are currently present by scanning live_inputs
+        finalized_prefix = finalize_prefix(curr_prefix)
+        present_rows = 0
+        for live_key in live_inputs:
+            # Keys look like "<prefix>.<row>.<field_id>"
+            if live_key.startswith(finalized_prefix + "."):
+                remainder = live_key[len(finalized_prefix) + 1:]
+                parts = remainder.split(".", 1)
+                if len(parts) >= 1:
+                    try:
+                        row_idx = int(parts[0])
+                        present_rows = max(present_rows, row_idx + 1)
+                    except ValueError:
+                        pass
+
+        if present_rows > max_rows:
+            raise ValueError(
+                f"DynamicGroup input '{finalized_prefix}' received {present_rows} rows but max is {max_rows}."
+            )
+        row_count = max(min_rows, present_rows)
+
+        for row in range(row_count):
+            for field_id, field_value, is_required_field in field_specs:
+                slot_id = f"{finalized_prefix}.{row}.{field_id}"
+                if row < min_rows and is_required_field:
+                    out_dict["required"][slot_id] = field_value
+                else:
+                    out_dict["optional"][slot_id] = field_value
+                # Register into dynamic_paths so build_nested_inputs places value at the right path
+                out_dict["dynamic_paths"][slot_id] = slot_id
+
+        # Track the list root path so build_nested_inputs can convert the index dict to a list
+        out_dict.setdefault("list_paths", set()).add(finalized_prefix)
+
+        # Handle the empty case (0 rows) – emit an empty-list default for the parent.
+        # This must only fire when there are genuinely no rows; otherwise the parent
+        # path would clobber the per-row dict built from the slot ids above.
+        if row_count == 0:
+            out_dict["dynamic_paths"][finalized_prefix] = finalized_prefix
+            out_dict["dynamic_paths_default_value"][finalized_prefix] = DynamicPathsDefaultValue.EMPTY_LIST
+
+
 @comfytype(io_type="IMAGECOMPARE")
 class ImageCompare(ComfyTypeI):
   Type = dict
@@ -1418,6 +1567,8 @@ def setup_dynamic_input_funcs():
     register_dynamic_input_func(DynamicCombo.io_type, DynamicCombo._expand_schema_for_dynamic)
     # DynamicSlot.Input
     register_dynamic_input_func(DynamicSlot.io_type, DynamicSlot._expand_schema_for_dynamic)
+    # DynamicGroup.Input
+    register_dynamic_input_func(DynamicGroup.io_type, DynamicGroup._expand_schema_for_dynamic)
 
 if len(DYNAMIC_INPUT_LOOKUP) == 0:
     setup_dynamic_input_funcs()
@@ -1429,6 +1580,8 @@ class V3Data(TypedDict):
     'Dictionary where the keys are the input ids and the values dictate how to turn the inputs into a nested dictionary.'
     dynamic_paths_default_value: dict[str, Any]
     'Dictionary where the keys are the input ids and the values are a string from DynamicPathsDefaultValue for the inputs if value is None.'
+    list_paths: set[str]
+    'Set of top-level keys whose index-keyed dict values should be converted to a sorted list[dict] after build_nested_inputs runs.'
     create_dynamic_tuple: bool
     'When True, the value of the dynamic input will be in the format (value, path_key).'
 
@@ -1770,6 +1923,7 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
         "optional": {},
         "dynamic_paths": {},
         "dynamic_paths_default_value": {},
+        "list_paths": set(),
     }
     d = d.copy()
     # ignore hidden for parsing
@@ -1785,6 +1939,10 @@ def get_finalized_class_inputs(d: dict[str, Any], live_inputs: dict[str, Any], i
     dynamic_paths_default_value = out_dict.pop("dynamic_paths_default_value", None)
     if dynamic_paths_default_value is not None and len(dynamic_paths_default_value) > 0:
         v3_data["dynamic_paths_default_value"] = dynamic_paths_default_value
+    # list_paths: keys whose nested dict should be post-converted to a sorted list[dict]
+    list_paths = out_dict.pop("list_paths", None)
+    if list_paths:
+        v3_data["list_paths"] = list_paths
     return out_dict, hidden, v3_data
 
 def parse_class_inputs(out_dict: dict[str, Any], live_inputs: dict[str, Any], curr_dict: dict[str, Any], curr_prefix: list[str] | None=None) -> None:
@@ -1820,10 +1978,12 @@ def add_to_dict_v1(i: Input, d: dict):
 
 class DynamicPathsDefaultValue:
     EMPTY_DICT = "empty_dict"
+    EMPTY_LIST = "empty_list"
 
 def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
     paths = v3_data.get("dynamic_paths", None)
     default_value_dict = v3_data.get("dynamic_paths_default_value", {})
+    list_paths: set[str] = v3_data.get("list_paths", set()) or set()
     if paths is None:
         return values
     values = values.copy()
@@ -1846,6 +2006,8 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                     default_option = default_value_dict.get(key, None)
                     if default_option == DynamicPathsDefaultValue.EMPTY_DICT:
                         value = {}
+                    elif default_option == DynamicPathsDefaultValue.EMPTY_LIST:
+                        value = []
                 if create_tuple:
                     value = (value, key)
                 current[p] = value
@@ -1853,6 +2015,34 @@ def build_nested_inputs(values: dict[str, Any], v3_data: V3Data):
                 current = current.setdefault(p, {})
 
     values.update(result)
+
+    # Post-pass: convert index-keyed dicts to sorted lists for io.DynamicGroup fields
+    for list_path in list_paths:
+        parts = list_path.split(".")
+        # Navigate to the parent container, then convert the leaf
+        container = values
+        for part in parts[:-1]:
+            if not isinstance(container, dict) or part not in container:
+                container = None
+                break
+            container = container[part]
+        if container is None:
+            continue
+        leaf_key = parts[-1]
+        leaf = container.get(leaf_key, None)
+        if isinstance(leaf, dict):
+            try:
+                sorted_rows = [leaf[k] for k in sorted(leaf.keys(), key=int)]
+                container[leaf_key] = sorted_rows
+            except (ValueError, TypeError):
+                # Keys are not all integers; leave as-is
+                pass
+        elif isinstance(leaf, list):
+            # Already a list (e.g. the EMPTY_LIST default was applied above)
+            pass
+        elif leaf is None:
+            container[leaf_key] = []
+
     return values
 
 
@@ -2417,7 +2607,9 @@ __all__ = [
     # Dynamic Types
     "MatchType",
     "DynamicCombo",
+    "DynamicSlot",
     "Autogrow",
+    "DynamicGroup",
     # Other classes
     "HiddenHolder",
     "Hidden",

comfy_api_nodes/util/request_logger.py

@@ -9,7 +9,6 @@ from typing import Any
 import folder_paths
 
 logger = logging.getLogger(__name__)
-_SENSITIVE_HEADERS = {"authorization", "x-api-key"}
 
 
 def get_log_directory():
@@ -74,10 +73,6 @@ def _format_data_for_logging(data: Any) -> str:
     return str(data)
 
 
-def _redact_headers(headers: dict) -> dict:
-    return {k: ("***" if k.lower() in _SENSITIVE_HEADERS else v) for k, v in headers.items()}
-
-
 def log_request_response(
     operation_id: str,
     request_method: str,
@@ -106,7 +101,7 @@ def log_request_response(
         log_content.append(f"Method: {request_method}")
         log_content.append(f"URL: {request_url}")
         if request_headers:
-            log_content.append(f"Headers:\n{_format_data_for_logging(_redact_headers(request_headers))}")
+            log_content.append(f"Headers:\n{_format_data_for_logging(request_headers)}")
         if request_params:
             log_content.append(f"Params:\n{_format_data_for_logging(request_params)}")
         if request_data is not None:

comfy_api_nodes/util/upload_helpers.py

@@ -158,14 +158,7 @@ async def upload_video_to_comfyapi(
 
     # Convert VideoInput to BytesIO using specified container/codec
     video_bytes_io = BytesIO()
-    try:
-        video.save_to(video_bytes_io, format=container, codec=codec)
-    except Exception as e:
-        raise ValueError(
-            f"Could not convert the input video to {container.value.upper()} for upload; "
-            f"the file may be corrupted or use an unsupported codec. "
-            f"Try re-exporting it as MP4 (H.264). Original error: {e}"
-        ) from e
+    video.save_to(video_bytes_io, format=container, codec=codec)
     video_bytes_io.seek(0)
 
     return await upload_file_to_comfyapi(cls, video_bytes_io, filename, upload_mime_type, wait_label)

comfy_execution/caching.py

@@ -503,21 +503,6 @@ RAM_CACHE_DEFAULT_RAM_USAGE = 0.05
 
 RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER = 1.3
 
-
-def all_outputs_dynamic(outputs):
-    if outputs is None:
-        return False
-
-    for output in outputs:
-        if isinstance(output, (list, tuple)):
-            if not all_outputs_dynamic(output):
-                return False
-        elif not hasattr(output, "is_dynamic") or not output.is_dynamic():
-            return False
-
-    return True
-
-
 class RAMPressureCache(LRUCache):
 
     def __init__(self, key_class, enable_providers=False):
@@ -548,11 +533,7 @@ class RAMPressureCache(LRUCache):
         for key, cache_entry in self.cache.items():
             if not free_active and self.used_generation[key] == self.generation:
                 continue
-
-            if all_outputs_dynamic(cache_entry.outputs) and self.used_generation[key] == self.generation:
-                continue
-
-            oom_score = RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
+            oom_score =  RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
 
             ram_usage = RAM_CACHE_DEFAULT_RAM_USAGE
             def scan_list_for_ram_usage(outputs):

comfy_extras/nodes_color.py

@@ -16,30 +16,23 @@ class ColorToRGBInt(io.ComfyNode):
             ],
             outputs=[
                 io.Int.Output(display_name="rgb_int"),
-                io.Color.Output(display_name="hex"),
-                io.Float.Output(display_name="alpha"),
+                io.Color.Output(display_name="hex")
             ],
         )
 
     @classmethod
     def execute(cls, color: str) -> io.NodeOutput:
-        # expect format #RRGGBB or #RRGGBBAA
-        if len(color) not in (7, 9) or color[0] != "#":
-            raise ValueError("Color must be in format #RRGGBB or #RRGGBBAA")
+        # expect format #RRGGBB
+        if len(color) != 7 or color[0] != "#":
+            raise ValueError("Color must be in format #RRGGBB")
         try:
             int(color[1:], 16)
         except ValueError:
-            raise ValueError("Color must be in format #RRGGBB or #RRGGBBAA") from None
-
-        alpha = 1.0
-        if len(color) == 9:
-            alpha = int(color[7:9], 16) / 255.0
-            color = color[:7]
-
+            raise ValueError("Color must be in format #RRGGBB") from None
         r, g, b = hex_to_rgb(color)
 
         rgb_int = r * 256 * 256 + g * 256 + b
-        return io.NodeOutput(rgb_int, color, alpha)
+        return io.NodeOutput(rgb_int, color)
 
 
 class ColorExtension(ComfyExtension):

comfy_extras/nodes_lora_stack.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+import comfy.sd
+import comfy.utils
+import folder_paths
+from comfy_api.latest import ComfyExtension, io
+
+
+def _load_lora_file(lora_name: str):
+    lora_path = folder_paths.get_full_path_or_raise("loras", lora_name)
+    return comfy.utils.load_torch_file(lora_path, safe_load=True, return_metadata=True)
+
+
+def _lora_template() -> list[io.Input]:
+    return [
+        io.Combo.Input("lora_name", options=folder_paths.get_filename_list("loras"),
+                       tooltip="The name of the LoRA file to apply."),
+        io.Float.Input("strength", default=1.0, min=-100.0, max=100.0, step=0.01,
+                       tooltip="How strongly to apply this LoRA. 0 = off, negative inverts the effect."),
+    ]
+
+
+class LoadLoraModel(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="LoadLoraModel",
+            display_name="Load LoRA (Model)",
+            search_aliases=["lora", "load lora", "apply lora", "lora model", "lora stack"],
+            category="model/loaders",
+            description="Apply a stack of LoRAs to a diffusion model. Add one row per LoRA; "
+                        "each row picks a LoRA file and its strength.",
+            inputs=[
+                io.Model.Input("model", tooltip="The diffusion model the LoRAs will be applied to."),
+                io.DynamicGroup.Input(
+                    "loras",
+                    template=_lora_template(),
+                    min=1,
+                    max=50,
+                    tooltip="Each row applies one LoRA to the model.",
+                    group_name="LoRA",
+                ),
+            ],
+            outputs=[io.Model.Output(tooltip="The modified diffusion model.")],
+        )
+
+    @classmethod
+    def execute(cls, model, loras: list[dict]) -> io.NodeOutput:
+        for row in loras:
+            lora_name = row.get("lora_name")
+            strength = row.get("strength", 1.0)
+            if not lora_name or lora_name == "none" or strength == 0:
+                continue
+            lora, metadata = _load_lora_file(lora_name)
+            model, _ = comfy.sd.load_lora_for_models(model, None, lora, strength, 0, lora_metadata=metadata)
+        return io.NodeOutput(model)
+
+
+class LoadLoraTextEncoder(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="LoadLoraTextEncoder",
+            display_name="Load LoRA (Text Encoder)",
+            search_aliases=["lora", "load lora", "apply lora", "clip lora", "lora stack"],
+            category="model/loaders",
+            description="Apply a stack of LoRAs to a CLIP text encoder. Add one row per LoRA; "
+                        "each row picks a LoRA file and its strength.",
+            inputs=[
+                io.Clip.Input("clip", tooltip="The CLIP text encoder the LoRAs will be applied to."),
+                io.DynamicGroup.Input(
+                    "loras",
+                    template=_lora_template(),
+                    min=1,
+                    max=50,
+                    tooltip="Each row applies one LoRA to the text encoder.",
+                    group_name="LoRA",
+                ),
+            ],
+            outputs=[io.Clip.Output(tooltip="The modified CLIP text encoder.")],
+        )
+
+    @classmethod
+    def execute(cls, clip, loras: list[dict]) -> io.NodeOutput:
+        for row in loras:
+            lora_name = row.get("lora_name")
+            strength = row.get("strength", 1.0)
+            if not lora_name or lora_name == "none" or strength == 0:
+                continue
+            lora, metadata = _load_lora_file(lora_name)
+            _, clip = comfy.sd.load_lora_for_models(None, clip, lora, 0, strength, lora_metadata=metadata)
+        return io.NodeOutput(clip)
+
+
+class LoraStackExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[io.ComfyNode]]:
+        return [
+            LoadLoraModel,
+            LoadLoraTextEncoder,
+        ]
+
+
+async def comfy_entrypoint() -> LoraStackExtension:
+    return LoraStackExtension()

comfy_extras/nodes_text_overlay.py

@@ -1,150 +0,0 @@
-import numpy as np
-import torch
-from PIL import Image as PILImage, ImageColor, ImageDraw, ImageFont
-from typing_extensions import override
-
-from comfy_api.latest import ComfyExtension, IO
-
-
-class TextOverlay(IO.ComfyNode):
-    @classmethod
-    def define_schema(cls):
-        return IO.Schema(
-            node_id="TextOverlay",
-            display_name="Draw Text Overlay",
-            category="text",
-            description="Draw text overlay on an image or batch of images.",
-            search_aliases=["text", "label", "caption", "subtitle", "watermark", "title", "addlabel", "overlay"],
-            inputs=[
-                IO.Image.Input("images"),
-                IO.String.Input("text", multiline=True, default=""),
-                IO.Float.Input("font_size", default=5.0, min=0.5, max=50.0, step=0.5, tooltip="Font size as a percentage of the image height."),
-                IO.Color.Input("color", default="#ffffff", tooltip="Color of the text."),
-                IO.Combo.Input("position", options=["top", "bottom"], default="top"),
-                IO.Combo.Input("align", options=["left", "center", "right"], default="left"),
-                IO.Boolean.Input("outline", default=True, tooltip="Draw a black outline around the text."),
-            ],
-            outputs=[IO.Image.Output(display_name="images")],
-        )
-
-    @classmethod
-    def execute(cls, images, text, font_size, color, position, align, outline) -> IO.NodeOutput:
-        if text.strip() == "":
-            return IO.NodeOutput(images)
-
-        text = text.replace("\\n", "\n").replace("\\t", "\t")
-
-        text_rgba = cls.parse_color_to_rgba(color)
-        outline_rgba = (0, 0, 0, 255) if outline else (0, 0, 0, 0)
-
-        # Render the overlay once and composite it across all frames in the batch
-        height = images.shape[1]
-        width = images.shape[2]
-        overlay_rgb, overlay_alpha = cls.render_overlay_text(width, height, text, position, align, font_size, text_rgba, outline_rgba)
-        overlay_rgb = overlay_rgb.to(device=images.device, dtype=images.dtype)
-        overlay_alpha = overlay_alpha.to(device=images.device, dtype=images.dtype)
-
-        result = images * (1.0 - overlay_alpha) + overlay_rgb * overlay_alpha
-        return IO.NodeOutput(result)
-
-    @staticmethod
-    def parse_color_to_rgba(color_string):
-        parsed = ImageColor.getrgb(color_string)
-
-        if len(parsed) == 3:
-            return (*parsed, 255)
-
-        return parsed
-
-    @classmethod
-    def render_overlay_text(cls, width, height, text, position, align, font_size, text_rgba, outline_rgba):
-        line_spacing = 1.2
-        margin_percent = 1.0
-        min_font_percent = 2.0
-        min_font_pixels = 10
-        outline_thickness_factor = 0.04
-
-        # Draw onto a transparent layer so the result can be alpha-composited over any frame.
-        layer = PILImage.new("RGBA", (width, height), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(layer)
-
-        margin = int(round(margin_percent / 100.0 * min(width, height)))
-        max_width = max(1, width - 2 * margin)
-        max_height = max(1, height - 2 * margin)
-
-        # Font scales with resolution, then shrinks to fit the height.
-        size = max(1, int(round(font_size / 100.0 * height)))
-        floor = min(size, max(min_font_pixels, int(round(min_font_percent / 100.0 * height))))
-
-        while True:
-            font = ImageFont.load_default(size=size)
-            stroke = max(1, int(round(size * outline_thickness_factor))) if outline_rgba[3] > 0 else 0
-            block = "\n".join(cls.wrap_text(text, font, max_width))
-            # convert line spacing to pixel spacing
-            single = draw.textbbox((0, 0), "Ay", font=font, stroke_width=stroke)
-            double = draw.multiline_textbbox((0, 0), "Ay\nAy", font=font, spacing=0, stroke_width=stroke)
-            natural_advance = (double[3] - double[1]) - (single[3] - single[1])
-            pixel_spacing = int(round(size * line_spacing - natural_advance))
-            box = draw.multiline_textbbox((0, 0), block, font=font, spacing=pixel_spacing, stroke_width=stroke)
-            block_height = box[3] - box[1]
-
-            if block_height <= max_height or size <= floor:
-                break
-
-            size = max(floor, int(size * 0.9))
-
-        anchor_h, x = {"left": ("l", margin), "center": ("m", width / 2), "right": ("r", width - margin)}[align]
-
-        # Offset y so the rendered text sits flush against the margin
-        if position == "bottom":
-            y = height - margin - box[3]
-        else:
-            y = margin - box[1]
-
-        draw.multiline_text((x, y), block, font=font, fill=text_rgba, anchor=anchor_h + "a",
-                            align=align, spacing=pixel_spacing, stroke_width=stroke, stroke_fill=outline_rgba)
-
-        overlay = np.array(layer).astype(np.float32) / 255.0
-        overlay_rgb = torch.from_numpy(overlay[:, :, :3])
-        overlay_alpha = torch.from_numpy(overlay[:, :, 3:4])
-        return overlay_rgb, overlay_alpha
-
-    @staticmethod
-    def wrap_text(text, font, max_width):
-        lines = []
-        for raw_line in text.split("\n"):
-            words = raw_line.split()
-            if not words:
-                lines.append("")
-                continue
-            current = ""
-            # Break the line into words and split words that are too long
-            for word in words:
-                while font.getlength(word) > max_width and len(word) > 1:
-                    cut = 1
-                    while cut < len(word) and font.getlength(word[:cut + 1]) <= max_width:
-                        cut += 1
-                    if current:
-                        lines.append(current)
-                        current = ""
-                    lines.append(word[:cut])
-                    word = word[cut:]
-                candidate = word if not current else current + " " + word
-                if not current or font.getlength(candidate) <= max_width:
-                    current = candidate
-                else:
-                    lines.append(current)
-                    current = word
-            if current:
-                lines.append(current)
-        return lines
-
-
-class TextOverlayExtension(ComfyExtension):
-    @override
-    async def get_node_list(self) -> list[type[IO.ComfyNode]]:
-        return [TextOverlay]
-
-
-async def comfy_entrypoint() -> TextOverlayExtension:
-    return TextOverlayExtension()

nodes.py

@@ -2478,7 +2478,6 @@ async def init_builtin_extra_nodes():
         "nodes_glsl.py",
         "nodes_lora_debug.py",
         "nodes_textgen.py",
-        "nodes_text_overlay.py",
         "nodes_color.py",
         "nodes_toolkit.py",
         "nodes_replacements.py",
@@ -2503,6 +2502,7 @@ async def init_builtin_extra_nodes():
         "nodes_triposplat.py",
         "nodes_depth_anything_3.py",
         "nodes_seed.py",
+        "nodes_lora_stack.py",
     ]
 
     import_failed = []

requirements.txt

@@ -1,6 +1,6 @@
 comfyui-frontend-package==1.45.20
 comfyui-workflow-templates==0.11.2
-comfyui-embedded-docs==0.5.7
+comfyui-embedded-docs==0.5.6
 torch
 torchsde
 torchvision

tests-unit/comfy_api_test/io_dynamic_group_test.py

@@ -0,0 +1,204 @@
+"""Unit tests for io.DynamicGroup: expansion/reconstruction (0-row and N-row cases)."""
+import sys
+import types
+import pytest
+
+# Stub torch (type-hint only in _io.py; real torch not available in unit-test env)
+if "torch" not in sys.modules:
+    _torch_stub = types.ModuleType("torch")
+    _torch_stub.Tensor = object  # type: ignore[attr-defined]
+    sys.modules["torch"] = _torch_stub
+
+from comfy_api.latest._io import (  # noqa: E402
+    DynamicGroup,
+    Float,
+    Int,
+    String,
+    Boolean,
+    get_finalized_class_inputs,
+    build_nested_inputs,
+    create_input_dict_v1,
+    setup_dynamic_input_funcs,
+)
+
+# Make sure dynamic input funcs are registered (may already be done at import time)
+setup_dynamic_input_funcs()
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_class_inputs(group_input: DynamicGroup.Input) -> dict:
+    """Wrap a DynamicGroup.Input into the required/optional dict structure."""
+    return create_input_dict_v1([group_input])
+
+
+def _run(group_input: DynamicGroup.Input, live_values: dict) -> dict:
+    """End-to-end helper: expand schema + reconstruct values.
+
+    Mirrors the production split in execution.py:
+      1. get_finalized_class_inputs  (schema expansion, line 162)
+      2. build_nested_inputs          (value reconstruction, line 281)
+
+    The two steps are separate in production because the engine resolves
+    linked node outputs between them, but in tests we supply values directly.
+    """
+    class_inputs = _make_class_inputs(group_input)
+    _, _, v3_data = get_finalized_class_inputs(class_inputs, live_values)
+    return build_nested_inputs(dict(live_values), v3_data)
+
+
+# ---------------------------------------------------------------------------
+# Schema construction
+# ---------------------------------------------------------------------------
+
+class TestDynamicGroupInputConstruction:
+    def test_basic_construction(self):
+        inp = DynamicGroup.Input(
+            "loras",
+            template=[
+                Float.Input("strength", default=1.0),
+                String.Input("name"),
+            ],
+            min=0,
+            max=10,
+        )
+        assert inp.id == "loras"
+        assert inp.min == 0
+        assert inp.max == 10
+        assert len(inp.template) == 2
+
+    def test_get_all_includes_self_and_template(self):
+        inp = DynamicGroup.Input(
+            "items",
+            template=[Float.Input("value")],
+        )
+        all_inputs = inp.get_all()
+        assert all_inputs[0] is inp
+        assert all_inputs[1].id == "value"
+
+    def test_as_dict_has_template_min_max(self):
+        inp = DynamicGroup.Input(
+            "items",
+            template=[Float.Input("val", default=0.5)],
+            min=1,
+            max=5,
+        )
+        d = inp.as_dict()
+        assert "template" in d
+        assert d["min"] == 1
+        assert d["max"] == 5
+
+    def test_duplicate_field_ids_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input(
+                "bad",
+                template=[Float.Input("x"), Float.Input("x")],
+            )
+
+    def test_empty_template_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[])
+
+    def test_min_gt_max_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[Float.Input("x")], min=5, max=3)
+
+    def test_max_exceeds_limit_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input("bad", template=[Float.Input("x")], max=101)
+
+    def test_dynamic_input_in_template_raises(self):
+        with pytest.raises(AssertionError):
+            DynamicGroup.Input(
+                "bad",
+                template=[DynamicGroup.Input("nested", template=[Float.Input("x")])],
+            )
+
+    def test_validate_calls_through(self):
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", min=-1.0, max=1.0)])
+        inp.validate()  # should not raise
+
+
+# ---------------------------------------------------------------------------
+# 0-row case
+# ---------------------------------------------------------------------------
+
+class TestZeroRows:
+    def test_empty_live_inputs_produces_empty_list(self):
+        """With min=0 and no live values, the result should be an empty list."""
+        inp = DynamicGroup.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        assert _run(inp, {}).get("loras") == []
+
+    def test_min_zero_with_values(self):
+        """min=0 but 2 rows of live data."""
+        inp = DynamicGroup.Input("loras", template=[Float.Input("strength", default=1.0)], min=0, max=10)
+        result = _run(inp, {"loras.0.strength": 0.8, "loras.1.strength": 0.5})
+        assert result["loras"] == [{"strength": 0.8}, {"strength": 0.5}]
+
+
+# ---------------------------------------------------------------------------
+# N-row case
+# ---------------------------------------------------------------------------
+
+class TestNRows:
+    def test_two_rows_two_fields(self):
+        """Two rows with two fields each produce a list[dict]."""
+        inp = DynamicGroup.Input(
+            "loras",
+            template=[String.Input("lora_name"), Float.Input("strength", default=1.0)],
+            min=0, max=50,
+        )
+        result = _run(inp, {
+            "loras.0.lora_name": "model_a.safetensors", "loras.0.strength": 0.9,
+            "loras.1.lora_name": "model_b.safetensors", "loras.1.strength": 0.4,
+        })
+        assert result["loras"] == [
+            {"lora_name": "model_a.safetensors", "strength": 0.9},
+            {"lora_name": "model_b.safetensors", "strength": 0.4},
+        ]
+
+    def test_rows_are_sorted_by_index(self):
+        """Rows must be in ascending index order even if dict iteration is unordered."""
+        inp = DynamicGroup.Input("items", template=[Int.Input("v", default=0)], min=0, max=10)
+        result = _run(inp, {"items.0.v": 10, "items.2.v": 30, "items.1.v": 20})
+        assert [row["v"] for row in result["items"]] == [10, 20, 30]
+
+    def test_min_rows_schema_slots(self):
+        """With min=2 and no live data, 2 slots must appear in the expanded schema."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        out, _, _ = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        all_slots = {**out.get("required", {}), **out.get("optional", {})}
+        assert "items.0.val" in all_slots
+        assert "items.1.val" in all_slots
+
+    def test_min_rows_reconstructs_when_no_values(self):
+        """min=2 with NO live values must still yield a 2-element list,
+        not collapse to [] (regression: parent-path clobber)."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {})
+        assert len(result["items"]) == 2
+        assert all("val" in row for row in result["items"])
+
+    def test_min_rows_reconstructs_with_partial_values(self):
+        """min=2 with only the first row's value present still yields 2 rows."""
+        inp = DynamicGroup.Input("items", template=[Float.Input("val", default=0.0)], min=2, max=5)
+        result = _run(inp, {"items.0.val": 0.7})
+        assert len(result["items"]) == 2
+        assert result["items"][0]["val"] == 0.7
+        assert result["items"][1]["val"] is None
+
+    def test_list_paths_in_v3_data(self):
+        """list_paths must contain the group id so build_nested_inputs knows to convert."""
+        inp = DynamicGroup.Input("things", template=[Boolean.Input("flag")], min=0, max=5)
+        _, _, v3_data = get_finalized_class_inputs(_make_class_inputs(inp), {})
+        assert "things" in v3_data.get("list_paths", set())
+
+    def test_no_leftover_flat_keys(self):
+        """Flat keys must be consumed; only the reconstructed list remains."""
+        inp = DynamicGroup.Input("rows", template=[Float.Input("x", default=0.0)], min=0, max=5)
+        result = _run(inp, {"rows.0.x": 1.0, "rows.1.x": 2.0})
+        assert "rows.0.x" not in result
+        assert "rows.1.x" not in result
+        assert isinstance(result["rows"], list)

tests-unit/comfy_api_test/video_types_test.py

@@ -2,12 +2,11 @@ import pytest
 import torch
 import tempfile
 import os
-import sys
 import av
 import io
 from fractions import Fraction
 from comfy_api.input_impl.video_types import VideoFromFile, VideoFromComponents
-from comfy_api.util.video_types import VideoComponents, VideoContainer, VideoCodec
+from comfy_api.util.video_types import VideoComponents
 from comfy_api.input.basic_types import AudioInput
 from av.error import InvalidDataError
 
@@ -238,386 +237,3 @@ def test_duration_consistency(video_components):
     manual_duration = float(components.images.shape[0] / components.frame_rate)
 
     assert duration == pytest.approx(manual_duration)
-
-
-def create_transcode_source(
-    width=64, height=64, frames=30, fps=30, audio_streams=1, undecodable_audio=0, rotation=False,
-    container_format="mov", audio_codec="pcm_s16le",
-):
-    """Create a temp video that save_to must transcode (mpeg4 video, so codec != h264).
-
-    ``undecodable_audio`` trailing PCM streams get their fourcc corrupted so no decoder exists
-    (``codec_context is None``), like the APAC track in iPhone spatial-audio recordings.
-    ``rotation`` patches a 90-degree display matrix into the video track header.
-    """
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format=container_format) as container:
-        video_stream = container.add_stream("mpeg4", rate=fps)
-        video_stream.width = width
-        video_stream.height = height
-        video_stream.pix_fmt = "yuv420p"
-        audio = []
-        for _ in range(audio_streams + undecodable_audio):
-            stream = container.add_stream(audio_codec, rate=44100)
-            stream.sample_rate = 44100
-            audio.append(stream)
-
-        for i in range(frames):
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((height, width, 3), (i * 7) % 256, dtype=torch.uint8).numpy(),
-                format="rgb24",
-            )
-            container.mux(video_stream.encode(frame.reformat(format="yuv420p")))
-        # write audio in 1024-sample frames, like real decoders produce, so the
-        # per-frame skip/cap logic in the transcode path actually runs
-        for stream in audio:
-            for offset in range(0, 44100 * frames // fps, 1024):
-                n = min(1024, 44100 * frames // fps - offset)
-                audio_frame = av.AudioFrame.from_ndarray(
-                    torch.zeros(1, n, dtype=torch.int16).numpy(), format="s16", layout="mono"
-                )
-                audio_frame.sample_rate = 44100
-                audio_frame.pts = offset
-                container.mux(stream.encode(audio_frame))
-        for stream in [video_stream, *audio]:
-            container.mux(stream.encode(None))
-
-    data = bytearray(buffer.getvalue())
-    end = len(data)
-    for _ in range(undecodable_audio):
-        end = data.rindex(b"sowt", 0, end)
-        data[end:end + 4] = b"Xpac"
-    if rotation:
-        # the 3x3 display matrix sits 40 bytes into the version-0 tkhd payload; first tkhd
-        # inside moov = video track (search from moov so mdat bytes can't false-match)
-        matrix_offset = data.index(b"tkhd", data.rindex(b"moov")) + 4 + 40
-        values = [0, 1 << 16, 0, -(1 << 16), 0, 0, 0, 0, 1 << 30]
-        data[matrix_offset:matrix_offset + 36] = b"".join(v.to_bytes(4, "big", signed=True) for v in values)
-
-    tmp = tempfile.NamedTemporaryFile(suffix=f".{container_format}", delete=False)
-    tmp.write(bytes(data))
-    tmp.close()
-    return tmp.name
-
-
-def transcode_and_probe(video):
-    buffer = io.BytesIO()
-    video.save_to(buffer, format=VideoContainer.MP4, codec=VideoCodec.H264)
-    buffer.seek(0)
-    with av.open(buffer) as container:
-        video_stream = container.streams.video[0]
-        audio_stream = container.streams.audio[0] if container.streams.audio else None
-        frames = 0
-        first_pts = None
-        for packet in container.demux(video_stream):
-            for frame in packet.decode():
-                if first_pts is None:
-                    first_pts = frame.pts
-                frames += 1
-        return {
-            "codec": video_stream.codec_context.name,
-            "width": video_stream.codec_context.width,
-            "height": video_stream.codec_context.height,
-            "frames": frames,
-            "first_pts": first_pts,
-            "video_seconds": float(video_stream.duration * video_stream.time_base) if video_stream.duration else None,
-            "audio_seconds": float(audio_stream.duration * audio_stream.time_base)
-            if audio_stream and audio_stream.duration else None,
-            "audio_codecs": [s.codec_context.name for s in container.streams.audio],
-        }
-
-
-def test_save_to_transcode_streams_without_buffering_frames():
-    """Transcoding must not decode the whole video into memory first (~2 GiB for this source)"""
-    resource = pytest.importorskip("resource")  # no getrusage on Windows
-    rss_scale = 1 if sys.platform == "darwin" else 1024  # ru_maxrss: bytes on macOS, KiB elsewhere
-    # ru_maxrss is a lifetime peak: a heavier test running earlier would shrink the measured
-    # delta and quietly defang this canary, so keep this source the biggest thing in the suite
-    file_path = create_transcode_source(width=640, height=480, frames=300)
-    try:
-        rss_before = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * rss_scale
-        result = transcode_and_probe(VideoFromFile(file_path))
-        rss_delta = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * rss_scale - rss_before
-
-        assert result["codec"] == "h264"
-        assert result["frames"] == 300
-        assert rss_delta < 500 * 2**20, f"transcode buffered frames in RAM (peak grew {rss_delta / 2**20:.0f} MiB)"
-    finally:
-        os.unlink(file_path)
-
-
-def test_save_to_transcode_honors_trim_window():
-    """start_time/duration trim applies to both video and audio on the streaming path"""
-    file_path = create_transcode_source(frames=90)  # 3s @ 30fps
-    try:
-        result = transcode_and_probe(VideoFromFile(file_path, start_time=1, duration=1))
-        assert result["frames"] == pytest.approx(30, abs=2)
-        assert result["first_pts"] == 0  # trimmed output is rebased to start at zero
-        assert result["video_seconds"] == pytest.approx(1.0, abs=0.1)
-        assert result["audio_seconds"] == pytest.approx(1.0, abs=0.1)
-    finally:
-        os.unlink(file_path)
-
-
-def test_save_to_transcode_keeps_audio_of_sparse_video():
-    """Audio that runs ahead of a sparse video track (slideshows, timelapses) must be
-    kept in full — it is only clamped to the video's end, never to the video cursor."""
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mp4") as container:
-        video_stream = container.add_stream("mpeg4", rate=30)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        audio_stream = container.add_stream("aac", rate=48000, layout="stereo")
-        for t in (0, 30, 60):  # 3 frames spread over 60 seconds
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((64, 64, 3), t * 4, dtype=torch.uint8).numpy(), format="rgb24"
-            ).reformat(format="yuv420p")
-            frame.pts = t * 15360
-            frame.time_base = Fraction(1, 15360)
-            container.mux(video_stream.encode(frame))
-        container.mux(video_stream.encode(None))
-        for offset in range(0, 48000 * 60, 1024):
-            n = min(1024, 48000 * 60 - offset)
-            audio_frame = av.AudioFrame.from_ndarray(
-                torch.zeros(2, n, dtype=torch.float32).numpy(), format="fltp", layout="stereo"
-            )
-            audio_frame.sample_rate = 48000
-            audio_frame.pts = offset
-            audio_frame.time_base = Fraction(1, 48000)
-            container.mux(audio_stream.encode(audio_frame))
-        container.mux(audio_stream.encode(None))
-
-    buffer.seek(0)
-    result = transcode_and_probe(VideoFromFile(buffer))
-    assert result["audio_seconds"] == pytest.approx(60.0, abs=1.0)
-
-
-def test_save_to_transcode_vfr_audio_covers_video_span():
-    """A trim window in the sparse region of a VFR file keeps audio for the true pts span
-    of the kept frames. Deriving the span as frames/average_rate undercuts it badly: the
-    average is dominated by the dense region (and can be plain wrong on MediaRecorder files)."""
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mp4") as container:
-        video_stream = container.add_stream("mpeg4", rate=30)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        audio_stream = container.add_stream("aac", rate=48000, layout="stereo")
-        # 10 frames inside the first second, then one every 1.25 s
-        for i, t in enumerate([x / 10 for x in range(10)] + [1.0, 2.25, 3.5, 4.75]):
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((64, 64, 3), (i * 16) % 256, dtype=torch.uint8).numpy(), format="rgb24"
-            ).reformat(format="yuv420p")
-            frame.pts = int(t * 15360)
-            frame.time_base = Fraction(1, 15360)
-            container.mux(video_stream.encode(frame))
-        container.mux(video_stream.encode(None))
-        for offset in range(0, 48000 * 6, 1024):
-            n = min(1024, 48000 * 6 - offset)
-            audio_frame = av.AudioFrame.from_ndarray(
-                torch.zeros(2, n, dtype=torch.float32).numpy(), format="fltp", layout="stereo"
-            )
-            audio_frame.sample_rate = 48000
-            audio_frame.pts = offset
-            audio_frame.time_base = Fraction(1, 48000)
-            container.mux(audio_stream.encode(audio_frame))
-        container.mux(audio_stream.encode(None))
-
-    buffer.seek(0)
-    result = transcode_and_probe(VideoFromFile(buffer, start_time=1, duration=5))
-    # kept frames: 1.0/2.25/3.5/4.75 s -> rebased span 3.75 s + one nominal interval
-    assert result["frames"] == 4
-    assert result["audio_seconds"] == pytest.approx(4.0, abs=0.45)
-
-
-def test_save_to_transcode_trims_audio_in_stream_time_base_units():
-    """Matroska audio timestamps tick in 1/1000, not 1/sample_rate; trim and audio timing
-    must convert through the frame's time base instead of assuming sample units. AAC audio,
-    because it decodes straight to the encoder's format and hits the resampler passthrough
-    that keeps the source time base on the frames."""
-    file_path = create_transcode_source(frames=90, container_format="matroska", audio_codec="aac")
-    try:
-        result = transcode_and_probe(VideoFromFile(file_path, start_time=1, duration=1))
-        assert result["audio_codecs"] == ["aac"]
-        assert result["video_seconds"] == pytest.approx(1.0, abs=0.1)
-        assert result["audio_seconds"] == pytest.approx(1.0, abs=0.1)
-    finally:
-        os.unlink(file_path)
-
-
-def test_save_to_transcode_learns_unprobed_audio_params():
-    """mpegts is only probed a few seconds deep at open, so an audio stream whose first
-    packet comes later (live captures where audio kicks in late) still has sample_rate 0
-    when the transcode starts; the parameters must be learned from the stream itself."""
-    sample_rate, fps, video_seconds, audio_start = 48000, 30, 13, 12
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mpegts") as container:
-        video_stream = container.add_stream("mpeg4", rate=fps)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        audio_stream = container.add_stream("aac", rate=sample_rate, layout="mono")
-        for i in range(video_seconds * fps):
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((64, 64, 3), (i * 7) % 256, dtype=torch.uint8).numpy(), format="rgb24"
-            )
-            container.mux(video_stream.encode(frame.reformat(format="yuv420p")))
-        for offset in range(0, (video_seconds - audio_start) * sample_rate, 1024):
-            n = min(1024, (video_seconds - audio_start) * sample_rate - offset)
-            audio_frame = av.AudioFrame.from_ndarray(
-                torch.zeros(1, n, dtype=torch.float32).numpy(), format="fltp", layout="mono"
-            )
-            audio_frame.sample_rate = sample_rate
-            audio_frame.pts = audio_start * sample_rate + offset
-            container.mux(audio_stream.encode(audio_frame))
-        for stream in (video_stream, audio_stream):
-            container.mux(stream.encode(None))
-
-    buffer.seek(0)
-    with av.open(buffer) as container:
-        # the scenario requires unprobed parameters; if a future FFmpeg probes deeper,
-        # push audio_start/video_seconds further out to restore it
-        assert container.streams.audio[0].codec_context.sample_rate == 0
-    result = transcode_and_probe(VideoFromFile(buffer))
-    assert result["frames"] == video_seconds * fps
-    assert result["audio_codecs"] == ["aac"]
-    assert result["audio_seconds"] == pytest.approx(1.0, abs=0.1)
-
-
-def test_save_to_transcode_trimmed_fragmented_mp4_keeps_audio():
-    """Fragmented mp4 (MediaRecorder, DASH/HLS-derived files) delivers audio well behind
-    video, so when the trim window's last video frame arrives the audio demuxed so far
-    does not cover the window yet; the transcode must keep demuxing audio until it does
-    instead of finalizing on the first audio frame it sees afterwards."""
-    sample_rate, fps, seconds = 48000, 30, 6
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mp4", options={"movflags": "frag_keyframe+empty_moov"}) as container:
-        video_stream = container.add_stream("h264", rate=fps)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        audio_stream = container.add_stream("aac", rate=sample_rate, layout="mono")
-        next_audio_pts = 0
-        for i in range(seconds * fps):
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((64, 64, 3), (i * 7) % 256, dtype=torch.uint8).numpy(), format="rgb24"
-            )
-            container.mux(video_stream.encode(frame.reformat(format="yuv420p")))
-            while next_audio_pts / sample_rate <= i / fps:  # feed audio alongside, like a live pipeline
-                audio_frame = av.AudioFrame.from_ndarray(
-                    torch.zeros(1, 1024, dtype=torch.float32).numpy(), format="fltp", layout="mono"
-                )
-                audio_frame.sample_rate = sample_rate
-                audio_frame.pts = next_audio_pts
-                container.mux(audio_stream.encode(audio_frame))
-                next_audio_pts += 1024
-        for stream in (video_stream, audio_stream):
-            container.mux(stream.encode(None))
-
-    result = transcode_and_probe(VideoFromFile(buffer, start_time=0.5, duration=1.0))
-    assert result["video_seconds"] == pytest.approx(1.0, abs=0.05)
-    assert result["audio_seconds"] == pytest.approx(1.0, abs=0.05)
-
-
-def test_save_to_transcode_sparse_video_keeps_true_duration():
-    """average_rate is not a frame duration: a 3-frame video spanning 60 s averages
-    0.05 fps, and padding the last frame with 1/average_rate used to extend the
-    output — and the audio kept with it — about 20 s past the source span."""
-    sample_rate = 48000
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mp4") as container:
-        video_stream = container.add_stream("mpeg4", rate=30)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        audio_stream = container.add_stream("aac", rate=sample_rate, layout="mono")
-        for i, second in enumerate((0, 30, 60)):
-            frame = av.VideoFrame.from_ndarray(
-                torch.full((64, 64, 3), i * 80, dtype=torch.uint8).numpy(), format="rgb24"
-            ).reformat(format="yuv420p")
-            frame.pts = second * 30
-            frame.time_base = Fraction(1, 30)
-            container.mux(video_stream.encode(frame))
-        for offset in range(0, 90 * sample_rate, 1024):
-            n = min(1024, 90 * sample_rate - offset)
-            audio_frame = av.AudioFrame.from_ndarray(
-                torch.zeros(1, n, dtype=torch.float32).numpy(), format="fltp", layout="mono"
-            )
-            audio_frame.sample_rate = sample_rate
-            audio_frame.pts = offset
-            container.mux(audio_stream.encode(audio_frame))
-        for stream in (video_stream, audio_stream):
-            container.mux(stream.encode(None))
-
-    result = transcode_and_probe(VideoFromFile(buffer))
-    assert result["frames"] == 3
-    # the last frame keeps its true stts duration (1/30 s), not 1/average_rate (~20 s)
-    assert result["video_seconds"] == pytest.approx(60.03, abs=0.05)
-    assert result["audio_seconds"] == pytest.approx(60.03, abs=0.1)
-
-    trimmed = transcode_and_probe(VideoFromFile(buffer, duration=45))
-    assert trimmed["frames"] == 2
-    # a kept frame whose source duration crosses the window end is clamped to it
-    assert trimmed["video_seconds"] == pytest.approx(45.0, abs=0.05)
-    assert trimmed["audio_seconds"] == pytest.approx(45.0, abs=0.1)
-
-
-def test_save_to_transcode_irregular_vfr_keeps_span():
-    """B-frames reorder packets, and mp4 sample durations follow decode order: the dts
-    timeline ends before the pts timeline, so an irregular-VFR source's tail holds fell
-    out of the container (this 20.23 s span used to come out as 15.27 s, and the 10 s
-    trim as 6.03 s). The transcode encodes without B-frames so every sample keeps its
-    true display duration."""
-    durations = [1, 1, 60, 1, 1, 120, 1, 180, 1, 1, 150, 90]  # 1/30 s ticks, span 20.2333 s
-    generator = torch.Generator().manual_seed(7)
-    buffer = io.BytesIO()
-    with av.open(buffer, mode="w", format="mp4") as container:
-        video_stream = container.add_stream("mpeg4", rate=30)
-        video_stream.width = video_stream.height = 64
-        video_stream.pix_fmt = "yuv420p"
-        pts = 0
-        for duration in durations:
-            # textured frames, so an encoder with default settings has B-frames to gain from
-            frame = av.VideoFrame.from_ndarray(
-                torch.randint(0, 255, (64, 64, 3), generator=generator, dtype=torch.uint8).numpy(),
-                format="rgb24",
-            ).reformat(format="yuv420p")
-            frame.pts = pts
-            frame.time_base = Fraction(1, 30)
-            pts += duration
-            for packet in video_stream.encode(frame):
-                packet.duration = duration  # exact stts in the source
-                container.mux(packet)
-        container.mux(video_stream.encode(None))
-
-    result = transcode_and_probe(VideoFromFile(buffer))
-    assert result["frames"] == len(durations)
-    assert result["video_seconds"] == pytest.approx(sum(durations) / 30, abs=0.05)
-
-    trimmed = transcode_and_probe(VideoFromFile(buffer, duration=10))
-    assert trimmed["frames"] == 8  # frames at 12.167 s+ fall outside the window
-    assert trimmed["video_seconds"] == pytest.approx(10.0, abs=0.05)
-
-
-def test_save_to_transcode_bakes_rotation():
-    """A 90-degree display-matrix rotation swaps the output dimensions (portrait video)"""
-    file_path = create_transcode_source(width=64, height=32, rotation=True)
-    try:
-        result = transcode_and_probe(VideoFromFile(file_path))
-        assert (result["width"], result["height"]) == (32, 64)
-        assert result["frames"] == 30
-    finally:
-        os.unlink(file_path)
-
-
-def test_save_to_transcode_skips_undecodable_audio():
-    """Streaming transcode keeps the decodable audio track and drops undecodable ones;
-    with no decodable audio at all the output is video-only instead of crashing."""
-    mixed = all_bad = None
-    try:
-        mixed = create_transcode_source(audio_streams=1, undecodable_audio=1)
-        all_bad = create_transcode_source(audio_streams=0, undecodable_audio=2)
-        result = transcode_and_probe(VideoFromFile(mixed))
-        assert result["audio_codecs"] == ["aac"]
-        assert result["audio_seconds"] == pytest.approx(1.0, abs=0.1)
-        assert transcode_and_probe(VideoFromFile(all_bad))["audio_codecs"] == []
-    finally:
-        for path in (mixed, all_bad):
-            if path:
-                os.unlink(path)