refactor(ui): group example image download actions into a submenu

Move the 'Download Missing' / 'Re-process All' example image actions
under a single 'Download Example Images' submenu item in the single-model
and bulk context menus, matching the existing send-to-workflow submenu
pattern. Shorten the submenu labels and update all locale translations.

locales/en.json

@@ -714,7 +714,9 @@
         "versionsCount": "Local Versions",
         "versionsCountDesc": "Most versions first",
         "versionsCountAsc": "Fewest versions first",
-        "versionIdDesc": "Newest version first"
+        "versionIdDesc": "Newest version first",
+        "random": "Random",
+        "randomAction": "Randomize (shuffle)"
       },
       "refresh": {
         "title": "Refresh model list",
@@ -771,6 +773,8 @@
       "deleteAll": "Delete Selected",
       "downloadMissingLoras": "Download Missing LoRAs",
       "downloadExamples": "Download Example Images",
+      "downloadMissingExamples": "Download Missing",
+      "reprocessExamples": "Re-process All",
       "clear": "Clear Selection",
       "skipMetadataRefreshCount": "Skip ({count} models)",
       "resumeMetadataRefreshCount": "Resume ({count} models)",
@@ -806,6 +810,8 @@
       "sendToWorkflowReplace": "Send to Workflow (Replace)",
       "openExamples": "Open Examples Folder",
       "downloadExamples": "Download Example Images",
+      "downloadMissingExamples": "Download Missing",
+      "reprocessExamples": "Re-process All",
       "replacePreview": "Replace Preview",
       "setContentRating": "Set Content Rating",
       "moveToFolder": "Move to Folder",

py/metadata_collector/node_extractors.py

@@ -2,7 +2,8 @@ import json
 import os
 import re
 
-from .constants import CLIP_SKIP_SENTINEL, MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES, IS_SAMPLER, OVERWRITE, METADATA_OVERWRITE_FIELDS
+from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES, IS_SAMPLER, OVERWRITE
+from .overwrite_utils import collect_overwrite_params
 
 
 def _store_checkpoint_metadata(metadata, node_id, model_name):
@@ -1233,14 +1234,7 @@ class MetadataOverwriteExtractor(NodeMetadataExtractor):
         if not inputs:
             return
 
-        overwrite_params = {}
-        for key in METADATA_OVERWRITE_FIELDS:
-            value = inputs.get(key)
-            if key == "clip_skip":
-                if value != CLIP_SKIP_SENTINEL:
-                    overwrite_params[key] = value
-            elif value:  # truthy — only overwrite when user provided a real value
-                overwrite_params[key] = value
+        overwrite_params = collect_overwrite_params(inputs)
 
         if overwrite_params:
             metadata.setdefault(OVERWRITE, {})

py/metadata_collector/overwrite_utils.py

@@ -0,0 +1,42 @@
+"""Shared helpers for Metadata Overwrite node metadata collection.
+
+Used by both the MetadataOverwriteLM node (execution time) and the
+MetadataOverwriteExtractor (hook time) so the conversion/filtering logic
+cannot drift between the two paths.
+"""
+
+import logging
+from typing import Any, Dict
+
+from ..utils.utils import model_patcher_to_name
+from .constants import CLIP_SKIP_SENTINEL, METADATA_OVERWRITE_FIELDS
+
+logger = logging.getLogger(__name__)
+
+
+def collect_overwrite_params(values: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert node input values into non-default overwrite parameters.
+
+    For most fields, a falsy value (empty string, 0) means "not set" and is
+    skipped.  clip_skip uses a dedicated sentinel (-25) so that a wired value
+    of 0 is preserved.  The ``model`` field accepts either a manual string or
+    a wired MODEL (ModelPatcher) connection; in the latter case the source
+    model name is extracted from the patcher's ``cached_patcher_init`` and
+    stored as a ComfyUI-style relative path.
+    """
+    result: Dict[str, Any] = {}
+    for key in METADATA_OVERWRITE_FIELDS:
+        value = values.get(key)
+        if key == "model" and not isinstance(value, str):
+            value = model_patcher_to_name(value)
+            if value is None:
+                logger.warning(
+                    "Could not extract model name from wired MODEL input "
+                    "(no cached_patcher_init); model metadata overwrite skipped"
+                )
+        if key == "clip_skip":
+            if value != CLIP_SKIP_SENTINEL:
+                result[key] = value
+        elif value:
+            result[key] = value
+    return result

py/nodes/lora_stack_combiner.py

@@ -1,26 +1,102 @@
+from __future__ import annotations
+
+import inspect
+import re
+from typing import Any
+
+_STACK_INPUT_PATTERN = re.compile(r"^lora_stack(?:_([ab])|(\d+))$")
+
+
+def _is_stack_input(name: str) -> bool:
+    return bool(_STACK_INPUT_PATTERN.match(name))
+
+
+def _stack_slot_number(name: str) -> int:
+    """Numeric slot used to order stack inputs; legacy a/b map to 1/2."""
+    match = _STACK_INPUT_PATTERN.match(name)
+    if not match:
+        return -1
+    letter, digits = match.group(1), match.group(2)
+    if digits is not None:
+        return int(digits)
+    return 1 if letter == "a" else 2
+
+
+class _LoraStackOptionalInputs:
+    """Lookup that preserves explicit optional inputs and dynamic lora_stack slots."""
+
+    def __init__(self, explicit_inputs: dict[str, tuple[str, dict[str, Any]]]) -> None:
+        self._explicit_inputs = explicit_inputs
+
+    def __contains__(self, item: object) -> bool:
+        if not isinstance(item, str):
+            return False
+        return item in self._explicit_inputs or _is_stack_input(item)
+
+    def __getitem__(self, key: str) -> tuple[str, dict[str, Any]]:
+        if key in self._explicit_inputs:
+            return self._explicit_inputs[key]
+        if _is_stack_input(key):
+            return (
+                "LORA_STACK",
+                {
+                    "tooltip": "A LoRA stack to combine. Connect to add more inputs.",
+                },
+            )
+        raise KeyError(key)
+
+
 class LoraStackCombinerLM:
     NAME = "Lora Stack Combiner (LoraManager)"
     CATEGORY = "Lora Manager/stackers"
+    DESCRIPTION = (
+        "Combines multiple LoRA stacks into a single stack. "
+        "Supports dynamic inputs: connect a stack to add more inputs."
+    )
 
     @classmethod
     def INPUT_TYPES(cls):
+        optional_inputs: dict[str, tuple[str, dict[str, Any]]] = {
+            "lora_stack1": (
+                "LORA_STACK",
+                {
+                    "tooltip": "A LoRA stack to combine. Connect to add more inputs.",
+                },
+            ),
+            "lora_stack2": (
+                "LORA_STACK",
+                {
+                    "tooltip": "A LoRA stack to combine. Connect to add more inputs.",
+                },
+            ),
+        }
+
+        stack = inspect.stack()
+        if len(stack) > 2 and stack[2].function == "get_input_info":
+            optional_inputs = _LoraStackOptionalInputs(optional_inputs)  # type: ignore[assignment]
+
         return {
-            "required": {
-                "lora_stack_a": ("LORA_STACK",),
-                "lora_stack_b": ("LORA_STACK",),
-            },
+            "required": {},
+            "optional": optional_inputs,
         }
 
     RETURN_TYPES = ("LORA_STACK",)
     RETURN_NAMES = ("LORA_STACK",)
     FUNCTION = "combine_stacks"
 
-    def combine_stacks(self, lora_stack_a, lora_stack_b):
-        combined_stack = []
+    def combine_stacks(self, lora_stack1=None, lora_stack2=None, **kwargs):
+        stacks = {
+            "lora_stack1": lora_stack1,
+            "lora_stack2": lora_stack2,
+        }
+        for key, value in kwargs.items():
+            if _is_stack_input(key) and value is not None:
+                stacks[key] = value
 
-        if lora_stack_a:
-            combined_stack.extend(lora_stack_a)
-        if lora_stack_b:
-            combined_stack.extend(lora_stack_b)
+        combined_stack = []
+        for key in sorted(stacks, key=_stack_slot_number):
+            stack = stacks[key]
+            if stack:
+                combined_stack.extend(stack)
 
         return (combined_stack,)

py/nodes/metadata_overwrite.py

@@ -9,10 +9,8 @@ but users may wire 0 to express "no clip skip / default".
 
 from typing import Any
 
-from ..metadata_collector.constants import (
-    CLIP_SKIP_SENTINEL as _CLIP_SKIP_SENTINEL,
-    METADATA_OVERWRITE_FIELDS,
-)
+from ..metadata_collector.constants import CLIP_SKIP_SENTINEL as _CLIP_SKIP_SENTINEL
+from ..metadata_collector.overwrite_utils import collect_overwrite_params
 
 
 class MetadataOverwriteLM:
@@ -87,12 +85,16 @@ class MetadataOverwriteLM:
                     },
                 ),
                 "model": (
-                    "STRING",
+                    "STRING,MODEL",
                     {
                         "default": "",
+                        "widgetType": "STRING",
                         "tooltip": (
                             "The checkpoint or diffusion model (UNet) used "
-                            "for generation. Only overwrites when non-empty."
+                            "for generation. Fill in the name manually or "
+                            "connect a MODEL output — the model name is then "
+                            "extracted automatically. Only overwrites when "
+                            "non-empty."
                         ),
                     },
                 ),
@@ -158,13 +160,10 @@ class MetadataOverwriteLM:
         For most fields, a falsy value (empty string, 0) means "not set"
         and is skipped.  clip_skip uses a dedicated sentinel (-25) so that
         a wired value of 0 is preserved and reaches the metadata pipeline.
+
+        The ``model`` field accepts either a manual string or a wired MODEL
+        (ModelPatcher) connection; in the latter case the underlying model
+        name is extracted from the patcher's ``cached_patcher_init`` and
+        stored as a ComfyUI-style relative path.
         """
-        result: dict[str, Any] = {}
-        for key in METADATA_OVERWRITE_FIELDS:
-            value = kwargs.get(key)
-            if key == "clip_skip":
-                if value != _CLIP_SKIP_SENTINEL:
-                    result[key] = value
-            elif value:
-                result[key] = value
-        return (result,)
+        return (collect_overwrite_params(kwargs),)

py/nodes/unet_loader.py

@@ -7,6 +7,21 @@ from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_c
 logger = logging.getLogger(__name__)
 
 
+def _reload_gguf_unet(
+    unet_path: str, weight_dtype: str, disable_dynamic: bool = False
+) -> object:
+    """Reload a GGUF diffusion model from disk (cached_patcher_init factory).
+
+    Mirrors the GGUF branch of UNETLoaderLM.load_unet so ModelPatcher
+    deepclone/dynamic machinery can rebuild GGUF models with the correct
+    GGMLOps. ``disable_dynamic`` is accepted for signature compatibility
+    with core ComfyUI loaders.
+    """
+    loader = UNETLoaderLM()
+    model, = loader._load_gguf_unet(unet_path, unet_path, weight_dtype)
+    return model
+
+
 class UNETLoaderLM:
     """UNET Loader with support for extra folder paths
 
@@ -196,6 +211,12 @@ class UNETLoaderLM:
             # Wrap with GGUFModelPatcher
             model = GGUFModelPatcher.clone(model)
 
+            # Register a reload factory so the MODEL carries its source path
+            # (cached_patcher_init) like core ComfyUI loaders do — required
+            # for model-name extraction downstream and for ModelPatcher
+            # deepclone/dynamic machinery.
+            model.cached_patcher_init = (_reload_gguf_unet, (unet_path, weight_dtype))
+
             return (model,)
 
         except Exception as e:

py/routes/handlers/misc_handlers.py

@@ -2590,6 +2590,8 @@ class ModelLibraryHandler:
                     status=400,
                 )
 
+            cursor = request.query.get("cursor")
+
             metadata_provider = await self._metadata_provider_factory()
             if not metadata_provider:
                 return web.json_response(
@@ -2598,7 +2600,7 @@ class ModelLibraryHandler:
                 )
 
             try:
-                models = await metadata_provider.get_user_models(username)
+                result = await metadata_provider.get_user_models(username, cursor)
             except NotImplementedError:
                 return web.json_response(
                     {
@@ -2608,14 +2610,35 @@ class ModelLibraryHandler:
                     status=501,
                 )
 
-            if models is None:
+            if result is None:
                 return web.json_response(
                     {"success": False, "error": "Failed to fetch user models"},
                     status=502,
                 )
 
+            if isinstance(result, dict):
+                models = result.get("items")
+                next_cursor = result.get("nextCursor")
+            else:
+                # Defensive: tolerate providers that still return a raw list
+                models = result
+                next_cursor = None
+
             if not isinstance(models, list):
                 models = []
+            if next_cursor is not None and not isinstance(next_cursor, str):
+                next_cursor = str(next_cursor)
+
+            estimated_total = None
+            if cursor is None:
+                get_count = getattr(metadata_provider, "get_creator_model_count", None)
+                if get_count is not None:
+                    try:
+                        estimated_total = await get_count(username)
+                    except Exception:  # best-effort only
+                        estimated_total = None
+                if not isinstance(estimated_total, int):
+                    estimated_total = None
 
             lora_scanner = await self._service_registry.get_lora_scanner()
             checkpoint_scanner = await self._service_registry.get_checkpoint_scanner()
@@ -2635,6 +2658,7 @@ class ModelLibraryHandler:
             versions: list[dict] = []
             history_service = await self._get_download_history_service()
             model_ids: list[int] = []
+            model_count = 0
             for model in models:
                 try:
                     model_ids.append(int(model.get("id")))
@@ -2668,6 +2692,8 @@ class ModelLibraryHandler:
                 if model_type not in normalized_allowed_types:
                     continue
 
+                model_count += 1
+
                 scanner = type_scanner_map.get(model_type)
                 if scanner is None:
                     return web.json_response(
@@ -2733,7 +2759,15 @@ class ModelLibraryHandler:
                     )
 
             return web.json_response(
-                {"success": True, "username": username, "versions": versions}
+                {
+                    "success": True,
+                    "username": username,
+                    "versions": versions,
+                    "modelCount": model_count,
+                    "nextCursor": next_cursor,
+                    "hasMore": next_cursor is not None,
+                    "estimatedTotal": estimated_total,
+                }
             )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to get Civitai user models: %s", exc, exc_info=True)

py/services/base_model_service.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 import asyncio
 import re
+import random
 from typing import Any, Dict, List, Optional, Type, Union, TYPE_CHECKING
 import logging
 import os
@@ -390,6 +391,12 @@ class BaseModelService(ABC):
                 (item.get("model_name") or item.get("file_name") or "").lower(),
                 item.get("file_path", "").lower(),
             )
+        elif key_name == "random":
+            # Seeded random shuffle: same seed -> same order (stable pagination)
+            rng = random.Random(sort_params.seed or "random")
+            result = list(data)
+            rng.shuffle(result)
+            return result
         elif key_name == "size":
             key_fn = lambda item: (
                 int(item.get("size", 0) or 0),

py/services/civitai_client.py

@@ -2,6 +2,7 @@ import asyncio
 import copy
 import logging
 import os
+import time
 from collections import OrderedDict
 from typing import Any, Optional, Dict, Tuple, List, Sequence
 from .connectivity_guard import (
@@ -19,6 +20,12 @@ from ..utils.civitai_utils import resolve_license_payload
 
 logger = logging.getLogger(__name__)
 
+# Best-effort cache for creator model counts, keyed by lowercase username.
+# Values are (monotonic timestamp, count or None); None results are cached
+# too so repeated failures don't hammer the API.
+_CREATOR_COUNT_CACHE_TTL_SECONDS = 600
+_creator_model_count_cache: Dict[str, Tuple[float, Optional[int]]] = {}
+
 
 class CivitaiClient:
     _instance = None
@@ -743,17 +750,34 @@ class CivitaiClient:
 
         return all_versions if all_versions else None
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
-        """Fetch all models for a specific Civitai user."""
+    async def get_user_models(
+        self, username: str, cursor: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Fetch one page (up to 100 models) for a specific Civitai user.
+
+        Returns ``{"items": [...], "nextCursor": <str|None>}`` on success,
+        or None on failure. Pass ``cursor`` (from a previous response's
+        ``nextCursor``) to fetch subsequent pages.
+        """
         if not username:
             return None
 
+        params: Dict[str, Any] = {
+            "username": username,
+            "nsfw": "true",
+            "limit": 100,
+            "sort": "Newest",
+            "period": "AllTime",
+        }
+        if cursor:
+            params["cursor"] = cursor
+
         try:
             success, result = await self._make_request(
                 "GET",
                 f"{self.base_url}/models",
                 use_auth=True,
-                params={"username": username, "nsfw": "true"},
+                params=params,
             )
 
             if not success:
@@ -765,7 +789,7 @@ class CivitaiClient:
 
             items = result.get("items") if isinstance(result, dict) else None
             if not isinstance(items, list):
-                return []
+                items = []
 
             for model in items:
                 versions = model.get("modelVersions")
@@ -774,9 +798,68 @@ class CivitaiClient:
                 for version in versions:
                     self._remove_comfy_metadata(version)
 
-            return items
+            next_cursor: Optional[str] = None
+            metadata = result.get("metadata") if isinstance(result, dict) else None
+            if isinstance(metadata, dict):
+                raw_cursor = metadata.get("nextCursor")
+                if raw_cursor is not None:
+                    next_cursor = str(raw_cursor)
+
+            return {"items": items, "nextCursor": next_cursor}
         except RateLimitError:
             raise
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Error fetching models for %s: %s", username, exc)
             return None
+
+    async def get_creator_model_count(self, username: str) -> Optional[int]:
+        """Best-effort lookup of a creator's published model count.
+
+        Uses the ``/creators`` endpoint (a contains-match query), picking the
+        entry whose username matches exactly (case-insensitive). Returns None
+        on any failure; never raises. Results (including None) are cached
+        for ``_CREATOR_COUNT_CACHE_TTL_SECONDS``.
+        """
+        if not username:
+            return None
+
+        cache_key = username.lower()
+        cached = _creator_model_count_cache.get(cache_key)
+        if cached is not None:
+            cached_at, cached_count = cached
+            if time.monotonic() - cached_at < _CREATOR_COUNT_CACHE_TTL_SECONDS:
+                return cached_count
+
+        count: Optional[int] = None
+        try:
+            success, result = await self._make_request(
+                "GET",
+                f"{self.base_url}/creators",
+                use_auth=True,
+                params={"query": username, "limit": 10},
+            )
+
+            if success and isinstance(result, dict):
+                creators = result.get("items")
+                if isinstance(creators, list):
+                    for creator in creators:
+                        if not isinstance(creator, dict):
+                            continue
+                        creator_name = creator.get("username")
+                        if not isinstance(creator_name, str):
+                            continue
+                        if creator_name.lower() != cache_key:
+                            continue
+                        model_count = creator.get("modelCount")
+                        if isinstance(model_count, (int, float)) and not isinstance(
+                            model_count, bool
+                        ):
+                            count = int(model_count)
+                        break
+        except Exception as exc:  # best-effort only, never propagate
+            logger.debug(
+                "Failed to fetch creator model count for %s: %s", username, exc
+            )
+
+        _creator_model_count_cache[cache_key] = (time.monotonic(), count)
+        return count

py/services/model_cache.py

@@ -1,6 +1,7 @@
 import asyncio
 import time
 import logging
+import random
 
 logger = logging.getLogger(__name__)
 from typing import Any, Dict, List, Optional, Tuple
@@ -38,8 +39,8 @@ class ModelCache:
 
     def __post_init__(self):
         self._lock = asyncio.Lock()
-        # Cache for last sort: (sort_key, order) -> sorted list
-        self._last_sort: Tuple[str, str] = (None, None)
+        # Cache for last sort: (sort_key, order, seed) -> sorted list
+        self._last_sort: Tuple[Optional[str], str, Optional[str]] = (None, "asc", None)
         self._last_sorted_data: List[Dict] = []
         self._normalize_raw_data()
         self.name_display_mode = self._normalize_display_mode(self.name_display_mode)
@@ -203,9 +204,9 @@ class ModelCache:
     async def resort(self):
         """Resort cached data according to last sort mode if set"""
         async with self._lock:
-            if self._last_sort != (None, None):
-                sort_key, order = self._last_sort
-                sorted_data = self._sort_data(self.raw_data, sort_key, order)
+            if self._last_sort[0] is not None:
+                sort_key, order, seed = self._last_sort
+                sorted_data = self._sort_data(self.raw_data, sort_key, order, seed)
                 self._last_sorted_data = sorted_data
                 # Update folder list
             # else: do nothing
@@ -218,7 +219,7 @@ class ModelCache:
             self.folders = sorted(list(all_folders), key=lambda x: x.lower())
             self.rebuild_version_index()
 
-    def _sort_data(self, data: List[Dict], sort_key: str, order: str) -> List[Dict]:
+    def _sort_data(self, data: List[Dict], sort_key: str, order: str, seed: Optional[str] = None) -> List[Dict]:
         """Sort data by sort_key and order"""
         start_time = time.perf_counter()
         reverse = (order == 'desc')
@@ -265,6 +266,13 @@ class ModelCache:
                 ),
                 reverse=reverse
             )
+        elif sort_key == 'random':
+            # Random shuffle seeded for stable pagination: the same seed
+            # always yields the same order, so successive page requests
+            # stay consistent while browsing.
+            rng = random.Random(seed or 'random')
+            result = list(data)
+            rng.shuffle(result)
         elif sort_key == 'versions_count':
             # Pre-dedup sort: fall back to name sort.
             # Actual re-sort by version_count happens in get_paginated_data after dedup.
@@ -285,15 +293,16 @@ class ModelCache:
             logger.debug("ModelCache._sort_data(%s, %s) for %d items took %.3fs", sort_key, order, len(data), duration)
         return result
 
-    async def get_sorted_data(self, sort_key: str = 'name', order: str = 'asc') -> List[Dict]:
+    async def get_sorted_data(self, sort_key: str = 'name', order: str = 'asc', seed: Optional[str] = None) -> List[Dict]:
         """Get sorted data by sort_key and order, using cache if possible"""
         async with self._lock:
-            if (sort_key, order) == self._last_sort:
+            cache_key = (sort_key, order, seed)
+            if cache_key == self._last_sort:
                 return self._last_sorted_data
             
             start_time = time.perf_counter()
-            sorted_data = self._sort_data(self.raw_data, sort_key, order)
-            self._last_sort = (sort_key, order)
+            sorted_data = self._sort_data(self.raw_data, sort_key, order, seed)
+            self._last_sort = cache_key
             self._last_sorted_data = sorted_data
             
             duration = time.perf_counter() - start_time
@@ -313,8 +322,8 @@ class ModelCache:
             self.name_display_mode = normalized
 
             if self._last_sort[0] == 'name':
-                sort_key, order = self._last_sort
-                self._last_sorted_data = self._sort_data(self.raw_data, sort_key, order)
+                sort_key, order, seed = self._last_sort
+                self._last_sorted_data = self._sort_data(self.raw_data, sort_key, order, seed)
 
     async def update_preview_url(self, file_path: str, preview_url: str, preview_nsfw_level: int) -> bool:
         """Update preview_url for a specific model in all cached data

py/services/model_metadata_provider.py

@@ -143,10 +143,18 @@ class ModelMetadataProvider(ABC):
         pass
 
     @abstractmethod
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
-        """Fetch models owned by the specified user"""
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
+        """Fetch one page of models owned by the specified user.
+
+        Returns ``{"items": [...], "nextCursor": <str|None>}`` on success,
+        or None when unsupported/failed. ``cursor`` continues a previous page.
+        """
         pass
 
+    async def get_creator_model_count(self, username: str) -> Optional[int]:
+        """Published model count for the user; None when unsupported."""
+        return None
+
 class CivitaiModelMetadataProvider(ModelMetadataProvider):
     """Provider that uses Civitai API for metadata"""
     
@@ -175,8 +183,11 @@ class CivitaiModelMetadataProvider(ModelMetadataProvider):
     async def get_model_version_info(self, version_id: str) -> Tuple[Optional[Dict], Optional[str]]:
         return await self.client.get_model_version_info(version_id)
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
-        return await self.client.get_user_models(username)
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
+        return await self.client.get_user_models(username, cursor)
+
+    async def get_creator_model_count(self, username: str) -> Optional[int]:
+        return await self.client.get_creator_model_count(username)
 
 class CivArchiveModelMetadataProvider(ModelMetadataProvider):
     """Provider that uses CivArchive API for metadata"""
@@ -196,7 +207,7 @@ class CivArchiveModelMetadataProvider(ModelMetadataProvider):
     async def get_model_version_info(self, version_id: str) -> Tuple[Optional[Dict], Optional[str]]:
         return await self.client.get_model_version_info(version_id)
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
         """Not supported by CivArchive provider"""
         return None
 
@@ -347,7 +358,7 @@ class SQLiteModelMetadataProvider(ModelMetadataProvider):
             version_data = await self._get_version_with_model_data(db, model_id, version_id)
             return version_data, None
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
         """Listing models by username is not supported for archive database"""
         return None
     
@@ -602,13 +613,14 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 continue
         return None
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
         for provider, label in self._iter_providers():
             try:
                 result = await self._call_with_rate_limit(
                     label,
                     provider.get_user_models,
                     username,
+                    cursor=cursor,
                 )
                 if result is not None:
                     return result
@@ -624,6 +636,19 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 continue
         return None
 
+    async def get_creator_model_count(self, username: str) -> Optional[int]:
+        for provider, label in self._iter_providers():
+            try:
+                result = await provider.get_creator_model_count(username)
+                if result is not None:
+                    return result
+            except Exception as e:
+                logger.debug(
+                    "Provider %s failed for get_creator_model_count: %s", label, e
+                )
+                continue
+        return None
+
     def _iter_providers(self):
         return zip(self.providers, self._provider_labels)
 
@@ -704,13 +729,17 @@ class RateLimitRetryingProvider(ModelMetadataProvider):
             version_id,
         )
 
-    async def get_user_models(self, username: str) -> Optional[List[Dict]]:
+    async def get_user_models(self, username: str, cursor: Optional[str] = None) -> Optional[Dict]:
         return await self._rate_limit_helper.run(
             self._label,
             self._provider.get_user_models,
             username,
+            cursor=cursor,
         )
 
+    async def get_creator_model_count(self, username: str) -> Optional[int]:
+        return await self._provider.get_creator_model_count(username)
+
 class ModelMetadataProviderManager:
     """Manager for selecting and using model metadata providers"""
     
@@ -776,10 +805,20 @@ class ModelMetadataProviderManager:
         except NotImplementedError:
             return None
 
-    async def get_user_models(self, username: str, provider_name: str = None) -> Optional[List[Dict]]:
-        """Fetch models owned by the specified user"""
+    async def get_user_models(
+        self,
+        username: str,
+        provider_name: str = None,
+        cursor: Optional[str] = None,
+    ) -> Optional[Dict]:
+        """Fetch one page of models owned by the specified user"""
         provider = self._get_provider(provider_name)
-        return await provider.get_user_models(username)
+        return await provider.get_user_models(username, cursor)
+
+    async def get_creator_model_count(self, username: str, provider_name: str = None) -> Optional[int]:
+        """Best-effort published model count for the specified user"""
+        provider = self._get_provider(provider_name)
+        return await provider.get_creator_model_count(username)
         
     def _get_provider(self, provider_name: str = None) -> ModelMetadataProvider:
         """Get provider by name or default provider"""

py/services/model_query.py

@@ -85,6 +85,7 @@ class SortParams:
 
     key: str
     order: str
+    seed: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -116,7 +117,7 @@ class ModelCacheRepository:
     async def fetch_sorted(self, params: SortParams) -> List[Dict[str, Any]]:
         """Fetch cached data pre-sorted according to ``params``."""
         cache = await self.get_cache()
-        return await cache.get_sorted_data(params.key, params.order)
+        return await cache.get_sorted_data(params.key, params.order, params.seed)
 
     @staticmethod
     def parse_sort(sort_by: str) -> SortParams:
@@ -132,10 +133,17 @@ class ModelCacheRepository:
             sort_key = sort_by.strip().lower() or "name"
             order = "asc"
 
-        if order not in ("asc", "desc"):
+        seed = None
+        if sort_key == "random":
+            # Random sort: the portion after ':' is the shuffle seed.
+            # A stable seed keeps paginated requests consistent; order is
+            # meaningless for a random shuffle.
+            seed = order if order and order not in ("asc", "desc") else None
+            order = "asc"
+        elif order not in ("asc", "desc"):
             order = "asc"
 
-        return SortParams(key=sort_key, order=order)
+        return SortParams(key=sort_key, order=order, seed=seed)
 
 
 class ModelFilterSet:

py/services/model_scanner.py

@@ -1752,7 +1752,7 @@ class ModelScanner:
         # ---- Conditional resort (only when sort-key fields changed) ----
         need_resort = False
         _last = cache._last_sort
-        sort_key: Optional[str] = _last[0] if _last != (None, None) else None
+        sort_key: Optional[str] = _last[0] if _last[0] is not None else None
         if sort_key == "name":
             if (
                 old_model_name != desired_entry.get("model_name", "")

py/utils/example_images_download_manager.py

@@ -14,11 +14,16 @@ from ..services.service_registry import ServiceRegistry
 from ..utils.example_images_paths import (
     ExampleImagePathResolver,
     ensure_library_root_exists,
+    get_example_images_root,
+    is_hash_folder,
     uses_library_scoped_folders,
 )
 from ..utils.metadata_manager import MetadataManager
 from .example_images_processor import ExampleImagesProcessor
-from .example_images_metadata import MetadataUpdater
+from .example_images_metadata import (
+    MetadataUpdater,
+    update_cache_from_metadata,
+)
 from ..services.downloader import get_downloader
 from ..services.settings_manager import get_settings_manager
 
@@ -87,6 +92,13 @@ class _DownloadProgress(dict):
         return snapshot
 
 
+# When fewer candidates than this remain in check_pending_models, probe each
+# model folder directly (preserving legacy-folder migration semantics). Above
+# it, build a folder index with a single directory scan so libraries with
+# 100k+ models do not pay one syscall per candidate.
+_BULK_LOOKUP_THRESHOLD = 1000
+
+
 def _model_directory_has_files(path: str) -> bool:
     """Return True when the provided directory exists and contains entries."""
 
@@ -103,6 +115,36 @@ def _model_directory_has_files(path: str) -> bool:
     return False
 
 
+def _build_example_folder_index(output_dir: str) -> dict[str, bool]:
+    """Build a ``{hash: has_files}`` index for a library's example-image folders.
+
+    A single directory scan over the library root replaces ``O(candidates)``
+    per-folder ``os.scandir`` calls, which is required for libraries with
+    100k+ models. Each hash folder is classified by whether it contains any
+    entries, matching the semantics of ``_model_directory_has_files``.
+    """
+
+    index: dict[str, bool] = {}
+    if not output_dir or not os.path.isdir(output_dir):
+        return index
+
+    try:
+        with os.scandir(output_dir) as entries:
+            for entry in entries:
+                name = entry.name
+                if not entry.is_dir() or not is_hash_folder(name):
+                    continue
+                try:
+                    with os.scandir(entry.path) as subentries:
+                        index[name.lower()] = any(subentries)
+                except OSError:
+                    index[name.lower()] = False
+    except OSError:
+        pass
+
+    return index
+
+
 class DownloadManager:
     """Manages downloading example images for models."""
 
@@ -130,6 +172,7 @@ class DownloadManager:
         model_types = data.get("model_types", ["lora", "checkpoint"])
         delay = float(data.get("delay", 0.2))
         force = data.get("force", False)
+        model_hashes = data.get("model_hashes", [])
 
         # Step 2: Validate configuration (fast lookup)
         settings_manager = get_settings_manager()
@@ -199,6 +242,7 @@ class DownloadManager:
                         delay,
                         active_library,
                         force,
+                        model_hashes,
                     )
                 )
 
@@ -410,14 +454,49 @@ class DownloadManager:
             # Calculate pending count: check which models actually need processing.
             # A model is pending if it has a hash, is not already processed or known-failed,
             # and its folder doesn't exist or is empty.
-            pending_hashes = set()
-            for model_hash, model_name in all_models_with_hash:
-                if model_hash not in processed_models and model_hash not in failed_models:
+            candidate_hashes = [
+                model_hash
+                for model_hash, _ in all_models_with_hash
+                if model_hash not in processed_models
+                and model_hash not in failed_models
+            ]
+
+            pending_hashes: set[str] = set()
+            # For small candidate counts the existing per-folder check is fine
+            # and handles legacy folder migration.
+            # For large libraries, scan the library root once and do set lookups.
+            if len(candidate_hashes) <= _BULK_LOOKUP_THRESHOLD or not output_dir:
+                for model_hash in candidate_hashes:
                     model_dir = ExampleImagePathResolver.get_model_folder(
                         model_hash, active_library
                     )
                     if not _model_directory_has_files(model_dir):
                         pending_hashes.add(model_hash)
+            else:
+                folder_index = await asyncio.get_event_loop().run_in_executor(
+                    None, _build_example_folder_index, output_dir
+                )
+                # In multi-library mode, folders that have not been consolidated
+                # into the library root yet (startup migration skipped, failed
+                # move, or created at the legacy path afterwards) still live at
+                # the legacy root/<hash> location. Only scan that root when at
+                # least one candidate is missing from the library-root index, so
+                # the fully-consolidated case does not pay an extra directory
+                # pass on every call.
+                if uses_library_scoped_folders() and any(
+                    not folder_index.get(model_hash, False)
+                    for model_hash in candidate_hashes
+                ):
+                    legacy_root = get_example_images_root()
+                    if legacy_root and legacy_root != output_dir:
+                        legacy_index = await asyncio.get_event_loop().run_in_executor(
+                            None, _build_example_folder_index, legacy_root
+                        )
+                        for hash_key, has_files in legacy_index.items():
+                            folder_index.setdefault(hash_key, has_files)
+                for model_hash in candidate_hashes:
+                    if not folder_index.get(model_hash, False):
+                        pending_hashes.add(model_hash)
 
             pending_count = len(pending_hashes)
 
@@ -500,8 +579,9 @@ class DownloadManager:
         delay,
         library_name,
         force: bool = False,
+        model_hashes: list[str] | None = None,
     ):
-        """Download example images for all models."""
+        """Download example images for all models (or only the given hashes)."""
 
         downloader = await get_downloader()
 
@@ -529,6 +609,18 @@ class DownloadManager:
                         if model.get("sha256"):
                             all_models.append((scanner_type, model, scanner))
 
+            # Restrict to the requested hashes when provided (empty = all models).
+            # Explicit targets are a directed user request, so previously failed
+            # models are retried instead of skipped.
+            explicit_targets = bool(model_hashes)
+            if model_hashes:
+                hash_set = {h.lower() for h in model_hashes}
+                all_models = [
+                    (scanner_type, model, scanner)
+                    for scanner_type, model, scanner in all_models
+                    if model.get("sha256", "").lower() in hash_set
+                ]
+
             # Update total count
             self._progress["total"] = len(all_models)
             logger.debug(f"Found {self._progress['total']} models to process")
@@ -552,6 +644,7 @@ class DownloadManager:
                     downloader,
                     library_name,
                     force,
+                    explicit_targets,
                 )
 
                 # Update progress
@@ -648,6 +741,7 @@ class DownloadManager:
         downloader,
         library_name,
         force: bool = False,
+        explicit_targets: bool = False,
     ):
         """Process a single model download."""
 
@@ -670,8 +764,9 @@ class DownloadManager:
             self._progress["current_model"] = f"{model_name} ({model_hash[:8]})"
             await self._broadcast_progress(status="running")
 
-            # Skip if already in failed models (unless force mode is enabled)
-            if not force and model_hash in self._progress["failed_models"]:
+            # Skip if already in failed models (unless force mode is enabled or
+            # the model was explicitly targeted by hash)
+            if not force and not explicit_targets and model_hash in self._progress["failed_models"]:
                 logger.debug(f"Skipping known failed model: {model_name}")
                 return False
 
@@ -680,30 +775,34 @@ class DownloadManager:
             )
             existing_files = _model_directory_has_files(model_dir)
 
-            # Skip if already processed AND directory exists with files
-            if model_hash in self._progress["processed_models"]:
-                if existing_files:
-                    logger.debug(f"Skipping already processed model: {model_name}")
+            # Model-level guard: a populated folder counts as done. Explicitly
+            # targeted models bypass it so the per-image existence pre-check can
+            # fill individual gaps without re-fetching existing files.
+            if not explicit_targets:
+                # Skip if already processed AND directory exists with files
+                if model_hash in self._progress["processed_models"]:
+                    if existing_files:
+                        logger.debug(f"Skipping already processed model: {model_name}")
+                        return False
+
+                    logger.debug(
+                        "Model %s (%s) marked as processed but folder empty or missing, reprocessing triggered",
+                        model_name,
+                        model_hash,
+                    )
+                    # Track that we are reprocessing this model for summary logging
+                    self._progress["reprocessed_models"].add(model_hash)
+                    # Remove from processed models since we need to reprocess
+                    self._progress["processed_models"].discard(model_hash)
+
+                if existing_files and model_hash not in self._progress["processed_models"]:
+                    logger.debug(
+                        "Model folder already populated for %s, marking as processed without download",
+                        model_name,
+                    )
+                    self._progress["processed_models"].add(model_hash)
                     return False
 
-                logger.debug(
-                    "Model %s (%s) marked as processed but folder empty or missing, reprocessing triggered",
-                    model_name,
-                    model_hash,
-                )
-                # Track that we are reprocessing this model for summary logging
-                self._progress["reprocessed_models"].add(model_hash)
-                # Remove from processed models since we need to reprocess
-                self._progress["processed_models"].discard(model_hash)
-
-            if existing_files and model_hash not in self._progress["processed_models"]:
-                logger.debug(
-                    "Model folder already populated for %s, marking as processed without download",
-                    model_name,
-                )
-                self._progress["processed_models"].add(model_hash)
-                return False
-
             if not model_dir:
                 logger.warning(
                     "Unable to resolve example images folder for model %s (%s)",
@@ -807,7 +906,7 @@ class DownloadManager:
                         model_name,
                     )
                     # Clear failed_models so non-force runs can retry
-                    if force and model_hash in self._progress["failed_models"]:
+                    if (force or explicit_targets) and model_hash in self._progress["failed_models"]:
                         self._progress["failed_models"].discard(model_hash)
                         logger.info(
                             f"Removed {model_name} from failed_models after force retry with rate-limited images"
@@ -827,7 +926,7 @@ class DownloadManager:
                     )
                 elif success:
                     self._progress["processed_models"].add(model_hash)
-                    if force and model_hash in self._progress["failed_models"]:
+                    if (force or explicit_targets) and model_hash in self._progress["failed_models"]:
                         self._progress["failed_models"].discard(model_hash)
                         logger.info(
                             f"Removed {model_name} from failed_models after successful force retry"
@@ -1343,8 +1442,8 @@ class DownloadManager:
                 await MetadataManager.save_metadata(file_path, model_copy)
 
                 try:
-                    await scanner.update_single_model_cache(
-                        file_path, file_path, model_data
+                    await update_cache_from_metadata(
+                        scanner, file_path, model_copy
                     )
                 except AttributeError:
                     logger.debug(

py/utils/example_images_metadata.py

@@ -1,3 +1,4 @@
+import inspect
 import logging
 import os
 import re
@@ -28,6 +29,31 @@ if TYPE_CHECKING:  # pragma: no cover - import for type checkers only
     from ..services.settings_manager import SettingsManager
 
 
+async def update_cache_from_metadata(
+    scanner: Any, file_path: str, metadata: Dict[str, Any]
+) -> bool:
+    """Update the scanner cache from a metadata dict using the in-place sync path.
+
+    ``sync_cache_from_metadata`` patches the existing cache entry incrementally
+    (tag/hash/version indexes, targeted single-row SQL update) and only resorts
+    when a sort-key field changed. This avoids the ``O(n)`` full-list resort and
+    full cache rewrite that ``update_single_model_cache`` performs on every call,
+    which is critical for libraries with 100k+ models.
+
+    Falls back to the legacy full update when the scanner does not expose an
+    async ``sync_cache_from_metadata`` method.
+
+    Returns:
+        ``True`` if the cache entry was updated, ``False`` otherwise.
+    """
+
+    sync_method = getattr(scanner, "sync_cache_from_metadata", None)
+    if inspect.iscoroutinefunction(sync_method):
+        return await sync_method(file_path, metadata)
+
+    return await scanner.update_single_model_cache(file_path, file_path, metadata)
+
+
 def _build_metadata_sync_service(settings_manager: "SettingsManager") -> MetadataSyncService:
     """Construct a metadata sync service bound to the provided settings."""
 
@@ -103,8 +129,8 @@ class MetadataUpdater:
                 progress['refreshed_models'].add(model_hash)
             
             async def update_cache_func(old_path, new_path, metadata):
-                return await scanner.update_single_model_cache(old_path, new_path, metadata)
-            
+                return await update_cache_from_metadata(scanner, new_path, metadata)
+
             await MetadataManager.hydrate_model_data(model_data)
             success, error = await _get_metadata_sync_service().fetch_and_update_model(
                 sha256=model_hash,
@@ -234,6 +260,7 @@ class MetadataUpdater:
                 
                 # Save metadata to .metadata.json file
                 file_path = model.get('file_path')
+                model_copy: Optional[Dict[str, Any]] = None
                 try:
                     model_copy = model.copy()
                     model_copy.pop('folder', None)
@@ -241,14 +268,18 @@ class MetadataUpdater:
                     logger.info(f"Saved metadata for {model.get('model_name')}")
                 except Exception as e:
                     logger.error(f"Failed to save metadata for {model.get('model_name')}: {str(e)}")
-                
-                # Save updated metadata to scanner cache
-                success = await scanner.update_single_model_cache(file_path, file_path, model)
-                if success:
+
+                # Save updated metadata to scanner cache. sync_cache_from_metadata
+                # returns False both for "already in sync" and for actual failures,
+                # so the cache sync result is deliberately not treated as an error;
+                # the return value reflects whether the metadata was persisted.
+                if file_path and model_copy is not None:
+                    await update_cache_from_metadata(scanner, file_path, model_copy)
                     logger.info(f"Successfully updated metadata for {model.get('model_name')} with {len(images)} local examples")
                     return True
-                else:
-                    logger.warning(f"Failed to update metadata for {model.get('model_name')}")
+
+                logger.warning(f"Failed to update metadata for {model.get('model_name')}")
+                return False
             
             return False
         except Exception as e:
@@ -336,6 +367,7 @@ class MetadataUpdater:
             
             # Save metadata to .metadata.json file
             file_path = model_data.get('file_path')
+            model_copy: Optional[Dict[str, Any]] = None
             if file_path:
                 try:
                     model_copy = model_data.copy()
@@ -344,11 +376,11 @@ class MetadataUpdater:
                     logger.info(f"Saved metadata for {model_data.get('model_name')}")
                 except Exception as e:
                     logger.error(f"Failed to save metadata: {str(e)}")
-            
+
             # Save updated metadata to scanner cache
-            if file_path:
-                await scanner.update_single_model_cache(file_path, file_path, model_data)
-            
+            if file_path and model_copy is not None:
+                await update_cache_from_metadata(scanner, file_path, model_copy)
+
             # Get regular images array (might be None)
             regular_images = civitai_data.get('images', [])
             

py/utils/example_images_migration.py

@@ -15,6 +15,7 @@ from ..utils.example_images_paths import (
 )
 from ..utils.metadata_manager import MetadataManager
 from ..utils.example_images_processor import ExampleImagesProcessor
+from ..utils.example_images_metadata import update_cache_from_metadata
 from ..utils.constants import SUPPORTED_MEDIA_EXTENSIONS
 
 logger = logging.getLogger(__name__)
@@ -421,7 +422,7 @@ class ExampleImagesMigration:
                         await MetadataManager.save_metadata(file_path, model_copy)
                         
                         # Update scanner cache
-                        await scanner.update_single_model_cache(file_path, file_path, model_metadata)
+                        await update_cache_from_metadata(scanner, file_path, model_copy)
                         
                         updated_models += 1
                     except Exception as e:

py/utils/example_images_processor.py

@@ -9,7 +9,7 @@ from ..utils.constants import SUPPORTED_MEDIA_EXTENSIONS
 from ..services.service_registry import ServiceRegistry
 from ..services.settings_manager import get_settings_manager
 from ..utils.example_images_paths import get_model_folder, get_model_relative_path
-from .example_images_metadata import MetadataUpdater
+from .example_images_metadata import MetadataUpdater, update_cache_from_metadata
 from ..utils.metadata_manager import MetadataManager
 
 logger = logging.getLogger(__name__)
@@ -113,6 +113,26 @@ class ExampleImagesProcessor:
         message = str(error).lower()
         return '404' in message or 'file not found' in message
 
+    @staticmethod
+    def _example_image_file_exists(model_dir: str, index: int, media_type_hint: str | None = None) -> bool:
+        """Return True when the file that would be written for a media index already exists.
+
+        The final filename (``image_{index}{extension}``) depends on the downloaded
+        content, so the extension cannot be known ahead of time. The post-download
+        check skips the write when the exact target file exists; this pre-check
+        approximates that with the candidate extensions for the media type (videos
+        only when the metadata hints at a video) so the network request is avoided
+        for files that already exist on disk.
+        """
+        if media_type_hint == "video":
+            extensions = SUPPORTED_MEDIA_EXTENSIONS['videos']
+        else:
+            extensions = SUPPORTED_MEDIA_EXTENSIONS['images']
+        return any(
+            os.path.exists(os.path.join(model_dir, f"image_{index}{ext}"))
+            for ext in extensions
+        )
+
     @staticmethod
     async def download_model_images(model_hash, model_name, model_images, model_dir, optimize, downloader):
         """Download images for a single model
@@ -139,7 +159,12 @@ class ExampleImagesProcessor:
             original_url = image_url
             if optimize and 'civitai.com' in image_url:
                 image_url = ExampleImagesProcessor.get_civitai_optimized_url(image_url)
-            
+
+            # Skip the download when the file already exists on disk
+            if ExampleImagesProcessor._example_image_file_exists(model_dir, i, image.get("type")):
+                logger.debug("File already exists, skipping download for %s", image_url)
+                continue
+
             # Download the file first to determine the actual file type
             try:
                 logger.debug(f"Downloading media file {i} for {model_name}")
@@ -229,6 +254,11 @@ class ExampleImagesProcessor:
             if optimize and 'civitai.com' in image_url:
                 image_url = ExampleImagesProcessor.get_civitai_optimized_url(image_url)
 
+            # Skip the download when the file already exists on disk
+            if ExampleImagesProcessor._example_image_file_exists(model_dir, i, image.get("type")):
+                logger.debug("File already exists, skipping download for %s", image_url)
+                continue
+
             async def _attempt_download() -> tuple:
                 logger.debug("Downloading media file %s for %s", i, model_name)
                 return await downloader.download_to_memory(
@@ -644,7 +674,7 @@ class ExampleImagesProcessor:
                     }, status=500)
             
                 # Update cache
-                await scanner.update_single_model_cache(file_path, file_path, model_data)
+                await update_cache_from_metadata(scanner, file_path, model_data)
             
             # Get regular images array (might be None)
             regular_images = civitai_data.get('images', [])
@@ -759,7 +789,7 @@ class ExampleImagesProcessor:
                 model_copy = model_data.copy()
                 model_copy.pop('folder', None)
                 await MetadataManager.save_metadata(file_path, model_copy)
-                await scanner.update_single_model_cache(file_path, file_path, model_data)
+                await update_cache_from_metadata(scanner, file_path, model_copy)
 
             return web.json_response({
                 'success': True,

py/utils/utils.py

@@ -1,7 +1,7 @@
 from difflib import SequenceMatcher
 import os
 import re
-from typing import Dict
+from typing import Any, Dict, List, Optional
 from ..services.service_registry import ServiceRegistry
 from ..config import config
 from ..services.settings_manager import get_settings_manager
@@ -294,6 +294,53 @@ def _format_model_name_for_comfyui(file_path: str, model_roots: list) -> str:
     return os.path.basename(file_path)
 
 
+def model_patcher_to_name(model_patcher: Any) -> Optional[str]:
+    """Extract a ComfyUI-style model name from a MODEL (ModelPatcher) object.
+
+    Core ComfyUI loaders record the absolute weight file path on the patcher's
+    ``cached_patcher_init`` attribute:
+      - load_checkpoint_guess_config -> (fn, (ckpt_path, ...), index)
+      - load_diffusion_model -> (fn, (unet_path, model_options))
+    Patcher clones (LoRA loaders, model merges, ...) preserve the attribute,
+    so the name is recoverable anywhere downstream of a core loader — including
+    from LoRA Manager's own loaders (CheckpointLoaderLM / UNETLoaderLM), which
+    call the same core load functions.
+
+    The absolute path is converted to the ComfyUI-style relative name used by
+    the metadata pipeline (covering standard ComfyUI roots and LoRA Manager
+    extra folder paths).
+
+    Returns None when the path cannot be recovered (e.g. third-party loaders
+    that never set ``cached_patcher_init``).
+    """
+    init = getattr(model_patcher, "cached_patcher_init", None)
+    if not isinstance(init, (tuple, list)) or len(init) < 2:
+        return None
+    args = init[1]
+    abs_path = args[0] if args else None
+    if not isinstance(abs_path, str) or not abs_path:
+        return None
+    return _abs_model_path_to_name(abs_path)
+
+
+def _abs_model_path_to_name(abs_path: str) -> str:
+    """Convert an absolute model path to a ComfyUI-style relative name.
+
+    Tries standard ComfyUI model roots plus LoRA Manager extra folder paths;
+    falls back to the bare filename.
+    """
+    try:
+        roots: List[str] = list(config.base_models_roots or [])
+        roots.extend(config.extra_checkpoints_roots or [])
+        roots.extend(config.extra_unet_roots or [])
+        formatted = _format_model_name_for_comfyui(abs_path, roots)
+        if formatted:
+            return formatted
+    except Exception:
+        pass
+    return os.path.basename(abs_path)
+
+
 def fuzzy_match(text: str, pattern: str, threshold: float = 0.85) -> bool:
     """
     Check if text matches pattern using fuzzy matching.

static/js/api/apiConfig.js

@@ -184,7 +184,8 @@ export const DOWNLOAD_ENDPOINTS = {
     downloadGet: '/api/lm/download-model-get',
     cancelGet: '/api/lm/cancel-download-get',
     progress: '/api/lm/download-progress',
-    exampleImages: '/api/lm/force-download-example-images' // New endpoint for downloading example images
+    exampleImages: '/api/lm/force-download-example-images', // Re-process example images ignoring previous status
+    exampleImagesMissing: '/api/lm/download-example-images' // Download only missing example images
 };
 
 // Hugging Face API endpoints

static/js/api/baseModelApi.js

@@ -1641,7 +1641,7 @@ export class BaseModelApiClient {
         }
     }
 
-    async downloadExampleImages(modelHashes, modelTypes = null) {
+    async downloadExampleImages(modelHashes, modelTypes = null, { force = true } = {}) {
         let ws = null;
 
         await state.loadingManager.showWithProgress(async (loading) => {
@@ -1700,8 +1700,13 @@ export class BaseModelApiClient {
                 // Determine optimize setting
                 const optimize = state.global?.settings?.optimize_example_images ?? true;
 
+                // force=false routes to the regular endpoint, which skips already-processed models
+                const endpoint = force
+                    ? DOWNLOAD_ENDPOINTS.exampleImages
+                    : DOWNLOAD_ENDPOINTS.exampleImagesMissing;
+
                 // Make the API request to start the download process
-                const response = await fetch(DOWNLOAD_ENDPOINTS.exampleImages, {
+                const response = await fetch(endpoint, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json'
@@ -1710,6 +1715,7 @@ export class BaseModelApiClient {
                         model_hashes: modelHashes,
                         output_dir: outputDir,
                         optimize: optimize,
+                        force: force,
                         model_types: modelTypes || [this.apiConfig.config.singularName]
                     })
                 });

static/js/components/ContextMenu/BulkContextMenu.js

@@ -137,11 +137,10 @@ export class BulkContextMenu extends BaseContextMenu {
             downloadMissingLorasItem.style.display = currentModelType === 'recipes' ? 'flex' : 'none';
         }
 
-        const downloadExampleImagesItem = this.menu.querySelector('[data-action="download-example-images"]');
-        if (downloadExampleImagesItem) {
+        const downloadExampleImagesSubmenu = this.menu.querySelector('[data-has-submenu="download-example-images"]');
+        if (downloadExampleImagesSubmenu) {
             // Show on model pages (loras, checkpoints, embeddings), hide on recipes
-            const modelPages = ['loras', 'checkpoints', 'embeddings'];
-            downloadExampleImagesItem.style.display = modelPages.includes(currentModelType) ? 'flex' : 'none';
+            downloadExampleImagesSubmenu.style.display = ['loras', 'checkpoints', 'embeddings'].includes(currentModelType) ? 'flex' : 'none';
         }
 
         const skipMetadataRefreshItem = this.menu.querySelector('[data-action="skip-metadata-refresh"]');
@@ -294,8 +293,11 @@ export class BulkContextMenu extends BaseContextMenu {
             case 'download-missing-loras':
                 this.handleDownloadMissingLoras();
                 break;
+            case 'download-missing-example-images':
+                this.handleDownloadExampleImages({ force: false });
+                break;
             case 'download-example-images':
-                this.handleDownloadExampleImages();
+                this.handleDownloadExampleImages({ force: true });
                 break;
             case 'clear':
                 bulkManager.clearSelection();
@@ -340,7 +342,7 @@ export class BulkContextMenu extends BaseContextMenu {
         await bulkMissingLoraDownloadManager.downloadMissingLoras(selectedRecipes);
     }
 
-    async handleDownloadExampleImages() {
+    async handleDownloadExampleImages({ force = true } = {}) {
         if (state.selectedModels.size === 0) {
             return;
         }
@@ -361,7 +363,7 @@ export class BulkContextMenu extends BaseContextMenu {
 
         try {
             const apiClient = getModelApiClient();
-            await apiClient.downloadExampleImages([...hashes]);
+            await apiClient.downloadExampleImages([...hashes], null, { force });
         } catch (error) {
             console.error('Bulk download example images failed:', error);
         }

static/js/components/ContextMenu/ModelContextMenuMixin.js

@@ -347,7 +347,10 @@ export const ModelContextMenuMixin = {
                 openExampleImagesFolder(this.currentCard.dataset.sha256);
                 return true;
             case 'download-examples':
-                this.downloadExampleImages();
+                this.downloadExampleImages(false);
+                return true;
+            case 'download-examples-force':
+                this.downloadExampleImages(true);
                 return true;
             case 'civitai':
                 if (this.currentCard.dataset.from_civitai === 'true') {
@@ -378,7 +381,7 @@ export const ModelContextMenuMixin = {
     },
 
     // Download example images method
-    async downloadExampleImages() {
+    async downloadExampleImages(force = false) {
         const modelHash = this.currentCard.dataset.sha256;
         if (!modelHash) {
             showToast('toast.contextMenu.missingHash', {}, 'error');
@@ -387,7 +390,7 @@ export const ModelContextMenuMixin = {
 
         try { 
             const apiClient = getModelApiClient();
-            await apiClient.downloadExampleImages([modelHash]);
+            await apiClient.downloadExampleImages([modelHash], null, { force });
         } catch (error) {
             console.error('Error downloading example images:', error);
         }

static/js/components/controls/PageControls.js

@@ -108,10 +108,20 @@ export class PageControls {
         const sortSelect = document.getElementById('sortSelect');
         if (sortSelect) {
             initSortDropdown(sortSelect);
-            sortSelect.value = this.pageState.sortBy;
+            this.applySortToSelect(this.pageState.sortBy);
             sortSelect.addEventListener('change', async (e) => {
-                this.pageState.sortBy = e.target.value;
-                this.saveSortPreference(e.target.value);
+                let value = e.target.value;
+                if (value.startsWith('random')) {
+                    // Every pick of Random reshuffles the list: generate a
+                    // fresh seed so the backend keeps a stable order across
+                    // paginated requests.
+                    value = this._randomizeSortValue();
+                }
+                this.pageState.sortBy = value;
+                this.saveSortPreference(value);
+                // Reset the seeded Random option when switching away from
+                // Random, or re-apply the fresh seed when picking it again.
+                this.applySortToSelect(value);
                 await this.resetAndReload();
             });
         }
@@ -312,6 +322,44 @@ export class PageControls {
         }
     }
     
+    /**
+     * Apply a sort value to the native sort <select>, keeping the Random
+     * option's value in sync when the persisted value carries a seed
+     * (e.g. "random:abc123"). Must be used instead of assigning
+     * sortSelect.value directly whenever the value may be a seeded random
+     * sort, otherwise the native select has no matching option.
+     * @param {string} sortValue - Sort value like "name:asc" or "random:<seed>"
+     */
+    applySortToSelect(sortValue) {
+        const sortSelect = document.getElementById('sortSelect');
+        if (!sortSelect) return;
+        const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
+        if (randomOpt) {
+            randomOpt.value = String(sortValue).startsWith('random') ? sortValue : 'random';
+        }
+        sortSelect.value = sortValue;
+    }
+
+    /**
+     * Generate a fresh seeded random sort value ("random:<seed>") and keep
+     * the native <select> in sync so its value matches the persisted sort
+     * string and the dropdown shows the selected label.
+     * @returns {string} The new sort value, e.g. "random:abc123xyz"
+     */
+    _randomizeSortValue() {
+        const seed = Math.random().toString(36).slice(2, 12);
+        const value = `random:${seed}`;
+        const sortSelect = document.getElementById('sortSelect');
+        if (sortSelect) {
+            const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
+            if (randomOpt) {
+                randomOpt.value = value;
+            }
+            sortSelect.value = value;
+        }
+        return value;
+    }
+
     /**
      * Load sort preference from storage
      */
@@ -326,10 +374,7 @@ export class PageControls {
             // Handle legacy format conversion
             const convertedSort = this.convertLegacySortFormat(savedSort);
             this.pageState.sortBy = convertedSort;
-            const sortSelect = document.getElementById('sortSelect');
-            if (sortSelect) {
-                sortSelect.value = convertedSort;
-            }
+            this.applySortToSelect(convertedSort);
         }
     }
     
@@ -523,9 +568,9 @@ export class PageControls {
         this.pageState.sortBy = restoredSort;
         this.saveSortPreference(restoredSort);
         this._removeVlmSortOption();
+        this.applySortToSelect(restoredSort);
         const sortSelect = document.getElementById('sortSelect');
         if (sortSelect) {
-            sortSelect.value = restoredSort;
             sortSelect.disabled = false;
         }
     }
@@ -575,10 +620,7 @@ export class PageControls {
             const savedGroupedSort = getStorageItem(groupedKey);
             if (savedGroupedSort) {
                 this.pageState.sortBy = savedGroupedSort;
-                const sortSelect = document.getElementById('sortSelect');
-                if (sortSelect) {
-                    sortSelect.value = savedGroupedSort;
-                }
+                this.applySortToSelect(savedGroupedSort);
             }
         } else {
             // Leaving group mode: persist current sort for next time, restore non-group sort
@@ -586,10 +628,7 @@ export class PageControls {
             const savedNormalSort = getStorageItem(`${this.pageType}_sort`);
             if (savedNormalSort) {
                 this.pageState.sortBy = savedNormalSort;
-                const sortSelect = document.getElementById('sortSelect');
-                if (sortSelect) {
-                    sortSelect.value = savedNormalSort;
-                }
+                this.applySortToSelect(savedNormalSort);
             }
         }
     }
@@ -874,7 +913,7 @@ export class PageControls {
         }
 
         if (sortSelect) {
-            sortSelect.value = this.pageState.sortBy;
+            this.applySortToSelect(this.pageState.sortBy);
         }
         if (searchInput) {
             searchInput.value = this.pageState.filters?.search || '';

static/js/components/controls/SortDropdown.js

@@ -96,7 +96,16 @@ export function initSortDropdown(select) {
     };
 
     const choose = (value) => {
-        if (select.value === value) return;
+        if (select.value === value) {
+            // Re-picking the already-selected option is normally a no-op,
+            // matching native <select> behavior. The seeded Random sort is
+            // the exception: clicking it again should reshuffle, so let the
+            // change handler (PageControls) generate a fresh seed.
+            if (String(value).startsWith('random')) {
+                select.dispatchEvent(new Event('change', { bubbles: true }));
+            }
+            return;
+        }
         select.value = value;
         select.dispatchEvent(new Event('change', { bubbles: true }));
     };
@@ -277,9 +286,10 @@ export function initSortDropdown(select) {
     }
 
     // Rebuild the menu when <option>s change (VLM adds/removes a temporary
-    // option at runtime).
+    // option at runtime, and the seeded Random sort option gets a new value
+    // attribute each time it is picked).
     const observer = new MutationObserver(() => buildMenu());
-    observer.observe(select, { childList: true });
+    observer.observe(select, { childList: true, subtree: true, attributes: true, attributeFilter: ['value'] });
 
     buildMenu();
     group.dataset.sortReady = '1';

static/js/managers/BulkManager.js

@@ -90,7 +90,7 @@ export class BulkManager {
                 moveAll: true,
                 autoOrganize: false,
                 deleteAll: true,
-                setContentRating: false,
+                setContentRating: true,
                 skipMetadataRefresh: false,
                 setFavorite: true,
                 unfavorite: true,
@@ -1528,14 +1528,18 @@ export class BulkManager {
         let failureCount = 0;
 
         try {
-            const apiClient = getModelApiClient();
+            const isRecipesPage = state.currentPageType === 'recipes';
             for (const filePath of targets) {
                 if (cancelled) {
                     showToast('toast.api.operationCancelled', {}, 'info');
                     break;
                 }
                 try {
-                    await apiClient.saveModelMetadata(filePath, { preview_nsfw_level: level });
+                    if (isRecipesPage) {
+                        await updateRecipeMetadata(filePath, { preview_nsfw_level: level });
+                    } else {
+                        await getModelApiClient().saveModelMetadata(filePath, { preview_nsfw_level: level });
+                    }
                     successCount++;
                 } catch (error) {
                     failureCount++;

templates/checkpoints.html

@@ -32,7 +32,12 @@
     <div class="context-menu-separator menu-section-break"></div>
     <!-- Media / Preview -->
     <div class="context-menu-item" data-action="preview"><i class="fas fa-folder-open"></i> {{ t('loras.contextMenu.openExamples') }}</div>
-    <div class="context-menu-item" data-action="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadExamples') }}</div>
+    <div class="context-menu-item has-submenu" data-has-submenu="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadExamples') }} <i class="fas fa-chevron-right submenu-arrow"></i>
+        <div class="context-submenu">
+            <div class="context-menu-item" data-action="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadMissingExamples') }}</div>
+            <div class="context-menu-item" data-action="download-examples-force"><i class="fas fa-redo-alt"></i> {{ t('loras.contextMenu.reprocessExamples') }}</div>
+        </div>
+    </div>
     <div class="context-menu-item" data-action="replace-preview"><i class="fas fa-image"></i> {{ t('loras.contextMenu.replacePreview') }}</div>
     <div class="context-menu-separator menu-section-break"></div>
     <!-- Attributes -->

templates/components/context_menu.html

@@ -44,8 +44,18 @@
     <div class="context-menu-item" data-action="preview">
         <i class="fas fa-folder-open"></i> <span>{{ t('loras.contextMenu.openExamples') }}</span>
     </div>
-    <div class="context-menu-item" data-action="download-examples">
-        <i class="fas fa-download"></i> <span>{{ t('loras.contextMenu.downloadExamples') }}</span>
+    <div class="context-menu-item has-submenu" data-has-submenu="download-examples">
+        <i class="fas fa-download"></i>
+        <span>{{ t('loras.contextMenu.downloadExamples') }}</span>
+        <i class="fas fa-chevron-right submenu-arrow"></i>
+        <div class="context-submenu">
+            <div class="context-menu-item" data-action="download-examples">
+                <i class="fas fa-download"></i> <span>{{ t('loras.contextMenu.downloadMissingExamples') }}</span>
+            </div>
+            <div class="context-menu-item" data-action="download-examples-force">
+                <i class="fas fa-redo-alt"></i> <span>{{ t('loras.contextMenu.reprocessExamples') }}</span>
+            </div>
+        </div>
     </div>
     <div class="context-menu-item" data-action="replace-preview">
         <i class="fas fa-image"></i> <span>{{ t('loras.contextMenu.replacePreview') }}</span>
@@ -136,8 +146,18 @@
     </div>
     <div class="context-menu-section" data-section="download">
         <div class="context-menu-section-header">{{ t('loras.bulkOperations.sections.download') }}</div>
-        <div class="context-menu-item" data-action="download-example-images">
-            <i class="fas fa-download"></i> <span>{{ t('loras.bulkOperations.downloadExamples') }}</span>
+        <div class="context-menu-item has-submenu" data-has-submenu="download-example-images">
+            <i class="fas fa-download"></i>
+            <span>{{ t('loras.bulkOperations.downloadExamples') }}</span>
+            <i class="fas fa-chevron-right submenu-arrow"></i>
+            <div class="context-submenu">
+                <div class="context-menu-item" data-action="download-missing-example-images">
+                    <i class="fas fa-download"></i> <span>{{ t('loras.bulkOperations.downloadMissingExamples') }}</span>
+                </div>
+                <div class="context-menu-item" data-action="download-example-images">
+                    <i class="fas fa-redo-alt"></i> <span>{{ t('loras.bulkOperations.reprocessExamples') }}</span>
+                </div>
+            </div>
         </div>
         <div class="context-menu-item" data-action="download-missing-loras">
             <i class="fas fa-download"></i> <span>{{ t('loras.bulkOperations.downloadMissingLoras') }}</span>

templates/components/controls.html

@@ -48,6 +48,11 @@
                             <option value="versions_count:asc">{{ t('loras.controls.sort.versionsCountAsc', default='Fewest versions first') }}</option>
                         </optgroup>
                     {% endif %}
+                    {% if page_id != 'recipes' %}
+                        <optgroup label="{{ t('loras.controls.sort.random', default='Random') }}">
+                            <option value="random">{{ t('loras.controls.sort.randomAction', default='Randomize (shuffle)') }}</option>
+                        </optgroup>
+                    {% endif %}
                     {% if page_id == 'recipes' %}
                         <optgroup label="{{ t('recipes.controls.sort.lorasCount') }}">
                             <option value="loras_count:desc">{{ t('recipes.controls.sort.lorasCountDesc') }}</option>

templates/embeddings.html

@@ -32,7 +32,12 @@
     <div class="context-menu-separator menu-section-break"></div>
     <!-- Media / Preview -->
     <div class="context-menu-item" data-action="preview"><i class="fas fa-folder-open"></i> {{ t('loras.contextMenu.openExamples') }}</div>
-    <div class="context-menu-item" data-action="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadExamples') }}</div>
+    <div class="context-menu-item has-submenu" data-has-submenu="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadExamples') }} <i class="fas fa-chevron-right submenu-arrow"></i>
+        <div class="context-submenu">
+            <div class="context-menu-item" data-action="download-examples"><i class="fas fa-download"></i> {{ t('loras.contextMenu.downloadMissingExamples') }}</div>
+            <div class="context-menu-item" data-action="download-examples-force"><i class="fas fa-redo-alt"></i> {{ t('loras.contextMenu.reprocessExamples') }}</div>
+        </div>
+    </div>
     <div class="context-menu-item" data-action="replace-preview"><i class="fas fa-image"></i> {{ t('loras.contextMenu.replacePreview') }}</div>
     <div class="context-menu-separator menu-section-break"></div>
     <!-- Attributes -->

tests/frontend/components/contextMenu.interactions.test.js

@@ -2155,4 +2155,35 @@ describe('Interaction-level regression coverage', () => {
     excludedItem.dispatchEvent(new Event('click', { bubbles: true }));
     expect(window.pageControls.enterExcludedView).toHaveBeenCalledTimes(1);
   });
+
+  it('routes single-model example downloads to missing-only and force paths', async () => {
+    document.body.innerHTML = `
+      <div id="loraContextMenu" class="context-menu">
+        <div class="context-menu-item has-submenu" data-has-submenu="download-examples">
+          <div class="context-submenu">
+            <div class="context-menu-item" data-action="download-examples"></div>
+            <div class="context-menu-item" data-action="download-examples-force"></div>
+          </div>
+        </div>
+      </div>
+    `;
+
+    const { LoraContextMenu } = await import('../../../static/js/components/ContextMenu/LoraContextMenu.js');
+    const contextMenu = new LoraContextMenu();
+
+    const card = document.createElement('div');
+    card.className = 'model-card';
+    card.dataset.filepath = '/models/test.safetensors';
+    card.dataset.sha256 = 'abc123hash';
+    document.body.appendChild(card);
+
+    contextMenu.showMenu(100, 100, card);
+
+    document.querySelector('[data-action="download-examples"]').dispatchEvent(new Event('click', { bubbles: true }));
+    expect(downloadExampleImagesApiMock).toHaveBeenCalledWith(['abc123hash'], null, { force: false });
+
+    contextMenu.showMenu(100, 100, card);
+    document.querySelector('[data-action="download-examples-force"]').dispatchEvent(new Event('click', { bubbles: true }));
+    expect(downloadExampleImagesApiMock).toHaveBeenCalledWith(['abc123hash'], null, { force: true });
+  });
 });

tests/frontend/components/pageControls.randomSort.test.js

@@ -0,0 +1,221 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+
+const resetAndReloadMock = vi.fn();
+const getModelApiClientMock = vi.fn();
+
+vi.mock('../../../static/js/api/modelApiFactory.js', () => ({
+  getModelApiClient: getModelApiClientMock,
+  resetAndReload: resetAndReloadMock,
+}));
+
+vi.mock('../../../static/js/utils/uiHelpers.js', () => ({
+  showToast: vi.fn(),
+  openCivitaiByMetadata: vi.fn(),
+  updatePanelPositions: vi.fn(),
+}));
+
+vi.mock('../../../static/js/managers/DownloadManager.js', () => ({
+  downloadManager: { showDownloadModal: vi.fn() },
+}));
+
+vi.mock('../../../static/js/components/SidebarManager.js', () => ({
+  sidebarManager: {
+    setHostPageControls: vi.fn(),
+    initialize: vi.fn(async () => {}),
+    refresh: vi.fn(async () => {}),
+    cleanup: vi.fn(),
+    isInitialized: false,
+  },
+}));
+
+vi.mock('../../../static/js/components/alphabet/index.js', () => ({
+  createAlphabetBar: vi.fn(() => ({ destroy: vi.fn() })),
+}));
+
+vi.mock('../../../static/js/utils/updateCheckHelpers.js', () => ({
+  performModelUpdateCheck: vi.fn(async () => ({ status: 'success', displayName: 'LoRA', records: [] })),
+}));
+
+beforeEach(() => {
+  vi.resetModules();
+  vi.clearAllMocks();
+  localStorage.clear();
+  sessionStorage.clear();
+
+  resetAndReloadMock.mockResolvedValue(undefined);
+  getModelApiClientMock.mockReturnValue({});
+
+  global.fetch = vi.fn().mockResolvedValue({
+    ok: true,
+    json: async () => ({ success: true, base_models: [] }),
+  });
+});
+
+afterEach(() => {
+  delete window.bulkManager;
+  delete window.modelDuplicatesManager;
+  delete global.fetch;
+});
+
+function renderControlsDom(pageKey) {
+  document.body.dataset.page = pageKey;
+  document.body.innerHTML = `
+    <div class="controls">
+      <div id="excludedViewBanner" class="excluded-view-banner hidden">
+        <button id="excludedViewBackBtn">Back</button>
+      </div>
+      <div class="actions">
+        <div class="action-buttons">
+          <div class="control-group">
+            <select id="sortSelect">
+              <option value="name:asc">Name Asc</option>
+              <option value="name:desc">Name Desc</option>
+              <option value="random">Randomize (shuffle)</option>
+            </select>
+          </div>
+          <div class="control-group dropdown-group">
+            <button data-action="refresh" class="dropdown-main"></button>
+            <button class="dropdown-toggle"></button>
+            <div class="dropdown-menu">
+              <div class="dropdown-item" data-action="full-rebuild"></div>
+            </div>
+          </div>
+          <div class="control-group">
+            <button data-action="fetch"></button>
+          </div>
+          <div class="control-group">
+            <button data-action="download"></button>
+          </div>
+          <div class="control-group">
+            <button data-action="bulk"></button>
+          </div>
+          <div class="control-group">
+            <button data-action="find-duplicates"></button>
+          </div>
+          <div class="control-group">
+            <button id="favoriteFilterBtn" class="favorite-filter"></button>
+          </div>
+          <div class="control-group dropdown-group update-filter-group">
+            <button id="updateFilterBtn" class="dropdown-main update-filter" aria-busy="false">
+              <span>Updates</span>
+            </button>
+            <button id="updateFilterMenuToggle" class="dropdown-toggle"></button>
+            <div class="dropdown-menu">
+              <div id="checkUpdatesMenuItem" class="dropdown-item" data-action="check-updates">
+                <span>Check updates</span>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div id="customFilterIndicator" class="control-group hidden">
+      <div class="filter-active">
+        <span class="customFilterText" title=""></span>
+        <i class="fas fa-times-circle clear-filter"></i>
+      </div>
+    </div>
+    <div id="breadcrumbContainer"></div>
+    <div id="duplicatesBanner" style="display: none;"></div>
+    <div class="alphabet-bar-container"></div>
+  `;
+}
+
+async function createControls() {
+  const stateModule = await import('../../../static/js/state/index.js');
+  stateModule.initPageState('loras');
+  const { LorasControls } = await import('../../../static/js/components/controls/LorasControls.js');
+  return { stateModule, controls: new LorasControls() };
+}
+
+describe('Random sort option', () => {
+  it('generates a seeded sort value when Random is picked', async () => {
+    renderControlsDom('loras');
+    const { controls } = await createControls();
+    const sortSelect = document.getElementById('sortSelect');
+    const randomOpt = sortSelect.querySelector('option[value="random"]');
+
+    sortSelect.value = 'random';
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+
+    expect(controls.pageState.sortBy).toMatch(/^random:[a-z0-9]+$/);
+    expect(localStorage.getItem('lora_manager_loras_sort')).toBe(controls.pageState.sortBy);
+    expect(randomOpt.value).toBe(controls.pageState.sortBy);
+    expect(sortSelect.value).toBe(controls.pageState.sortBy);
+    expect(resetAndReloadMock).toHaveBeenCalled();
+  });
+
+  it('reshuffles with a fresh seed every time Random is picked again', async () => {
+    renderControlsDom('loras');
+    const { controls } = await createControls();
+    const sortSelect = document.getElementById('sortSelect');
+    const randomOpt = sortSelect.querySelector('option[value="random"]');
+
+    // First pick
+    sortSelect.value = 'random';
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+    const firstSeed = controls.pageState.sortBy;
+
+    // Second pick: the option now carries the seeded value, like a menu click
+    sortSelect.value = randomOpt.value;
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+
+    expect(controls.pageState.sortBy).toMatch(/^random:[a-z0-9]+$/);
+    expect(controls.pageState.sortBy).not.toBe(firstSeed);
+  });
+
+  it('restores a persisted seeded random sort on load', async () => {
+    renderControlsDom('loras');
+    const savedSort = 'random:persistedseed';
+    localStorage.setItem('lora_manager_loras_sort', savedSort);
+
+    const { controls } = await createControls();
+    const sortSelect = document.getElementById('sortSelect');
+
+    expect(controls.pageState.sortBy).toBe(savedSort);
+    expect(sortSelect.value).toBe(savedSort);
+    expect(sortSelect.querySelector('option[value="random:persistedseed"]')).not.toBeNull();
+  });
+
+  it('applies a non-random sort back to the plain random option', async () => {
+    renderControlsDom('loras');
+    const { controls } = await createControls();
+    const sortSelect = document.getElementById('sortSelect');
+    const randomOpt = sortSelect.querySelector('option[value="random"]');
+
+    // Seed a random sort, then switch to a normal sort
+    sortSelect.value = 'random';
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+    controls.applySortToSelect('name:desc');
+
+    expect(sortSelect.value).toBe('name:desc');
+    expect(randomOpt.value).toBe('random');
+  });
+
+  it('resets the seeded option when switching away from Random via the dropdown change handler', async () => {
+    renderControlsDom('loras');
+    const { controls } = await createControls();
+    const sortSelect = document.getElementById('sortSelect');
+    const randomOpt = sortSelect.querySelector('option[value="random"]');
+
+    // Pick Random: the option is now seeded
+    sortSelect.value = 'random';
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+    expect(randomOpt.value).toMatch(/^random:[a-z0-9]+$/);
+
+    // Switch to a non-random sort through the change handler (as a menu
+    // click does); the option must go back to the plain "random" value
+    sortSelect.value = 'name:desc';
+    sortSelect.dispatchEvent(new Event('change', { bubbles: true }));
+    await Promise.resolve();
+
+    expect(controls.pageState.sortBy).toBe('name:desc');
+    expect(sortSelect.value).toBe('name:desc');
+    expect(randomOpt.value).toBe('random');
+  });
+});

tests/frontend/components/sortDropdown.menuSync.test.js

@@ -0,0 +1,68 @@
+import { describe, it, beforeEach, expect } from 'vitest';
+import { initSortDropdown } from '../../../static/js/components/controls/SortDropdown.js';
+
+function renderSortDropdownDom() {
+    document.body.innerHTML = `
+    <div class="sort-dropdown-group">
+      <select id="sortSelect">
+        <option value="name:asc">Name Asc</option>
+        <option value="name:desc">Name Desc</option>
+        <option value="random" selected>Randomize (shuffle)</option>
+      </select>
+      <button class="sort-trigger" type="button">
+        <span class="sort-trigger__label"></span>
+      </button>
+      <div class="sort-dropdown-menu"></div>
+    </div>
+  `;
+    return {
+        select: document.getElementById('sortSelect'),
+        menu: document.querySelector('.sort-dropdown-menu'),
+        label: document.querySelector('.sort-trigger__label'),
+    };
+}
+
+describe('SortDropdown menu sync', () => {
+    let select;
+    let menu;
+    let label;
+
+    beforeEach(() => {
+        ({ select, menu, label } = renderSortDropdownDom());
+        initSortDropdown(select);
+    });
+
+    it('rebuilds the menu and highlights the selected item when an option value attribute changes', async () => {
+        // The seeded Random option gets a new value each time it is picked.
+        // The select's value getter follows the selected option's new value.
+        const randomOpt = select.querySelector('option[value="random"]');
+        randomOpt.value = 'random:abc123';
+        await Promise.resolve();
+
+        const items = [...menu.querySelectorAll('.sort-option')];
+        expect(items.map((el) => el.dataset.value)).toContain('random:abc123');
+        const seededItem = items.find((el) => el.dataset.value === 'random:abc123');
+        expect(seededItem.classList.contains('is-selected')).toBe(true);
+        expect(label.textContent).toBe('Randomize (shuffle)');
+    });
+
+    it('drops the stale seeded item and re-selects the plain random item when the option is reset', async () => {
+        const randomOpt = select.querySelector('option[value="random"]');
+        randomOpt.value = 'random:abc123';
+        await Promise.resolve();
+
+        // The rebuild must have happened: the seeded item is in the menu
+        const seededItems = [...menu.querySelectorAll('.sort-option')]
+            .filter((el) => el.dataset.value === 'random:abc123');
+        expect(seededItems).toHaveLength(1);
+
+        // PageControls resets the option to "random" when switching away
+        randomOpt.value = 'random';
+        await Promise.resolve();
+
+        const items = [...menu.querySelectorAll('.sort-option')];
+        expect(items.map((el) => el.dataset.value)).not.toContain('random:abc123');
+        const randomItem = items.find((el) => el.dataset.value === 'random');
+        expect(randomItem.classList.contains('is-selected')).toBe(true);
+    });
+});

tests/frontend/core/loraStackDynamicInputs.test.js

@@ -0,0 +1,195 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { APP_MODULE, EXTENSION_MODULE, appMock, registeredExtensions } =
+  vi.hoisted(() => {
+    const registeredExtensions = [];
+    const appMock = {
+      configuringGraph: false,
+      registerExtension: (ext) => registeredExtensions.push(ext),
+    };
+    return {
+      APP_MODULE: new URL("../../../scripts/app.js", import.meta.url).pathname,
+      EXTENSION_MODULE: new URL(
+        "../../../web/comfyui/lora_stack_dynamic_inputs.js",
+        import.meta.url
+      ).pathname,
+      appMock,
+      registeredExtensions,
+    };
+  });
+
+vi.mock(APP_MODULE, () => ({
+  app: appMock,
+}));
+
+describe("Lora Stack Combiner dynamic inputs", () => {
+  let extension;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    registeredExtensions.length = 0;
+    appMock.configuringGraph = false;
+    await import(EXTENSION_MODULE);
+    extension = registeredExtensions.find(
+      (ext) => ext.name === "Comfy.LoraManager.LoraStackCombiner"
+    );
+    expect(extension).toBeDefined();
+  });
+
+  function createNodeType() {
+    const nodeType = { prototype: {} };
+    extension.beforeRegisterNodeDef(
+      nodeType,
+      { name: "Lora Stack Combiner (LoraManager)" },
+      appMock
+    );
+    return nodeType;
+  }
+
+  function createNode(inputs = []) {
+    const node = {
+      comfyClass: "Lora Stack Combiner (LoraManager)",
+      inputs: inputs.map((name) => ({ name, type: "LORA_STACK" })),
+      addInput: vi.fn(function (name, type, opts) {
+        this.inputs.push({ name, type, ...opts });
+      }),
+      removeInput: vi.fn(function (index) {
+        this.inputs.splice(index, 1);
+      }),
+    };
+    return node;
+  }
+
+  function makeLinkInfo() {
+    return { id: 999, origin_id: 1, target_id: 2 };
+  }
+
+  it("adds a third input when the last slot gets connected", () => {
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2"]);
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 1, true, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+      "lora_stack3",
+    ]);
+  });
+
+  it("does not add an input when a non-last slot gets connected", () => {
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2", "lora_stack3"]);
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 0, true, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+      "lora_stack3",
+    ]);
+  });
+
+  it("removes a disconnected middle slot and renumbers", () => {
+    // Simulates a real LiteGraph disconnect event: it fires only for slots that
+    // had a link, and input.link has already been cleared before the event fires.
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2", "lora_stack3"]);
+    node.inputs[0].link = 11;
+    node.inputs[1].link = null; // slot 2 was just disconnected
+    node.inputs[2].link = 13;
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 1, false, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+    ]);
+  });
+
+  it("keeps the last slot when it is disconnected", () => {
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2", "lora_stack3"]);
+    node.inputs[0].link = 11;
+    node.inputs[1].link = 12;
+    node.inputs[2].link = null; // last slot was just disconnected
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 2, false, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+      "lora_stack3",
+    ]);
+    expect(node.removeInput).not.toHaveBeenCalled();
+  });
+
+  it("keeps at least two inputs when disconnecting", () => {
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2"]);
+    node.inputs[0].link = 11;
+    node.inputs[1].link = null; // slot 2 was just disconnected
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 1, false, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+    ]);
+    expect(node.removeInput).not.toHaveBeenCalled();
+  });
+
+  it("does nothing while the graph is being configured", () => {
+    appMock.configuringGraph = true;
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack1", "lora_stack2"]);
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 1, true, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+    ]);
+    expect(node.addInput).not.toHaveBeenCalled();
+  });
+
+  it("leaves legacy lora_stack_a/b inputs untouched", () => {
+    const nodeType = createNodeType();
+    const node = createNode(["lora_stack_a", "lora_stack_b"]);
+    node.onConnectionsChange = nodeType.prototype.onConnectionsChange;
+
+    node.onConnectionsChange(1, 0, true, makeLinkInfo());
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack_a",
+      "lora_stack_b",
+    ]);
+    expect(node.addInput).not.toHaveBeenCalled();
+  });
+
+  it("ensures two numbered inputs exist on creation", () => {
+    const node = createNode([]);
+    extension.nodeCreated(node, {});
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack1",
+      "lora_stack2",
+    ]);
+  });
+
+  it("does not add numbered inputs to legacy workflows", () => {
+    const node = createNode(["lora_stack_a", "lora_stack_b"]);
+    extension.nodeCreated(node, {});
+
+    expect(node.inputs.map((input) => input.name)).toEqual([
+      "lora_stack_a",
+      "lora_stack_b",
+    ]);
+  });
+});

tests/frontend/managers/BulkManager.contentRating.test.js

@@ -0,0 +1,133 @@
+import { describe, it, beforeEach, expect, vi } from 'vitest';
+
+const showToastMock = vi.fn();
+const translateMock = vi.fn((key, params, fallback) => (typeof fallback === 'string' ? fallback : key));
+const getNSFWLevelNameMock = vi.fn((level) => {
+  if (level >= 16) return 'XXX';
+  if (level >= 8) return 'X';
+  if (level >= 4) return 'R';
+  if (level >= 2) return 'PG13';
+  if (level >= 1) return 'PG';
+  return 'Unknown';
+});
+
+const loadingManagerStub = {
+  showSimpleLoading: vi.fn(),
+  showCancelButton: vi.fn(),
+  hide: vi.fn(),
+};
+
+const stateStub = {
+  currentPageType: 'recipes',
+  bulkMode: false,
+  selectedModels: new Set(),
+  loadingManager: loadingManagerStub,
+  virtualScroller: { updateSingleItem: vi.fn() },
+  global: { settings: {} },
+};
+
+const saveModelMetadataMock = vi.fn();
+const getModelApiClientMock = vi.fn(() => ({ saveModelMetadata: saveModelMetadataMock }));
+const updateRecipeMetadataMock = vi.fn(() => Promise.resolve({ success: true }));
+
+vi.mock('../../../static/js/state/index.js', () => ({
+  state: stateStub,
+  getCurrentPageState: vi.fn(),
+}));
+
+vi.mock('../../../static/js/utils/uiHelpers.js', () => ({
+  showToast: showToastMock,
+  copyToClipboard: vi.fn(),
+  sendLoraToWorkflow: vi.fn(),
+  sendEmbeddingToWorkflow: vi.fn(),
+  buildLoraSyntax: vi.fn(),
+  getNSFWLevelName: getNSFWLevelNameMock,
+}));
+
+vi.mock('../../../static/js/api/modelApiFactory.js', () => ({
+  getModelApiClient: getModelApiClientMock,
+  resetAndReload: vi.fn(),
+}));
+
+vi.mock('../../../static/js/api/recipeApi.js', () => ({
+  RecipeSidebarApiClient: class {},
+  updateRecipeMetadata: updateRecipeMetadataMock,
+  extractRecipeId: vi.fn(),
+}));
+
+vi.mock('../../../static/js/api/apiConfig.js', () => ({
+  MODEL_TYPES: { LORA: 'loras', CHECKPOINT: 'checkpoints', EMBEDDING: 'embeddings' },
+  MODEL_CONFIG: {},
+}));
+
+vi.mock('../../../static/js/managers/ModalManager.js', () => ({
+  modalManager: { showModal: vi.fn(), closeModal: vi.fn() },
+}));
+
+vi.mock('../../../static/js/components/shared/ModelCard.js', () => ({
+  updateCardsForBulkMode: vi.fn(),
+}));
+
+vi.mock('../../../static/js/utils/i18nHelpers.js', () => ({
+  translate: translateMock,
+}));
+
+vi.mock('../../../static/js/utils/priorityTagHelpers.js', () => ({
+  getPriorityTagSuggestions: vi.fn(),
+}));
+
+vi.mock('../../../static/js/components/shared/NsfwLevelSelector.js', () => ({
+  getNsfwLevelSelector: vi.fn(),
+}));
+
+describe('BulkManager bulk content rating', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    stateStub.currentPageType = 'recipes';
+    stateStub.bulkMode = false;
+    stateStub.selectedModels.clear();
+    saveModelMetadataMock.mockResolvedValue(undefined);
+    updateRecipeMetadataMock.mockResolvedValue({ success: true });
+  });
+
+  async function createBulkManager() {
+    const { BulkManager } = await import('../../../static/js/managers/BulkManager.js');
+    return new BulkManager();
+  }
+
+  it('exposes the content rating action on the recipes page action config', async () => {
+    const bulk = await createBulkManager();
+    expect(bulk.actionConfig.recipes.setContentRating).toBe(true);
+  });
+
+  it('persists the rating through the recipe API when on the recipes page', async () => {
+    const bulk = await createBulkManager();
+    stateStub.currentPageType = 'recipes';
+    stateStub.selectedModels.add('/recipes/test.webp');
+
+    const ok = await bulk.setBulkContentRating(4, ['/recipes/test.webp']);
+
+    expect(ok).toBe(true);
+    expect(updateRecipeMetadataMock).toHaveBeenCalledWith('/recipes/test.webp', { preview_nsfw_level: 4 });
+    expect(updateRecipeMetadataMock).toHaveBeenCalledTimes(1);
+    expect(saveModelMetadataMock).not.toHaveBeenCalled();
+    expect(showToastMock).toHaveBeenCalledWith(
+      'toast.models.bulkContentRatingSet',
+      { count: 1, level: 'R' },
+      'success'
+    );
+  });
+
+  it('persists the rating through the model API on model pages', async () => {
+    const bulk = await createBulkManager();
+    stateStub.currentPageType = 'loras';
+    stateStub.selectedModels.add('/models/test.safetensors');
+
+    const ok = await bulk.setBulkContentRating(8, ['/models/test.safetensors']);
+
+    expect(ok).toBe(true);
+    expect(saveModelMetadataMock).toHaveBeenCalledWith('/models/test.safetensors', { preview_nsfw_level: 8 });
+    expect(saveModelMetadataMock).toHaveBeenCalledTimes(1);
+    expect(updateRecipeMetadataMock).not.toHaveBeenCalled();
+  });
+});

tests/nodes/test_lora_stack_combiner.py

@@ -1,4 +1,11 @@
-from py.nodes.lora_stack_combiner import LoraStackCombinerLM
+import types
+
+import pytest
+
+from py.nodes.lora_stack_combiner import (
+    LoraStackCombinerLM,
+    _LoraStackOptionalInputs,
+)
 
 
 def test_combine_stacks_preserves_order():
@@ -49,3 +56,109 @@ def test_combine_stacks_allows_duplicate_entries():
     (combined_stack,) = node.combine_stacks([duplicate_entry], [duplicate_entry])
 
     assert combined_stack == [duplicate_entry, duplicate_entry]
+
+
+def test_combine_stacks_returns_empty_when_both_unconnected():
+    node = LoraStackCombinerLM()
+
+    (combined_stack,) = node.combine_stacks()
+
+    assert combined_stack == []
+
+
+def test_combine_stacks_returns_other_when_one_unconnected():
+    node = LoraStackCombinerLM()
+    stack_a = [("folder/a.safetensors", 0.7, 0.6)]
+
+    (combined_stack_a,) = node.combine_stacks(lora_stack1=stack_a)
+    (combined_stack_b,) = node.combine_stacks(lora_stack2=stack_a)
+
+    assert combined_stack_a == stack_a
+    assert combined_stack_b == stack_a
+
+
+def test_combine_stacks_with_dynamic_third_slot():
+    node = LoraStackCombinerLM()
+    stack_a = [("folder/a.safetensors", 0.7, 0.6)]
+    stack_b = [("folder/b.safetensors", 0.8, 0.8)]
+    stack_c = [("folder/c.safetensors", 1.0, 0.9)]
+
+    (combined_stack,) = node.combine_stacks(
+        lora_stack1=stack_a, lora_stack2=stack_b, lora_stack3=stack_c
+    )
+
+    assert combined_stack == stack_a + stack_b + stack_c
+
+
+def test_combine_stacks_orders_by_slot_number_not_call_order():
+    node = LoraStackCombinerLM()
+    stack_a = [("folder/a.safetensors", 0.7, 0.6)]
+    stack_b = [("folder/b.safetensors", 0.8, 0.8)]
+    stack_c = [("folder/c.safetensors", 1.0, 0.9)]
+
+    (combined_stack,) = node.combine_stacks(
+        lora_stack3=stack_c, lora_stack2=stack_b, lora_stack1=stack_a
+    )
+
+    assert combined_stack == stack_a + stack_b + stack_c
+
+
+def test_combine_stacks_accepts_only_dynamic_slot():
+    node = LoraStackCombinerLM()
+    stack_c = [("folder/c.safetensors", 1.0, 0.9)]
+
+    (combined_stack,) = node.combine_stacks(lora_stack3=stack_c)
+
+    assert combined_stack == stack_c
+
+
+def test_combine_stacks_handles_legacy_input_names():
+    node = LoraStackCombinerLM()
+    stack_a = [("folder/a.safetensors", 0.7, 0.6)]
+    stack_b = [("folder/b.safetensors", 0.8, 0.8)]
+
+    (combined_stack,) = node.combine_stacks(lora_stack_a=stack_a, lora_stack_b=stack_b)
+
+    assert combined_stack == stack_a + stack_b
+
+
+def test_input_types_exposes_two_default_slots():
+    input_types = LoraStackCombinerLM.INPUT_TYPES()
+
+    assert set(input_types["optional"]) == {"lora_stack1", "lora_stack2"}
+    assert input_types["optional"]["lora_stack1"][0] == "LORA_STACK"
+    assert input_types["optional"]["lora_stack2"][0] == "LORA_STACK"
+
+
+def test_input_types_recognizes_dynamic_slots_from_get_input_info(monkeypatch):
+    frames = [None, None, types.SimpleNamespace(function="get_input_info")]
+    monkeypatch.setattr(
+        "py.nodes.lora_stack_combiner.inspect.stack", lambda: frames
+    )
+
+    input_types = LoraStackCombinerLM.INPUT_TYPES()
+    optional = input_types["optional"]
+
+    assert "lora_stack3" in optional
+    assert optional["lora_stack3"][0] == "LORA_STACK"
+    assert "lora_stack25" in optional
+    assert optional["lora_stack25"][0] == "LORA_STACK"
+
+
+def test_lora_stack_optional_inputs_proxy():
+    proxy = _LoraStackOptionalInputs({"lora_stack1": ("LORA_STACK", {})})
+
+    assert "lora_stack1" in proxy
+    assert "lora_stack2" in proxy
+    assert "lora_stack10" in proxy
+    assert "lora_stack_a" in proxy
+    assert "lora_stack" not in proxy
+    assert "lora_stacka" not in proxy
+    assert "lora_stack_1" not in proxy
+    assert "text" not in proxy
+
+    assert proxy["lora_stack1"][0] == "LORA_STACK"
+    assert proxy["lora_stack5"][0] == "LORA_STACK"
+
+    with pytest.raises(KeyError):
+        proxy["not_a_stack"]

tests/routes/test_misc_routes.py

@@ -900,18 +900,28 @@ class FakeMetadataProvider:
     async def get_model_versions(self, _model_id):
         return {"modelVersions": [], "name": "", "type": "lora"}
 
-    async def get_user_models(self, _username):
-        return []
+    async def get_user_models(self, _username, cursor=None):
+        return {"items": [], "nextCursor": None}
+
+    async def get_creator_model_count(self, _username):
+        return None
 
 
 class FakeUserModelsProvider(FakeMetadataProvider):
-    def __init__(self, models):
+    def __init__(self, models, next_cursor=None, estimated_total=None):
         self.models = models
+        self.next_cursor = next_cursor
+        self.estimated_total = estimated_total
         self.received_usernames: list[str] = []
+        self.received_cursors: list = []
 
-    async def get_user_models(self, username):
+    async def get_user_models(self, username, cursor=None):
         self.received_usernames.append(username)
-        return self.models
+        self.received_cursors.append(cursor)
+        return {"items": self.models, "nextCursor": self.next_cursor}
+
+    async def get_creator_model_count(self, _username):
+        return self.estimated_total
 
 
 async def fake_metadata_provider_factory():
@@ -1286,6 +1296,88 @@ async def test_get_civitai_user_models_requires_username():
     assert "username" in payload["error"].lower()
 
 
+@pytest.mark.asyncio
+async def test_get_civitai_user_models_returns_pagination_fields():
+    models = [
+        {
+            "id": 1,
+            "name": "Model A",
+            "type": "LORA",
+            "tags": [],
+            "modelVersions": [
+                {"id": 100, "name": "v1", "images": [{"url": "http://example.com/a.jpg"}]},
+            ],
+        },
+        {
+            "id": 2,
+            "name": "Unsupported",
+            "type": "Other",
+            "modelVersions": [{"id": 200, "name": "v1"}],
+        },
+    ]
+
+    provider = FakeUserModelsProvider(models, next_cursor="cursor-token", estimated_total=2140)
+
+    async def provider_factory():
+        return provider
+
+    handler = ModelLibraryHandler(
+        ServiceRegistryAdapter(
+            get_lora_scanner=fake_scanner_factory,
+            get_checkpoint_scanner=fake_scanner_factory,
+            get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
+        ),
+        metadata_provider_factory=provider_factory,
+    )
+
+    response = await handler.get_civitai_user_models(
+        FakeRequest(query={"username": "pixel"})
+    )
+    payload = json.loads(response.text)
+
+    assert response.status == 200
+    assert payload["success"] is True
+    # modelCount only counts models surviving the type filter
+    assert payload["modelCount"] == 1
+    assert payload["nextCursor"] == "cursor-token"
+    assert payload["hasMore"] is True
+    # first page includes the estimated total
+    assert payload["estimatedTotal"] == 2140
+    assert provider.received_cursors == [None]
+
+
+@pytest.mark.asyncio
+async def test_get_civitai_user_models_passes_cursor_and_omits_estimate():
+    provider = FakeUserModelsProvider([], next_cursor=None, estimated_total=999)
+
+    async def provider_factory():
+        return provider
+
+    handler = ModelLibraryHandler(
+        ServiceRegistryAdapter(
+            get_lora_scanner=fake_scanner_factory,
+            get_checkpoint_scanner=fake_scanner_factory,
+            get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
+        ),
+        metadata_provider_factory=provider_factory,
+    )
+
+    response = await handler.get_civitai_user_models(
+        FakeRequest(query={"username": "pixel", "cursor": "opaque-token"})
+    )
+    payload = json.loads(response.text)
+
+    assert response.status == 200
+    assert payload["success"] is True
+    assert payload["nextCursor"] is None
+    assert payload["hasMore"] is False
+    # cursor requests must not include the estimated total
+    assert payload["estimatedTotal"] is None
+    assert provider.received_cursors == ["opaque-token"]
+
+
 def test_ensure_handler_mapping_caches_result():
     call_records = []
 

tests/services/test_base_model_service.py

@@ -183,7 +183,7 @@ class FakeCache:
     def __init__(self, items):
         self.items = list(items)
 
-    async def get_sorted_data(self, sort_key, order):
+    async def get_sorted_data(self, sort_key, order, seed=None):
         if sort_key == "name":
             data = sorted(self.items, key=lambda x: x["model_name"].lower())
             if order == "desc":

tests/services/test_check_pending_models.py

@@ -363,6 +363,148 @@ async def test_check_pending_models_handles_corrupted_progress_file(
     assert result["pending_count"] == 1
 
 
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("tmp_path")
+async def test_check_pending_models_uses_bulk_folder_index_for_large_libraries(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    settings_manager,
+):
+    """For >1000 candidates the pre-check scans the library root once instead of
+    probing every folder individually."""
+
+    ws_manager = RecordingWebSocketManager()
+    manager = download_module.DownloadManager(ws_manager=ws_manager)
+
+    monkeypatch.setitem(settings_manager.settings, "example_images_path", str(tmp_path))
+
+    # 1500 unprocessed models triggers the bulk lookup path
+    models = [
+        {"sha256": f"{i:064x}", "model_name": f"Model {i}"}
+        for i in range(1500)
+    ]
+
+    # Create folders with files for the first 500 models
+    for i in range(500):
+        model_dir = tmp_path / f"{i:064x}"
+        model_dir.mkdir()
+        (model_dir / "image_0.png").write_text("data")
+
+    _patch_scanners(monkeypatch, lora_scanner=StubScanner(models))
+
+    per_model_checks = 0
+
+    def counting_model_directory_has_files(path: str) -> bool:
+        nonlocal per_model_checks
+        per_model_checks += 1
+        return False
+
+    monkeypatch.setattr(
+        download_module,
+        "_model_directory_has_files",
+        counting_model_directory_has_files,
+    )
+
+    result = await manager.check_pending_models(["lora"])
+
+    assert result["success"] is True
+    assert result["total_models"] == 1500
+    assert result["pending_count"] == 1000
+    assert result["needs_download"] is True
+    # The per-folder check should not be used once we cross the threshold.
+    assert per_model_checks == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("tmp_path")
+async def test_check_pending_models_uses_per_folder_check_for_small_candidate_sets(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    settings_manager,
+):
+    """For <=1000 candidates the pre-check keeps the accurate per-folder path."""
+
+    ws_manager = RecordingWebSocketManager()
+    manager = download_module.DownloadManager(ws_manager=ws_manager)
+
+    monkeypatch.setitem(settings_manager.settings, "example_images_path", str(tmp_path))
+
+    models = [
+        {"sha256": f"{i:064x}", "model_name": f"Model {i}"}
+        for i in range(500)
+    ]
+
+    # Create folders with files for the first 200 models
+    for i in range(200):
+        model_dir = tmp_path / f"{i:064x}"
+        model_dir.mkdir()
+        (model_dir / "image_0.png").write_text("data")
+
+    _patch_scanners(monkeypatch, lora_scanner=StubScanner(models))
+
+    per_model_checks = 0
+    original_has_files = download_module._model_directory_has_files
+
+    def counting_model_directory_has_files(path: str) -> bool:
+        nonlocal per_model_checks
+        per_model_checks += 1
+        return original_has_files(path)
+
+    monkeypatch.setattr(
+        download_module,
+        "_model_directory_has_files",
+        counting_model_directory_has_files,
+    )
+
+    result = await manager.check_pending_models(["lora"])
+
+    assert result["success"] is True
+    assert result["total_models"] == 500
+    assert result["pending_count"] == 300
+    assert result["needs_download"] is True
+    # Per-folder path should run once per candidate.
+    assert per_model_checks == 500
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("tmp_path")
+async def test_check_pending_models_bulk_index_includes_legacy_folders(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    settings_manager,
+):
+    """In multi-library mode the bulk index also scans the legacy root so models
+    whose folders have not been consolidated yet are not reported pending."""
+
+    ws_manager = RecordingWebSocketManager()
+    manager = download_module.DownloadManager(ws_manager=ws_manager)
+
+    monkeypatch.setitem(settings_manager.settings, "example_images_path", str(tmp_path))
+    monkeypatch.setitem(settings_manager.settings, "libraries", {"default": {}, "extra": {}})
+    monkeypatch.setitem(settings_manager.settings, "active_library", "extra")
+
+    # 1500 unprocessed models triggers the bulk lookup path
+    models = [
+        {"sha256": f"{i:064x}", "model_name": f"Model {i}"}
+        for i in range(1500)
+    ]
+
+    # Folders live at the LEGACY root/<hash> path (not yet consolidated)
+    for i in range(500):
+        model_dir = tmp_path / f"{i:064x}"
+        model_dir.mkdir()
+        (model_dir / "image_0.png").write_text("data")
+
+    _patch_scanners(monkeypatch, lora_scanner=StubScanner(models))
+
+    result = await manager.check_pending_models(["lora"])
+
+    assert result["success"] is True
+    assert result["total_models"] == 1500
+    assert result["pending_count"] == 1000
+    assert result["needs_download"] is True
+
+
 @pytest.fixture
 def settings_manager():
     return get_settings_manager()

tests/services/test_civitai_client.py

@@ -35,9 +35,11 @@ class DummyDownloader:
 def reset_singletons():
     CivitaiClient._instance = None
     ModelMetadataProviderManager._instance = None
+    civitai_client_module._creator_model_count_cache.clear()
     yield
     CivitaiClient._instance = None
     ModelMetadataProviderManager._instance = None
+    civitai_client_module._creator_model_count_cache.clear()
 
 
 @pytest.fixture
@@ -622,3 +624,162 @@ async def test_get_image_info_handles_invalid_id(monkeypatch, downloader, caplog
 
     assert result is None
     assert "Invalid image ID format" in caplog.text
+
+
+async def test_get_user_models_requests_first_page_with_stable_params(downloader):
+    request_calls = []
+
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        request_calls.append({"method": method, "url": url, "kwargs": kwargs})
+        return True, {
+            "items": [
+                {
+                    "id": 1,
+                    "modelVersions": [
+                        {"id": 100, "images": [{"meta": {"comfy": {"x": 1}}}]}
+                    ],
+                }
+            ],
+            "metadata": {"nextCursor": "next-token"},
+        }
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    result = await client.get_user_models("pixel")
+
+    assert result is not None
+    assert result["nextCursor"] == "next-token"
+    assert len(result["items"]) == 1
+    # comfy metadata is still stripped
+    assert "comfy" not in result["items"][0]["modelVersions"][0]["images"][0]["meta"]
+
+    call = request_calls[0]
+    assert call["method"] == "GET"
+    assert call["url"] == "https://civitai.red/api/v1/models"
+    params = call["kwargs"]["params"]
+    assert params["username"] == "pixel"
+    assert params["nsfw"] == "true"
+    assert params["limit"] == 100
+    assert params["sort"] == "Newest"
+    assert params["period"] == "AllTime"
+    assert "cursor" not in params
+
+
+async def test_get_user_models_passes_cursor_and_stringifies_next_cursor(downloader):
+    request_calls = []
+
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        request_calls.append(kwargs)
+        return True, {"items": [], "metadata": {"nextCursor": 12345}}
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    result = await client.get_user_models("pixel", cursor="opaque-token")
+
+    assert request_calls[0]["params"]["cursor"] == "opaque-token"
+    assert result == {"items": [], "nextCursor": "12345"}
+
+
+async def test_get_user_models_without_next_cursor_returns_none_cursor(downloader):
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        return True, {"items": [{"id": 1, "modelVersions": []}], "metadata": {}}
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    result = await client.get_user_models("pixel")
+
+    assert result == {"items": [{"id": 1, "modelVersions": []}], "nextCursor": None}
+
+
+async def test_get_user_models_failure_returns_none(downloader):
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        return False, "500 server error"
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    result = await client.get_user_models("pixel")
+
+    assert result is None
+
+
+async def test_get_creator_model_count_matches_exact_username(downloader):
+    request_calls = []
+
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        request_calls.append({"url": url, "kwargs": kwargs})
+        return True, {
+            "items": [
+                {"username": "pixelart", "modelCount": 5},
+                {"username": "Pixel", "modelCount": 2140},
+            ]
+        }
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    count = await client.get_creator_model_count("pixel")
+
+    assert count == 2140
+    assert request_calls[0]["url"] == "https://civitai.red/api/v1/creators"
+    assert request_calls[0]["kwargs"]["params"] == {"query": "pixel", "limit": 10}
+
+
+async def test_get_creator_model_count_without_exact_match_returns_none(downloader):
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        return True, {"items": [{"username": "pixelart", "modelCount": 5}]}
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    count = await client.get_creator_model_count("pixel")
+
+    assert count is None
+
+
+async def test_get_creator_model_count_caches_results(downloader):
+    request_count = 0
+
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        nonlocal request_count
+        request_count += 1
+        return True, {"items": [{"username": "pixel", "modelCount": 42}]}
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+
+    assert await client.get_creator_model_count("pixel") == 42
+    # case-insensitive cache key, second call served from cache
+    assert await client.get_creator_model_count("Pixel") == 42
+    assert request_count == 1
+
+
+async def test_get_creator_model_count_caches_failures(downloader):
+    request_count = 0
+
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        nonlocal request_count
+        request_count += 1
+        return False, "500 server error"
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+
+    assert await client.get_creator_model_count("pixel") is None
+    assert await client.get_creator_model_count("pixel") is None
+    assert request_count == 1
+
+
+async def test_get_creator_model_count_never_raises(downloader):
+    async def fake_make_request(method, url, use_auth=True, **kwargs):
+        return True, "unexpected non-dict payload"
+
+    downloader.make_request = fake_make_request
+
+    client = await CivitaiClient.get_instance()
+    assert await client.get_creator_model_count("pixel") is None

tests/services/test_example_images_download_manager_async.py

@@ -26,6 +26,7 @@ class StubScanner:
 
     def __init__(self, models: list[dict]) -> None:
         self._cache = SimpleNamespace(raw_data=models)
+        self.sync_calls: list[tuple[str, dict]] = []
 
     async def get_cached_data(self):
         return self._cache
@@ -38,6 +39,14 @@ class StubScanner:
                 break
         return True
 
+    async def sync_cache_from_metadata(self, file_path: str, metadata: dict) -> bool:
+        self.sync_calls.append((file_path, metadata))
+        for index, model in enumerate(self._cache.raw_data):
+            if model.get("file_path") == metadata.get("file_path"):
+                self._cache.raw_data[index] = metadata
+                break
+        return True
+
 
 def _patch_scanner(monkeypatch: pytest.MonkeyPatch, scanner: StubScanner) -> None:
     async def _get_lora_scanner(cls):
@@ -520,7 +529,8 @@ async def test_not_found_example_images_are_cleaned(
 
     model_dir = images_root / model_hash
     model_dir.mkdir(parents=True, exist_ok=True)
-    (model_dir / "image_0.png").write_bytes(b"first")
+    # Pre-existing file collides with the valid image index (1) so the
+    # pre-download existence check must skip it without a network request
     (model_dir / "image_1.png").write_bytes(b"second")
 
     async def fake_process_local_examples(*_args, **_kwargs):
@@ -588,6 +598,9 @@ async def test_not_found_example_images_are_cleaned(
     assert missing_url in downloader.calls
     assert manager._progress["failed_models"] == {model_hash}
     assert model_hash in manager._progress["processed_models"]
+    assert scanner.sync_calls
+    assert len(scanner.sync_calls) == 1
+    assert scanner.sync_calls[0][0] == str(model_path)
 
     remaining_images = model_metadata["civitai"]["images"]
     assert remaining_images == [
@@ -596,11 +609,188 @@ async def test_not_found_example_images_are_cleaned(
     ]
 
     files = sorted(p.name for p in model_dir.iterdir())
-    assert files == ["image_0.png", "image_1.png"]
-    assert (model_dir / "image_0.png").read_bytes() == b"first"
+    assert files == ["image_1.png"]
     assert (model_dir / "image_1.png").read_bytes() == b"second"
 
 
+async def test_failed_models_retried_when_explicitly_targeted(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    settings_manager,
+):
+    ws_manager = RecordingWebSocketManager()
+    manager = download_module.DownloadManager(ws_manager=ws_manager)
+
+    images_root = tmp_path / "examples"
+    monkeypatch.setitem(settings_manager.settings, "example_images_path", str(images_root))
+
+    model_hash = "a" * 64
+    model_path = tmp_path / "model.safetensors"
+    model_path.write_text("data", encoding="utf-8")
+
+    model_metadata = {
+        "sha256": model_hash,
+        "model_name": "Failed Example",
+        "file_path": str(model_path),
+        "file_name": "model.safetensors",
+        "civitai": {"images": [{"url": "https://example.com/valid.png"}]},
+    }
+
+    scanner = StubScanner([model_metadata.copy()])
+    _patch_scanner(monkeypatch, scanner)
+
+    # Persist a previous failure so the skip path is exercised
+    images_root.mkdir(parents=True, exist_ok=True)
+    (images_root / ".download_progress.json").write_text(
+        json.dumps(
+            {
+                "failed_models": [model_hash],
+                "processed_models": [],
+                "rate_limited_models": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    async def fake_process_local_examples(*_args, **_kwargs):
+        return False
+
+    async def fake_get_updated_model(model_hash_arg, _scanner):
+        return model_metadata
+
+    class DownloaderStub:
+        def __init__(self):
+            self.calls: list[str] = []
+
+        async def download_to_memory(self, url, *_args, **_kwargs):
+            self.calls.append(url)
+            return True, b"\x89PNG\r\n\x1a\n", {"content-type": "image/png"}
+
+    downloader = DownloaderStub()
+
+    async def fake_get_downloader():
+        return downloader
+
+    monkeypatch.setattr(
+        download_module.ExampleImagesProcessor,
+        "process_local_examples",
+        staticmethod(fake_process_local_examples),
+    )
+    monkeypatch.setattr(
+        download_module.MetadataUpdater,
+        "get_updated_model",
+        staticmethod(fake_get_updated_model),
+    )
+    monkeypatch.setattr(download_module, "get_downloader", fake_get_downloader)
+
+    # Without explicit hashes the previously failed model is skipped
+    skipped_manager = download_module.DownloadManager(ws_manager=RecordingWebSocketManager())
+    result = await skipped_manager.start_download({"model_types": ["lora"], "delay": 0})
+    assert result["success"] is True
+    if skipped_manager._download_task is not None:
+        await asyncio.wait_for(skipped_manager._download_task, timeout=1)
+    assert downloader.calls == []
+
+    # With explicit hashes the previously failed model is retried and cleared
+    result = await manager.start_download(
+        {"model_types": ["lora"], "delay": 0, "model_hashes": [model_hash]}
+    )
+    assert result["success"] is True
+    if manager._download_task is not None:
+        await asyncio.wait_for(manager._download_task, timeout=1)
+    assert downloader.calls == ["https://example.com/valid.png"]
+    assert manager._progress["failed_models"] == set()
+    assert model_hash in manager._progress["processed_models"]
+
+
+async def test_explicit_targets_fill_partial_example_gaps(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path,
+    settings_manager,
+):
+    ws_manager = RecordingWebSocketManager()
+
+    images_root = tmp_path / "examples"
+    monkeypatch.setitem(settings_manager.settings, "example_images_path", str(images_root))
+
+    model_hash = "b" * 64
+    model_path = tmp_path / "model.safetensors"
+    model_path.write_text("data", encoding="utf-8")
+
+    model_metadata = {
+        "sha256": model_hash,
+        "model_name": "Partial Example",
+        "file_path": str(model_path),
+        "file_name": "model.safetensors",
+        "civitai": {
+            "images": [
+                {"url": "https://example.com/first.png"},
+                {"url": "https://example.com/second.png"},
+            ]
+        },
+    }
+
+    scanner = StubScanner([model_metadata.copy()])
+    _patch_scanner(monkeypatch, scanner)
+
+    # Simulate a partially populated folder: index 0 already downloaded
+    model_dir = images_root / model_hash
+    model_dir.mkdir(parents=True, exist_ok=True)
+    (model_dir / "image_0.png").write_bytes(b"existing")
+
+    async def fake_process_local_examples(*_args, **_kwargs):
+        return False
+
+    async def fake_get_updated_model(model_hash_arg, _scanner):
+        return model_metadata
+
+    class DownloaderStub:
+        def __init__(self):
+            self.calls: list[str] = []
+
+        async def download_to_memory(self, url, *_args, **_kwargs):
+            self.calls.append(url)
+            return True, b"\x89PNG\r\n\x1a\n", {"content-type": "image/png"}
+
+    downloader = DownloaderStub()
+
+    async def fake_get_downloader():
+        return downloader
+
+    monkeypatch.setattr(
+        download_module.ExampleImagesProcessor,
+        "process_local_examples",
+        staticmethod(fake_process_local_examples),
+    )
+    monkeypatch.setattr(
+        download_module.MetadataUpdater,
+        "get_updated_model",
+        staticmethod(fake_get_updated_model),
+    )
+    monkeypatch.setattr(download_module, "get_downloader", fake_get_downloader)
+
+    # Untargeted run treats the populated folder as done
+    untargeted = download_module.DownloadManager(ws_manager=RecordingWebSocketManager())
+    result = await untargeted.start_download({"model_types": ["lora"], "delay": 0})
+    assert result["success"] is True
+    if untargeted._download_task is not None:
+        await asyncio.wait_for(untargeted._download_task, timeout=1)
+    assert downloader.calls == []
+
+    # Explicitly targeted run fills only the missing index, skipping the
+    # existing file without a network request
+    targeted = download_module.DownloadManager(ws_manager=ws_manager)
+    result = await targeted.start_download(
+        {"model_types": ["lora"], "delay": 0, "model_hashes": [model_hash]}
+    )
+    assert result["success"] is True
+    if targeted._download_task is not None:
+        await asyncio.wait_for(targeted._download_task, timeout=1)
+    assert downloader.calls == ["https://example.com/second.png"]
+    assert (model_dir / "image_1.png").exists()
+    assert (model_dir / "image_0.png").read_bytes() == b"existing"
+
+
 @pytest.fixture
 def settings_manager():
     return get_settings_manager()

tests/services/test_model_scanner.py

@@ -884,7 +884,7 @@ async def test_sync_cache_conditional_resort_skipped(tmp_path: Path, monkeypatch
         raw_data=[dict(entry)], folders=[], name_display_mode="model_name"
     )
     await scanner._cache.resort()
-    scanner._cache._last_sort = ("name", "asc")  # name sort is active
+    scanner._cache._last_sort = ("name", "asc", None)  # name sort is active
     scanner._tags_count = {"alpha": 1}
     scanner._hash_index.add_entry("abc123", "/m/a.safetensors")
 
@@ -935,7 +935,7 @@ async def test_sync_cache_conditional_resort_triggered(tmp_path: Path, monkeypat
         raw_data=[dict(entry)], folders=[], name_display_mode="model_name"
     )
     await scanner._cache.resort()
-    scanner._cache._last_sort = ("name", "asc")
+    scanner._cache._last_sort = ("name", "asc", None)
     scanner._tags_count = {"alpha": 1}
     scanner._hash_index.add_entry("abc123", "/m/a.safetensors")
 

tests/services/test_model_sort.py

@@ -0,0 +1,97 @@
+"""Tests for sort parsing and the seeded random sort mode."""
+
+import asyncio
+
+import pytest
+
+from py.services.model_cache import ModelCache
+from py.services.model_query import ModelCacheRepository, SortParams
+
+
+def _make_cache(items):
+    return ModelCache(
+        raw_data=[
+            {
+                "file_path": f"/models/{name}.safetensors",
+                "file_name": f"{name}.safetensors",
+                "model_name": name,
+                "folder": "",
+                "size": 100,
+                "modified": 0.0,
+            }
+            for name in items
+        ],
+        folders=[],
+    )
+
+
+class TestParseSort:
+    def test_random_with_seed(self):
+        params = ModelCacheRepository.parse_sort("random:abc123")
+        assert params == SortParams(key="random", order="asc", seed="abc123")
+
+    def test_random_without_seed(self):
+        params = ModelCacheRepository.parse_sort("random")
+        assert params == SortParams(key="random", order="asc", seed=None)
+
+    def test_random_empty_seed_falls_back_to_none(self):
+        params = ModelCacheRepository.parse_sort("random:")
+        assert params.seed is None
+
+    def test_regular_sorts_unaffected(self):
+        params = ModelCacheRepository.parse_sort("name:desc")
+        assert params == SortParams(key="name", order="desc", seed=None)
+
+
+class TestRandomShuffle:
+    @pytest.mark.asyncio
+    async def test_same_seed_yields_same_order(self):
+        cache = _make_cache(["a", "b", "c", "d", "e"])
+        await asyncio.sleep(0)  # allow background resort task to run
+
+        first = await cache.get_sorted_data("random", "asc", "seed1")
+        second = await cache.get_sorted_data("random", "asc", "seed1")
+
+        assert [item["model_name"] for item in first] == [
+            item["model_name"] for item in second
+        ]
+
+    @pytest.mark.asyncio
+    async def test_different_seeds_yield_different_orders(self):
+        cache = _make_cache([f"m{i}" for i in range(20)])
+        await asyncio.sleep(0)
+
+        first = await cache.get_sorted_data("random", "asc", "seed-a")
+        second = await cache.get_sorted_data("random", "asc", "seed-b")
+
+        assert [item["model_name"] for item in first] != [
+            item["model_name"] for item in second
+        ]
+
+    @pytest.mark.asyncio
+    async def test_shuffle_is_a_permutation(self):
+        cache = _make_cache(["a", "b", "c", "d", "e"])
+        await asyncio.sleep(0)
+
+        shuffled = await cache.get_sorted_data("random", "asc", "seed")
+
+        assert sorted(item["model_name"] for item in shuffled) == [
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+        ]
+        assert len({item["file_path"] for item in shuffled}) == 5
+
+    @pytest.mark.asyncio
+    async def test_missing_seed_is_stable(self):
+        cache = _make_cache(["a", "b", "c", "d", "e"])
+        await asyncio.sleep(0)
+
+        first = await cache.get_sorted_data("random", "asc")
+        second = await cache.get_sorted_data("random", "asc")
+
+        assert [item["model_name"] for item in first] == [
+            item["model_name"] for item in second
+        ]

tests/utils/test_example_images_download_manager_unit.py

@@ -63,7 +63,7 @@ async def test_start_download_bootstraps_progress_and_task(
     release = asyncio.Event()
 
     async def fake_download(
-        self, output_dir, optimize, model_types, delay, library_name, force=False
+        self, output_dir, optimize, model_types, delay, library_name, force=False, model_hashes=None
     ):
         started.set()
         await release.wait()
@@ -93,6 +93,44 @@ async def test_start_download_bootstraps_progress_and_task(
     assert manager._progress["status"] == "completed"
 
 
+async def test_start_download_forwards_model_hashes(
+    monkeypatch: pytest.MonkeyPatch, tmp_path
+) -> None:
+    settings_manager = get_settings_manager()
+    settings_manager.settings["example_images_path"] = str(tmp_path)
+    settings_manager.settings["libraries"] = {"default": {}}
+    settings_manager.settings["active_library"] = "default"
+
+    manager = download_module.DownloadManager(ws_manager=RecordingWebSocketManager())
+
+    received: Dict[str, Any] = {}
+
+    async def fake_download(
+        self, output_dir, optimize, model_types, delay, library_name, force=False, model_hashes=None
+    ):
+        received["model_hashes"] = model_hashes
+        async with self._state_lock:
+            self._is_downloading = False
+            self._download_task = None
+        self._progress["status"] = "completed"
+
+    monkeypatch.setattr(
+        download_module.DownloadManager,
+        "_download_all_example_images",
+        fake_download,
+    )
+
+    result = await manager.start_download(
+        {"model_types": ["lora"], "delay": 0, "model_hashes": ["abc123", "def456"]}
+    )
+    assert result["success"] is True
+
+    task = manager._download_task
+    assert task is not None
+    await asyncio.wait_for(task, timeout=1)
+    assert received["model_hashes"] == ["abc123", "def456"]
+
+
 async def test_pause_and_resume_flow(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
     settings_manager = get_settings_manager()
     settings_manager.settings["example_images_path"] = str(tmp_path)

tests/utils/test_example_images_metadata.py

@@ -15,6 +15,7 @@ class StubScanner:
     def __init__(self, cache_items: List[Dict[str, Any]]) -> None:
         self.cache = SimpleNamespace(raw_data=cache_items)
         self.updates: List[Tuple[str, str, Dict[str, Any]]] = []
+        self.sync_updates: List[Tuple[str, Dict[str, Any]]] = []
 
     async def get_cached_data(self):
         return self.cache
@@ -23,6 +24,10 @@ class StubScanner:
         self.updates.append((old_path, new_path, metadata))
         return True
 
+    async def sync_cache_from_metadata(self, file_path: str, metadata: Dict[str, Any]) -> bool:
+        self.sync_updates.append((file_path, metadata))
+        return True
+
 
 @pytest.fixture(autouse=True)
 def patch_metadata_manager(monkeypatch: pytest.MonkeyPatch):
@@ -83,7 +88,7 @@ async def test_update_metadata_after_import_enriches_entries(monkeypatch: pytest
     assert custom[0]["type"] == "image"
 
     assert Path(patch_metadata_manager[0][0]) == model_file
-    assert scanner.updates
+    assert scanner.sync_updates
 
 
 @pytest.mark.asyncio
@@ -151,8 +156,8 @@ async def test_update_metadata_after_import_preserves_existing_metadata(
     assert saved_payload["civitai"]["trainedWords"] == ["foo"]
     assert {entry["id"] for entry in saved_payload["civitai"]["customImages"]} == {"existing-id", "new-id"}
 
-    assert scanner.updates
-    updated_metadata = scanner.updates[-1][2]
+    assert scanner.sync_updates
+    updated_metadata = scanner.sync_updates[-1][1]
     assert updated_metadata["civitai"]["images"] == existing_payload["civitai"]["images"]
     assert {entry["id"] for entry in updated_metadata["civitai"]["customImages"]} == {"existing-id", "new-id"}
 

tests/utils/test_example_images_processor_unit.py

@@ -100,6 +100,54 @@ def test_get_file_extension_media_type_hint_low_priority() -> None:
     assert ext == ".mp4"
 
 
+def test_example_image_file_exists_checks_plausible_extensions(tmp_path) -> None:
+    proc = processor_module.ExampleImagesProcessor
+    assert proc._example_image_file_exists(str(tmp_path), 0) is False
+    Path(tmp_path, "image_0.webp").write_bytes(b"x")
+    assert proc._example_image_file_exists(str(tmp_path), 0) is True
+    assert proc._example_image_file_exists(str(tmp_path), 1) is False
+
+
+def test_example_image_file_exists_video_hint_only_checks_video_extensions(tmp_path) -> None:
+    proc = processor_module.ExampleImagesProcessor
+    Path(tmp_path, "image_2.jpg").write_bytes(b"x")
+    # An existing image file must not satisfy a video-hinted lookup
+    assert proc._example_image_file_exists(str(tmp_path), 2, "video") is False
+    Path(tmp_path, "image_2.mp4").write_bytes(b"x")
+    assert proc._example_image_file_exists(str(tmp_path), 2, "video") is True
+
+
+async def test_download_model_images_with_tracking_skips_existing_files(tmp_path) -> None:
+    proc = processor_module.ExampleImagesProcessor
+    images = [
+        {"url": "https://image.civitai.com/a/b", "type": "image"},
+        {"url": "https://image.civitai.com/c/d", "type": "image"},
+    ]
+    Path(tmp_path, "image_0.jpg").write_bytes(b"existing")
+
+    class RecordingDownloader:
+        def __init__(self) -> None:
+            self.calls: list[str] = []
+
+        async def download_to_memory(self, url, use_auth=False, return_headers=False):
+            self.calls.append(url)
+            return True, b"\xff\xd8\xff" + b"data", {}
+
+    downloader = RecordingDownloader()
+    success, is_stale, failed, rate_limited = await proc.download_model_images_with_tracking(
+        "hash", "model", images, str(tmp_path), False, downloader
+    )
+
+    assert success is True
+    assert is_stale is False
+    assert failed == []
+    assert rate_limited == []
+    # Only the missing image is requested; the existing one is skipped without a network call
+    assert len(downloader.calls) == 1
+    assert "c/d" in downloader.calls[0]
+    assert Path(tmp_path, "image_1.jpg").exists()
+
+
 class StubScanner:
     def __init__(self, models: list[Dict[str, Any]]) -> None:
         self._cache = SimpleNamespace(raw_data=models)

web/comfyui/lora_stack_dynamic_inputs.js

@@ -0,0 +1,127 @@
+import { app } from "../../scripts/app.js";
+
+/**
+ * Extension for LoraStackCombinerLM node to support dynamic lora_stack inputs.
+ * Defaults to two inputs; connecting the last slot adds a new empty one, and
+ * disconnecting a non-last slot removes it (at least two are always kept).
+ * Based on the dynamic input pattern from Impact Pack's Switch (Any) node.
+ */
+const STACK_INPUT_PATTERN = /^lora_stack\d+$/;
+
+app.registerExtension({
+    name: "Comfy.LoraManager.LoraStackCombiner",
+
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (nodeData.name !== "Lora Stack Combiner (LoraManager)") {
+            return;
+        }
+
+        const onConnectionsChange = nodeType.prototype.onConnectionsChange;
+        
+        nodeType.prototype.onConnectionsChange = function(type, index, connected, link_info) {
+            // Skip while the graph is being (re)configured (load, paste, subgraph ops)
+            if (app.configuringGraph) {
+                return onConnectionsChange?.apply?.(this, arguments);
+            }
+
+            const stackTrace = new Error().stack;
+            
+            // Skip during graph loading/pasting to avoid interference
+            if (stackTrace.includes('loadGraphData') || stackTrace.includes('pasteFromClipboard')) {
+                return onConnectionsChange?.apply?.(this, arguments);
+            }
+            
+            // Skip subgraph operations
+            if (stackTrace.includes('convertToSubgraph') || stackTrace.includes('Subgraph.configure')) {
+                return onConnectionsChange?.apply?.(this, arguments);
+            }
+            
+            if (!link_info) {
+                return onConnectionsChange?.apply?.(this, arguments);
+            }
+
+            // Handle input connections (type === 1)
+            if (type === 1) {
+                const input = this.inputs[index];
+                
+                // Only process numbered lora_stack inputs (legacy a/b slots are left untouched)
+                if (!input || !STACK_INPUT_PATTERN.test(input.name)) {
+                    return onConnectionsChange?.apply?.(this, arguments);
+                }
+
+                // Count existing numbered lora_stack inputs
+                let stackInputCount = 0;
+                for (const inp of this.inputs) {
+                    if (STACK_INPUT_PATTERN.test(inp.name)) {
+                        stackInputCount++;
+                    }
+                }
+
+                // Renumber all numbered lora_stack inputs sequentially
+                let slotIndex = 1;
+                for (const inp of this.inputs) {
+                    if (STACK_INPUT_PATTERN.test(inp.name)) {
+                        inp.name = `lora_stack${slotIndex}`;
+                        slotIndex++;
+                    }
+                }
+
+                // Add new input slot if connected and this was the last one
+                if (connected) {
+                    const lastStackIndex = stackInputCount;
+                    if (index === lastStackIndex || index === this.inputs.findIndex(i => i.name === `lora_stack${lastStackIndex}`)) {
+                        this.addInput(`lora_stack${slotIndex}`, "LORA_STACK", { 
+                            tooltip: "A LoRA stack to combine. Connect to add more inputs."
+                        });
+                    }
+                }
+
+                // Remove disconnected input slots (but keep at least two).
+                // LiteGraph fires this event only for slots that had a link, and
+                // it has already cleared input.link by the time the event fires,
+                // so the disconnected slot is always empty at this point.
+                if (!connected && stackInputCount > 2) {
+                    const disconnectedInput = this.inputs[index];
+                    if (disconnectedInput && STACK_INPUT_PATTERN.test(disconnectedInput.name)) {
+                        // Keep the last slot so there is always an empty slot to reconnect into
+                        const isLastStackSlot = index === this.inputs.findLastIndex(i => STACK_INPUT_PATTERN.test(i.name));
+                        if (!isLastStackSlot) {
+                            this.removeInput(index);
+                            
+                            // Renumber again after removal
+                            let newSlotIndex = 1;
+                            for (const inp of this.inputs) {
+                                if (STACK_INPUT_PATTERN.test(inp.name)) {
+                                    inp.name = `lora_stack${newSlotIndex}`;
+                                    newSlotIndex++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return onConnectionsChange?.apply?.(this, arguments);
+        };
+    },
+
+    nodeCreated(node, app) {
+        if (node.comfyClass !== "Lora Stack Combiner (LoraManager)") {
+            return;
+        }
+
+        // Leave legacy (a/b) workflows untouched
+        const hasLegacyInputs = node.inputs.some(inp => inp.name === "lora_stack_a" || inp.name === "lora_stack_b");
+        if (hasLegacyInputs) {
+            return;
+        }
+
+        // Ensure at least two numbered lora_stack inputs exist on creation
+        const stackInputCount = node.inputs.filter(inp => STACK_INPUT_PATTERN.test(inp.name)).length;
+        for (let i = stackInputCount + 1; i <= 2; i++) {
+            node.addInput(`lora_stack${i}`, "LORA_STACK", { 
+                tooltip: "A LoRA stack to combine. Connect to add more inputs."
+            });
+        }
+    }
+});