Merge 1ff364873a into 639f631a08

* chore: update workflow templates to v0.9.69

* Update comfyui-workflow-templates to version 0.9.70

* Downgrade comfyui-workflow-templates to 0.9.69

---------

Co-authored-by: Alexander Piskun <13381981+bigcat88@users.noreply.github.com>

.gitignore

@@ -23,3 +23,4 @@ web_custom_versions/
 .DS_Store
 filtered-openapi.yaml
 uv.lock
+.comfy_environment

README.md

@@ -1,7 +1,7 @@
 <div align="center">
 
 # ComfyUI
-**The most powerful and modular visual AI engine and application.**
+**The most powerful and modular AI engine for content creation.**
 
 
 [![Website][website-shield]][website-url]
@@ -31,10 +31,16 @@
 [github-downloads-latest-shield]: https://img.shields.io/github/downloads/comfyanonymous/ComfyUI/latest/total?style=flat&label=downloads%40latest
 [github-downloads-link]: https://github.com/comfyanonymous/ComfyUI/releases
 
-![ComfyUI Screenshot](https://github.com/user-attachments/assets/7ccaf2c1-9b72-41ae-9a89-5688c94b7abe)
+<img width="1590" height="795" alt="ComfyUI Screenshot" src="https://github.com/user-attachments/assets/36e065e0-bfae-4456-8c7f-8369d5ea48a2" />
+<br>
 </div>
 
-ComfyUI lets you design and execute advanced stable diffusion pipelines using a graph/nodes/flowchart based interface. Available on Windows, Linux, and macOS.
+ComfyUI is the AI creation engine for visual professionals who demand control over every model, every parameter, and every output. Its powerful and modular node graph interface empowers creatives to generate images, videos, 3D models, audio, and more...
+- ComfyUI natively supports the latest open-source state of the art models.
+- API nodes provide access to the best closed source models such as Nano Banana, Seedance, Hunyuan3D, etc.
+- It is available on Windows, Linux, and macOS, locally with our desktop application or on our cloud.
+- The most sophisticated workflows can be exposed through a simple UI thanks to App Mode.
+- It integrates seamlessly into production pipelines with our API endpoints.
 
 ## Get Started
 
@@ -77,6 +83,7 @@ See what ComfyUI can do with the [newer template workflows](https://comfy.org/wo
    - [Hunyuan Image 2.1](https://comfyanonymous.github.io/ComfyUI_examples/hunyuan_image/)
    - [Flux 2](https://comfyanonymous.github.io/ComfyUI_examples/flux2/)
    - [Z Image](https://comfyanonymous.github.io/ComfyUI_examples/z_image/)
+   - Ernie Image
 - Image Editing Models
    - [Omnigen 2](https://comfyanonymous.github.io/ComfyUI_examples/omnigen/)
    - [Flux Kontext](https://comfyanonymous.github.io/ComfyUI_examples/flux/#flux-kontext-image-editing-model)
@@ -126,7 +133,7 @@ Workflow examples can be found on the [Examples page](https://comfyanonymous.git
 ComfyUI follows a weekly release cycle targeting Monday but this regularly changes because of model releases or large changes to the codebase. There are three interconnected repositories:
 
 1. **[ComfyUI Core](https://github.com/comfyanonymous/ComfyUI)**
-   - Releases a new stable version (e.g., v0.7.0) roughly every week.
+   - Releases a new major stable version (e.g., v0.7.0) roughly every 2 weeks.
    - Starting from v0.4.0 patch versions will be used for fixes backported onto the current stable release.
    - Minor versions will be used for releases off the master branch.
    - Patch versions may still be used for releases on the master branch in cases where a backport would not make sense.

comfy/cli_args.py

@@ -91,6 +91,7 @@ parser.add_argument("--directml", type=int, nargs="?", metavar="DIRECTML_DEVICE"
 
 parser.add_argument("--oneapi-device-selector", type=str, default=None, metavar="SELECTOR_STRING", help="Sets the oneAPI device(s) this instance will use.")
 parser.add_argument("--supports-fp8-compute", action="store_true", help="ComfyUI will act like if the device supports fp8 compute.")
+parser.add_argument("--enable-triton-backend", action="store_true", help="ComfyUI will enable the use of Triton backend in comfy-kitchen. Is disabled at launch by default.")
 
 class LatentPreviewMethod(enum.Enum):
     NoPreviews = "none"
@@ -237,6 +238,8 @@ database_default_path = os.path.abspath(
 )
 parser.add_argument("--database-url", type=str, default=f"sqlite:///{database_default_path}", help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'.")
 parser.add_argument("--enable-assets", action="store_true", help="Enable the assets system (API routes, database synchronization, and background scanning).")
+parser.add_argument("--feature-flag", type=str, action='append', default=[], metavar="KEY[=VALUE]", help="Set a server feature flag. Use KEY=VALUE to set an explicit value, or bare KEY to set it to true. Can be specified multiple times. Boolean values (true/false) and numbers are auto-converted. Examples: --feature-flag show_signin_button=true  or  --feature-flag show_signin_button")
+parser.add_argument("--list-feature-flags", action="store_true", help="Print the registry of known CLI-settable feature flags as JSON and exit.")
 
 if comfy.options.args_parsing:
     args = parser.parse_args()

comfy/deploy_environment.py

@@ -0,0 +1,34 @@
+import functools
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_DEPLOY_ENV = "local-git"
+_ENV_FILENAME = ".comfy_environment"
+
+# Resolve the ComfyUI install directory (the parent of this `comfy/` package).
+# We deliberately avoid `folder_paths.base_path` here because that is overridden
+# by the `--base-directory` CLI arg to a user-supplied path, whereas the
+# `.comfy_environment` marker is written by launchers/installers next to the
+# ComfyUI install itself.
+_COMFY_INSTALL_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+
+@functools.cache
+def get_deploy_environment() -> str:
+    env_file = os.path.join(_COMFY_INSTALL_DIR, _ENV_FILENAME)
+    try:
+        with open(env_file, encoding="utf-8") as f:
+            # Cap the read so a malformed or maliciously crafted file (e.g.
+            # a single huge line with no newline) can't blow up memory.
+            first_line = f.readline(128).strip()
+            value = "".join(c for c in first_line if 32 <= ord(c) < 127)
+            if value:
+                return value
+    except FileNotFoundError:
+        pass
+    except Exception as e:
+        logger.error("Failed to read %s: %s", env_file, e)
+
+    return _DEFAULT_DEPLOY_ENV

comfy/k_diffusion/sampling.py

@@ -1810,3 +1810,102 @@ def sample_sa_solver(model, x, sigmas, extra_args=None, callback=None, disable=F
 def sample_sa_solver_pece(model, x, sigmas, extra_args=None, callback=None, disable=False, tau_func=None, s_noise=1.0, noise_sampler=None, predictor_order=3, corrector_order=4, simple_order_2=False):
     """Stochastic Adams Solver with PECE (Predict–Evaluate–Correct–Evaluate) mode (NeurIPS 2023)."""
     return sample_sa_solver(model, x, sigmas, extra_args=extra_args, callback=callback, disable=disable, tau_func=tau_func, s_noise=s_noise, noise_sampler=noise_sampler, predictor_order=predictor_order, corrector_order=corrector_order, use_pece=True, simple_order_2=simple_order_2)
+
+
+@torch.no_grad()
+def sample_ar_video(model, x, sigmas, extra_args=None, callback=None, disable=None,
+                    num_frame_per_block=1):
+    """
+    Autoregressive video sampler: block-by-block denoising with KV cache
+    and flow-match re-noising for Causal Forcing / Self-Forcing models.
+
+    Requires a Causal-WAN compatible model (diffusion_model must expose
+    init_kv_caches / init_crossattn_caches) and 5-D latents [B,C,T,H,W].
+
+    All AR-loop parameters are passed via the SamplerARVideo node, not read
+    from the checkpoint or transformer_options.
+    """
+    extra_args = {} if extra_args is None else extra_args
+    model_options = extra_args.get("model_options", {})
+    transformer_options = model_options.get("transformer_options", {})
+
+    if x.ndim != 5:
+        raise ValueError(
+            f"ar_video sampler requires 5-D video latents [B,C,T,H,W], got {x.ndim}-D tensor with shape {x.shape}. "
+            "This sampler is only compatible with autoregressive video models (e.g. Causal-WAN)."
+        )
+
+    inner_model = model.inner_model.inner_model
+    causal_model = inner_model.diffusion_model
+
+    if not (hasattr(causal_model, "init_kv_caches") and hasattr(causal_model, "init_crossattn_caches")):
+        raise TypeError(
+            "ar_video sampler requires a Causal-WAN compatible model whose diffusion_model "
+            "exposes init_kv_caches() and init_crossattn_caches(). The loaded checkpoint "
+            "does not support this interface — choose a different sampler."
+        )
+
+    seed = extra_args.get("seed", 0)
+
+    bs, c, lat_t, lat_h, lat_w = x.shape
+    frame_seq_len = -(-lat_h // 2) * -(-lat_w // 2) # ceiling division
+    num_blocks = -(-lat_t // num_frame_per_block)   # ceiling division
+    device = x.device
+    model_dtype = inner_model.get_dtype()
+
+    kv_caches = causal_model.init_kv_caches(bs, lat_t * frame_seq_len, device, model_dtype)
+    crossattn_caches = causal_model.init_crossattn_caches(bs, device, model_dtype)
+
+    output = torch.zeros_like(x)
+    s_in = x.new_ones([x.shape[0]])
+    current_start_frame = 0
+    num_sigma_steps = len(sigmas) - 1
+    total_real_steps = num_blocks * num_sigma_steps
+    step_count = 0
+
+    try:
+        for block_idx in trange(num_blocks, disable=disable):
+            bf = min(num_frame_per_block, lat_t - current_start_frame)
+            fs, fe = current_start_frame, current_start_frame + bf
+            noisy_input = x[:, :, fs:fe]
+
+            ar_state = {
+                "start_frame": current_start_frame,
+                "kv_caches": kv_caches,
+                "crossattn_caches": crossattn_caches,
+            }
+            transformer_options["ar_state"] = ar_state
+
+            for i in range(num_sigma_steps):
+                denoised = model(noisy_input, sigmas[i] * s_in, **extra_args)
+
+                if callback is not None:
+                    scaled_i = step_count * num_sigma_steps // total_real_steps
+                    callback({"x": noisy_input, "i": scaled_i, "sigma": sigmas[i],
+                              "sigma_hat": sigmas[i], "denoised": denoised})
+
+                if sigmas[i + 1] == 0:
+                    noisy_input = denoised
+                else:
+                    sigma_next = sigmas[i + 1]
+                    torch.manual_seed(seed + block_idx * 1000 + i)
+                    fresh_noise = torch.randn_like(denoised)
+                    noisy_input = (1.0 - sigma_next) * denoised + sigma_next * fresh_noise
+
+                    for cache in kv_caches:
+                        cache["end"] -= bf * frame_seq_len
+
+                step_count += 1
+
+            output[:, :, fs:fe] = noisy_input
+
+            for cache in kv_caches:
+                cache["end"] -= bf * frame_seq_len
+            zero_sigma = sigmas.new_zeros([1])
+            _ = model(noisy_input, zero_sigma * s_in, **extra_args)
+
+            current_start_frame += bf
+    finally:
+        transformer_options.pop("ar_state", None)
+
+    return output

comfy/ldm/wan/ar_model.py

@@ -0,0 +1,276 @@
+"""
+CausalWanModel: Wan 2.1 backbone with KV-cached causal self-attention for
+autoregressive (frame-by-frame) video generation via Causal Forcing.
+
+Weight-compatible with the standard WanModel -- same layer names, same shapes.
+The difference is purely in the forward pass: this model processes one temporal
+block at a time and maintains a KV cache across blocks.
+
+Reference: https://github.com/thu-ml/Causal-Forcing
+"""
+
+import torch
+import torch.nn as nn
+
+from comfy.ldm.modules.attention import optimized_attention
+from comfy.ldm.flux.math import apply_rope1
+from comfy.ldm.wan.model import (
+    sinusoidal_embedding_1d,
+    repeat_e,
+    WanModel,
+    WanAttentionBlock,
+)
+import comfy.ldm.common_dit
+import comfy.model_management
+
+
+class CausalWanSelfAttention(nn.Module):
+    """Self-attention with KV cache support for autoregressive inference."""
+
+    def __init__(self, dim, num_heads, window_size=(-1, -1), qk_norm=True,
+                 eps=1e-6, operation_settings={}):
+        assert dim % num_heads == 0
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.head_dim = dim // num_heads
+        self.qk_norm = qk_norm
+        self.eps = eps
+
+        ops = operation_settings.get("operations")
+        device = operation_settings.get("device")
+        dtype = operation_settings.get("dtype")
+
+        self.q = ops.Linear(dim, dim, device=device, dtype=dtype)
+        self.k = ops.Linear(dim, dim, device=device, dtype=dtype)
+        self.v = ops.Linear(dim, dim, device=device, dtype=dtype)
+        self.o = ops.Linear(dim, dim, device=device, dtype=dtype)
+        self.norm_q = ops.RMSNorm(dim, eps=eps, elementwise_affine=True, device=device, dtype=dtype) if qk_norm else nn.Identity()
+        self.norm_k = ops.RMSNorm(dim, eps=eps, elementwise_affine=True, device=device, dtype=dtype) if qk_norm else nn.Identity()
+
+    def forward(self, x, freqs, kv_cache=None, transformer_options={}):
+        b, s, n, d = *x.shape[:2], self.num_heads, self.head_dim
+
+        q = apply_rope1(self.norm_q(self.q(x)).view(b, s, n, d), freqs)
+        k = apply_rope1(self.norm_k(self.k(x)).view(b, s, n, d), freqs)
+        v = self.v(x).view(b, s, n, d)
+
+        if kv_cache is None:
+            x = optimized_attention(
+                q.view(b, s, n * d),
+                k.view(b, s, n * d),
+                v.view(b, s, n * d),
+                heads=self.num_heads,
+                transformer_options=transformer_options,
+            )
+        else:
+            end = kv_cache["end"]
+            new_end = end + s
+
+            # Roped K and plain V go into cache
+            kv_cache["k"][:, end:new_end] = k
+            kv_cache["v"][:, end:new_end] = v
+            kv_cache["end"] = new_end
+
+            x = optimized_attention(
+                q.view(b, s, n * d),
+                kv_cache["k"][:, :new_end].view(b, new_end, n * d),
+                kv_cache["v"][:, :new_end].view(b, new_end, n * d),
+                heads=self.num_heads,
+                transformer_options=transformer_options,
+            )
+
+        x = self.o(x)
+        return x
+
+
+class CausalWanAttentionBlock(WanAttentionBlock):
+    """Transformer block with KV-cached self-attention and cross-attention caching."""
+
+    def __init__(self, cross_attn_type, dim, ffn_dim, num_heads,
+                 window_size=(-1, -1), qk_norm=True, cross_attn_norm=False,
+                 eps=1e-6, operation_settings={}):
+        super().__init__(cross_attn_type, dim, ffn_dim, num_heads,
+                         window_size, qk_norm, cross_attn_norm, eps,
+                         operation_settings=operation_settings)
+        self.self_attn = CausalWanSelfAttention(
+            dim, num_heads, window_size, qk_norm, eps,
+            operation_settings=operation_settings)
+
+    def forward(self, x, e, freqs, context, context_img_len=257,
+                kv_cache=None, crossattn_cache=None, transformer_options={}):
+        if e.ndim < 4:
+            e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device) + e).chunk(6, dim=1)
+        else:
+            e = (comfy.model_management.cast_to(self.modulation, dtype=x.dtype, device=x.device).unsqueeze(0) + e).unbind(2)
+
+        # Self-attention with optional KV cache
+        x = x.contiguous()
+        y = self.self_attn(
+            torch.addcmul(repeat_e(e[0], x), self.norm1(x), 1 + repeat_e(e[1], x)),
+            freqs, kv_cache=kv_cache, transformer_options=transformer_options)
+        x = torch.addcmul(x, y, repeat_e(e[2], x))
+        del y
+
+        # Cross-attention with optional caching
+        if crossattn_cache is not None and crossattn_cache.get("is_init"):
+            q = self.cross_attn.norm_q(self.cross_attn.q(self.norm3(x)))
+            x_ca = optimized_attention(
+                q, crossattn_cache["k"], crossattn_cache["v"],
+                heads=self.num_heads, transformer_options=transformer_options)
+            x = x + self.cross_attn.o(x_ca)
+        else:
+            x = x + self.cross_attn(self.norm3(x), context, context_img_len=context_img_len, transformer_options=transformer_options)
+            if crossattn_cache is not None:
+                crossattn_cache["k"] = self.cross_attn.norm_k(self.cross_attn.k(context))
+                crossattn_cache["v"] = self.cross_attn.v(context)
+                crossattn_cache["is_init"] = True
+
+        # FFN
+        y = self.ffn(torch.addcmul(repeat_e(e[3], x), self.norm2(x), 1 + repeat_e(e[4], x)))
+        x = torch.addcmul(x, y, repeat_e(e[5], x))
+        return x
+
+
+class CausalWanModel(WanModel):
+    """
+    Wan 2.1 diffusion backbone with causal KV-cache support.
+
+    Same weight structure as WanModel -- loads identical state dicts.
+    Adds forward_block() for frame-by-frame autoregressive inference.
+    """
+
+    def __init__(self,
+                 model_type='t2v',
+                 patch_size=(1, 2, 2),
+                 text_len=512,
+                 in_dim=16,
+                 dim=2048,
+                 ffn_dim=8192,
+                 freq_dim=256,
+                 text_dim=4096,
+                 out_dim=16,
+                 num_heads=16,
+                 num_layers=32,
+                 window_size=(-1, -1),
+                 qk_norm=True,
+                 cross_attn_norm=True,
+                 eps=1e-6,
+                 image_model=None,
+                 device=None,
+                 dtype=None,
+                 operations=None):
+        super().__init__(
+            model_type=model_type, patch_size=patch_size, text_len=text_len,
+            in_dim=in_dim, dim=dim, ffn_dim=ffn_dim, freq_dim=freq_dim,
+            text_dim=text_dim, out_dim=out_dim, num_heads=num_heads,
+            num_layers=num_layers, window_size=window_size, qk_norm=qk_norm,
+            cross_attn_norm=cross_attn_norm, eps=eps, image_model=image_model,
+            wan_attn_block_class=CausalWanAttentionBlock,
+            device=device, dtype=dtype, operations=operations)
+
+    def forward_block(self, x, timestep, context, start_frame,
+                      kv_caches, crossattn_caches, clip_fea=None):
+        """
+        Forward one temporal block for autoregressive inference.
+
+        Args:
+            x: [B, C, block_frames, H, W] input latent for the current block
+            timestep: [B, block_frames] per-frame timesteps
+            context: [B, L, text_dim] raw text embeddings (pre-text_embedding)
+            start_frame: temporal frame index for RoPE offset
+            kv_caches: list of per-layer KV cache dicts
+            crossattn_caches: list of per-layer cross-attention cache dicts
+            clip_fea: optional CLIP features for I2V
+
+        Returns:
+            flow_pred: [B, C_out, block_frames, H, W] flow prediction
+        """
+        x = comfy.ldm.common_dit.pad_to_patch_size(x, self.patch_size)
+        bs, c, t, h, w = x.shape
+
+        x = self.patch_embedding(x.float()).to(x.dtype)
+        grid_sizes = x.shape[2:]
+        x = x.flatten(2).transpose(1, 2)
+
+        # Per-frame time embedding
+        e = self.time_embedding(
+            sinusoidal_embedding_1d(self.freq_dim, timestep.flatten()).to(dtype=x.dtype))
+        e = e.reshape(timestep.shape[0], -1, e.shape[-1])
+        e0 = self.time_projection(e).unflatten(2, (6, self.dim))
+
+        # Text embedding (reuses crossattn_cache after first block)
+        context = self.text_embedding(context)
+
+        context_img_len = None
+        if clip_fea is not None and self.img_emb is not None:
+            context_clip = self.img_emb(clip_fea)
+            context = torch.concat([context_clip, context], dim=1)
+            context_img_len = clip_fea.shape[-2]
+
+        # RoPE for current block's temporal position
+        freqs = self.rope_encode(t, h, w, t_start=start_frame, device=x.device, dtype=x.dtype)
+
+        # Transformer blocks
+        for i, block in enumerate(self.blocks):
+            x = block(x, e=e0, freqs=freqs, context=context,
+                      context_img_len=context_img_len,
+                      kv_cache=kv_caches[i],
+                      crossattn_cache=crossattn_caches[i])
+
+        # Head
+        x = self.head(x, e)
+
+        # Unpatchify
+        x = self.unpatchify(x, grid_sizes)
+        return x[:, :, :t, :h, :w]
+
+    def init_kv_caches(self, batch_size, max_seq_len, device, dtype):
+        """Create fresh KV caches for all layers."""
+        caches = []
+        for _ in range(self.num_layers):
+            caches.append({
+                "k": torch.zeros(batch_size, max_seq_len, self.num_heads, self.head_dim, device=device, dtype=dtype),
+                "v": torch.zeros(batch_size, max_seq_len, self.num_heads, self.head_dim, device=device, dtype=dtype),
+                "end": 0,
+            })
+        return caches
+
+    def init_crossattn_caches(self, batch_size, device, dtype):
+        """Create fresh cross-attention caches for all layers."""
+        caches = []
+        for _ in range(self.num_layers):
+            caches.append({"is_init": False})
+        return caches
+
+    def reset_kv_caches(self, kv_caches):
+        """Reset KV caches to empty (reuse allocated memory)."""
+        for cache in kv_caches:
+            cache["end"] = 0
+
+    def reset_crossattn_caches(self, crossattn_caches):
+        """Reset cross-attention caches."""
+        for cache in crossattn_caches:
+            cache["is_init"] = False
+
+    @property
+    def head_dim(self):
+        return self.dim // self.num_heads
+
+    def forward(self, x, timestep, context, clip_fea=None, time_dim_concat=None, transformer_options={}, **kwargs):
+        ar_state = transformer_options.get("ar_state")
+        if ar_state is not None:
+            bs = x.shape[0]
+            block_frames = x.shape[2]
+            t_per_frame = timestep.unsqueeze(1).expand(bs, block_frames)
+            return self.forward_block(
+                x=x, timestep=t_per_frame, context=context,
+                start_frame=ar_state["start_frame"],
+                kv_caches=ar_state["kv_caches"],
+                crossattn_caches=ar_state["crossattn_caches"],
+                clip_fea=clip_fea,
+            )
+
+        return super().forward(x, timestep, context, clip_fea=clip_fea,
+                               time_dim_concat=time_dim_concat,
+                               transformer_options=transformer_options, **kwargs)

comfy/model_base.py

@@ -42,6 +42,7 @@ import comfy.ldm.cosmos.predict2
 import comfy.ldm.lumina.model
 import comfy.ldm.wan.model
 import comfy.ldm.wan.model_animate
+import comfy.ldm.wan.ar_model
 import comfy.ldm.hunyuan3d.model
 import comfy.ldm.hidream.model
 import comfy.ldm.chroma.model
@@ -1365,6 +1366,13 @@ class WAN21(BaseModel):
         return out
 
 
+class WAN21_CausalAR(WAN21):
+    def __init__(self, model_config, model_type=ModelType.FLOW, device=None):
+        super(WAN21, self).__init__(model_config, model_type, device=device,
+                                    unet_model=comfy.ldm.wan.ar_model.CausalWanModel)
+        self.image_to_video = False
+
+
 class WAN21_Vace(WAN21):
     def __init__(self, model_config, model_type=ModelType.FLOW, image_to_video=False, device=None):
         super(WAN21, self).__init__(model_config, model_type, device=device, unet_model=comfy.ldm.wan.model.VaceWanModel)

comfy/model_management.py

@@ -721,13 +721,15 @@ def load_models_gpu(models, memory_required=0, force_patch_weights=False, minimu
     else:
         minimum_memory_required = max(inference_memory, minimum_memory_required + extra_reserved_memory())
 
-    models_temp = set()
+    # Order-preserving dedup. A plain set() would randomize iteration order across runs
+    models_temp = {}
     for m in models:
-        models_temp.add(m)
+        models_temp[m] = None
         for mm in m.model_patches_models():
-            models_temp.add(mm)
+            models_temp[mm] = None
 
-    models = models_temp
+    models = list(models_temp)
+    models.reverse()
 
     models_to_load = []
 

comfy/model_prefetch.py

@@ -37,7 +37,8 @@ def prefetch_queue_pop(queue, device, module):
     consumed = queue.pop(0)
     if consumed is not None:
         offload_stream, prefetch_state = consumed
-        offload_stream.wait_stream(comfy.model_management.current_stream(device))
+        if offload_stream is not None:
+            offload_stream.wait_stream(comfy.model_management.current_stream(device))
         _, comfy_modules = prefetch_state
         if comfy_modules is not None:
             cleanup_prefetched_modules(comfy_modules)

comfy/ops.py

@@ -253,6 +253,9 @@ def resolve_cast_module_with_vbar(s, dtype, device, bias_dtype, compute_dtype, w
     if bias is not None:
         bias = post_cast(s, "bias", bias, bias_dtype, prefetch["resident"], update_weight)
 
+    if prefetch["signature"] is not None:
+        prefetch["resident"] = True
+
     return weight, bias
 
 

comfy/quant_ops.py

@@ -1,6 +1,8 @@
 import torch
 import logging
 
+from comfy.cli_args import args
+
 try:
     import comfy_kitchen as ck
     from comfy_kitchen.tensor import (
@@ -21,7 +23,15 @@ try:
             ck.registry.disable("cuda")
             logging.warning("WARNING: You need pytorch with cu130 or higher to use optimized CUDA operations.")
 
-    ck.registry.disable("triton")
+    if args.enable_triton_backend:
+        try:
+            import triton
+            logging.info("Found triton %s. Enabling comfy-kitchen triton backend.", triton.__version__)
+        except ImportError as e:
+            logging.error(f"Failed to import triton, Error: {e}, the comfy-kitchen triton backend will not be available.")
+            ck.registry.disable("triton")
+    else:
+        ck.registry.disable("triton")
     for k, v in ck.list_backends().items():
         logging.info(f"Found comfy_kitchen backend {k}: {v}")
 except ImportError as e:

comfy/sampler_helpers.py

@@ -89,7 +89,8 @@ def get_additional_models(conds, dtype):
         gligen += get_models_from_cond(conds[k], "gligen")
         add_models += get_models_from_cond(conds[k], "additional_models")
 
-    control_nets = set(cnets)
+    # Order-preserving dedup. A plain set() would randomize iteration order across runs
+    control_nets = list(dict.fromkeys(cnets))
 
     inference_memory = 0
     control_models = []

comfy/supported_models.py

@@ -1167,6 +1167,25 @@ class WAN21_T2V(supported_models_base.BASE):
         t5_detect = comfy.text_encoders.sd3_clip.t5_xxl_detect(state_dict, "{}umt5xxl.transformer.".format(pref))
         return supported_models_base.ClipTarget(comfy.text_encoders.wan.WanT5Tokenizer, comfy.text_encoders.wan.te(**t5_detect))
 
+class WAN21_CausalAR_T2V(WAN21_T2V):
+    unet_config = {
+        "image_model": "wan2.1",
+        "model_type": "t2v",
+        "causal_ar": True,
+    }
+
+    sampling_settings = {
+        "shift": 5.0,
+    }
+
+    def __init__(self, unet_config):
+        super().__init__(unet_config)
+        self.unet_config.pop("causal_ar", None)
+
+    def get_model(self, state_dict, prefix="", device=None):
+        return model_base.WAN21_CausalAR(self, device=device)
+
+
 class WAN21_I2V(WAN21_T2V):
     unet_config = {
         "image_model": "wan2.1",
@@ -1929,6 +1948,7 @@ models = [
     ZImage,
     Lumina2,
     WAN22_T2V,
+    WAN21_CausalAR_T2V,
     WAN21_T2V,
     WAN21_I2V,
     WAN21_FunControl2V,

comfy/utils.py

@@ -119,6 +119,76 @@ def load_safetensors(ckpt):
     return sd, header.get("__metadata__", {}),
 
 
+def load_safetensors_no_mmap(ckpt, device=None, return_metadata=False):
+    # Load a .safetensors / .sft file without ever mmap'ing it.
+    #
+    # safetensors.safe_open() (and therefore safetensors.torch.load_file) always
+    # mmaps the underlying file in Rust. On systems with unified CPU/GPU memory
+    # like NVIDIA Grace Blackwell / DGX Spark, Apple Silicon, AMD APUs, etc.
+    # this is fatal for large models: the OS page-cache pages backing the mmap
+    # and any subsequent device copy both reside in the same physical memory
+    # pool, doubling peak memory and causing OOM well before the hardware
+    # limit is reached.
+    # See: https://github.com/Comfy-Org/ComfyUI/issues/10896
+    #      https://github.com/safetensors/safetensors/issues/758
+    #      https://github.com/safetensors/safetensors/pull/759
+    #
+    # This is a temporary workaround until upstream safetensors exposes a
+    # public ``mmap=False`` option. Here we parse the safetensors header
+    # ourselves and read each tensor straight from disk into a per-tensor
+    # ``bytearray`` via ``readinto``, then zero-copy-wrap it as a torch tensor
+    # with ``torch.frombuffer``. Peak memory is one model copy (plus, if a
+    # non-CPU device is requested, the bytes of a single tensor in flight
+    # while it is being moved).
+    if device is None:
+        device = torch.device("cpu")
+
+    sd = {}
+    metadata = None
+    with open(ckpt, "rb") as f:
+        header_bytes = f.read(8)
+        if len(header_bytes) != 8:
+            raise ValueError("HeaderTooLarge: file is too small to be a valid safetensors file: {}".format(ckpt))
+        header_size = struct.unpack("<Q", header_bytes)[0]
+        header_data = f.read(header_size)
+        if len(header_data) != header_size:
+            raise ValueError("MetadataIncompleteBuffer: truncated header in {}".format(ckpt))
+        header = json.loads(header_data.decode("utf-8"))
+        data_base_offset = 8 + header_size
+
+        if return_metadata:
+            metadata = header.get("__metadata__", {})
+
+        for name, info in header.items():
+            if name == "__metadata__":
+                continue
+
+            dtype = _TYPES[info["dtype"]]
+            shape = info["shape"]
+            start, end = info["data_offsets"]
+            num_bytes = end - start
+
+            if num_bytes == 0:
+                tensor = torch.empty(shape, dtype=dtype)
+            else:
+                buf = bytearray(num_bytes)
+                f.seek(data_base_offset + start)
+                view = memoryview(buf)
+                offset = 0
+                while offset < num_bytes:
+                    n = f.readinto(view[offset:])
+                    if not n:
+                        raise ValueError("MetadataIncompleteBuffer: unexpected EOF reading tensor {!r} from {}".format(name, ckpt))
+                    offset += n
+                tensor = torch.frombuffer(buf, dtype=dtype).reshape(shape)
+
+            if device.type != "cpu":
+                tensor = tensor.to(device=device)
+            sd[name] = tensor
+
+    return sd, metadata
+
+
 def load_torch_file(ckpt, safe_load=False, device=None, return_metadata=False):
     if device is None:
         device = torch.device("cpu")
@@ -129,14 +199,15 @@ def load_torch_file(ckpt, safe_load=False, device=None, return_metadata=False):
                 sd, metadata = load_safetensors(ckpt)
                 if not return_metadata:
                     metadata = None
+            elif DISABLE_MMAP:
+                sd, metadata = load_safetensors_no_mmap(ckpt, device=device, return_metadata=return_metadata)
+                if not return_metadata:
+                    metadata = None
             else:
                 with safetensors.safe_open(ckpt, framework="pt", device=device.type) as f:
                     sd = {}
                     for k in f.keys():
-                        tensor = f.get_tensor(k)
-                        if DISABLE_MMAP:  # TODO: Not sure if this is the best way to bypass the mmap issues
-                            tensor = tensor.to(device=device, copy=True)
-                        sd[k] = tensor
+                        sd[k] = f.get_tensor(k)
                     if return_metadata:
                         metadata = f.metadata()
         except Exception as e:

comfy_api/feature_flags.py

@@ -5,12 +5,95 @@ This module handles capability negotiation between frontend and backend,
 allowing graceful protocol evolution while maintaining backward compatibility.
 """
 
-from typing import Any
+import logging
+from typing import Any, TypedDict
 
 from comfy.cli_args import args
 
+
+class FeatureFlagInfo(TypedDict):
+    type: str
+    default: Any
+    description: str
+
+
+# Registry of known CLI-settable feature flags.
+# Launchers can query this via --list-feature-flags to discover valid flags.
+CLI_FEATURE_FLAG_REGISTRY: dict[str, FeatureFlagInfo] = {
+    "show_signin_button": {
+        "type": "bool",
+        "default": False,
+        "description": "Show the sign-in button in the frontend even when not signed in",
+    },
+}
+
+
+def _coerce_bool(v: str) -> bool:
+    """Strict bool coercion: only 'true'/'false' (case-insensitive).
+
+    Anything else raises ValueError so the caller can warn and drop the flag,
+    rather than silently treating typos like 'ture' or 'yes' as False.
+    """
+    lower = v.lower()
+    if lower == "true":
+        return True
+    if lower == "false":
+        return False
+    raise ValueError(f"expected 'true' or 'false', got {v!r}")
+
+
+_COERCE_FNS: dict[str, Any] = {
+    "bool": _coerce_bool,
+    "int": lambda v: int(v),
+    "float": lambda v: float(v),
+}
+
+
+def _coerce_flag_value(key: str, raw_value: str) -> Any:
+    """Coerce a raw string value using the registry type, or keep as string.
+
+    Returns the raw string if the key is unregistered or the type is unknown.
+    Raises ValueError/TypeError if the key is registered with a known type but
+    the value cannot be coerced; callers are expected to warn and drop the flag.
+    """
+    info = CLI_FEATURE_FLAG_REGISTRY.get(key)
+    if info is None:
+        return raw_value
+    coerce = _COERCE_FNS.get(info["type"])
+    if coerce is None:
+        return raw_value
+    return coerce(raw_value)
+
+
+def _parse_cli_feature_flags() -> dict[str, Any]:
+    """Parse --feature-flag key=value pairs from CLI args into a dict.
+
+    Items without '=' default to the value 'true' (bare flag form).
+    Flags whose value cannot be coerced to the registered type are dropped
+    with a warning, so a typo like '--feature-flag some_bool=ture' does not
+    silently take effect as the wrong value.
+    """
+    result: dict[str, Any] = {}
+    for item in getattr(args, "feature_flag", []):
+        key, sep, raw_value = item.partition("=")
+        key = key.strip()
+        if not key:
+            continue
+        if not sep:
+            raw_value = "true"
+        try:
+            result[key] = _coerce_flag_value(key, raw_value.strip())
+        except (ValueError, TypeError) as e:
+            info = CLI_FEATURE_FLAG_REGISTRY.get(key, {})
+            logging.warning(
+                "Could not coerce --feature-flag %s=%r to %s (%s); dropping flag.",
+                key, raw_value.strip(), info.get("type", "?"), e,
+            )
+    return result
+
+
 # Default server capabilities
-SERVER_FEATURE_FLAGS: dict[str, Any] = {
+_CORE_FEATURE_FLAGS: dict[str, Any] = {
     "supports_preview_metadata": True,
     "max_upload_size": args.max_upload_size * 1024 * 1024, # Convert MB to bytes
     "extension": {"manager": {"supports_v4": True}},
@@ -18,6 +101,11 @@ SERVER_FEATURE_FLAGS: dict[str, Any] = {
     "assets": args.enable_assets,
 }
 
+# CLI-provided flags cannot overwrite core flags
+_cli_flags = {k: v for k, v in _parse_cli_feature_flags().items() if k not in _CORE_FEATURE_FLAGS}
+
+SERVER_FEATURE_FLAGS: dict[str, Any] = {**_CORE_FEATURE_FLAGS, **_cli_flags}
+
 
 def get_connection_feature(
     sockets_metadata: dict[str, dict[str, Any]],

comfy_api_nodes/apis/luma.py

@@ -1,15 +1,12 @@
 from __future__ import annotations
 
-
-import torch
-
 from enum import Enum
 from typing import Optional, Union
 
+import torch
 from pydantic import BaseModel, Field, confloat
 
 
-
 class LumaIO:
     LUMA_REF = "LUMA_REF"
     LUMA_CONCEPTS = "LUMA_CONCEPTS"
@@ -183,13 +180,13 @@ class LumaAssets(BaseModel):
 
 
 class LumaImageRef(BaseModel):
-    '''Used for image gen'''
+    """Used for image gen"""
     url: str = Field(..., description='The URL of the image reference')
     weight: confloat(ge=0.0, le=1.0) = Field(..., description='The weight of the image reference')
 
 
 class LumaImageReference(BaseModel):
-    '''Used for video gen'''
+    """Used for video gen"""
     type: Optional[str] = Field('image', description='Input type, defaults to image')
     url: str = Field(..., description='The URL of the image')
 
@@ -251,3 +248,32 @@ class LumaGeneration(BaseModel):
     assets: Optional[LumaAssets] = Field(None, description='The assets of the generation')
     model: str = Field(..., description='The model used for the generation')
     request: Union[LumaGenerationRequest, LumaImageGenerationRequest] = Field(..., description="The request used for the generation")
+
+
+class Luma2ImageRef(BaseModel):
+    url: str | None = None
+    data: str | None = None
+    media_type: str | None = None
+
+
+class Luma2GenerationRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=6000)
+    model: str | None = None
+    type: str | None = None
+    aspect_ratio: str | None = None
+    style: str | None = None
+    output_format: str | None = None
+    web_search: bool | None = None
+    image_ref: list[Luma2ImageRef] | None = None
+    source: Luma2ImageRef | None = None
+
+
+class Luma2Generation(BaseModel):
+    id: str | None = None
+    type: str | None = None
+    state: str | None = None
+    model: str | None = None
+    created_at: str | None = None
+    output: list[LumaImageReference] | None = None
+    failure_reason: str | None = None
+    failure_code: str | None = None

comfy_api_nodes/apis/openai.py

@@ -56,14 +56,14 @@ class ModelResponseProperties(BaseModel):
     instructions: str | None = Field(None)
     max_output_tokens: int | None = Field(None)
     model: str | None = Field(None)
-    temperature: float | None = Field(1, description="Controls randomness in the response", ge=0.0, le=2.0)
+    temperature: float | None = Field(None, description="Controls randomness in the response", ge=0.0, le=2.0)
     top_p: float | None = Field(
-        1,
+        None,
         description="Controls diversity of the response via nucleus sampling",
         ge=0.0,
         le=1.0,
     )
-    truncation: str | None = Field("disabled", description="Allowed values: 'auto' or 'disabled'")
+    truncation: str | None = Field(None, description="Allowed values: 'auto' or 'disabled'")
 
 
 class ResponseProperties(BaseModel):

comfy_api_nodes/nodes_luma.py

@@ -1,10 +1,11 @@
-from typing import Optional
-
 import torch
 from typing_extensions import override
 
-from comfy_api.latest import IO, ComfyExtension
+from comfy_api.latest import IO, ComfyExtension, Input
 from comfy_api_nodes.apis.luma import (
+    Luma2Generation,
+    Luma2GenerationRequest,
+    Luma2ImageRef,
     LumaAspectRatio,
     LumaCharacterRef,
     LumaConceptChain,
@@ -30,6 +31,7 @@ from comfy_api_nodes.util import (
     download_url_to_video_output,
     poll_op,
     sync_op,
+    upload_image_to_comfyapi,
     upload_images_to_comfyapi,
     validate_string,
 )
@@ -212,9 +214,9 @@ class LumaImageGenerationNode(IO.ComfyNode):
         aspect_ratio: str,
         seed,
         style_image_weight: float,
-        image_luma_ref: Optional[LumaReferenceChain] = None,
-        style_image: Optional[torch.Tensor] = None,
-        character_image: Optional[torch.Tensor] = None,
+        image_luma_ref: LumaReferenceChain | None = None,
+        style_image: torch.Tensor | None = None,
+        character_image: torch.Tensor | None = None,
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=True, min_length=3)
         # handle image_luma_ref
@@ -434,7 +436,7 @@ class LumaTextToVideoGenerationNode(IO.ComfyNode):
         duration: str,
         loop: bool,
         seed,
-        luma_concepts: Optional[LumaConceptChain] = None,
+        luma_concepts: LumaConceptChain | None = None,
     ) -> IO.NodeOutput:
         validate_string(prompt, strip_whitespace=False, min_length=3)
         duration = duration if model != LumaVideoModel.ray_1_6 else None
@@ -533,7 +535,6 @@ class LumaImageToVideoGenerationNode(IO.ComfyNode):
             ],
             is_api_node=True,
             price_badge=PRICE_BADGE_VIDEO,
-
         )
 
     @classmethod
@@ -644,6 +645,293 @@ PRICE_BADGE_VIDEO = IO.PriceBadge(
 )
 
 
+def _luma2_uni1_common_inputs(max_image_refs: int) -> list:
+    return [
+        IO.Combo.Input(
+            "style",
+            options=["auto", "manga"],
+            default="auto",
+            tooltip="Style preset. 'auto' picks based on the prompt; "
+            "'manga' applies a manga/anime aesthetic and requires a portrait "
+            "aspect ratio (2:3, 9:16, 1:2, 1:3).",
+        ),
+        IO.Boolean.Input(
+            "web_search",
+            default=False,
+            tooltip="Search the web for visual references before generating.",
+        ),
+        IO.Autogrow.Input(
+            "image_ref",
+            template=IO.Autogrow.TemplateNames(
+                IO.Image.Input("image"),
+                names=[f"image_{i}" for i in range(1, max_image_refs + 1)],
+                min=0,
+            ),
+            optional=True,
+            tooltip=f"Up to {max_image_refs} reference images for style/content guidance.",
+        ),
+    ]
+
+
+async def _luma2_upload_image_refs(
+    cls: type[IO.ComfyNode],
+    refs: dict | None,
+    max_count: int,
+) -> list[Luma2ImageRef] | None:
+    if not refs:
+        return None
+    out: list[Luma2ImageRef] = []
+    for key in refs:
+        url = await upload_image_to_comfyapi(cls, refs[key])
+        out.append(Luma2ImageRef(url=url))
+    if len(out) > max_count:
+        raise ValueError(f"Maximum {max_count} reference images are allowed.")
+    return out or None
+
+
+async def _luma2_submit_and_poll(
+    cls: type[IO.ComfyNode],
+    request: Luma2GenerationRequest,
+) -> Input.Image:
+    initial = await sync_op(
+        cls,
+        ApiEndpoint(path="/proxy/luma_2/generations", method="POST"),
+        response_model=Luma2Generation,
+        data=request,
+    )
+    if not initial.id:
+        raise RuntimeError("Luma 2 API did not return a generation id.")
+    final = await poll_op(
+        cls,
+        ApiEndpoint(path=f"/proxy/luma_2/generations/{initial.id}", method="GET"),
+        response_model=Luma2Generation,
+        status_extractor=lambda r: r.state,
+        progress_extractor=lambda r: None,
+    )
+    if not final.output:
+        msg = final.failure_reason or "no output returned"
+        raise RuntimeError(f"Luma 2 generation failed: {msg}")
+    url = final.output[0].url
+    if not url:
+        raise RuntimeError("Luma 2 generation completed without an output URL.")
+    return await download_url_to_image_tensor(url)
+
+
+class LumaImageNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="LumaImageNode2",
+            display_name="Luma UNI-1 Image",
+            category="api node/image/Luma",
+            description="Generate images from text using the Luma UNI-1 model.",
+            inputs=[
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    default="",
+                    tooltip="Text description of the desired image. 1–6000 characters.",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(
+                            "uni-1",
+                            [
+                                IO.Combo.Input(
+                                    "aspect_ratio",
+                                    options=[
+                                        "auto",
+                                        "3:1",
+                                        "2:1",
+                                        "16:9",
+                                        "3:2",
+                                        "1:1",
+                                        "2:3",
+                                        "9:16",
+                                        "1:2",
+                                        "1:3",
+                                    ],
+                                    default="auto",
+                                    tooltip="Output image aspect ratio. 'auto' lets "
+                                    "the model pick based on the prompt.",
+                                ),
+                                *_luma2_uni1_common_inputs(max_image_refs=9),
+                            ],
+                        ),
+                        IO.DynamicCombo.Option(
+                            "uni-1-max",
+                            [
+                                IO.Combo.Input(
+                                    "aspect_ratio",
+                                    options=[
+                                        "auto",
+                                        "3:1",
+                                        "2:1",
+                                        "16:9",
+                                        "3:2",
+                                        "1:1",
+                                        "2:3",
+                                        "9:16",
+                                        "1:2",
+                                        "1:3",
+                                    ],
+                                    default="auto",
+                                    tooltip="Output image aspect ratio. 'auto' lets "
+                                    "the model pick based on the prompt.",
+                                ),
+                                *_luma2_uni1_common_inputs(max_image_refs=9),
+                            ],
+                        ),
+                    ],
+                    tooltip="Model to use for generation.",
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=0,
+                    min=0,
+                    max=2147483647,
+                    control_after_generate=True,
+                    tooltip="Seed controls whether the node should re-run; "
+                    "results are non-deterministic regardless of seed.",
+                ),
+            ],
+            outputs=[IO.Image.Output()],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+            is_api_node=True,
+            price_badge=IO.PriceBadge(
+                depends_on=IO.PriceBadgeDepends(widgets=["model"], input_groups=["model.image_ref"]),
+                expr="""
+                (
+                  $m := widgets.model;
+                  $refs := $lookup(inputGroups, "model.image_ref");
+                  $base := $m = "uni-1-max" ? 0.1 : 0.0404;
+                  {"type":"usd","usd": $round($base + 0.003 * $refs, 4)}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        prompt: str,
+        model: dict,
+        seed: int,
+    ) -> IO.NodeOutput:
+        validate_string(prompt, min_length=1, max_length=6000)
+        aspect_ratio = model["aspect_ratio"]
+        style = model["style"]
+        allowed_manga_ratios = {"2:3", "9:16", "1:2", "1:3"}
+        if style == "manga" and aspect_ratio != "auto" and aspect_ratio not in allowed_manga_ratios:
+            raise ValueError(
+                f"'manga' style requires a portrait aspect ratio "
+                f"({', '.join(sorted(allowed_manga_ratios))}) or 'auto'; got '{aspect_ratio}'."
+            )
+        request = Luma2GenerationRequest(
+            prompt=prompt,
+            model=model["model"],
+            type="image",
+            aspect_ratio=aspect_ratio if aspect_ratio != "auto" else None,
+            style=style if style != "auto" else None,
+            output_format="png",
+            web_search=model["web_search"],
+            image_ref=await _luma2_upload_image_refs(cls, model.get("image_ref"), max_count=9),
+        )
+        return IO.NodeOutput(await _luma2_submit_and_poll(cls, request))
+
+
+class LumaImageEditNode(IO.ComfyNode):
+
+    @classmethod
+    def define_schema(cls) -> IO.Schema:
+        return IO.Schema(
+            node_id="LumaImageEditNode2",
+            display_name="Luma UNI-1 Image Edit",
+            category="api node/image/Luma",
+            description="Edit an existing image with a text prompt using the Luma UNI-1 model.",
+            inputs=[
+                IO.Image.Input(
+                    "source",
+                    tooltip="Source image to edit.",
+                ),
+                IO.String.Input(
+                    "prompt",
+                    multiline=True,
+                    default="",
+                    tooltip="Description of the desired edit. 1–6000 characters.",
+                ),
+                IO.DynamicCombo.Input(
+                    "model",
+                    options=[
+                        IO.DynamicCombo.Option(
+                            "uni-1",
+                            _luma2_uni1_common_inputs(max_image_refs=8),
+                        ),
+                        IO.DynamicCombo.Option(
+                            "uni-1-max",
+                            _luma2_uni1_common_inputs(max_image_refs=8),
+                        ),
+                    ],
+                    tooltip="Model to use for editing.",
+                ),
+                IO.Int.Input(
+                    "seed",
+                    default=0,
+                    min=0,
+                    max=2147483647,
+                    control_after_generate=True,
+                    tooltip="Seed controls whether the node should re-run; "
+                    "results are non-deterministic regardless of seed.",
+                ),
+            ],
+            outputs=[IO.Image.Output()],
+            hidden=[
+                IO.Hidden.auth_token_comfy_org,
+                IO.Hidden.api_key_comfy_org,
+                IO.Hidden.unique_id,
+            ],
+            is_api_node=True,
+            price_badge=IO.PriceBadge(
+                depends_on=IO.PriceBadgeDepends(widgets=["model"], input_groups=["model.image_ref"]),
+                expr="""
+                (
+                  $m := widgets.model;
+                  $refs := $lookup(inputGroups, "model.image_ref");
+                  $base := $m = "uni-1-max" ? 0.103 : 0.0434;
+                  {"type":"usd","usd": $round($base + 0.003 * $refs, 4)}
+                )
+                """,
+            ),
+        )
+
+    @classmethod
+    async def execute(
+        cls,
+        source: Input.Image,
+        prompt: str,
+        model: dict,
+        seed: int,
+    ) -> IO.NodeOutput:
+        validate_string(prompt, min_length=1, max_length=6000)
+        request = Luma2GenerationRequest(
+            prompt=prompt,
+            model=model["model"],
+            type="image_edit",
+            source=Luma2ImageRef(url=await upload_image_to_comfyapi(cls, source)),
+            style=model["style"] if model["style"] != "auto" else None,
+            output_format="png",
+            web_search=model["web_search"],
+            image_ref=await _luma2_upload_image_refs(cls, model.get("image_ref"), max_count=8),
+        )
+        return IO.NodeOutput(await _luma2_submit_and_poll(cls, request))
+
+
 class LumaExtension(ComfyExtension):
     @override
     async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -654,6 +942,8 @@ class LumaExtension(ComfyExtension):
             LumaImageToVideoGenerationNode,
             LumaReferenceNode,
             LumaConceptsNode,
+            LumaImageNode,
+            LumaImageEditNode,
         ]
 
 

comfy_api_nodes/nodes_openai.py

@@ -39,16 +39,18 @@ STARTING_POINT_ID_PATTERN = r"<starting_point_id:(.*)>"
 
 
 class SupportedOpenAIModel(str, Enum):
-    o4_mini = "o4-mini"
-    o1 = "o1"
-    o3 = "o3"
-    o1_pro = "o1-pro"
-    gpt_4_1 = "gpt-4.1"
-    gpt_4_1_mini = "gpt-4.1-mini"
-    gpt_4_1_nano = "gpt-4.1-nano"
+    gpt_5_5_pro = "gpt-5.5-pro"
+    gpt_5_5 = "gpt-5.5"
     gpt_5 = "gpt-5"
     gpt_5_mini = "gpt-5-mini"
     gpt_5_nano = "gpt-5-nano"
+    gpt_4_1 = "gpt-4.1"
+    gpt_4_1_mini = "gpt-4.1-mini"
+    gpt_4_1_nano = "gpt-4.1-nano"
+    o4_mini = "o4-mini"
+    o3 = "o3"
+    o1_pro = "o1-pro"
+    o1 = "o1"
 
 
 async def validate_and_cast_response(response, timeout: int = None) -> torch.Tensor:
@@ -739,6 +741,16 @@ class OpenAIChatNode(IO.ComfyNode):
                     "usd": [0.002, 0.008],
                     "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
                   }
+                  : $contains($m, "gpt-5.5-pro") ? {
+                    "type": "list_usd",
+                    "usd": [0.03, 0.18],
+                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
+                  }
+                  : $contains($m, "gpt-5.5") ? {
+                    "type": "list_usd",
+                    "usd": [0.005, 0.03],
+                    "format": { "approximate": true, "separator": "-", "suffix": " per 1K tokens" }
+                  }
                   : $contains($m, "gpt-5-nano") ? {
                     "type": "list_usd",
                     "usd": [0.00005, 0.0004],

comfy_api_nodes/nodes_sora.py

@@ -33,7 +33,7 @@ class OpenAIVideoSora2(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="OpenAIVideoSora2",
-            display_name="OpenAI Sora - Video (Deprecated)",
+            display_name="OpenAI Sora - Video (DEPRECATED)",
             category="api node/video/Sora",
             description=(
                 "OpenAI video and audio generation.\n\n"

comfy_api_nodes/util/client.py

@@ -19,6 +19,8 @@ from comfy import utils
 from comfy_api.latest import IO
 from server import PromptServer
 
+from comfy.deploy_environment import get_deploy_environment
+
 from . import request_logger
 from ._helpers import (
     default_base_url,
@@ -624,6 +626,7 @@ async def _request_base(cfg: _RequestConfig, expect_binary: bool):
         payload_headers = {"Accept": "*/*"} if expect_binary else {"Accept": "application/json"}
         if not parsed_url.scheme and not parsed_url.netloc:  # is URL relative?
             payload_headers.update(get_auth_header(cfg.node_cls))
+            payload_headers["Comfy-Env"] = get_deploy_environment()
         if cfg.endpoint.headers:
             payload_headers.update(cfg.endpoint.headers)
 

comfy_extras/frame_interpolation_models/film_net.py

@@ -199,6 +199,9 @@ class FILMNet(nn.Module):
     def get_dtype(self):
         return self.extract.extract_sublevels.convs[0][0].conv.weight.dtype
 
+    def memory_used_forward(self, shape, dtype):
+        return 1700 * shape[1] * shape[2] * dtype.itemsize
+
     def _build_warp_grids(self, H, W, device):
         """Pre-compute warp grids for all pyramid levels."""
         if (H, W) in self._warp_grids:

comfy_extras/frame_interpolation_models/ifnet.py

@@ -74,6 +74,9 @@ class IFNet(nn.Module):
     def get_dtype(self):
         return self.encode.cnn0.weight.dtype
 
+    def memory_used_forward(self, shape, dtype):
+        return 300 * shape[1] * shape[2] * dtype.itemsize
+
     def _build_warp_grids(self, H, W, device):
         if (H, W) in self._warp_grids:
             return

comfy_extras/nodes_ar_video.py

@@ -0,0 +1,84 @@
+"""
+ComfyUI nodes for autoregressive video generation (Causal Forcing, Self-Forcing, etc.).
+  - EmptyARVideoLatent: create 5D [B, C, T, H, W] video latent tensors
+  - SamplerARVideo: SAMPLER for the block-by-block autoregressive denoising loop
+"""
+
+import torch
+from typing_extensions import override
+
+import comfy.model_management
+import comfy.samplers
+from comfy_api.latest import ComfyExtension, io
+
+
+class EmptyARVideoLatent(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="EmptyARVideoLatent",
+            category="latent/video",
+            inputs=[
+                io.Int.Input("width", default=832, min=16, max=8192, step=16),
+                io.Int.Input("height", default=480, min=16, max=8192, step=16),
+                io.Int.Input("length", default=81, min=1, max=1024, step=4),
+                io.Int.Input("batch_size", default=1, min=1, max=64),
+            ],
+            outputs=[
+                io.Latent.Output(display_name="LATENT"),
+            ],
+        )
+
+    @classmethod
+    def execute(cls, width, height, length, batch_size) -> io.NodeOutput:
+        lat_t = ((length - 1) // 4) + 1
+        latent = torch.zeros(
+            [batch_size, 16, lat_t, height // 8, width // 8],
+            device=comfy.model_management.intermediate_device(),
+        )
+        return io.NodeOutput({"samples": latent})
+
+
+class SamplerARVideo(io.ComfyNode):
+    """Sampler for autoregressive video models (Causal Forcing, Self-Forcing).
+
+    All AR-loop parameters are owned by this node so they live in the workflow.
+    Add new widgets here as the AR sampler grows new options.
+    """
+
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id="SamplerARVideo",
+            display_name="Sampler AR Video",
+            category="sampling/custom_sampling/samplers",
+            inputs=[
+                io.Int.Input(
+                    "num_frame_per_block",
+                    default=1, min=1, max=64,
+                    tooltip="Frames per autoregressive block. 1 = framewise, "
+                            "3 = chunkwise. Must match the checkpoint's training mode.",
+                ),
+            ],
+            outputs=[io.Sampler.Output()],
+        )
+
+    @classmethod
+    def execute(cls, num_frame_per_block) -> io.NodeOutput:
+        extra_options = {
+            "num_frame_per_block": num_frame_per_block,
+        }
+        return io.NodeOutput(comfy.samplers.ksampler("ar_video", extra_options))
+
+
+class ARVideoExtension(ComfyExtension):
+    @override
+    async def get_node_list(self) -> list[type[io.ComfyNode]]:
+        return [
+            EmptyARVideoLatent,
+            SamplerARVideo,
+        ]
+
+
+async def comfy_entrypoint() -> ARVideoExtension:
+    return ARVideoExtension()

comfy_extras/nodes_compositing.py

@@ -202,14 +202,11 @@ class JoinImageWithAlpha(io.ComfyNode):
 
     @classmethod
     def execute(cls, image: torch.Tensor, alpha: torch.Tensor) -> io.NodeOutput:
-        batch_size = min(len(image), len(alpha))
-        out_images = []
-
+        batch_size = max(len(image), len(alpha))
         alpha = 1.0 - resize_mask(alpha, image.shape[1:])
-        for i in range(batch_size):
-           out_images.append(torch.cat((image[i][:,:,:3], alpha[i].unsqueeze(2)), dim=2))
-
-        return io.NodeOutput(torch.stack(out_images))
+        alpha = comfy.utils.repeat_to_batch_size(alpha, batch_size)
+        image = comfy.utils.repeat_to_batch_size(image, batch_size)
+        return io.NodeOutput(torch.cat((image[..., :3], alpha.unsqueeze(-1)), dim=-1))
 
 
 class CompositingExtension(ComfyExtension):

comfy_extras/nodes_frame_interpolation.py

@@ -37,7 +37,7 @@ class FrameInterpolationModelLoader(io.ComfyNode):
         model = cls._detect_and_load(sd)
         dtype = torch.float16 if model_management.should_use_fp16(model_management.get_torch_device()) else torch.float32
         model.eval().to(dtype)
-        patcher = comfy.model_patcher.ModelPatcher(
+        patcher = comfy.model_patcher.CoreModelPatcher(
             model,
             load_device=model_management.get_torch_device(),
             offload_device=model_management.unet_offload_device(),
@@ -78,7 +78,7 @@ class FrameInterpolate(io.ComfyNode):
         return io.Schema(
             node_id="FrameInterpolate",
             display_name="Frame Interpolate",
-            category="image/video",
+            category="video",
             search_aliases=["rife", "film", "frame interpolation", "slow motion", "interpolate frames", "vfi"],
             inputs=[
                 FrameInterpolationModel.Input("interp_model"),
@@ -98,16 +98,13 @@ class FrameInterpolate(io.ComfyNode):
         if num_frames < 2 or multiplier < 2:
             return io.NodeOutput(images)
 
-        model_management.load_model_gpu(interp_model)
         device = interp_model.load_device
         dtype = interp_model.model_dtype()
         inference_model = interp_model.model
-
-        # Free VRAM for inference activations (model weights + ~20x a single frame's worth)
-        H, W = images.shape[1], images.shape[2]
-        activation_mem = H * W * 3 * images.element_size() * 20
-        model_management.free_memory(activation_mem, device)
+        activation_mem = inference_model.memory_used_forward(images.shape, dtype)
+        model_management.load_models_gpu([interp_model], memory_required=activation_mem)
         align = getattr(inference_model, "pad_align", 1)
+        H, W = images.shape[1], images.shape[2]
 
         # Prepare a single padded frame on device for determining output dimensions
         def prepare_frame(idx):

comfy_extras/nodes_image_compare.py

@@ -11,7 +11,7 @@ class ImageCompare(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="ImageCompare",
-            display_name="Image Compare",
+            display_name="Compare Images",
             description="Compares two images side by side with a slider.",
             category="image",
             essentials_category="Image Tools",

comfy_extras/nodes_images.py

@@ -24,7 +24,7 @@ class ImageCrop(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageCrop",
             search_aliases=["trim"],
-            display_name="Image Crop (Deprecated)",
+            display_name="Crop Image (DEPRECATED)",
             category="image/transform",
             is_deprecated=True,
             essentials_category="Image Tools",
@@ -56,7 +56,7 @@ class ImageCropV2(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageCropV2",
             search_aliases=["trim"],
-            display_name="Image Crop",
+            display_name="Crop Image",
             category="image/transform",
             essentials_category="Image Tools",
             has_intermediate_output=True,
@@ -109,6 +109,7 @@ class RepeatImageBatch(IO.ComfyNode):
         return IO.Schema(
             node_id="RepeatImageBatch",
             search_aliases=["duplicate image", "clone image"],
+            display_name="Repeat Image Batch",
             category="image/batch",
             inputs=[
                 IO.Image.Input("image"),
@@ -131,6 +132,7 @@ class ImageFromBatch(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageFromBatch",
             search_aliases=["select image", "pick from batch", "extract image"],
+            display_name="Get Image from Batch",
             category="image/batch",
             inputs=[
                 IO.Image.Input("image"),
@@ -157,7 +159,8 @@ class ImageAddNoise(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageAddNoise",
             search_aliases=["film grain"],
-            category="image",
+            display_name="Add Noise to Image",
+            category="image/postprocessing",
             inputs=[
                 IO.Image.Input("image"),
                 IO.Int.Input(
@@ -259,7 +262,7 @@ class ImageStitch(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageStitch",
             search_aliases=["combine images", "join images", "concatenate images", "side by side"],
-            display_name="Image Stitch",
+            display_name="Stitch Images",
             description="Stitches image2 to image1 in the specified direction.\n"
             "If image2 is not provided, returns image1 unchanged.\n"
             "Optional spacing can be added between images.",
@@ -434,6 +437,7 @@ class ResizeAndPadImage(IO.ComfyNode):
         return IO.Schema(
             node_id="ResizeAndPadImage",
             search_aliases=["fit to size"],
+            display_name="Resize And Pad Image",
             category="image/transform",
             inputs=[
                 IO.Image.Input("image"),
@@ -485,6 +489,7 @@ class SaveSVGNode(IO.ComfyNode):
         return IO.Schema(
             node_id="SaveSVGNode",
             search_aliases=["export vector", "save vector graphics"],
+            display_name="Save SVG",
             description="Save SVG files on disk.",
             category="image/save",
             inputs=[
@@ -591,7 +596,7 @@ class ImageRotate(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="ImageRotate",
-            display_name="Image Rotate",
+            display_name="Rotate Image",
             search_aliases=["turn", "flip orientation"],
             category="image/transform",
             essentials_category="Image Tools",
@@ -624,6 +629,7 @@ class ImageFlip(IO.ComfyNode):
         return IO.Schema(
             node_id="ImageFlip",
             search_aliases=["mirror", "reflect"],
+            display_name="Flip Image",
             category="image/transform",
             inputs=[
                 IO.Image.Input("image"),
@@ -650,6 +656,7 @@ class ImageScaleToMaxDimension(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="ImageScaleToMaxDimension",
+            display_name="Scale Image to Max Dimension",
             category="image/upscaling",
             inputs=[
                 IO.Image.Input("image"),
@@ -709,7 +716,7 @@ class SplitImageToTileList(IO.ComfyNode):
     def get_grid_coords(width, height, tile_width, tile_height, overlap):
         coords = []
         stride_x = round(max(tile_width * 0.25, tile_width - overlap))
-        stride_y = round(max(tile_width * 0.25, tile_height - overlap))
+        stride_y = round(max(tile_height * 0.25, tile_height - overlap))
 
         y = 0
         while y < height:

comfy_extras/nodes_mask.py

@@ -80,7 +80,8 @@ class ImageCompositeMasked(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="ImageCompositeMasked",
-            search_aliases=["paste image", "overlay", "layer"],
+            search_aliases=["overlay", "layer", "paste image", "images composition"],
+            display_name="Image Composite Masked",
             category="image",
             inputs=[
                 IO.Image.Input("destination"),
@@ -201,6 +202,7 @@ class InvertMask(IO.ComfyNode):
         return IO.Schema(
             node_id="InvertMask",
             search_aliases=["reverse mask", "flip mask"],
+            display_name="Invert Mask",
             category="mask",
             inputs=[
                 IO.Mask.Input("mask"),
@@ -222,6 +224,7 @@ class CropMask(IO.ComfyNode):
         return IO.Schema(
             node_id="CropMask",
             search_aliases=["cut mask", "extract mask region", "mask slice"],
+            display_name="Crop Mask",
             category="mask",
             inputs=[
                 IO.Mask.Input("mask"),
@@ -247,7 +250,8 @@ class MaskComposite(IO.ComfyNode):
     def define_schema(cls):
         return IO.Schema(
             node_id="MaskComposite",
-            search_aliases=["combine masks", "blend masks", "layer masks"],
+            search_aliases=["combine masks", "blend masks", "layer masks", "masks composition"],
+            display_name="Combine Masks",
             category="mask",
             inputs=[
                 IO.Mask.Input("destination"),
@@ -298,6 +302,7 @@ class FeatherMask(IO.ComfyNode):
         return IO.Schema(
             node_id="FeatherMask",
             search_aliases=["soft edge mask", "blur mask edges", "gradient mask edge"],
+            display_name="Feather Mask",
             category="mask",
             inputs=[
                 IO.Mask.Input("mask"),

comfy_extras/nodes_morphology.py

@@ -59,7 +59,8 @@ class ImageRGBToYUV(io.ComfyNode):
         return io.Schema(
             node_id="ImageRGBToYUV",
             search_aliases=["color space conversion"],
-            category="image/batch",
+            display_name="Image RGB to YUV",
+            category="image/color",
             inputs=[
                 io.Image.Input("image"),
             ],
@@ -81,7 +82,8 @@ class ImageYUVToRGB(io.ComfyNode):
         return io.Schema(
             node_id="ImageYUVToRGB",
             search_aliases=["color space conversion"],
-            category="image/batch",
+            display_name="Image YUV to RGB",
+            category="image/color",
             inputs=[
                 io.Image.Input("Y"),
                 io.Image.Input("U"),

comfy_extras/nodes_post_processing.py

@@ -20,7 +20,8 @@ class Blend(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="ImageBlend",
-            display_name="Image Blend",
+            search_aliases=["mix images"],
+            display_name="Blend Images",
             category="image/postprocessing",
             essentials_category="Image Tools",
             inputs=[
@@ -224,6 +225,7 @@ class ImageScaleToTotalPixels(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="ImageScaleToTotalPixels",
+            display_name="Scale Image to Total Pixels",
             category="image/upscaling",
             inputs=[
                 io.Image.Input("image"),
@@ -568,7 +570,7 @@ class BatchImagesNode(io.ComfyNode):
         return io.Schema(
             node_id="BatchImagesNode",
             display_name="Batch Images",
-            category="image",
+            category="image/batch",
             essentials_category="Image Tools",
             search_aliases=["batch", "image batch", "batch images", "combine images", "merge images", "stack images"],
             inputs=[
@@ -666,12 +668,13 @@ class ColorTransfer(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="ColorTransfer",
+            display_name="Color Transfer",
             category="image/postprocessing",
             description="Match the colors of one image to another using various algorithms.",
             search_aliases=["color match", "color grading", "color correction", "match colors", "color transform", "mkl", "reinhard", "histogram"],
             inputs=[
                 io.Image.Input("image_target", tooltip="Image(s) to apply the color transform to."),
-                io.Image.Input("image_ref", optional=True, tooltip="Reference image(s) to match colors to. If not provided, processing is skipped"),
+                io.Image.Input("image_ref", tooltip="Reference image(s) to match colors to."),
                 io.Combo.Input("method", options=['reinhard_lab', 'mkl_lab', 'histogram'],),
                 io.DynamicCombo.Input("source_stats",
                     tooltip="per_frame: each frame matched to image_ref individually. uniform: pool stats across all source frames as baseline, match to image_ref. target_frame: use one chosen frame as the baseline for the transform to image_ref, applied uniformly to all frames (preserves relative differences)",

comfy_extras/nodes_primitive.py

@@ -9,7 +9,8 @@ class String(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="PrimitiveString",
-            display_name="String",
+            search_aliases=["text", "string", "text box", "prompt"],
+            display_name="Text String",
             category="utils/primitive",
             inputs=[
                 io.String.Input("value"),
@@ -27,7 +28,8 @@ class StringMultiline(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="PrimitiveStringMultiline",
-            display_name="String (Multiline)",
+            search_aliases=["text", "string", "text multiline", "string multiline", "text box", "prompt"],
+            display_name="Text String (Multiline)",
             category="utils/primitive",
             essentials_category="Basics",
             inputs=[
@@ -49,7 +51,7 @@ class Int(io.ComfyNode):
             display_name="Int",
             category="utils/primitive",
             inputs=[
-                io.Int.Input("value", min=-sys.maxsize, max=sys.maxsize, control_after_generate=True),
+                io.Int.Input("value", min=-sys.maxsize, max=sys.maxsize, control_after_generate=io.ControlAfterGenerate.fixed),
             ],
             outputs=[io.Int.Output()],
         )

comfy_extras/nodes_string.py

@@ -10,9 +10,9 @@ class StringConcatenate(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringConcatenate",
-            display_name="Text Concatenate",
-            category="utils/string",
-            search_aliases=["Concatenate", "text concat", "join text", "merge text", "combine strings", "concat", "concatenate", "append text", "combine text", "string"],
+            search_aliases=["concatenate", "text concat", "join text", "merge text", "combine strings", "string concat", "append text", "combine text"],
+            display_name="Concatenate Text",
+            category="text",
             inputs=[
                 io.String.Input("string_a", multiline=True),
                 io.String.Input("string_b", multiline=True),
@@ -33,9 +33,9 @@ class StringSubstring(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringSubstring",
-            search_aliases=["Substring", "extract text", "text portion"],
-            display_name="Text Substring",
-            category="utils/string",
+            search_aliases=["substring", "extract text", "text portion"],
+            display_name="Substring",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.Int.Input("start"),
@@ -58,7 +58,7 @@ class StringLength(io.ComfyNode):
             node_id="StringLength",
             search_aliases=["character count", "text size", "string length"],
             display_name="Text Length",
-            category="utils/string",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
             ],
@@ -77,9 +77,9 @@ class CaseConverter(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="CaseConverter",
-            search_aliases=["Case Converter", "text case", "uppercase", "lowercase", "capitalize"],
-            display_name="Text Case Converter",
-            category="utils/string",
+            search_aliases=["case converter", "text case", "uppercase", "lowercase", "capitalize"],
+            display_name="Convert Text Case",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.Combo.Input("mode", options=["UPPERCASE", "lowercase", "Capitalize", "Title Case"]),
@@ -110,9 +110,9 @@ class StringTrim(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringTrim",
-            search_aliases=["Trim", "clean whitespace", "remove whitespace", "strip"],
-            display_name="Text Trim",
-            category="utils/string",
+            search_aliases=["trim", "clean whitespace", "remove whitespace", "remove spaces","strip"],
+            display_name="Trim Text",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.Combo.Input("mode", options=["Both", "Left", "Right"]),
@@ -141,9 +141,9 @@ class StringReplace(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringReplace",
-            search_aliases=["Replace", "find and replace", "substitute", "swap text"],
-            display_name="Text Replace",
-            category="utils/string",
+            search_aliases=["replace", "find and replace", "substitute", "swap text"],
+            display_name="Replace Text",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("find", multiline=True),
@@ -164,9 +164,9 @@ class StringContains(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringContains",
-            search_aliases=["Contains", "text includes", "string includes"],
-            display_name="Text Contains",
-            category="utils/string",
+            search_aliases=["contains", "text includes", "string includes"],
+            display_name="Contains Text",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("substring", multiline=True),
@@ -192,9 +192,9 @@ class StringCompare(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="StringCompare",
-            search_aliases=["Compare", "text match", "string equals", "starts with", "ends with"],
-            display_name="Text Compare",
-            category="utils/string",
+            search_aliases=["compare", "text match", "string equals", "starts with", "ends with"],
+            display_name="Compare Text",
+            category="text",
             inputs=[
                 io.String.Input("string_a", multiline=True),
                 io.String.Input("string_b", multiline=True),
@@ -228,9 +228,9 @@ class RegexMatch(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="RegexMatch",
-            search_aliases=["Regex Match", "regex", "pattern match", "text contains", "string match"],
-            display_name="Text Match",
-            category="utils/string",
+            search_aliases=["regex match", "regex", "pattern match", "text contains", "string match"],
+            display_name="Match Text",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("regex_pattern", multiline=True),
@@ -269,9 +269,9 @@ class RegexExtract(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="RegexExtract",
-            search_aliases=["Regex Extract", "regex", "pattern extract", "text parser", "parse text"],
-            display_name="Text Extract Substring",
-            category="utils/string",
+            search_aliases=["regex extract", "regex", "pattern extract", "text parser", "parse text"],
+            display_name="Extract Text",
+            category="text",
             inputs=[
                 io.String.Input("string", multiline=True),
                 io.String.Input("regex_pattern", multiline=True),
@@ -344,9 +344,9 @@ class RegexReplace(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="RegexReplace",
-            search_aliases=["Regex Replace", "regex", "pattern replace", "regex replace", "substitution"],
-            display_name="Text Replace (Regex)",
-            category="utils/string",
+            search_aliases=["regex replace", "regex", "pattern replace", "substitution"],
+            display_name="Replace Text (Regex)",
+            category="text",
             description="Find and replace text using regex patterns.",
             inputs=[
                 io.String.Input("string", multiline=True),
@@ -381,8 +381,8 @@ class JsonExtractString(io.ComfyNode):
     def define_schema(cls):
         return io.Schema(
             node_id="JsonExtractString",
-            display_name="Extract String from JSON",
-            category="utils/string",
+            display_name="Extract Text from JSON",
+            category="text",
             search_aliases=["json", "extract json", "parse json", "json value", "read json"],
             inputs=[
                 io.String.Input("json_string", multiline=True),

comfy_extras/nodes_video.py

@@ -17,7 +17,8 @@ class SaveWEBM(io.ComfyNode):
         return io.Schema(
             node_id="SaveWEBM",
             search_aliases=["export webm"],
-            category="image/video",
+            display_name="Save WEBM",
+            category="video",
             is_experimental=True,
             inputs=[
                 io.Image.Input("images"),
@@ -72,7 +73,7 @@ class SaveVideo(io.ComfyNode):
             node_id="SaveVideo",
             search_aliases=["export video"],
             display_name="Save Video",
-            category="image/video",
+            category="video",
             essentials_category="Basics",
             description="Saves the input images to your ComfyUI output directory.",
             inputs=[
@@ -121,7 +122,7 @@ class CreateVideo(io.ComfyNode):
             node_id="CreateVideo",
             search_aliases=["images to video"],
             display_name="Create Video",
-            category="image/video",
+            category="video",
             description="Create a video from images.",
             inputs=[
                 io.Image.Input("images", tooltip="The images to create a video from."),
@@ -146,7 +147,7 @@ class GetVideoComponents(io.ComfyNode):
             node_id="GetVideoComponents",
             search_aliases=["extract frames", "split video", "video to images", "demux"],
             display_name="Get Video Components",
-            category="image/video",
+            category="video",
             description="Extracts all components from a video: frames, audio, and framerate.",
             inputs=[
                 io.Video.Input("video", tooltip="The video to extract components from."),
@@ -174,7 +175,7 @@ class LoadVideo(io.ComfyNode):
             node_id="LoadVideo",
             search_aliases=["import video", "open video", "video file"],
             display_name="Load Video",
-            category="image/video",
+            category="video",
             essentials_category="Basics",
             inputs=[
                 io.Combo.Input("file", options=sorted(files), upload=io.UploadType.video),
@@ -216,7 +217,7 @@ class VideoSlice(io.ComfyNode):
                 "frame load cap",
                 "start time",
             ],
-            category="image/video",
+            category="video",
             essentials_category="Video Tools",
             inputs=[
                 io.Video.Input("video"),

extra_model_paths.yaml.example

@@ -28,7 +28,7 @@
 #config for a1111 ui
 #all you have to do is uncomment this (remove the #) and change the base_path to where yours is installed
 
-#a111:
+#a1111:
 #     base_path: path/to/stable-diffusion-webui/
 #     checkpoints: models/Stable-diffusion
 #     configs: models/Stable-diffusion

main.py

@@ -1,13 +1,21 @@
 import comfy.options
 comfy.options.enable_args_parsing()
 
+from comfy.cli_args import args
+
+if args.list_feature_flags:
+    import json
+    from comfy_api.feature_flags import CLI_FEATURE_FLAG_REGISTRY
+    print(json.dumps(CLI_FEATURE_FLAG_REGISTRY, indent=2))  # noqa: T201
+    raise SystemExit(0)
+
 import os
 import importlib.util
 import shutil
 import importlib.metadata
 import folder_paths
 import time
-from comfy.cli_args import args, enables_dynamic_vram
+from comfy.cli_args import enables_dynamic_vram
 from app.logger import setup_logger
 setup_logger(log_level=args.verbose, use_stdout=args.log_stdout)
 

node_helpers.py

@@ -86,6 +86,6 @@ def image_alpha_fix(destination, source):
     if destination.shape[-1] < source.shape[-1]:
         source = source[...,:destination.shape[-1]]
     elif destination.shape[-1] > source.shape[-1]:
-        destination = torch.nn.functional.pad(destination, (0, 1))
-        destination[..., -1] = 1.0
+        source = torch.nn.functional.pad(source, (0, 1))
+        source[..., -1] = 1.0
     return destination, source

nodes.py

@@ -1754,57 +1754,49 @@ class LoadImage:
 
         return True
 
-class LoadImageMask:
+
+class LoadImageMask(LoadImage):
     ESSENTIALS_CATEGORY = "Image Tools"
     SEARCH_ALIASES = ["import mask", "alpha mask", "channel mask"]
 
     _color_channels = ["alpha", "red", "green", "blue"]
+
     @classmethod
     def INPUT_TYPES(s):
-        input_dir = folder_paths.get_input_directory()
-        files = [f for f in os.listdir(input_dir) if os.path.isfile(os.path.join(input_dir, f))]
-        return {"required":
-                    {"image": (sorted(files), {"image_upload": True}),
-                     "channel": (s._color_channels, ), }
-                }
+        types = super().INPUT_TYPES()
+        return {
+            "required": {
+                **types["required"],
+                "channel": (s._color_channels, )
+            }
+        }
 
     CATEGORY = "mask"
-
     RETURN_TYPES = ("MASK",)
-    FUNCTION = "load_image"
-    def load_image(self, image, channel):
-        image_path = folder_paths.get_annotated_filepath(image)
-        i = node_helpers.pillow(Image.open, image_path)
-        i = node_helpers.pillow(ImageOps.exif_transpose, i)
-        if i.getbands() != ("R", "G", "B", "A"):
-            if i.mode == 'I':
-                i = i.point(lambda i: i * (1 / 255))
-            i = i.convert("RGBA")
-        mask = None
+    FUNCTION = "load_image_mask"
+
+    def load_image_mask(self, image, channel):
+        image_tensor, mask_tensor = super().load_image(image)
         c = channel[0].upper()
-        if c in i.getbands():
-            mask = np.array(i.getchannel(c)).astype(np.float32) / 255.0
-            mask = torch.from_numpy(mask)
-            if c == 'A':
-                mask = 1. - mask
+
+        if c == 'A':
+            return (mask_tensor,)
+
+        channel_idx = {'R': 0, 'G': 1, 'B': 2}.get(c, 0)
+
+        if channel_idx < image_tensor.shape[-1]:
+            return (image_tensor[..., channel_idx].clone(),)
         else:
-            mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
-        return (mask.unsqueeze(0),)
+            empty_mask = torch.zeros(
+                image_tensor.shape[:-1],
+                dtype=image_tensor.dtype,
+                device=image_tensor.device
+            )
+            return (empty_mask,)
 
     @classmethod
     def IS_CHANGED(s, image, channel):
-        image_path = folder_paths.get_annotated_filepath(image)
-        m = hashlib.sha256()
-        with open(image_path, 'rb') as f:
-            m.update(f.read())
-        return m.digest().hex()
-
-    @classmethod
-    def VALIDATE_INPUTS(s, image):
-        if not folder_paths.exists_annotated_filepath(image):
-            return "Invalid image file: {}".format(image)
-
-        return True
+        return super().IS_CHANGED(image)
 
 
 class LoadImageOutput(LoadImage):
@@ -1895,7 +1887,7 @@ class ImageInvert:
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "invert"
 
-    CATEGORY = "image"
+    CATEGORY = "image/color"
 
     def invert(self, image):
         s = 1.0 - image
@@ -1911,7 +1903,7 @@ class ImageBatch:
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "batch"
 
-    CATEGORY = "image"
+    CATEGORY = "image/batch"
     DEPRECATED = True
 
     def batch(self, image1, image2):
@@ -1968,7 +1960,7 @@ class ImagePadForOutpaint:
     RETURN_TYPES = ("IMAGE", "MASK")
     FUNCTION = "expand_image"
 
-    CATEGORY = "image"
+    CATEGORY = "image/transform"
 
     def expand_image(self, image, left, top, right, bottom, feathering):
         d1, d2, d3, d4 = image.size()
@@ -2111,7 +2103,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "ConditioningSetArea": "Conditioning (Set Area)",
     "ConditioningSetAreaPercentage": "Conditioning (Set Area with Percentage)",
     "ConditioningSetMask": "Conditioning (Set Mask)",
-    "ControlNetApply": "Apply ControlNet (OLD)",
+    "ControlNetApply": "Apply ControlNet (DEPRECATED)",
     "ControlNetApplyAdvanced": "Apply ControlNet",
     # Latent
     "VAEEncodeForInpaint": "VAE Encode (for Inpainting)",
@@ -2129,6 +2121,7 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "LatentFromBatch" : "Latent From Batch",
     "RepeatLatentBatch": "Repeat Latent Batch",
     # Image
+    "EmptyImage": "Empty Image",
     "SaveImage": "Save Image",
     "PreviewImage": "Preview Image",
     "LoadImage": "Load Image",
@@ -2136,15 +2129,15 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "LoadImageOutput": "Load Image (from Outputs)",
     "ImageScale": "Upscale Image",
     "ImageScaleBy": "Upscale Image By",
-    "ImageInvert": "Invert Image",
+    "ImageInvert": "Invert Image Colors",
     "ImagePadForOutpaint": "Pad Image for Outpainting",
-    "ImageBatch": "Batch Images",
-    "ImageCrop": "Image Crop",
-    "ImageStitch": "Image Stitch",
-    "ImageBlend": "Image Blend",
-    "ImageBlur": "Image Blur",
-    "ImageQuantize": "Image Quantize",
-    "ImageSharpen": "Image Sharpen",
+    "ImageBatch": "Batch Images (DEPRECATED)",
+    "ImageCrop": "Crop Image",
+    "ImageStitch": "Stitch Images",
+    "ImageBlend": "Blend Images",
+    "ImageBlur": "Blur Image",
+    "ImageQuantize": "Quantize Image",
+    "ImageSharpen": "Sharpen Image",
     "ImageScaleToTotalPixels": "Scale Image to Total Pixels",
     "GetImageSize": "Get Image Size",
     # _for_testing
@@ -2419,6 +2412,7 @@ async def init_builtin_extra_nodes():
         "nodes_nop.py",
         "nodes_kandinsky5.py",
         "nodes_wanmove.py",
+        "nodes_ar_video.py",
         "nodes_image_compare.py",
         "nodes_zimage.py",
         "nodes_glsl.py",

openapi.yaml

@@ -1999,6 +1999,26 @@ components:
           items:
             type: string
           description: List of node IDs to execute (partial graph execution)
+        workflow_id:
+          type: string
+          format: uuid
+          nullable: true
+          x-runtime: [cloud]
+          description: |
+            UUID identifying a hosted-cloud workflow entity to associate with this
+            job. Local ComfyUI doesn't track workflow entities and returns `null`
+            (or omits the field). The `x-runtime: [cloud]` extension marks this
+            as populated only by the hosted-cloud runtime; absence of the tag
+            means a field is populated by all runtimes.
+        workflow_version_id:
+          type: string
+          format: uuid
+          nullable: true
+          x-runtime: [cloud]
+          description: |
+            UUID identifying a hosted-cloud workflow version to associate with
+            this job. Local ComfyUI returns `null` (or omits the field). See
+            `workflow_id` above for `x-runtime` semantics.
 
     PromptResponse:
       type: object
@@ -2347,7 +2367,12 @@ components:
           description: Device type (cuda, mps, cpu, etc.)
         index:
           type: number
-          description: Device index
+          nullable: true
+          description: |
+            Device index within its type (e.g. CUDA ordinal for `cuda:0`,
+            `cuda:1`). `null` for devices with no index, including the CPU
+            device returned in `--cpu` mode (PyTorch's `torch.device('cpu').index`
+            is `None`).
         vram_total:
           type: number
           description: Total VRAM in bytes
@@ -2503,7 +2528,18 @@ components:
           description: Alternative search terms for finding this node
         essentials_category:
           type: string
-          description: Category override used by the essentials pack
+          nullable: true
+          description: |
+            Category override used by the essentials pack. The
+            `essentials_category` key may be present with a string value,
+            present and `null`, or absent entirely:
+
+            - V1 nodes: `essentials_category` is **omitted** when the node
+              class doesn't define an `ESSENTIALS_CATEGORY` attribute, and
+              **`null`** if the attribute is explicitly set to `None`.
+            - V3 nodes (`comfy_api.latest.io`): `essentials_category` is
+              **always present**, and **`null`** for nodes whose `Schema`
+              doesn't populate it.
 
     # -------------------------------------------------------------------
     # Models

requirements.txt

@@ -1,5 +1,5 @@
 comfyui-frontend-package==1.42.15
-comfyui-workflow-templates==0.9.68
+comfyui-workflow-templates==0.9.69
 comfyui-embedded-docs==0.4.4
 torch
 torchsde

server.py

@@ -1,3 +1,4 @@
+import errno
 import os
 import sys
 import asyncio
@@ -1245,7 +1246,13 @@ class PromptServer():
             address = addr[0]
             port = addr[1]
             site = web.TCPSite(runner, address, port, ssl_context=ssl_ctx)
-            await site.start()
+            try:
+                await site.start()
+            except OSError as e:
+                if e.errno == errno.EADDRINUSE:
+                    logging.error(f"Port {port} is already in use on address {address}. Please close the other application or use a different port with --port.")
+                    raise SystemExit(1)
+                raise
 
             if not hasattr(self, 'address'):
                 self.address = address #TODO: remove this

tests-unit/deploy_environment_test.py

@@ -0,0 +1,109 @@
+"""Tests for comfy.deploy_environment."""
+
+import os
+
+import pytest
+
+from comfy import deploy_environment
+from comfy.deploy_environment import get_deploy_environment
+
+
+@pytest.fixture(autouse=True)
+def _reset_cache_and_install_dir(tmp_path, monkeypatch):
+    """Reset the functools cache and point the ComfyUI install dir at a tmp dir for each test."""
+    get_deploy_environment.cache_clear()
+    monkeypatch.setattr(deploy_environment, "_COMFY_INSTALL_DIR", str(tmp_path))
+    yield
+    get_deploy_environment.cache_clear()
+
+
+def _write_env_file(tmp_path, content: str) -> str:
+    """Write the env file with exact content (no newline translation).
+
+    `newline=""` disables Python's text-mode newline translation so the bytes
+    on disk match the literal string passed in, regardless of host OS.
+    Newline-style tests (CRLF, lone CR) rely on this.
+    """
+    path = os.path.join(str(tmp_path), ".comfy_environment")
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        f.write(content)
+    return path
+
+
+class TestGetDeployEnvironment:
+    def test_returns_local_git_when_file_missing(self):
+        assert get_deploy_environment() == "local-git"
+
+    def test_reads_value_from_file(self, tmp_path):
+        _write_env_file(tmp_path, "local-desktop2-standalone\n")
+        assert get_deploy_environment() == "local-desktop2-standalone"
+
+    def test_strips_trailing_whitespace_and_newline(self, tmp_path):
+        _write_env_file(tmp_path, "  local-desktop2-standalone  \n")
+        assert get_deploy_environment() == "local-desktop2-standalone"
+
+    def test_only_first_line_is_used(self, tmp_path):
+        _write_env_file(tmp_path, "first-line\nsecond-line\n")
+        assert get_deploy_environment() == "first-line"
+
+    def test_crlf_line_ending(self, tmp_path):
+        # Windows editors often save text files with CRLF line endings.
+        # The CR must not end up in the returned value.
+        _write_env_file(tmp_path, "local-desktop2-standalone\r\n")
+        assert get_deploy_environment() == "local-desktop2-standalone"
+
+    def test_crlf_multiline_only_first_line_used(self, tmp_path):
+        _write_env_file(tmp_path, "first-line\r\nsecond-line\r\n")
+        assert get_deploy_environment() == "first-line"
+
+    def test_crlf_with_surrounding_whitespace(self, tmp_path):
+        _write_env_file(tmp_path, "  local-desktop2-standalone  \r\n")
+        assert get_deploy_environment() == "local-desktop2-standalone"
+
+    def test_lone_cr_line_ending(self, tmp_path):
+        # Classic-Mac / some legacy editors use a bare CR.
+        # Universal-newlines decoding treats it as a line terminator too.
+        _write_env_file(tmp_path, "local-desktop2-standalone\r")
+        assert get_deploy_environment() == "local-desktop2-standalone"
+
+    def test_empty_file_falls_back_to_default(self, tmp_path):
+        _write_env_file(tmp_path, "")
+        assert get_deploy_environment() == "local-git"
+
+    def test_empty_after_whitespace_strip_falls_back_to_default(self, tmp_path):
+        _write_env_file(tmp_path, "   \n")
+        assert get_deploy_environment() == "local-git"
+
+    def test_strips_control_chars_within_first_line(self, tmp_path):
+        # Embedded NUL/control chars in the value should be stripped
+        # (header-injection / smuggling protection).
+        _write_env_file(tmp_path, "abc\x00\x07xyz\n")
+        assert get_deploy_environment() == "abcxyz"
+
+    def test_strips_non_ascii_characters(self, tmp_path):
+        _write_env_file(tmp_path, "café-é\n")
+        assert get_deploy_environment() == "caf-"
+
+    def test_caps_read_at_128_bytes(self, tmp_path):
+        # A single huge line with no newline must not be fully read into memory.
+        huge = "x" * 10_000
+        _write_env_file(tmp_path, huge)
+        result = get_deploy_environment()
+        assert result == "x" * 128
+
+    def test_result_is_cached_across_calls(self, tmp_path):
+        path = _write_env_file(tmp_path, "first_value\n")
+        assert get_deploy_environment() == "first_value"
+        # Overwrite the file — cached value should still be returned.
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("second_value\n")
+        assert get_deploy_environment() == "first_value"
+
+    def test_unreadable_file_falls_back_to_default(self, tmp_path, monkeypatch):
+        _write_env_file(tmp_path, "should_not_be_used\n")
+
+        def _boom(*args, **kwargs):
+            raise OSError("simulated read failure")
+
+        monkeypatch.setattr("builtins.open", _boom)
+        assert get_deploy_environment() == "local-git"

tests-unit/feature_flags_test.py

@@ -1,10 +1,15 @@
 """Tests for feature flags functionality."""
 
+import pytest
+
 from comfy_api.feature_flags import (
     get_connection_feature,
     supports_feature,
     get_server_features,
+    CLI_FEATURE_FLAG_REGISTRY,
     SERVER_FEATURE_FLAGS,
+    _coerce_flag_value,
+    _parse_cli_feature_flags,
 )
 
 
@@ -96,3 +101,83 @@ class TestFeatureFlags:
         result = get_connection_feature(sockets_metadata, "sid1", "any_feature")
         assert result is False
         assert supports_feature(sockets_metadata, "sid1", "any_feature") is False
+
+
+class TestCoerceFlagValue:
+    """Test suite for _coerce_flag_value."""
+
+    def test_registered_bool_true(self):
+        assert _coerce_flag_value("show_signin_button", "true") is True
+        assert _coerce_flag_value("show_signin_button", "True") is True
+
+    def test_registered_bool_false(self):
+        assert _coerce_flag_value("show_signin_button", "false") is False
+        assert _coerce_flag_value("show_signin_button", "FALSE") is False
+
+    def test_unregistered_key_stays_string(self):
+        assert _coerce_flag_value("unknown_flag", "true") == "true"
+        assert _coerce_flag_value("unknown_flag", "42") == "42"
+
+    def test_bool_typo_raises(self):
+        """Strict bool: typos like 'ture' or 'yes' must raise so the flag can be dropped."""
+        with pytest.raises(ValueError):
+            _coerce_flag_value("show_signin_button", "ture")
+        with pytest.raises(ValueError):
+            _coerce_flag_value("show_signin_button", "yes")
+        with pytest.raises(ValueError):
+            _coerce_flag_value("show_signin_button", "1")
+        with pytest.raises(ValueError):
+            _coerce_flag_value("show_signin_button", "")
+
+    def test_failed_int_coercion_raises(self, monkeypatch):
+        """Malformed values for typed flags must raise; caller decides what to do."""
+        monkeypatch.setitem(
+            CLI_FEATURE_FLAG_REGISTRY,
+            "test_int_flag",
+            {"type": "int", "default": 0, "description": "test"},
+        )
+        with pytest.raises(ValueError):
+            _coerce_flag_value("test_int_flag", "not_a_number")
+
+
+class TestParseCliFeatureFlags:
+    """Test suite for _parse_cli_feature_flags."""
+
+    def test_single_flag(self, monkeypatch):
+        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["show_signin_button=true"]})())
+        result = _parse_cli_feature_flags()
+        assert result == {"show_signin_button": True}
+
+    def test_missing_equals_defaults_to_true(self, monkeypatch):
+        """Bare flag without '=' is treated as the string 'true' (and coerced if registered)."""
+        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["show_signin_button", "valid=1"]})())
+        result = _parse_cli_feature_flags()
+        assert result == {"show_signin_button": True, "valid": "1"}
+
+    def test_empty_key_skipped(self, monkeypatch):
+        monkeypatch.setattr("comfy_api.feature_flags.args", type("Args", (), {"feature_flag": ["=value", "valid=1"]})())
+        result = _parse_cli_feature_flags()
+        assert result == {"valid": "1"}
+
+    def test_invalid_bool_value_dropped(self, monkeypatch, caplog):
+        """A typo'd bool value must be dropped entirely, not silently set to False
+        and not stored as a raw string. A warning must be logged."""
+        monkeypatch.setattr(
+            "comfy_api.feature_flags.args",
+            type("Args", (), {"feature_flag": ["show_signin_button=ture", "valid=1"]})(),
+        )
+        with caplog.at_level("WARNING"):
+            result = _parse_cli_feature_flags()
+        assert result == {"valid": "1"}
+        assert "show_signin_button" not in result
+        assert any("show_signin_button" in r.message and "drop" in r.message.lower() for r in caplog.records)
+
+
+class TestCliFeatureFlagRegistry:
+    """Test suite for the CLI feature flag registry."""
+
+    def test_registry_entries_have_required_fields(self):
+        for key, info in CLI_FEATURE_FLAG_REGISTRY.items():
+            assert "type" in info, f"{key} missing 'type'"
+            assert "default" in info, f"{key} missing 'default'"
+            assert "description" in info, f"{key} missing 'description'"