Merge branch 'main' into refactor/incremental-writer

Refactor/incremental writer

__init__.py

@@ -1,7 +1,7 @@
 from typing_extensions import override
 from comfy_api.latest import ComfyExtension, io
 
-from .nodes.lora_merger import LoRAMultiMerge, LoRAMultiMergeDARE
+from .nodes.lora_merger import LoRAMultiMerge, LoRAMultiMergeDARE, LoRAMultiMergeDAREEnhanced
 from .nodes.metakeys import (
     ModelMetaKeys, TextEncoderMetaKeys, LoRAMetaKeys,
     CheckpointMetaKeys, EmbeddingMetaKeys
@@ -30,8 +30,12 @@ from .nodes.lora_resize import (
     LoRAMergeToModel
 )
 from .nodes.downloader_nodes import (
-    CheckpointDownloader, DiffusionModelDownloader, LoRADownloader, EmbeddingDownloader,
-    VAEDownloader, ControlNetDownloader, ManualPathDownloader
+    CheckpointInfoMetaDownloader, DiffusionModelInfoMetaDownloader, LoRAInfoMetaDownloader, EmbeddingInfoMetaDownloader,
+    VAEInfoMetaDownloader, ControlNetInfoMetaDownloader, ManualPathInfoMetaDownloader
+)
+from .nodes.model_info_nodes import (
+    CheckpointInfoLoader, LoRAInfoLoader, EmbeddingInfoLoader,
+    VAEInfoLoader, ControlNetInfoLoader, DiffusionModelInfoLoader
 )
 
 
@@ -61,12 +65,15 @@ class ModelUtilsExtension(ComfyExtension):
             LoRAResizeFixed, LoRAResizeRatio,
             LoRAResizeFrobenius, LoRAResizeCumulative,
             # LoRA Multi-Merge
-            LoRAMultiMerge, LoRAMultiMergeDARE,
+            LoRAMultiMerge, LoRAMultiMergeDARE, LoRAMultiMergeDAREEnhanced,
             # LoRA Merge To Model
             LoRAMergeToModel,
             # Downloaders
-            CheckpointDownloader, DiffusionModelDownloader, LoRADownloader, EmbeddingDownloader,
-            VAEDownloader, ControlNetDownloader, ManualPathDownloader,
+            CheckpointInfoMetaDownloader, DiffusionModelInfoMetaDownloader, LoRAInfoMetaDownloader, EmbeddingInfoMetaDownloader,
+            VAEInfoMetaDownloader, ControlNetInfoMetaDownloader, ManualPathInfoMetaDownloader,
+            # Info Loaders
+            CheckpointInfoLoader, LoRAInfoLoader, EmbeddingInfoLoader,
+            VAEInfoLoader, ControlNetInfoLoader, DiffusionModelInfoLoader,
         ]
 
 

docs/merger_2_model_modes.md

@@ -33,6 +33,30 @@
 
 ---
 
+## Power-Up (DARE+TIES)
+> Combines DARE (Drop and Rescale) with TIES (Trim, Elect Sign) — the current best-practice algorithm for merging fine-tuned models, particularly LoRA-tuned ones. DARE sparsifies the task vector via random dropout and rescaling; TIES then removes residual low-magnitude noise and enforces sign consistency. The result is a cleaner, more targeted capability transfer from B to A with less interference.
+
+**Models Used:** A, B
+**Parameters:**
+- **Alpha:** DARE drop rate. Fraction of delta parameters randomly zeroed. Higher values produce a sparser, more targeted delta. Typical range: `0.5`–`0.9`.
+- **Beta:** TIES trim quantile. Fraction of the smallest-magnitude delta parameters zeroed after DARE, removing residual noise. `0.0` disables trimming. Typical range: `0.1`–`0.3`.
+- **Gamma:** Lambda scale. Final multiplier applied to the merged delta before adding to Model A. Equivalent to the task arithmetic scaling coefficient. Typical range: `0.5`–`1.5`.
+- **Seed:** Random seed for the DARE dropout mask. Controls reproducibility.
+
+**Algorithm:**
+1. Compute task vector `δ = B − A`
+2. **DARE:** apply random binary mask with keep probability `1 − alpha`; rescale survivors by `1/(1−alpha)`
+3. **TIES trim:** zero out parameters below the `beta`-quantile magnitude threshold
+4. **TIES elect:** determine dominant sign per position; zero out disagreeing parameters
+5. Return `A + gamma × δ_filtered`
+
+**Guidance:**
+- Start with `alpha=0.9, beta=0.2, gamma=1.0` for LoRA-derived models
+- Lower `alpha` (e.g. `0.5`) for full fine-tunes where more delta mass should be retained
+- Increase `gamma` beyond `1.0` to amplify B's influence; decrease below `1.0` to soften it
+
+---
+
 ## Enhanced Man Interp
 > Sophisticated interpolation between values from A and B depending on their difference relative to other values, with manual threshold control.
 

nodes/downloader_nodes.py

@@ -26,18 +26,18 @@ def get_subdirectories(folder_name: str) -> list[str]:
 
     return sorted(list(subdirs))
 
-class BaseDownloaderNode(io.ComfyNode):
+class BaseInfoMetaDownloaderNode(io.ComfyNode):
     CATEGORY = "ModelUtils/Downloader"
     OUTPUT_NODE = True
 
     @classmethod
     def get_common_inputs(cls):
         return {
-            "recursive": io.Boolean.Input("recursive", default=True),
-            "nsfw_level": io.Combo.Input("nsfw_level", options=["None", "Soft", "Mature", "X", "XXX", "All"], default="All"),
-            "max_examples": io.Int.Input("max_examples", default=0, min=0, max=100),
-            "threads": io.Int.Input("threads", default=4, min=1, max=32),
-            "api_key": io.String.Input("api_key", default="")
+            "recursive": io.Boolean.Input("recursive", default=True, tooltip="Whether to scan subdirectories recursively."),
+            "nsfw_level": io.Combo.Input("nsfw_level", options=["None", "Soft", "Mature", "X", "XXX", "All"], default="All", tooltip="Filter models based on NSFW level in metadata."),
+            "max_examples": io.Int.Input("max_examples", default=0, min=0, max=100, tooltip="Maximum number of examples to process."),
+            "threads": io.Int.Input("threads", default=4, min=1, max=32, tooltip="Number of threads to use for processing."),
+            "api_key": io.String.Input("api_key", default="", tooltip="API key for accessing the model repository.")
         }
 
     @classmethod
@@ -49,6 +49,7 @@ class BaseDownloaderNode(io.ComfyNode):
             inputs=list(cls.get_common_inputs().values()),
             outputs=[io.String.Output(display_name="status")],
             is_output_node=True,
+            description=("Scans specified directories for models, extracts metadata, generates previews, and optionally compresses files.")
         )
 
     @classmethod
@@ -84,7 +85,7 @@ class BaseDownloaderNode(io.ComfyNode):
     def get_scan_dirs(cls, **kwargs) -> list[str]:
         return []
 
-class CheckpointDownloader(BaseDownloaderNode):
+class CheckpointInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -121,7 +122,7 @@ class CheckpointDownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class DiffusionModelDownloader(BaseDownloaderNode):
+class DiffusionModelInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -158,7 +159,7 @@ class DiffusionModelDownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class LoRADownloader(BaseDownloaderNode):
+class LoRAInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -195,7 +196,7 @@ class LoRADownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class EmbeddingDownloader(BaseDownloaderNode):
+class EmbeddingInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -232,7 +233,7 @@ class EmbeddingDownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class VAEDownloader(BaseDownloaderNode):
+class VAEInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -269,7 +270,7 @@ class VAEDownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class ControlNetDownloader(BaseDownloaderNode):
+class ControlNetInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())
@@ -306,7 +307,7 @@ class ControlNetDownloader(BaseDownloaderNode):
                 target_paths.append(target_path)
         return target_paths
 
-class ManualPathDownloader(BaseDownloaderNode):
+class ManualPathInfoMetaDownloader(BaseInfoMetaDownloaderNode):
     @classmethod
     def define_schema(cls):
         inputs = list(cls.get_common_inputs().values())

nodes/downloader_utils.py

@@ -36,12 +36,7 @@ except ImportError:
 # Assuming downloader_utils.py is inside nodes/, the root is one level up
 root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.append(os.path.join(root_dir, 'unifiedefficientloader-reference'))
-try:
-    from unifiedefficientloader import UnifiedSafetensorsLoader
-    HAS_UNIFIED_LOADER = True
-except ImportError:
-    HAS_UNIFIED_LOADER = False
-    print("Warning: unifiedefficientloader not found. Safetensors metadata extraction disabled.")
+from unifiedefficientloader import UnifiedSafetensorsLoader
 
 # --- Database Path Logic ---
 try:
@@ -416,8 +411,6 @@ def filter_images_by_nsfw(images, threshold_level):
     return valid_images
 
 def extract_safetensors_metadata(filepath):
-    if not HAS_UNIFIED_LOADER:
-        return None
     try:
         # Use low_memory=True to only read the header and metadata without loading tensors
         loader = UnifiedSafetensorsLoader(filepath, low_memory=True)
@@ -576,6 +569,60 @@ def process_file(filepath, cache, api, nsfw_threshold, max_examples):
                         for k in stats: stats[k] += res.get(k, 0)
     return stats
 
+import numpy as np
+from PIL import Image, ImageOps
+import torch
+
+def load_image_tensor(path):
+    if not os.path.exists(path):
+        return None
+    try:
+        img = Image.open(path)
+        img = ImageOps.exif_transpose(img)
+        image = img.convert("RGB")
+        image = np.array(image).astype(np.float32) / 255.0
+        image = torch.from_numpy(image)[None,]
+        return image
+    except Exception as e:
+        print(f"Error loading image {path}: {e}")
+        return None
+
+def get_model_workflows(base_path):
+    workflows = []
+    # Main workflow
+    main_json = f"{base_path}.json"
+    if os.path.exists(main_json):
+        workflows.append(main_json)
+
+    # Example workflows
+    # They are named like base_path.example.N.json
+    # or base_path.preview.json (if extracted from preview)
+    preview_json = f"{base_path}.preview.json"
+    if os.path.exists(preview_json) and preview_json not in workflows:
+        workflows.append(preview_json)
+
+    example_jsons = glob.glob(f"{base_path}.example.*.json")
+    # Sort them by index
+    example_jsons.sort()
+    for ej in example_jsons:
+        if ej not in workflows:
+            workflows.append(ej)
+
+    return workflows
+
+def get_model_metadata_file(base_path):
+    # Prefer civitai.info if available
+    civitai_info = f"{base_path}.civitai.info"
+    if os.path.exists(civitai_info):
+        return civitai_info
+
+    # Fallback to metadata.json (safetensors metadata)
+    metadata_json = f"{base_path}.metadata.json"
+    if os.path.exists(metadata_json):
+        return metadata_json
+
+    return None
+
 def scan_and_process(scan_dirs, recursive=True, db_path=None, nsfw_level="All", max_examples=0, api_key=None, threads=4):
     """
     Scans directories for models and fetches their metadata/previews.

nodes/lora_extract_svd.py

@@ -4,6 +4,7 @@ LoRA Extraction via SVD decomposition.
 Native implementation of Low-Rank Adapter extraction with multiple rank selection modes.
 No external dependencies required.
 """
+import fnmatch
 import os
 import re
 import torch
@@ -12,13 +13,15 @@ import folder_paths
 import comfy.utils
 from tqdm import tqdm
 from comfy_api.latest import io
-from safetensors.torch import save_file
-from .merger_utils import MemoryEfficientSafeOpen, transfer_to_gpu_pinned
 from .device_utils import (
     estimate_model_size, prepare_for_large_operation,
     cleanup_after_operation, get_device_capabilities
 )
 
+from unifiedefficientloader import MemoryEfficientSafeOpen, transfer_to_gpu_pinned, IncrementalSafetensorsWriter
+
+
+
 
 # =============================================================================
 # Rank Index Functions - Determine LoRA rank from singular values
@@ -396,14 +399,22 @@ def _extract_chunked_layer(
 # Pattern Matching
 # =============================================================================
 
-def _compile_patterns(pattern_string: str) -> list:
-    """Compile regex patterns from whitespace-separated string."""
+def _compile_patterns(pattern_string: str, glob_mode: bool = False) -> list:
+    """Compile patterns from whitespace-separated string.
+
+    In regex mode (default) returns compiled re.Pattern objects.
+    In glob mode returns plain strings; fnmatch handles matching.
+    """
     if not pattern_string or not pattern_string.strip():
         return []
     patterns = []
     for p in pattern_string.split():
         p = p.strip()
-        if p:
+        if not p:
+            continue
+        if glob_mode:
+            patterns.append(p)
+        else:
             try:
                 patterns.append(re.compile(p))
             except re.error:
@@ -411,8 +422,15 @@ def _compile_patterns(pattern_string: str) -> list:
     return patterns
 
 
-def _matches_any_pattern(key: str, patterns: list) -> bool:
-    """Check if key matches any pattern."""
+def _matches_any_pattern(key: str, patterns: list, glob_mode: bool = False) -> bool:
+    """Check if key matches any pattern.
+
+    Glob mode: each pattern is matched as a substring glob using fnmatch
+    (dots are literal, * matches any sequence of characters).
+    Regex mode: each pattern is a compiled re.Pattern, matched via search().
+    """
+    if glob_mode:
+        return any(fnmatch.fnmatch(key, f"*{p}*") for p in patterns)
     return any(p.search(key) for p in patterns)
 
 
@@ -428,6 +446,7 @@ def extract_lora_from_files(
     conv_param: float,
     device: str,
     save_dtype: str,
+    output_path: str,
     linear_max_rank: int = None,
     conv_max_rank: int = None,
     clamp_quantile: float = 0.99,
@@ -438,9 +457,10 @@ def extract_lora_from_files(
     svd_niter: int = 2,
     lazy_load: bool = True,
     force_clear_cache: bool = True,
-) -> dict[str, torch.Tensor]:
+    glob_skip_patterns: bool = False,
+) -> None:
     """
-    Extract LoRA from difference between two models.
+    Extract LoRA from difference between two models, writing incrementally to disk.
 
     Args:
         model_a_path: Finetuned model path
@@ -450,6 +470,7 @@ def extract_lora_from_files(
         conv_param: Mode parameter for conv layers
         device: Computation device
         save_dtype: Output dtype
+        output_path: Full path to output safetensors file
         linear_max_rank: Max rank for linear layers
         conv_max_rank: Max rank for conv layers
         clamp_quantile: Quantile for weight clamping
@@ -457,16 +478,16 @@ def extract_lora_from_files(
         skip_patterns_str: Patterns for layers to skip
         mismatch_mode: How to handle mismatches
         chunk_large_layers: Enable chunked extraction
+        glob_skip_patterns: When True, treat skip_patterns as glob (* wildcard).
+                            When False (default), treat as Python regex.
     """
-    output_sd = {}
-
     save_torch_dtype = {
         "fp32": torch.float32,
         "fp16": torch.float16,
         "bf16": torch.bfloat16,
     }.get(save_dtype, torch.float16)
 
-    skip_patterns = _compile_patterns(skip_patterns_str)
+    skip_patterns = _compile_patterns(skip_patterns_str, glob_mode=glob_skip_patterns)
 
     # Prepare memory before heavy operation
     total_size_gb = estimate_model_size(model_a_path) + estimate_model_size(model_b_path)
@@ -486,7 +507,7 @@ def extract_lora_from_files(
         def _process_layer(key):
             lora_name = _format_lora_key(key)
 
-            if _matches_any_pattern(key, skip_patterns):
+            if _matches_any_pattern(key, skip_patterns, glob_mode=glob_skip_patterns):
                 return "skipped", None
 
             # Load tensors with pinned memory for CUDA
@@ -567,9 +588,8 @@ def extract_lora_from_files(
                             weight_diff, num_chunks, mode, linear_param, device, linear_max_rank
                         )
                         if lora_up is not None:
-                            layer_results[f"{lora_name}.lora_up.weight"] = lora_up.to(save_torch_dtype).cpu().contiguous()
-                            layer_results[f"{lora_name}.lora_down.weight"] = lora_down.to(save_torch_dtype).cpu().contiguous()
-                            layer_results[f"{lora_name}.alpha"] = torch.tensor(rank).to(save_torch_dtype)
+                            layer_results[f"{lora_name}.lora_B.weight"] = lora_up.to(save_torch_dtype).cpu().contiguous()
+                            layer_results[f"{lora_name}.lora_A.weight"] = lora_down.to(save_torch_dtype).cpu().contiguous()
                             del weight_diff
                             return "chunked", layer_results
 
@@ -583,27 +603,31 @@ def extract_lora_from_files(
                 status = "full"
             else:
                 lora_down, lora_up, _ = result
-                layer_results[f"{lora_name}.lora_down.weight"] = lora_down.to(save_torch_dtype).cpu().contiguous()
-                layer_results[f"{lora_name}.lora_up.weight"] = lora_up.to(save_torch_dtype).cpu().contiguous()
-                layer_results[f"{lora_name}.alpha"] = torch.tensor(lora_down.shape[0]).to(save_torch_dtype)
+                layer_results[f"{lora_name}.lora_A.weight"] = lora_down.to(save_torch_dtype).cpu().contiguous()
+                layer_results[f"{lora_name}.lora_B.weight"] = lora_up.to(save_torch_dtype).cpu().contiguous()
                 status = "extracted"
 
             del weight_diff
             return status, layer_results
 
-        for key in tqdm(weight_keys, desc="Extracting LoRA", unit="layers"):
-            status, layer_sd = _process_layer(key)
-            stats[status] += 1
-            if layer_sd:
-                output_sd.update(layer_sd)
+        writer = IncrementalSafetensorsWriter(output_path)
+        writer.__enter__()
+        try:
+            for key in tqdm(weight_keys, desc="Extracting LoRA", unit="layers"):
+                status, layer_sd = _process_layer(key)
+                stats[status] += 1
+                if layer_sd:
+                    writer.write_dict(layer_sd)
 
-            if force_clear_cache:
-                import gc
-                gc.collect()
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
+                if force_clear_cache:
+                    import gc
+                    gc.collect()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
 
-            pbar.update(1)
+                pbar.update(1)
+        finally:
+            writer.__exit__(None, None, None)
 
         print(f"[LoRA Extract] Done: {stats['extracted']} extracted, {stats['chunked']} chunked, "
               f"{stats['full']} full, {stats['skipped']} skipped")
@@ -613,22 +637,12 @@ def extract_lora_from_files(
         handler_b.__exit__(None, None, None)
         cleanup_after_operation()
 
-    return output_sd
-
-
-def _save_lora(output_sd: dict, output_filename: str) -> str:
-    """Save LoRA to file."""
-    if not output_sd:
-        raise ValueError("No LoRA weights extracted")
 
+def _build_lora_output_path(output_filename: str) -> str:
+    """Build output path for LoRA file."""
     output_dir = folder_paths.get_folder_paths("loras")[0]
     os.makedirs(output_dir, exist_ok=True)
-    output_path = os.path.join(output_dir, f"{output_filename.strip()}.safetensors")
-
-    save_file(output_sd, output_path)
-    print(f"[LoRA Extract] Saved to {output_path}")
-
-    return output_path
+    return os.path.join(output_dir, f"{output_filename.strip()}.safetensors")
 
 
 # =============================================================================
@@ -644,81 +658,49 @@ def _get_model_inputs():
     ]
 
 
-def _reconstruct_dots(key: str) -> str:
-    """Reconstruct dot structure from underscored key using heuristics."""
-    # Block indices: input_blocks_1 -> input_blocks.1
-    blocks = [
-        "input_blocks", "output_blocks", "middle_block",
-        "transformer_blocks", "single_transformer_blocks",
-        "double_blocks", "single_blocks",
-        "down_blocks", "up_blocks", "mid_block",
-        "attentions", "resnets", "upsamplers", "downsamplers"
-    ]
-    for b in blocks:
-        key = re.sub(f"{b}_(\\d+)", f"{b}.\\1", key)
-
-    # Sequential numbers: .1_1 -> .1.1
-    key = re.sub(r"(\.\d+)_(\d+)", r"\1.\2", key)
-
-    # Separators that should be preceded by dot
-    separators = [
-        "transformer_blocks", "single_transformer_blocks",
-        "attn1", "attn2", "attn",
-        "img_attn", "txt_attn",
-        "to_q", "to_k", "to_v", "to_out",
-        "q_proj", "k_proj", "v_proj", "out_proj",
-        "qkv", "proj", "ff", "net",
-        "norm1", "norm2", "norm3", "norm",
-        "time_emb_proj"
-    ]
-    for s in separators:
-        key = key.replace(f"_{s}", f".{s}")
-
-    # Special case: to_out_0 -> to_out.0
-    key = re.sub(r"to_out_(\d+)", r"to_out.\1", key)
-
-    return key
-
-
 def _format_lora_key(key: str) -> str:
     """
     Format the key for LoRA saving.
-    Standardizes to 'diffusion_model.' or 'transformer.' prefix.
+    Always standardizes to 'diffusion_model.' prefix for maximum compatibility.
+
+    ComfyUI maps 'diffusion_model.<layer>' generically for all model types, making
+    it universally compatible. The 'transformer.' prefix only works for a subset of
+    model types via model-specific mapping code and is intentionally not used here.
     """
     if key.endswith(".weight"):
         key = key[:-7]
 
-    # Handle ComfyUI Checkpoint wrapper
+    # Handle ComfyUI Checkpoint wrapper (ldm/sgm format: model.diffusion_model.*)
     if key.startswith("model.diffusion_model."):
-        # Check if it's a Diffusers-format transformer inside a checkpoint
-        inner_key = key[22:]  # len("model.diffusion_model.")
-        if inner_key.startswith("transformer_blocks") or inner_key.startswith("single_transformer_blocks"):
-            return f"transformer.{inner_key}"
-        # Standard checkpoint or Original Flux
+        inner_key = key[22:]  # strip len("model.diffusion_model.")
         return f"diffusion_model.{inner_key}"
 
-    # Handle direct Diffusers keys
+    # Handle net.* wrapper
+    if key.startswith("net."):
+        inner_key = key[4:]  # strip len("net.")
+        return f"diffusion_model.{inner_key}"
+
+    # Handle direct Diffusers keys (transformer_blocks.* / single_transformer_blocks.* without prefix)
     if key.startswith("transformer_blocks") or key.startswith("single_transformer_blocks"):
-        return f"transformer.{key}"
+        return f"diffusion_model.{key}"
 
     # Handle legacy lora_unet_ prefix (for resizing without base)
     if key.startswith("lora_unet_"):
-        core = key[10:]
-        dotted = _reconstruct_dots(core)
-        # Check if reconstructed key implies transformer format
-        if dotted.startswith("transformer_blocks") or dotted.startswith("single_transformer_blocks"):
-            return f"transformer.{dotted}"
-        return f"diffusion_model.{dotted}"
-
-    # Handle already correct prefixes
-    if key.startswith("diffusion_model.") or key.startswith("transformer."):
         return key
 
-    # Handle known Unet blocks (Diffusers format UNet)
+    # Handle already-prefixed keys
+    if key.startswith("diffusion_model."):
+        return key
+
+    # Absorb now-invalid transformer. prefix into diffusion_model. for compatibility
+    if key.startswith("transformer."):
+        return f"diffusion_model.{key[12:]}"
+
+    # Handle known Diffusers UNet blocks
     if any(key.startswith(p) for p in ["down_blocks", "up_blocks", "mid_block", "conv_in", "conv_out", "time_embedding", "class_embedding"]):
         return f"diffusion_model.{key}"
 
-    # Default fallback to diffusion_model
+    # Default fallback
     return f"diffusion_model.{key}"
 
 
@@ -737,7 +719,10 @@ def _get_common_inputs():
         io.Combo.Input("save_dtype", options=["fp16", "bf16", "fp32"], default="fp16"),
         io.Combo.Input("device", options=["cuda", "cpu"], default="cuda"),
         io.String.Input("skip_patterns", default="", multiline=True,
-                       tooltip="Regex patterns for layers to skip"),
+                       tooltip="Patterns for layers to skip (regex or glob depending on glob_skip_patterns)"),
+        io.Boolean.Input("glob_skip_patterns", default=False,
+                        tooltip="When True, skip_patterns use glob syntax (* = any sequence, ? = any char, dots are literal). "
+                                "When False (default), patterns are Python regex matched as substrings."),
     ]
 
 
@@ -768,19 +753,20 @@ class LoRAExtractFixed(io.ComfyNode):
     @classmethod
     def execute(cls, model_a, model_b, linear_dim, conv_dim, svd_niter, chunk_large_layers,
                 clamp_quantile, min_diff, mismatch_mode, output_filename,
-                save_dtype, device, skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
+                save_dtype, device, skip_patterns, glob_skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
 
         model_a_path = folder_paths.get_full_path_or_raise("diffusion_models", model_a)
         model_b_path = folder_paths.get_full_path_or_raise("diffusion_models", model_b)
+        output_path = _build_lora_output_path(output_filename)
 
-        output_sd = extract_lora_from_files(
+        extract_lora_from_files(
             model_a_path, model_b_path, "fixed", linear_dim, conv_dim,
-            device, save_dtype, linear_dim, conv_dim,
+            device, save_dtype, output_path, linear_dim, conv_dim,
             clamp_quantile, min_diff, skip_patterns, mismatch_mode, chunk_large_layers, svd_niter,
-            lazy_load, force_clear_cache
+            lazy_load, force_clear_cache, glob_skip_patterns
         )
 
-        return io.NodeOutput(_save_lora(output_sd, output_filename))
+        return io.NodeOutput(output_path)
 
 
 class LoRAExtractRatio(io.ComfyNode):
@@ -812,19 +798,21 @@ class LoRAExtractRatio(io.ComfyNode):
     @classmethod
     def execute(cls, model_a, model_b, linear_ratio, conv_ratio, linear_max_rank, conv_max_rank,
                 chunk_large_layers, clamp_quantile, min_diff, mismatch_mode, output_filename,
-                save_dtype, device, skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
+                save_dtype, device, skip_patterns, glob_skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
 
         model_a_path = folder_paths.get_full_path_or_raise("diffusion_models", model_a)
         model_b_path = folder_paths.get_full_path_or_raise("diffusion_models", model_b)
+        output_path = _build_lora_output_path(output_filename)
 
-        output_sd = extract_lora_from_files(
+        extract_lora_from_files(
             model_a_path, model_b_path, "ratio", linear_ratio, conv_ratio,
-            device, save_dtype, linear_max_rank, conv_max_rank,
+            device, save_dtype, output_path, linear_max_rank, conv_max_rank,
             clamp_quantile, min_diff, skip_patterns, mismatch_mode, chunk_large_layers,
-            lazy_load=lazy_load, force_clear_cache=force_clear_cache
+            lazy_load=lazy_load, force_clear_cache=force_clear_cache,
+            glob_skip_patterns=glob_skip_patterns
         )
 
-        return io.NodeOutput(_save_lora(output_sd, output_filename))
+        return io.NodeOutput(output_path)
 
 
 class LoRAExtractQuantile(io.ComfyNode):
@@ -856,19 +844,21 @@ class LoRAExtractQuantile(io.ComfyNode):
     @classmethod
     def execute(cls, model_a, model_b, linear_quantile, conv_quantile, linear_max_rank, conv_max_rank,
                 chunk_large_layers, clamp_quantile, min_diff, mismatch_mode, output_filename,
-                save_dtype, device, skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
+                save_dtype, device, skip_patterns, glob_skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
 
         model_a_path = folder_paths.get_full_path_or_raise("diffusion_models", model_a)
         model_b_path = folder_paths.get_full_path_or_raise("diffusion_models", model_b)
+        output_path = _build_lora_output_path(output_filename)
 
-        output_sd = extract_lora_from_files(
+        extract_lora_from_files(
             model_a_path, model_b_path, "quantile", linear_quantile, conv_quantile,
-            device, save_dtype, linear_max_rank, conv_max_rank,
+            device, save_dtype, output_path, linear_max_rank, conv_max_rank,
             clamp_quantile, min_diff, skip_patterns, mismatch_mode, chunk_large_layers,
-            lazy_load=lazy_load, force_clear_cache=force_clear_cache
+            lazy_load=lazy_load, force_clear_cache=force_clear_cache,
+            glob_skip_patterns=glob_skip_patterns
         )
 
-        return io.NodeOutput(_save_lora(output_sd, output_filename))
+        return io.NodeOutput(output_path)
 
 
 class LoRAExtractKnee(io.ComfyNode):
@@ -898,19 +888,21 @@ class LoRAExtractKnee(io.ComfyNode):
     @classmethod
     def execute(cls, model_a, model_b, knee_method, linear_max_rank, conv_max_rank,
                 chunk_large_layers, clamp_quantile, min_diff, mismatch_mode, output_filename,
-                save_dtype, device, skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
+                save_dtype, device, skip_patterns, glob_skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
 
         model_a_path = folder_paths.get_full_path_or_raise("diffusion_models", model_a)
         model_b_path = folder_paths.get_full_path_or_raise("diffusion_models", model_b)
+        output_path = _build_lora_output_path(output_filename)
 
-        output_sd = extract_lora_from_files(
+        extract_lora_from_files(
             model_a_path, model_b_path, knee_method, 0, 0,
-            device, save_dtype, linear_max_rank, conv_max_rank,
+            device, save_dtype, output_path, linear_max_rank, conv_max_rank,
             clamp_quantile, min_diff, skip_patterns, mismatch_mode, chunk_large_layers,
-            lazy_load=lazy_load, force_clear_cache=force_clear_cache
+            lazy_load=lazy_load, force_clear_cache=force_clear_cache,
+            glob_skip_patterns=glob_skip_patterns
         )
 
-        return io.NodeOutput(_save_lora(output_sd, output_filename))
+        return io.NodeOutput(output_path)
 
 
 class LoRAExtractFrobenius(io.ComfyNode):
@@ -942,16 +934,18 @@ class LoRAExtractFrobenius(io.ComfyNode):
     @classmethod
     def execute(cls, model_a, model_b, linear_target, conv_target, linear_max_rank, conv_max_rank,
                 chunk_large_layers, clamp_quantile, min_diff, mismatch_mode, output_filename,
-                save_dtype, device, skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
+                save_dtype, device, skip_patterns, glob_skip_patterns, lazy_load, force_clear_cache) -> io.NodeOutput:
 
         model_a_path = folder_paths.get_full_path_or_raise("diffusion_models", model_a)
         model_b_path = folder_paths.get_full_path_or_raise("diffusion_models", model_b)
+        output_path = _build_lora_output_path(output_filename)
 
-        output_sd = extract_lora_from_files(
+        extract_lora_from_files(
             model_a_path, model_b_path, "sv_fro", linear_target, conv_target,
-            device, save_dtype, linear_max_rank, conv_max_rank,
+            device, save_dtype, output_path, linear_max_rank, conv_max_rank,
             clamp_quantile, min_diff, skip_patterns, mismatch_mode, chunk_large_layers,
-            lazy_load=lazy_load, force_clear_cache=force_clear_cache
+            lazy_load=lazy_load, force_clear_cache=force_clear_cache,
+            glob_skip_patterns=glob_skip_patterns
         )
 
-        return io.NodeOutput(_save_lora(output_sd, output_filename))
+        return io.NodeOutput(output_path)

nodes/lora_resize.py

@@ -12,11 +12,13 @@ import folder_paths
 import comfy.utils
 from tqdm import tqdm
 from comfy_api.latest import io
-from safetensors.torch import save_file
-from typing import Optional, Dict, Tuple, List
-from .merger_utils import MemoryEfficientSafeOpen, transfer_to_gpu_pinned
 from .device_utils import estimate_model_size, prepare_for_large_operation, cleanup_after_operation
 
+from unifiedefficientloader import MemoryEfficientSafeOpen, transfer_to_gpu_pinned, IncrementalSafetensorsWriter
+from typing import Optional, Dict, Tuple, List
+
+
+
 # Reuse rank functions from extraction module
 from .lora_extract_svd import (
     _index_sv_ratio,
@@ -189,7 +191,7 @@ def detect_lora_rank(handler: MemoryEfficientSafeOpen, pairs: Dict) -> Tuple[int
         # Get dim from down weight shape
         if network_dim is None:
             down_key = block_keys["down"]
-            shape = handler.header[down_key]["shape"]
+            shape = handler.get_shape(down_key)
             # Linear: [rank, in_features] or Conv: [rank, in_ch, k, k]
             network_dim = shape[0]
 
@@ -416,66 +418,7 @@ def resize_lora_file(
             print(f"[LoRA Resize] Original dim={network_dim}, alpha={network_alpha:.1f}, scale={scale:.3f}")
             print(f"[LoRA Resize] Resizing with method={method_str}, max_rank={new_rank}")
 
-        output_sd = {}
-        fro_list = []
-        pbar = comfy.utils.ProgressBar(len(pairs))
-
-        with torch.no_grad():
-            for block_name, block_keys in tqdm(pairs.items(), desc="Resizing layers", unit="layers"):
-                if "down" not in block_keys or "up" not in block_keys:
-                    pbar.update(1)
-                    continue
-
-                lora_down = handler.get_tensor(block_keys["down"])
-                lora_up = handler.get_tensor(block_keys["up"])
-
-                is_conv = len(lora_down.shape) == 4
-
-                # Transfer to GPU with pinned memory if available
-                if device == 'cuda':
-                    lora_down = transfer_to_gpu_pinned(lora_down, device, torch.float32)
-                    lora_up = transfer_to_gpu_pinned(lora_up, device, torch.float32)
-
-                # Merge and re-extract
-                if is_conv:
-                    weight = _merge_conv(lora_down, lora_up, device)
-                    result = _extract_conv(weight, new_rank, dynamic_method, dynamic_param, scale, svd_niter)
-                else:
-                    weight = _merge_linear(lora_down, lora_up, device)
-                    result = _extract_linear(weight, new_rank, dynamic_method, dynamic_param, scale, svd_niter)
-
-                del weight, lora_down, lora_up
-
-                fro_list.append(result['fro_retained'])
-
-                # Store using same format suffixes as input
-                down_suffix = format_info["down_suffix"]
-                up_suffix = format_info["up_suffix"]
-                alpha_suffix = format_info["alpha_suffix"]
-
-                # Standardize prefix using heuristics if possible
-                new_block_name = _format_lora_key(block_name)
-
-                output_sd[f"{new_block_name}{down_suffix}"] = result["lora_down"].to(save_dtype)
-                output_sd[f"{new_block_name}{up_suffix}"] = result["lora_up"].to(save_dtype)
-                if alpha_suffix:
-                    output_sd[f"{new_block_name}{alpha_suffix}"] = torch.tensor(result["new_alpha"]).to(save_dtype)
-
-                del result
-                import gc
-                gc.collect()
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
-
-                pbar.update(1)
-
-        if verbose and fro_list:
-            import numpy as np
-            avg_fro = np.mean(fro_list)
-            std_fro = np.std(fro_list)
-            print(f"[LoRA Resize] Average Frobenius retention: {avg_fro:.1%} ± {std_fro:.3f}")
-
-        # Update metadata
+        # Build metadata and output path before loop (all values known at this point)
         if dynamic_method:
             metadata["ss_training_comment"] = f"Dynamic resize with {dynamic_method}: {dynamic_param} from dim {network_dim}"
             metadata["ss_network_dim"] = "Dynamic"
@@ -485,14 +428,78 @@ def resize_lora_file(
             metadata["ss_network_dim"] = str(new_rank)
             metadata["ss_network_alpha"] = str(scale * new_rank)
 
-        # Save
         output_dir = folder_paths.get_folder_paths("loras")[0]
         os.makedirs(output_dir, exist_ok=True)
         output_path = os.path.join(output_dir, f"{output_filename.strip()}.safetensors")
 
-        save_file(output_sd, output_path, metadata)
-        print(f"[LoRA Resize] Saved to {output_path}")
+        fro_list = []
+        pbar = comfy.utils.ProgressBar(len(pairs))
 
+        writer = IncrementalSafetensorsWriter(output_path, metadata=metadata)
+        writer.__enter__()
+        try:
+            with torch.no_grad():
+                for block_name, block_keys in tqdm(pairs.items(), desc="Resizing layers", unit="layers"):
+                    if "down" not in block_keys or "up" not in block_keys:
+                        pbar.update(1)
+                        continue
+
+                    lora_down = handler.get_tensor(block_keys["down"])
+                    lora_up = handler.get_tensor(block_keys["up"])
+
+                    is_conv = len(lora_down.shape) == 4
+
+                    # Transfer to GPU with pinned memory if available
+                    if device == 'cuda':
+                        lora_down = transfer_to_gpu_pinned(lora_down, device, torch.float32)
+                        lora_up = transfer_to_gpu_pinned(lora_up, device, torch.float32)
+
+                    # Merge and re-extract
+                    if is_conv:
+                        weight = _merge_conv(lora_down, lora_up, device)
+                        result = _extract_conv(weight, new_rank, dynamic_method, dynamic_param, scale, svd_niter)
+                    else:
+                        weight = _merge_linear(lora_down, lora_up, device)
+                        result = _extract_linear(weight, new_rank, dynamic_method, dynamic_param, scale, svd_niter)
+
+                    del weight, lora_down, lora_up
+
+                    fro_list.append(result['fro_retained'])
+
+                    # Store using same format suffixes as input
+                    down_suffix = format_info["down_suffix"]
+                    up_suffix = format_info["up_suffix"]
+                    alpha_suffix = format_info["alpha_suffix"]
+
+                    # Preserve original key format from input LoRA verbatim
+                    new_block_name = block_name
+
+                    block_sd = {
+                        f"{new_block_name}{down_suffix}": result["lora_down"].to(save_dtype),
+                        f"{new_block_name}{up_suffix}": result["lora_up"].to(save_dtype),
+                    }
+                    if alpha_suffix:
+                        block_sd[f"{new_block_name}{alpha_suffix}"] = torch.tensor(result["new_alpha"]).to(save_dtype)
+
+                    writer.write_dict(block_sd)
+
+                    del result
+                    import gc
+                    gc.collect()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
+
+                    pbar.update(1)
+        finally:
+            writer.__exit__(None, None, None)
+
+        if verbose and fro_list:
+            import numpy as np
+            avg_fro = np.mean(fro_list)
+            std_fro = np.std(fro_list)
+            print(f"[LoRA Resize] Average Frobenius retention: {avg_fro:.1%} ± {std_fro:.3f}")
+
+        print(f"[LoRA Resize] Saved to {output_path}")
         return output_path
 
     finally:
@@ -712,7 +719,7 @@ def merge_loras_to_model(
                 print(f"[LoRA Merge To Model] LoRA {i+1}: {format_info['format']}, {len(pairs)} layers, dim={network_dim}")
 
         # Common prefixes
-        BASE_PREFIXES = ["model.diffusion_model.", "diffusion_model.", "transformer.", "model."]
+        BASE_PREFIXES = ["model.diffusion_model.", "diffusion_model.", "transformer.", "model.", "net."]
         LORA_PREFIXES = [
             "lora_unet_", "lora_transformer_", "lora_te1_", "lora_te2_", "lora_te_",
             "lycoris_", "diffusion_model.", "transformer.", "unet."
@@ -758,7 +765,11 @@ def merge_loras_to_model(
         base_metadata = base_handler.metadata().copy() if base_handler.metadata() else {}
         base_metadata["merge_comment"] = f"Merged {len(lora_paths)} LoRAs with weights: {lora_weights}"
 
-        output_sd = {}
+        # Build output path before loop
+        base_dir = os.path.dirname(base_model_path)
+        os.makedirs(base_dir, exist_ok=True)
+        output_path = os.path.join(base_dir, f"{output_filename.strip()}.safetensors")
+
         stats = {"merged": 0, "copied": 0, "skipped": 0}
         base_keys = list(base_handler.keys())
         pbar = comfy.utils.ProgressBar(len(base_keys))
@@ -766,118 +777,116 @@ def merge_loras_to_model(
         if verbose:
             print(f"[LoRA Merge To Model] Processing {len(base_keys)} base model keys...")
 
-        with torch.no_grad():
-            for base_key in tqdm(base_keys, desc="Merging to model", unit="keys"):
-                # Check skip patterns
-                if _matches_any_pattern(base_key, skip_patterns):
-                    stats["skipped"] += 1
-                    pbar.update(1)
-                    continue
+        writer = IncrementalSafetensorsWriter(output_path, metadata=base_metadata)
+        writer.__enter__()
+        try:
+            with torch.no_grad():
+                for base_key in tqdm(base_keys, desc="Merging to model", unit="keys"):
+                    # Check skip patterns
+                    if _matches_any_pattern(base_key, skip_patterns):
+                        stats["skipped"] += 1
+                        pbar.update(1)
+                        continue
 
-                # Load base weight
-                cpu_base = base_handler.get_tensor(base_key)
+                    # Load base weight
+                    cpu_base = base_handler.get_tensor(base_key)
 
-                # Only process weight tensors for LoRA merging
-                if base_key.endswith(".weight"):
-                    core = extract_core_layer_base(base_key)
-                    core_underscored = core.replace(".", "_")
+                    # Only process weight tensors for LoRA merging
+                    if base_key.endswith(".weight"):
+                        core = extract_core_layer_base(base_key)
+                        core_underscored = core.replace(".", "_")
 
-                    # Check if any LoRA contributes to this layer
-                    if core_underscored in lora_lookup:
-                        # Transfer to GPU for computation
-                        if device == 'cuda':
-                            base_weight = transfer_to_gpu_pinned(cpu_base, device, torch.float32)
-                        else:
-                            base_weight = cpu_base.to(device=device, dtype=torch.float32)
-                        del cpu_base
-
-                        # Accumulate deltas from all contributing LoRAs
-                        for info, block_keys in lora_lookup[core_underscored]:
-                            is_full_diff = info["format_info"].get("is_full_diff", False)
-
-                            if is_full_diff:
-                                # Full diff format
-                                if "diff" not in block_keys:
-                                    continue
-                                cpu_diff = info["handler"].get_tensor(block_keys["diff"])
-                                if device == 'cuda':
-                                    delta = transfer_to_gpu_pinned(cpu_diff, device, torch.float32)
-                                else:
-                                    delta = cpu_diff.to(device=device, dtype=torch.float32)
-                                del cpu_diff
-                                effective_scale = info["weight"]
+                        # Check if any LoRA contributes to this layer
+                        if core_underscored in lora_lookup:
+                            # Transfer to GPU for computation
+                            if device == 'cuda':
+                                base_weight = transfer_to_gpu_pinned(cpu_base, device, torch.float32)
                             else:
-                                # Standard LoRA format
-                                if "down" not in block_keys or "up" not in block_keys:
-                                    continue
+                                base_weight = cpu_base.to(device=device, dtype=torch.float32)
+                            del cpu_base
 
-                                cpu_down = info["handler"].get_tensor(block_keys["down"])
-                                cpu_up = info["handler"].get_tensor(block_keys["up"])
-                                if device == 'cuda':
-                                    lora_down = transfer_to_gpu_pinned(cpu_down, device, torch.float32)
-                                    lora_up = transfer_to_gpu_pinned(cpu_up, device, torch.float32)
+                            # Accumulate deltas from all contributing LoRAs
+                            for info, block_keys in lora_lookup[core_underscored]:
+                                is_full_diff = info["format_info"].get("is_full_diff", False)
+
+                                if is_full_diff:
+                                    # Full diff format
+                                    if "diff" not in block_keys:
+                                        continue
+                                    cpu_diff = info["handler"].get_tensor(block_keys["diff"])
+                                    if device == 'cuda':
+                                        delta = transfer_to_gpu_pinned(cpu_diff, device, torch.float32)
+                                    else:
+                                        delta = cpu_diff.to(device=device, dtype=torch.float32)
+                                    del cpu_diff
+                                    effective_scale = info["weight"]
                                 else:
-                                    lora_down = cpu_down.to(device=device, dtype=torch.float32)
-                                    lora_up = cpu_up.to(device=device, dtype=torch.float32)
-                                del cpu_down, cpu_up
+                                    # Standard LoRA format
+                                    if "down" not in block_keys or "up" not in block_keys:
+                                        continue
 
-                                # Get alpha
-                                if "alpha" in block_keys:
-                                    alpha_tensor = info["handler"].get_tensor(block_keys["alpha"])
-                                    layer_alpha = float(alpha_tensor.item())
-                                else:
-                                    layer_alpha = float(info["network_dim"])
-                                layer_scale = layer_alpha / info["network_dim"] if info["network_dim"] > 0 else 1.0
-                                effective_scale = layer_scale * info["weight"]
+                                    cpu_down = info["handler"].get_tensor(block_keys["down"])
+                                    cpu_up = info["handler"].get_tensor(block_keys["up"])
+                                    if device == 'cuda':
+                                        lora_down = transfer_to_gpu_pinned(cpu_down, device, torch.float32)
+                                        lora_up = transfer_to_gpu_pinned(cpu_up, device, torch.float32)
+                                    else:
+                                        lora_down = cpu_down.to(device=device, dtype=torch.float32)
+                                        lora_up = cpu_up.to(device=device, dtype=torch.float32)
+                                    del cpu_down, cpu_up
 
-                                # Compute delta
-                                is_conv = len(lora_down.shape) == 4
-                                if is_conv:
-                                    in_rank, in_size, kernel_size, k_ = lora_down.shape
-                                    out_size, out_rank, _, _ = lora_up.shape
-                                    delta = lora_up.reshape(out_size, -1) @ lora_down.reshape(in_rank, -1)
-                                    delta = delta.reshape(out_size, in_size, kernel_size, kernel_size)
-                                else:
-                                    delta = lora_up @ lora_down
-                                del lora_down, lora_up
+                                    # Get alpha
+                                    if "alpha" in block_keys:
+                                        alpha_tensor = info["handler"].get_tensor(block_keys["alpha"])
+                                        layer_alpha = float(alpha_tensor.item())
+                                    else:
+                                        layer_alpha = float(info["network_dim"])
+                                    layer_scale = layer_alpha / info["network_dim"] if info["network_dim"] > 0 else 1.0
+                                    effective_scale = layer_scale * info["weight"]
 
-                            # Apply delta to base weight
-                            base_weight = base_weight + effective_scale * delta
-                            del delta
+                                    # Compute delta
+                                    is_conv = len(lora_down.shape) == 4
+                                    if is_conv:
+                                        in_rank, in_size, kernel_size, k_ = lora_down.shape
+                                        out_size, out_rank, _, _ = lora_up.shape
+                                        delta = lora_up.reshape(out_size, -1) @ lora_down.reshape(in_rank, -1)
+                                        delta = delta.reshape(out_size, in_size, kernel_size, kernel_size)
+                                    else:
+                                        delta = lora_up @ lora_down
+                                    del lora_down, lora_up
 
-                        # Store merged weight
-                        output_sd[base_key] = base_weight.to(save_dtype).cpu().contiguous()
-                        del base_weight
-                        stats["merged"] += 1
+                                # Apply delta to base weight
+                                base_weight = base_weight + effective_scale * delta
+                                del delta
+
+                            # Write merged weight
+                            writer.write(base_key, base_weight.to(save_dtype).cpu().contiguous())
+                            del base_weight
+                            stats["merged"] += 1
+                        else:
+                            # No LoRA contribution, write as-is
+                            writer.write(base_key, cpu_base.to(save_dtype).contiguous())
+                            del cpu_base
+                            stats["copied"] += 1
                     else:
-                        # No LoRA contribution, copy as-is
-                        output_sd[base_key] = cpu_base.to(save_dtype).contiguous()
+                        # Non-weight tensor (bias, norm, etc.), write as-is
+                        writer.write(base_key, cpu_base.to(save_dtype).contiguous())
                         del cpu_base
                         stats["copied"] += 1
-                else:
-                    # Non-weight tensor (bias, norm, etc.), copy as-is
-                    output_sd[base_key] = cpu_base.to(save_dtype).contiguous()
-                    del cpu_base
-                    stats["copied"] += 1
 
-                import gc
-                gc.collect()
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
+                    import gc
+                    gc.collect()
+                    if torch.cuda.is_available():
+                        torch.cuda.empty_cache()
 
-                pbar.update(1)
+                    pbar.update(1)
+        finally:
+            writer.__exit__(None, None, None)
 
         if verbose:
             print(f"[LoRA Merge To Model] Done: {stats['merged']} merged, {stats['copied']} copied, {stats['skipped']} skipped")
 
-        # Save to base model directory
-        base_dir = os.path.dirname(base_model_path)
-        os.makedirs(base_dir, exist_ok=True)
-        output_path = os.path.join(base_dir, f"{output_filename.strip()}.safetensors")
-
-        save_file(output_sd, output_path, base_metadata)
         print(f"[LoRA Merge To Model] Saved to {output_path}")
-
         return output_path
 
     finally:

nodes/merger.py

@@ -1,3 +1,4 @@
+import fnmatch
 import os
 import re
 import torch
@@ -5,13 +6,13 @@ import folder_paths
 import comfy.utils
 from tqdm import tqdm
 from comfy_api.latest import io
-from safetensors.torch import save_file
 from .merger_ops import TWO_MODEL_MODES, THREE_MODEL_MODES, MissingTensorBehavior, MissingTensorError
-from .merger_utils import MemoryEfficientSafeOpen, transfer_to_gpu_pinned
 from .device_utils import (
     estimate_model_size, prepare_for_large_operation, cleanup_after_operation
 )
 
+from unifiedefficientloader import MemoryEfficientSafeOpen, transfer_to_gpu_pinned, IncrementalSafetensorsWriter
+
 
 def load_documentation_from_file(filename):
     """Loads documentation from a markdown file in the ../docs/ directory."""
@@ -24,26 +25,38 @@ def load_documentation_from_file(filename):
         return f"# Documentation File Not Found\n\nPlease ensure `{filename}` exists in the `docs` directory of the custom node."
 
 
-def _compile_patterns(pattern_string):
-    """Compiles whitespace-separated regex patterns into a list of compiled patterns.
+def _compile_patterns(pattern_string, glob_mode=False):
+    """Compiles whitespace-separated patterns into a list.
 
-    Returns empty list if pattern_string is empty or whitespace-only.
-    Raises ValueError if any pattern is invalid regex.
+    In regex mode (default): returns compiled re.Pattern objects.
+      Raises ValueError if any pattern is invalid regex.
+    In glob mode: returns plain strings; fnmatch handles matching.
     """
     if not pattern_string or not pattern_string.strip():
         return []
 
     patterns = []
     for pattern in pattern_string.split():
-        try:
-            patterns.append(re.compile(pattern))
-        except re.error as e:
-            raise ValueError(f"Invalid regex pattern '{pattern}': {e}")
+        if not pattern:
+            continue
+        if glob_mode:
+            patterns.append(pattern)
+        else:
+            try:
+                patterns.append(re.compile(pattern))
+            except re.error as e:
+                raise ValueError(f"Invalid regex pattern '{pattern}': {e}")
     return patterns
 
 
-def _matches_any_pattern(key, patterns):
-    """Returns True if key matches any of the compiled regex patterns (substring search)."""
+def _matches_any_pattern(key, patterns, glob_mode=False):
+    """Returns True if key matches any pattern.
+
+    Glob mode: fnmatch substring match — dots are literal, * matches any sequence.
+    Regex mode: compiled re.Pattern substring search.
+    """
+    if glob_mode:
+        return any(fnmatch.fnmatch(key, f"*{p}*") for p in patterns)
     for pattern in patterns:
         if pattern.search(key):
             return True
@@ -76,6 +89,9 @@ class MergerLogic:
             process_device = recipe_params.get('device', 'cpu')
             print(f"[Merger] Preparing memory for {total_size_gb:.2f}GB merge operation...")
             prepare_for_large_operation(total_size_gb * 1.2, torch.device(process_device))
+            flush_threshold_bytes = int(total_size_gb * 1024**3 / 16)
+        else:
+            flush_threshold_bytes = 256 * 1024 * 1024  # 256MB fallback (min 8GB RAM assumed)
 
         handlers = {}
         for name in model_names.values():
@@ -96,8 +112,9 @@ class MergerLogic:
         alignment_mode = recipe_params.get('alignment_mode', 'pad/crop')
 
         # Compile filter patterns
-        exclude_patterns = _compile_patterns(recipe_params.get('exclude_patterns', ''))
-        discard_patterns = _compile_patterns(recipe_params.get('discard_patterns', ''))
+        glob_mode = recipe_params.get('glob_patterns', False)
+        exclude_patterns = _compile_patterns(recipe_params.get('exclude_patterns', ''), glob_mode=glob_mode)
+        discard_patterns = _compile_patterns(recipe_params.get('discard_patterns', ''), glob_mode=glob_mode)
 
         # Pre-compute key differences for logging
         primary_keys = set(all_keys)
@@ -124,12 +141,42 @@ class MergerLogic:
         discarded_keys = 0
         error_keys = []
 
+        output_folder = "loras" if calc_mode == "SVD LoRA Extraction" else model_type
+        # Use [-1] for diffusion_models to get the actual diffusion_models folder, not legacy unet
+        output_dir = folder_paths.get_folder_paths(output_folder)[-1]
+        os.makedirs(output_dir, exist_ok=True)
+        output_filename = recipe_params.get("output_filename")
+        output_path = os.path.join(output_dir, f"{output_filename}.safetensors")
+
+        writer = None
+
+        writer = IncrementalSafetensorsWriter(output_path, metadata=metadata)
+        writer.__enter__()
+
+        batch_buffer = {}
+        batch_bytes = 0
+        batch_key_count = 0
+
+        def _flush_batch():
+            nonlocal batch_buffer, batch_bytes, batch_key_count
+            if not batch_buffer:
+                return
+            writer.write_dict(batch_buffer)
+            pbar.update(batch_key_count)
+            batch_buffer = {}
+            batch_bytes = 0
+            batch_key_count = 0
+            if recipe_params.get('force_clear_cache', True):
+                import gc
+                gc.collect()
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+
         with torch.no_grad():
             for key in tqdm(all_keys, desc="Merging layers", unit="layers"):
                 # Check discard patterns first - skip entirely
-                if _matches_any_pattern(key, discard_patterns):
+                if _matches_any_pattern(key, discard_patterns, glob_mode=glob_mode):
                     discarded_keys += 1
-                    pbar.update(1)
                     continue
 
                 # Pre-load Model A's tensor with pinned memory for CUDA
@@ -141,10 +188,16 @@ class MergerLogic:
                 del cpu_tensor
 
                 # Check exclude patterns - use Model A only, no merge
-                if _matches_any_pattern(key, exclude_patterns):
-                    merged_state_dict[key] = tensor_a.detach().to(save_torch_dtype).cpu().clone()
+                if _matches_any_pattern(key, exclude_patterns, glob_mode=glob_mode):
+                    t = tensor_a.detach().to(save_torch_dtype).cpu()
+
+                    batch_buffer[key] = t
+                    batch_bytes += t.numel() * t.element_size()
+                    batch_key_count += 1
                     excluded_keys += 1
-                    pbar.update(1)
+                    del tensor_a
+                    if (batch_bytes >= flush_threshold_bytes or batch_key_count >= 32):
+                        _flush_batch()
                     continue
 
                 # Pass tensor_a metadata to recipes for zeros mode and fallback
@@ -157,6 +210,9 @@ class MergerLogic:
                     result = recipe.merge()
                 except MissingTensorError as e:
                     if mismatch_mode == MissingTensorBehavior.ERROR:
+
+                        _flush_batch()
+                        writer.__exit__(None, None, None)
                         raise ValueError(f"Layer mismatch error (mismatch_mode='error'): {e}")
                     result = None
                     error_keys.append(key)
@@ -168,7 +224,10 @@ class MergerLogic:
 
                 if isinstance(result, dict):
                     for r_key, r_tensor in result.items():
-                        merged_state_dict[r_key] = r_tensor.detach().to(save_torch_dtype).cpu().clone()
+                        t = r_tensor.detach().to(save_torch_dtype).cpu()
+
+                        batch_buffer[r_key] = t
+                        batch_bytes += t.numel() * t.element_size()
                 else:
                     # Ensure compatibility with Model A's architecture.
                     # If alignment_mode is 'pad/crop', we crop results that were padded.
@@ -179,7 +238,13 @@ class MergerLogic:
                             slices = tuple(slice(0, min(res_s, tgt_s)) for res_s, tgt_s in zip(result.shape, target_shape))
                             result = result[slices]
 
-                    merged_state_dict[key] = result.detach().to(save_torch_dtype).cpu().clone()
+                    t = result.detach().to(save_torch_dtype).cpu()
+
+                    batch_buffer[key] = t
+                    batch_bytes += t.numel() * t.element_size()
+
+
+                batch_key_count += 1
 
                 # Clean up references to allow GC immediately.
                 # Local loop variables must be explicitly deleted to prevent PyTorch from keeping tensors in VRAM.
@@ -189,13 +254,12 @@ class MergerLogic:
                 del recipe
                 del result
 
-                if recipe_params.get('force_clear_cache', True):
-                    import gc
-                    gc.collect()
-                    if torch.cuda.is_available():
-                        torch.cuda.empty_cache()
+                if (batch_bytes >= flush_threshold_bytes or batch_key_count >= 32):
+                    _flush_batch()
 
-                pbar.update(1)
+
+        _flush_batch()
+        writer.__exit__(None, None, None)
 
         # Log summary
         if excluded_keys > 0:
@@ -216,10 +280,9 @@ class MergerLogic:
         os.makedirs(output_dir, exist_ok=True)
         output_filename = recipe_params.get("output_filename")
         output_path = os.path.join(output_dir, f"{output_filename}.safetensors")
-        save_file(merged_state_dict, output_path, metadata=metadata)
-
+        if os.path.exists(output_path):
+            print(f"[Merger] Output saved to {output_path}")
         # Cleanup after heavy operation
-        del merged_state_dict
         cleanup_after_operation()
 
         return f"{output_filename}.safetensors"
@@ -243,16 +306,21 @@ class CheckpointTwoMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in TWO_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_2_checkpoint"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -265,9 +333,9 @@ class CheckpointTwoMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -275,10 +343,11 @@ class CheckpointTwoMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b}
@@ -302,16 +371,21 @@ class ModelTwoMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in TWO_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_2_model"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -324,9 +398,9 @@ class ModelTwoMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -334,10 +408,11 @@ class ModelTwoMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b}
@@ -361,16 +436,21 @@ class TextEncoderTwoMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in TWO_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_2_textencoder"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -383,9 +463,9 @@ class TextEncoderTwoMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -393,10 +473,11 @@ class TextEncoderTwoMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b}
@@ -420,16 +501,21 @@ class LoRATwoMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in TWO_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_2_lora"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -442,9 +528,9 @@ class LoRATwoMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -452,10 +538,11 @@ class LoRATwoMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b}
@@ -479,16 +566,21 @@ class EmbeddingTwoMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in TWO_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_2_embedding"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -501,9 +593,9 @@ class EmbeddingTwoMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_2_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -511,10 +603,11 @@ class EmbeddingTwoMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b}
@@ -541,16 +634,21 @@ class CheckpointThreeMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in THREE_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_3_checkpoint"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -563,9 +661,9 @@ class CheckpointThreeMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -573,10 +671,11 @@ class CheckpointThreeMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b, "model_c": model_c}
@@ -601,16 +700,21 @@ class ModelThreeMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in THREE_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_3_model"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -623,9 +727,9 @@ class ModelThreeMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -633,10 +737,11 @@ class ModelThreeMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b, "model_c": model_c}
@@ -661,16 +766,21 @@ class TextEncoderThreeMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in THREE_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.99, min=0.0, max=1.0, step=0.001),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.99, min=-10.0, max=10.0, step=0.001),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_3_textencoder"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -683,9 +793,9 @@ class TextEncoderThreeMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -693,10 +803,11 @@ class TextEncoderThreeMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b, "model_c": model_c}
@@ -721,16 +832,21 @@ class LoRAThreeMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in THREE_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_3_lora"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -743,9 +859,9 @@ class LoRAThreeMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -753,10 +869,11 @@ class LoRAThreeMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b, "model_c": model_c}
@@ -781,16 +898,21 @@ class EmbeddingThreeMerger(io.ComfyNode):
                 io.Combo.Input("calc_mode", options=[m.name for m in THREE_MODEL_MODES]),
                 io.Combo.Input("mismatch_mode", options=["skip", "zeros", "error"], default="skip"),
                 io.Combo.Input("alignment_mode", options=["pad/crop", "interpolate"], default="pad/crop"),
-                io.Float.Input("alpha", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("beta", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("gamma", default=0.5, min=-2.0, max=3.0, step=0.01),
-                io.Float.Input("delta", default=0.5, min=-2.0, max=3.0, step=0.01),
+                io.Float.Input("alpha", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("beta", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("gamma", default=0.5, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("delta", default=2.0, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("epsilon", default=0.01, min=-10.0, max=10.0, step=0.01),
+                io.Float.Input("zeta", default=0.0, min=-10.0, max=10.0, step=0.01),
                 io.Int.Input("seed", default=0, min=0, max=0xffffffffffffffff),
                 io.String.Input("output_filename", default="merged_3_embedding"),
                 io.Combo.Input("save_dtype", options=["fp32", "fp16", "bf16"]),
                 io.Combo.Input("process_device", options=["cuda", "cpu"]),
                 io.String.Input("exclude_patterns", default="", multiline=True),
                 io.String.Input("discard_patterns", default="", multiline=True),
+                io.Boolean.Input("glob_patterns", default=False,
+                                 tooltip="When True, exclude/discard patterns use glob syntax (* = any sequence, dots are literal). "
+                                         "When False (default), patterns are Python regex matched as substrings."),
                 io.Boolean.Input("lazy_load", default=True, tooltip="Low memory mode: load tensors from disk on demand"),
                 io.Boolean.Input("force_clear_cache", default=True, tooltip="Clear CUDA cache after each layer"),
             ],
@@ -803,9 +925,9 @@ class EmbeddingThreeMerger(io.ComfyNode):
     @classmethod
     def execute(cls, execution_mode: str, model_a: str, model_b: str, model_c: str,
                 calc_mode: str, mismatch_mode: str, alignment_mode: str, alpha: float, beta: float,
-                gamma: float, delta: float, seed: int, output_filename: str, save_dtype: str,
+                gamma: float, delta: float, epsilon: float, zeta: float, seed: int, output_filename: str, save_dtype: str,
                 process_device: str, exclude_patterns: str, discard_patterns: str,
-                lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
+                glob_patterns: bool, lazy_load: bool, force_clear_cache: bool) -> io.NodeOutput:
         doc = load_documentation_from_file('merger_3_model_modes.md')
         if execution_mode == "DOCUMENTATION ONLY":
             return io.NodeOutput("Documentation mode active. No merge performed.", doc)
@@ -813,10 +935,11 @@ class EmbeddingThreeMerger(io.ComfyNode):
         recipe_params = {
             "model_a": model_a, "model_b": model_b, "model_c": model_c, "calc_mode": calc_mode,
             "mismatch_mode": mismatch_mode, "alignment_mode": alignment_mode,
-            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "seed": seed,
+            "alpha": alpha, "beta": beta, "gamma": gamma, "delta": delta, "epsilon": epsilon, "zeta": zeta, "seed": seed,
             "output_filename": output_filename, "save_dtype": save_dtype,
             "device": process_device, "dtype": torch.float32,
             "exclude_patterns": exclude_patterns, "discard_patterns": discard_patterns,
+            "glob_patterns": glob_patterns,
             "lazy_load": lazy_load, "force_clear_cache": force_clear_cache,
         }
         model_names = {"model_a": model_a, "model_b": model_b, "model_c": model_c}

nodes/merger_ops.py

@@ -4,7 +4,7 @@ import torch.nn.functional as F
 from enum import Enum
 
 
-from .merger_utils import transfer_to_gpu_pinned
+from unifiedefficientloader import transfer_to_gpu_pinned
 
 class MissingTensorBehavior(Enum):
     """Controls behavior when a tensor key is missing from a model."""
@@ -319,6 +319,53 @@ class PowerUpOp(Operation):
         return (m * delta) / keep_prob
 
 
+class DARETIESOp(Operation):
+    """DARE + TIES combined operation on a single task vector (delta = b - a).
+
+    Step 1 — DARE: randomly drop `drop_rate` fraction of delta parameters,
+                   rescale survivors by 1/(1-drop_rate).
+    Step 2 — TIES trim: zero out parameters below the `trim_quantile` magnitude threshold.
+    Step 3 — TIES elect: determine dominant sign per parameter position.
+    Step 4 — TIES merge: zero out parameters that disagree with the dominant sign.
+
+    For a two-model merge the TIES elect/merge step degenerates to a no-op (single vector,
+    sign is always self-consistent) but the trim step still reduces interference from
+    near-zero noisy deltas. The dominant sign filter is included for correctness and
+    forward compatibility with n-model extensions.
+    """
+    def __init__(self, key, alpha, beta, gamma, seed, *sources):
+        super().__init__(key, *sources)
+        # alpha = drop_rate (DARE), beta = trim_quantile (TIES), gamma = lambda scale
+        self.alpha, self.beta, self.gamma, self.seed = alpha, beta, gamma, seed
+
+    def oper(self, a, b):
+        if a is None or b is None:
+            return None
+        a, b = resize_tensors(a, b, mode=self.alignment_mode)
+        delta = (b - a).float()
+
+        # --- DARE: drop and rescale ---
+        keep_prob = 1.0 - self.alpha
+        if keep_prob <= 0:
+            return torch.zeros_like(a)
+        rng = torch.Generator(device=delta.device).manual_seed(self.seed)
+        dare_mask = (torch.empty_like(delta).uniform_(0, 1, generator=rng) < keep_prob).float()
+        delta = (delta * dare_mask) / keep_prob
+
+        # --- TIES trim: zero parameters below magnitude threshold ---
+        if self.beta > 0:
+            flat_abs = delta.abs().flatten()
+            k = max(1, int(flat_abs.numel() * self.beta))
+            threshold = torch.kthvalue(flat_abs, k).values
+            delta = torch.where(delta.abs() < threshold, torch.zeros_like(delta), delta)
+
+        # --- TIES elect: dominant sign (trivially self-consistent for single vector) ---
+        dominant_sign = torch.sign(delta)
+        delta = torch.where(torch.sign(delta) == dominant_sign, delta, torch.zeros_like(delta))
+
+        return (a + self.gamma * delta).to(a.dtype)
+
+
 class InterpolateDifference(Operation):
     def __init__(self, key, alpha, beta, gamma, seed, *sources):
         super().__init__(key, *sources)
@@ -710,5 +757,179 @@ class WeightSumCutoffMode(CalcMode):
         return res
 
 
-TWO_MODEL_MODES = [WeightSum(), InterpDifference(), PowerUp(), SVDMode(), ManEnhInterpDifference(), AutoEnhInterpDifference(), WeightSumCutoffMode()]
+class DARETIESMode(CalcMode):
+    name = 'Power-Up (DARE+TIES)'
+    description = 'Adds capabilities of B to A using DARE (Drop and Rescale) followed by TIES (Trim, Elect Sign). Best practice for LoRA-tuned model merging.'
+    models_used = ['A', 'B']
+    param_docs = {
+        'alpha': 'DARE drop rate — fraction of delta parameters randomly zeroed. Higher = more aggressive sparsification.',
+        'beta':  'TIES trim quantile — fraction of smallest-magnitude delta parameters zeroed after DARE. Removes residual noise.',
+        'gamma': 'Lambda — scale multiplier applied to the final merged delta before adding to Model A.',
+        'seed':  'Random seed for the DARE dropout mask.',
+    }
+
+    def create_recipe(self, key, **kwargs):
+        mismatch_mode = kwargs.get('mismatch_mode', MissingTensorBehavior.SKIP)
+        alignment_mode = kwargs.get('alignment_mode', 'pad/crop')
+
+        if '_tensor_a' in kwargs:
+            a = PreloadedTensor(key, kwargs['_tensor_a'])
+        else:
+            loader_args_a = {"handlers": kwargs['handlers'], "device": kwargs['device'], "dtype": kwargs['dtype']}
+            a = LoadTensor(key, kwargs['model_a'], **loader_args_a)
+
+        loader_args_b = self._get_secondary_loader_args(kwargs, mismatch_mode)
+        b = LoadTensor(key, kwargs['model_b'], **loader_args_b)
+
+        op = DARETIESOp(
+            key,
+            kwargs['alpha'],   # drop_rate
+            kwargs['beta'],    # trim_quantile
+            kwargs['gamma'],   # lambda scale
+            kwargs['seed'],
+            a, b,
+        )
+        op.alignment_mode = alignment_mode
+        return op
+
+
+class EnhancedPowerUpOp(Operation):
+    def __init__(self, key, alpha, beta, gamma, delta, seed, *sources):
+        super().__init__(key, *sources)
+        self.mask_power = alpha       # Mask power
+        self.min_keep_prob = beta     # Min keep prob
+        self.mask_smooth = gamma      # Smoothness (0 or 1)
+        self.delta = delta            # Final multiplier
+        self.seed = seed
+
+    def oper(self, a, b):
+        if a is None or b is None: return None
+        a, b = resize_tensors(a, b, mode=self.alignment_mode)
+        delta_val = (b - a).float()
+        abs_delta = torch.abs(delta_val)
+        max_delta = torch.max(abs_delta)
+        if max_delta == 0: return torch.zeros_like(delta_val)
+
+        prob = torch.clamp((abs_delta / max_delta) ** max(self.mask_power, 0.001), min=self.min_keep_prob, max=1.0)
+
+        rng = torch.Generator(device=a.device).manual_seed(self.seed)
+        random_mask = torch.bernoulli(prob, generator=rng)
+        interpolated_mask = torch.lerp(random_mask, prob, self.mask_smooth)
+
+        rescaled_delta = delta_val * interpolated_mask
+        return rescaled_delta
+
+
+class EnhancedDARETIESOp(Operation):
+    def __init__(self, key, alpha, beta, gamma, delta, epsilon, zeta, seed, *sources):
+        super().__init__(key, *sources)
+        self.alpha = alpha       # Unused directly for drop scale
+        self.beta = beta         # TIES trim quantile
+        self.gamma = gamma       # TIES lambda scale
+        self.mask_power = delta
+        self.min_keep_prob = epsilon
+        self.mask_smooth = zeta
+        self.seed = seed
+
+    def oper(self, a, b):
+        if a is None or b is None: return None
+        a, b = resize_tensors(a, b, mode=self.alignment_mode)
+        delta_val = (b - a).float()
+        abs_delta = torch.abs(delta_val)
+        max_delta = torch.max(abs_delta)
+
+        if max_delta > 0:
+            prob = torch.clamp((abs_delta / max_delta) ** max(self.mask_power, 0.001), min=self.min_keep_prob, max=1.0)
+
+            rng = torch.Generator(device=a.device).manual_seed(self.seed)
+            random_mask = torch.bernoulli(prob, generator=rng)
+            interpolated_mask = torch.lerp(random_mask, prob, self.mask_smooth)
+
+            delta_val = delta_val * interpolated_mask
+
+        if self.beta > 0:
+            flat_abs = delta_val.abs().flatten()
+            k = max(1, int(flat_abs.numel() * self.beta))
+            threshold = torch.kthvalue(flat_abs, k).values
+            delta_val = torch.where(delta_val.abs() < threshold, torch.zeros_like(delta_val), delta_val)
+
+        dominant_sign = torch.sign(delta_val)
+        delta_val = torch.where(torch.sign(delta_val) == dominant_sign, delta_val, torch.zeros_like(delta_val))
+
+        return (a + self.gamma * delta_val).to(a.dtype)
+
+
+class EnhancedPowerUp(CalcMode):
+    name = 'Power-Up Enhanced (DARE)'
+    description = 'Adds capabilities of B to A using Enhanced Drop and Rescale based on relative tensor differences.'
+    models_used = ['A', 'B']
+    param_docs = {
+        'alpha': 'Mask power (Curve. 2.0 = quadratic).',
+        'beta': 'Minimum keep probability (Floor to prevent explosion).',
+        'gamma': 'Mask smoothness factor (0.0 = pure dropout, 1.0 = soft scale).',
+        'delta': 'Multiplier for the final difference.',
+    }
+    def create_recipe(self, key, **kwargs):
+        mismatch_mode = kwargs.get('mismatch_mode', MissingTensorBehavior.SKIP)
+        alignment_mode = kwargs.get('alignment_mode', 'pad/crop')
+
+        if '_tensor_a' in kwargs:
+            a = PreloadedTensor(key, kwargs['_tensor_a'])
+        else:
+            loader_args_a = {"handlers": kwargs['handlers'], "device": kwargs['device'], "dtype": kwargs['dtype']}
+            a = LoadTensor(key, kwargs['model_a'], **loader_args_a)
+
+        loader_args_b = self._get_secondary_loader_args(kwargs, mismatch_mode)
+        b = LoadTensor(key, kwargs['model_b'], **loader_args_b)
+
+        deltahat = EnhancedPowerUpOp(key, kwargs['alpha'], kwargs['beta'], kwargs['gamma'], kwargs['delta'], kwargs['seed'], a, b)
+        deltahat.alignment_mode = alignment_mode
+        multiplied = Multiply(key, kwargs['delta'], deltahat)
+        res = Add(key, a, multiplied)
+        res.alignment_mode = alignment_mode
+        return res
+
+
+class EnhancedDARETIESMode(CalcMode):
+    name = 'Power-Up Enhanced (DARE+TIES)'
+    description = 'Adds capabilities of B to A using Enhanced DARE mask followed by TIES.'
+    models_used = ['A', 'B']
+    param_docs = {
+        'alpha': 'Unused (Drop scale handled via mask interpolation).',
+        'beta': 'TIES trim quantile (fraction of smallest-magnitude delta zeroed).',
+        'gamma': 'TIES Lambda scale.',
+        'delta': 'Mask power (Curve. 2.0 = quadratic).',
+        'epsilon': 'Minimum keep probability (Floor to prevent explosion).',
+        'zeta': 'Mask smoothness factor (0.0 = pure dropout, 1.0 = soft scale).',
+    }
+
+    def create_recipe(self, key, **kwargs):
+        mismatch_mode = kwargs.get('mismatch_mode', MissingTensorBehavior.SKIP)
+        alignment_mode = kwargs.get('alignment_mode', 'pad/crop')
+
+        if '_tensor_a' in kwargs:
+            a = PreloadedTensor(key, kwargs['_tensor_a'])
+        else:
+            loader_args_a = {"handlers": kwargs['handlers'], "device": kwargs['device'], "dtype": kwargs['dtype']}
+            a = LoadTensor(key, kwargs['model_a'], **loader_args_a)
+
+        loader_args_b = self._get_secondary_loader_args(kwargs, mismatch_mode)
+        b = LoadTensor(key, kwargs['model_b'], **loader_args_b)
+
+        op = EnhancedDARETIESOp(
+            key,
+            kwargs.get('alpha', 0.5),
+            kwargs.get('beta', 0.2),
+            kwargs.get('gamma', 1.0),
+            kwargs.get('delta', 0.5),
+            kwargs.get('epsilon', 0.5),
+            kwargs.get('zeta', 0.5),
+            kwargs['seed'],
+            a, b,
+        )
+        op.alignment_mode = alignment_mode
+        return op
+
+
+TWO_MODEL_MODES = [WeightSum(), InterpDifference(), PowerUp(), DARETIESMode(), SVDMode(), ManEnhInterpDifference(), AutoEnhInterpDifference(), WeightSumCutoffMode(), EnhancedPowerUp(), EnhancedDARETIESMode()]
 THREE_MODEL_MODES = [AddDifference(), TrainDifference(), Extract(), AddDisimilarity()]

nodes/merger_utils.py

@@ -1,292 +1,7 @@
 """
-Memory-efficient safetensors utilities with pinned memory support.
-Forces direct file reads to minimize OS page cache usage and avoids VRAM accumulation.
+Utilities for model merging operations.
 """
-import os
-import gc
-import json
-import struct
-import torch
-from safetensors import safe_open
-from typing import Dict, List, Optional, Any
-
-# Module-level configuration for pinned transfer
-_verbose = False
-_pinned_transfer_stats = {"pinned": 0, "fallback": 0}
-
-def set_verbose(enabled: bool):
-    """Enable/disable verbose output for pinned transfers."""
-    global _verbose
-    _verbose = enabled
-
-def get_pinned_transfer_stats():
-    """Return pinned transfer statistics."""
-    return _pinned_transfer_stats.copy()
-
-def reset_pinned_transfer_stats():
-    """Reset transfer statistics."""
-    global _pinned_transfer_stats
-    _pinned_transfer_stats = {"pinned": 0, "fallback": 0}
-
-def transfer_to_gpu_pinned(
-    tensor: torch.Tensor,
-    device: str = 'cuda',
-    dtype: Optional[torch.dtype] = None
-) -> torch.Tensor:
-    """Transfer tensor to GPU using pinned memory for faster transfer."""
-    global _pinned_transfer_stats
-
-    if tensor.device.type != 'cpu' or not torch.cuda.is_available():
-        if dtype is not None:
-            return tensor.to(device=device, dtype=dtype)
-        return tensor.to(device=device)
-
-    if not str(device).startswith('cuda'):
-        if dtype is not None:
-            return tensor.to(device=device, dtype=dtype)
-        return tensor.to(device=device)
-
-    try:
-        pinned = tensor.pin_memory()
-        if dtype is not None:
-            result = pinned.to(device=device, dtype=dtype, non_blocking=True)
-        else:
-            result = pinned.to(device=device, non_blocking=True)
-
-        torch.cuda.current_stream().synchronize()
-        _pinned_transfer_stats["pinned"] += 1
-        return result
-    except Exception as e:
-        _pinned_transfer_stats["fallback"] += 1
-        if dtype is not None:
-            return tensor.to(device=device, dtype=dtype)
-        return tensor.to(device=device)
-
-
-class MemoryEfficientSafeOpen:
-    """Memory-efficient safetensors file reader with streaming and pinned memory support.
-
-    Operates strictly in streaming mode (low memory). Tensors are read byte-by-byte from
-    their exact offsets without using safe_open or memory mapping, ensuring tensors do not
-    remain persistently in OS page caches or RAM.
-    """
-
-    def __init__(self, filename: str, device: str = 'cpu', **kwargs):
-        # Ignore mmap_mode, low_memory, or any other legacy kwargs. We always stream.
-        self.filename = filename
-        self.device = device
-        self.header, self.header_size = self._read_header()
-        self.file = open(filename, "rb")
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.file.close()
-
-    def keys(self) -> List[str]:
-        """Return all tensor keys (excluding metadata)."""
-        return [k for k in self.header.keys() if k != "__metadata__"]
-
-    def metadata(self) -> Dict[str, str]:
-        """Return file metadata."""
-        return self.header.get("__metadata__", {})
-
-    def get_shape(self, key: str) -> tuple:
-        """Get tensor shape without loading tensor data."""
-        if key not in self.header:
-            raise KeyError(f"Tensor '{key}' not found in file")
-        return tuple(self.header[key]["shape"])
-
-    def get_ndim(self, key: str) -> int:
-        """Get tensor ndim without loading tensor data."""
-        return len(self.get_shape(key))
-
-    def keys_sorted_by_offset(self) -> List[str]:
-        keys_with_offsets = []
-        for key in self.keys():
-            offset = self.header[key]["data_offsets"][0]
-            keys_with_offsets.append((key, offset))
-        keys_with_offsets.sort(key=lambda x: x[1])
-        return [k for k, _ in keys_with_offsets]
-
-    def get_tensor(self, key: str) -> torch.Tensor:
-        """Load a single tensor by key directly from file byte offset."""
-        if key not in self.header:
-            raise KeyError(f"Tensor '{key}' not found in the file")
-
-        metadata = self.header[key]
-        offset_start, offset_end = metadata["data_offsets"]
-
-        if offset_start != offset_end:
-            self.file.seek(self.header_size + 8 + offset_start)
-            tensor_bytes = bytearray(offset_end - offset_start)
-            self.file.readinto(tensor_bytes)
-        else:
-            tensor_bytes = None
-
-        return self._deserialize_tensor(tensor_bytes, metadata)
-
-    def get_tensor_to_gpu(
-        self,
-        key: str,
-        device: str = 'cuda',
-        dtype: Optional[torch.dtype] = None
-    ) -> torch.Tensor:
-        cpu_tensor = self.get_tensor(key)
-        return transfer_to_gpu_pinned(cpu_tensor, device, dtype)
-
-    def get_tensors_parallel(
-        self,
-        keys: Optional[List[str]] = None,
-        workers: Optional[int] = None,
-        sort_by_offset: bool = True
-    ) -> Dict[str, torch.Tensor]:
-        if keys is None:
-            keys = self.keys()
-
-        if workers is None:
-            try:
-                from .device_utils import get_optimal_workers, estimate_model_size
-                model_size = estimate_model_size(self.filename)
-                workers = get_optimal_workers(model_size)
-            except ImportError:
-                workers = min(4, os.cpu_count() or 4)
-
-        if sort_by_offset:
-            keys_with_offsets = [(k, self.header[k]["data_offsets"][0]) for k in keys]
-            keys_with_offsets.sort(key=lambda x: x[1])
-            keys = [k for k, _ in keys_with_offsets]
-
-        result = {}
-        with ThreadPoolExecutor(max_workers=workers) as executor:
-            futures = {
-                executor.submit(
-                    _read_tensor_from_file,
-                    self.filename,
-                    key,
-                    self.header[key],
-                    self.header_size
-                ): key
-                for key in keys
-            }
-
-            for future in as_completed(futures):
-                key = futures[future]
-                try:
-                    tensor = future.result()
-                    if tensor is not None:
-                        result[key] = tensor
-                except Exception as e:
-                    print(f"[MemoryEfficientSafeOpen] Failed to load {key}: {e}")
-
-        return result
-
-    def get_tensor_as_dict(self, key: str) -> Dict[str, Any]:
-        if key not in self.header:
-            raise KeyError(f"Tensor '{key}' not found")
-
-        metadata = self.header[key]
-        offset_start, offset_end = metadata["data_offsets"]
-
-        if offset_start == offset_end:
-            return {}
-
-        self.file.seek(self.header_size + 8 + offset_start)
-        tensor_bytes = self.file.read(offset_end - offset_start)
-        return json.loads(tensor_bytes.decode("utf-8"))
-
-    def _read_header(self):
-        with open(self.filename, "rb") as f:
-            header_size = struct.unpack("<Q", f.read(8))[0]
-            header_json = f.read(header_size).decode("utf-8")
-        return json.loads(header_json), header_size
-
-    def _deserialize_tensor(self, tensor_bytes, metadata):
-        dtype_str = metadata["dtype"]
-        shape = metadata["shape"]
-        dtype = self._get_torch_dtype(dtype_str)
-
-        if tensor_bytes is None:
-            byte_tensor = torch.empty(0, dtype=torch.uint8)
-        else:
-            byte_tensor = torch.frombuffer(tensor_bytes, dtype=torch.uint8)
-
-        if dtype_str in ["F8_E5M2", "F8_E4M3"]:
-            return self._convert_float8(byte_tensor, dtype_str, shape)
-
-        return byte_tensor.view(dtype).reshape(shape)
-
-    @staticmethod
-    def _get_torch_dtype(dtype_str):
-        dtype_map = {
-            "F64": torch.float64, "F32": torch.float32, "F16": torch.float16, "BF16": torch.bfloat16,
-            "I64": torch.int64, "I32": torch.int32, "I16": torch.int16, "I8": torch.int8,
-            "U8": torch.uint8, "BOOL": torch.bool,
-        }
-        if hasattr(torch, "float8_e5m2"):
-            dtype_map["F8_E5M2"] = torch.float8_e5m2
-        if hasattr(torch, "float8_e4m3fn"):
-            dtype_map["F8_E4M3"] = torch.float8_e4m3fn
-
-        dtype = dtype_map.get(dtype_str)
-        if dtype is None:
-            raise ValueError(f"Unsupported dtype: {dtype_str}")
-        return dtype
-
-    @staticmethod
-    def _convert_float8(byte_tensor, dtype_str, shape):
-        if dtype_str == "F8_E5M2" and hasattr(torch, "float8_e5m2"):
-            return byte_tensor.view(torch.float8_e5m2).reshape(shape)
-        elif dtype_str == "F8_E4M3" and hasattr(torch, "float8_e4m3fn"):
-            return byte_tensor.view(torch.float8_e4m3fn).reshape(shape)
-        else:
-            raise ValueError(f"Unsupported float8 type: {dtype_str}")
-
-
-def _read_tensor_from_file(
-    filepath: str,
-    key: str,
-    metadata: Dict,
-    header_size: int
-) -> Optional[torch.Tensor]:
-    """Helper function to read a single tensor from file (for parallel execution).
-
-    Each worker opens its own file handle for thread safety.
-    """
-    offset_start, offset_end = metadata["data_offsets"]
-    dtype_str = metadata["dtype"]
-    shape = metadata["shape"]
-
-    if offset_start == offset_end:
-        return None
-
-    dtype_map = {
-        "F64": torch.float64, "F32": torch.float32, "F16": torch.float16, "BF16": torch.bfloat16,
-        "I64": torch.int64, "I32": torch.int32, "I16": torch.int16, "I8": torch.int8,
-        "U8": torch.uint8, "BOOL": torch.bool,
-    }
-    if hasattr(torch, "float8_e5m2"):
-        dtype_map["F8_E5M2"] = torch.float8_e5m2
-    if hasattr(torch, "float8_e4m3fn"):
-        dtype_map["F8_E4M3"] = torch.float8_e4m3fn
-
-    dtype = dtype_map.get(dtype_str, torch.float32)
-
-    with open(filepath, "rb") as f:
-        f.seek(header_size + 8 + offset_start)
-        tensor_bytes = f.read(offset_end - offset_start)
-
-    byte_tensor = torch.frombuffer(bytearray(tensor_bytes), dtype=torch.uint8)
-
-    if dtype_str in ["F8_E5M2", "F8_E4M3"]:
-        if dtype_str == "F8_E5M2" and hasattr(torch, "float8_e5m2"):
-            return byte_tensor.view(torch.float8_e5m2).reshape(shape)
-        elif dtype_str == "F8_E4M3" and hasattr(torch, "float8_e4m3fn"):
-            return byte_tensor.view(torch.float8_e4m3fn).reshape(shape)
-
-    return byte_tensor.view(dtype).reshape(shape)
-
+from typing import Dict, List
 
 def get_union_keys(*handlers) -> List[str]:
     """Returns the union of all tensor keys across multiple model handlers."""
@@ -305,4 +20,4 @@ def get_intersection_keys(*handlers) -> List[str]:
     all_keys = set(handlers[0].keys())
     for handler in handlers[1:]:
         all_keys &= set(handler.keys())
-    return sorted(all_keys)
+    return sorted(all_keys)

nodes/model_info_nodes.py

@@ -0,0 +1,184 @@
+import os
+import folder_paths
+from comfy_api.latest import io
+from .downloader_utils import get_potential_preview_files, load_image_tensor, get_model_workflows, get_model_metadata_file
+
+class BaseModelInfoLoader(io.ComfyNode):
+    CATEGORY = "ModelUtils/Info"
+
+    @classmethod
+    def get_info(cls, category, name, workflow_index):
+        full_path = folder_paths.get_full_path(category, name)
+        if not full_path or not os.path.exists(full_path):
+            return (None, "{}", "{}")
+
+        base_path = os.path.splitext(full_path)[0]
+
+        # 1. Image Preview
+        image_tensor = None
+        previews = get_potential_preview_files(base_path)
+        for p in previews:
+            if os.path.exists(p) and not p.lower().endswith('.mp4'):
+                image_tensor = load_image_tensor(p)
+                if image_tensor is not None:
+                    break
+
+        # 2. Workflow
+        workflow_json = "{}"
+        workflows = get_model_workflows(base_path)
+        if workflows and 0 <= workflow_index < len(workflows):
+            try:
+                with open(workflows[workflow_index], 'r', encoding='utf-8') as f:
+                    workflow_json = f.read()
+            except Exception as e:
+                print(f"Error reading workflow {workflows[workflow_index]}: {e}")
+
+        # 3. Metadata
+        metadata_json = "{}"
+        metadata_file = get_model_metadata_file(base_path)
+        if metadata_file:
+            try:
+                with open(metadata_file, 'r', encoding='utf-8') as f:
+                    metadata_json = f.read()
+            except Exception as e:
+                print(f"Error reading metadata {metadata_file}: {e}")
+
+        return (image_tensor, workflow_json, metadata_json)
+
+class CheckpointInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="Checkpoint Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("checkpoint", options=folder_paths.get_filename_list("checkpoints")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, checkpoint, workflow_index):
+        res = cls.get_info("checkpoints", checkpoint, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])
+
+class LoRAInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="LoRA Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("lora", options=folder_paths.get_filename_list("loras")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, lora, workflow_index):
+        res = cls.get_info("loras", lora, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])
+
+class EmbeddingInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="Embedding Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("embedding", options=folder_paths.get_filename_list("embeddings")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, embedding, workflow_index):
+        res = cls.get_info("embeddings", embedding, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])
+
+class VAEInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="VAE Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("vae", options=folder_paths.get_filename_list("vae")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, vae, workflow_index):
+        res = cls.get_info("vae", vae, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])
+
+class ControlNetInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="ControlNet Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("controlnet", options=folder_paths.get_filename_list("controlnet")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, controlnet, workflow_index):
+        res = cls.get_info("controlnet", controlnet, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])
+
+class DiffusionModelInfoLoader(BaseModelInfoLoader):
+    @classmethod
+    def define_schema(cls):
+        return io.Schema(
+            node_id=cls.__name__,
+            display_name="Diffusion Model Info Loader",
+            category=cls.CATEGORY,
+            inputs=[
+                io.Combo.Input("diffusion_model", options=folder_paths.get_filename_list("diffusion_models")),
+                io.Int.Input("workflow_index", default=0, min=0, max=100)
+            ],
+            outputs=[
+                io.Image.Output(display_name="preview"),
+                io.String.Output(display_name="workflow_json"),
+                io.String.Output(display_name="metadata_json")
+            ]
+        )
+
+    @classmethod
+    def execute(cls, diffusion_model, workflow_index):
+        res = cls.get_info("diffusion_models", diffusion_model, workflow_index)
+        return io.NodeOutput(res[0], res[1], res[2])

nodes/prunekeys.py

@@ -4,12 +4,12 @@ import folder_paths
 import comfy.utils
 from tqdm import tqdm
 from comfy_api.latest import io
-from safetensors.torch import save_file
 from safetensors import safe_open
 from .utils import convert_pt_to_safetensors
-from .merger_utils import MemoryEfficientSafeOpen
 from .device_utils import estimate_model_size, prepare_for_large_operation, cleanup_after_operation
 
+from unifiedefficientloader import MemoryEfficientSafeOpen, IncrementalSafetensorsWriter
+
 
 def _prune_keys(model_name: str, model_type: str, keys_to_prune_str: str,
                 use_regex: bool, output_filename: str) -> str:
@@ -39,32 +39,33 @@ def _prune_keys(model_name: str, model_type: str, keys_to_prune_str: str,
     if not patterns:
         raise ValueError("No keys/patterns provided to prune.")
 
-    # Stream tensors and filter on the fly
-    pruned_tensors = {}
-    with MemoryEfficientSafeOpen(model_path_to_load) as handler:
-        all_keys = handler.keys()
-        pbar = comfy.utils.ProgressBar(len(all_keys))
-        for key in tqdm(all_keys, desc="Pruning keys", unit="keys"):
-            is_match = False
-            if use_regex:
-                if any(re.search(pattern, key) for pattern in patterns):
-                    is_match = True
-            else:
-                if any(pattern in key for pattern in patterns):
-                    is_match = True
-
-            if not is_match:
-                pruned_tensors[key] = handler.get_tensor(key)
-            pbar.update(1)
-
     # Use [-1] for diffusion_models to get the actual diffusion_models folder, not legacy unet
     model_dir = folder_paths.get_folder_paths(model_type)[-1]
     output_path = os.path.join(model_dir, f"{output_filename.strip()}.safetensors")
 
-    save_file(pruned_tensors, output_path, metadata)
+    # Stream tensors, filter on the fly, write immediately
+    writer = IncrementalSafetensorsWriter(output_path, metadata=metadata)
+    writer.__enter__()
+    try:
+        with MemoryEfficientSafeOpen(model_path_to_load) as handler:
+            all_keys = handler.keys()
+            pbar = comfy.utils.ProgressBar(len(all_keys))
+            for key in tqdm(all_keys, desc="Pruning keys", unit="keys"):
+                is_match = False
+                if use_regex:
+                    if any(re.search(pattern, key) for pattern in patterns):
+                        is_match = True
+                else:
+                    if any(pattern in key for pattern in patterns):
+                        is_match = True
+
+                if not is_match:
+                    writer.write(key, handler.get_tensor(key).contiguous())
+                pbar.update(1)
+    finally:
+        writer.__exit__(None, None, None)
 
     # Cleanup after operation
-    del pruned_tensors
     cleanup_after_operation()
 
     return output_path

nodes/renamekeys.py

@@ -3,12 +3,13 @@ import folder_paths
 import comfy.utils
 from tqdm import tqdm
 from comfy_api.latest import io
-from safetensors.torch import save_file
 from safetensors import safe_open
 from .utils import convert_pt_to_safetensors
-from .merger_utils import MemoryEfficientSafeOpen
 from .device_utils import estimate_model_size, prepare_for_large_operation, cleanup_after_operation
 
+from unifiedefficientloader import MemoryEfficientSafeOpen, IncrementalSafetensorsWriter
+
+
 
 def _rename_keys(model_name: str, model_type: str, old_keys_str: str,
                  new_keys_str: str, output_filename: str) -> str:
@@ -41,24 +42,25 @@ def _rename_keys(model_name: str, model_type: str, old_keys_str: str,
 
     key_map = dict(zip(old_keys, new_keys))
 
-    # Stream tensors and rename on the fly
-    renamed_tensors = {}
-    with MemoryEfficientSafeOpen(model_path_to_load) as handler:
-        original_keys = handler.keys()
-        pbar = comfy.utils.ProgressBar(len(original_keys))
-        for key in tqdm(original_keys, desc="Renaming keys", unit="keys"):
-            new_key = key_map.get(key, key)
-            renamed_tensors[new_key] = handler.get_tensor(key)
-            pbar.update(1)
-
     # Use [-1] for diffusion_models to get the actual diffusion_models folder, not legacy unet
     model_dir = folder_paths.get_folder_paths(model_type)[-1]
     output_path = os.path.join(model_dir, f"{output_filename.strip()}.safetensors")
 
-    save_file(renamed_tensors, output_path, metadata)
+    # Stream tensors, rename on the fly, write immediately
+    writer = IncrementalSafetensorsWriter(output_path, metadata=metadata)
+    writer.__enter__()
+    try:
+        with MemoryEfficientSafeOpen(model_path_to_load) as handler:
+            original_keys = handler.keys()
+            pbar = comfy.utils.ProgressBar(len(original_keys))
+            for key in tqdm(original_keys, desc="Renaming keys", unit="keys"):
+                new_key = key_map.get(key, key)
+                writer.write(new_key, handler.get_tensor(key).contiguous())
+                pbar.update(1)
+    finally:
+        writer.__exit__(None, None, None)
 
     # Cleanup after operation
-    del renamed_tensors
     cleanup_after_operation()
 
     return output_path

pyproject.toml

@@ -1,9 +1,24 @@
 [project]
 name = "ComfyUI-ModelUtils"
 description = "[WIP]Custom nodes for handling, inspecting, modifying and creating various model files."
-version = "0.2.9"
+version = "0.4.1"
 license = { file = "LICENSE" }
 
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "unifiedefficientloader==0.4.4"
+]
+
 [project.urls]
 Repository = "https://github.com/silveroxides/ComfyUI-ModelUtils"
 #  Used by Comfy Registry https://comfyregistry.org

requirements.txt

@@ -1,5 +1,5 @@
 requests
 Pillow
 mutagen
-unifiedefficientloader
+unifiedefficientloader>=0.5.1
 av