Remove unnecessary comments.

.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

comfy/model_management.py

@@ -616,8 +616,6 @@ PIN_PRESSURE_HYSTERESIS = 256 * 1024 * 1024
 #Freeing registerables on pressure does imply a GPU sync, so go big on
 #the hysteresis so each expensive sync gives us back a good chunk.
 REGISTERABLE_PIN_HYSTERESIS = 2048 * 1024 * 1024
-WINDOWS_PIN_EVICTION_SWAP_PERCENT = 5.0
-WINDOWS_PIN_EVICTION_EMERGENCY_AVAILABLE = 512 * 1024 ** 2
 
 def module_size(module):
     module_mem = 0
@@ -644,15 +642,6 @@ def free_pins(size, evict_active=False):
             size -= freed
     return freed_total
 
-def should_free_pins_for_ram_pressure(shortfall):
-    if shortfall <= 0:
-        return False
-    if not WINDOWS:
-        return True
-    if psutil.virtual_memory().available < WINDOWS_PIN_EVICTION_EMERGENCY_AVAILABLE:
-        return True
-    return psutil.swap_memory().percent >= WINDOWS_PIN_EVICTION_SWAP_PERCENT
-
 def ensure_pin_budget(size, evict_active=False):
     if args.high_ram:
         return True

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/llama.py

@@ -937,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_api/latest/_input_impl/video_types.py

@@ -281,18 +281,11 @@ class VideoFromFile(VideoInput):
         video_done = False
         audio_done = True
 
-        # Use the last decodable audio stream. 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)
-        audio_stream = next(
-            (s for s in reversed(container.streams.audio) if s.codec_context is not None),
-            None,
-        )
-        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
-        elif len(container.streams.audio):
-            logging.warning("No decodable audio stream found in video; ignoring audio.")
 
         for packet in container.demux(*streams):
             if video_done and audio_done:
@@ -464,13 +457,10 @@ class VideoFromFile(VideoInput):
                         else:
                             output_container.metadata[key] = json.dumps(value)
 
-                # Add streams to the new container. Streams with no codec context cannot be used as an output template.
+                # 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
 

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,22 +503,6 @@ RAM_CACHE_DEFAULT_RAM_USAGE = 0.05
 
 RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER = 1.3
 
-RAM_CACHE_LARGE_INTERMEDIATE = 512 * 1024 ** 2
-
-
-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):
@@ -540,25 +524,20 @@ class RAMPressureCache(LRUCache):
         self.timestamps[self.cache_key_set.get_data_key(node_id)] = time.time()
         super().set_local(node_id, value)
 
-    def ram_release(self, target, free_active=False, min_entry_size=0):
+    def ram_release(self, target, free_active=False):
         if psutil.virtual_memory().available >= target:
-            return 0
+            return
 
         clean_list = []
 
         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
-            oom_ram_usage = ram_usage
             def scan_list_for_ram_usage(outputs):
-                nonlocal ram_usage, oom_ram_usage
+                nonlocal ram_usage
                 if outputs is None:
                     return
                 for output in outputs:
@@ -566,26 +545,19 @@ class RAMPressureCache(LRUCache):
                         scan_list_for_ram_usage(output)
                     elif isinstance(output, torch.Tensor) and output.device.type == 'cpu':
                         ram_usage += output.numel() * output.element_size()
-                        oom_ram_usage += output.numel() * output.element_size()
                     elif isinstance(output, ModelPatcher) and self.used_generation[key] != self.generation:
                         #old ModelPatchers are the first to go
-                        oom_ram_usage = 1e30
+                        ram_usage = 1e30
             scan_list_for_ram_usage(cache_entry.outputs)
 
-            if ram_usage < min_entry_size:
-                continue
-
-            oom_score *= oom_ram_usage
+            oom_score *= ram_usage
             #In the case where we have no information on the node ram usage at all,
             #break OOM score ties on the last touch timestamp (pure LRU)
-            bisect.insort(clean_list, (oom_score, self.timestamps[key], key, ram_usage))
+            bisect.insort(clean_list, (oom_score, self.timestamps[key], key))
 
-        freed = 0
         while psutil.virtual_memory().available < target and clean_list:
-            _, _, key, ram_usage = clean_list.pop()
+            _, _, key = clean_list.pop()
             del self.cache[key]
             self.used_generation.pop(key, None)
             self.timestamps.pop(key, None)
             self.children.pop(key, None)
-            freed += ram_usage
-        return freed

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_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()

execution.py

@@ -29,7 +29,6 @@ from comfy_execution.caching import (
     HierarchicalCache,
     LRUCache,
     RAMPressureCache,
-    RAM_CACHE_LARGE_INTERMEDIATE,
 )
 from comfy_execution.graph import (
     DynamicPrompt,
@@ -795,16 +794,12 @@ class PromptExecutor:
                     if self.cache_type == CacheType.RAM_PRESSURE:
                         ram_release_callback(ram_inactive_headroom)
                         ram_shortfall = ram_headroom - psutil.virtual_memory().available
-                        if ram_shortfall > 0:
-                            freed = ram_release_callback(ram_headroom, free_active=True, min_entry_size=RAM_CACHE_LARGE_INTERMEDIATE)
-                            ram_shortfall -= freed
-                        if comfy.model_management.should_free_pins_for_ram_pressure(ram_shortfall):
-                            freed = comfy.model_management.free_pins(ram_shortfall + 512 * (1024 ** 2))
-                            if freed < ram_shortfall:
-                                if freed > 64 * (1024 ** 2):
-                                    # AIMDO MEM_DECOMMIT can outrun psutil.available catching up.
-                                    time.sleep(0.05)
-                                ram_release_callback(ram_headroom, free_active=True)
+                        freed = comfy.model_management.free_pins(ram_shortfall + 512 * (1024 ** 2))
+                        if freed < ram_shortfall:
+                            if freed > 64 * (1024 ** 2):
+                                # AIMDO MEM_DECOMMIT can outrun psutil.available catching up.
+                                time.sleep(0.05)
+                            ram_release_callback(ram_headroom, free_active=True)
                 else:
                     # Only execute when the while-loop ends without break
                     # Send cached UI for intermediate output nodes that weren't executed

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",

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)