fix: cached LoRAs fully wired — dropdown discovers /data/loras/*.safetensors, loads direct from disk

- _community_lora_choices() scans bucket cache dir for .safetensors not
in registry, shows them with cache: prefix
- _load_lora_from_cache() loads safetensors by path, detects format
(ComfyUI/kohya/LoKR), converts, stores in _CUSTOM_LoRA
- _download_custom_lora() detects cache: prefix, skips download
- _generate_impl() handles cache: keys for the generate pipeline
- ~100 previously-invisible cached LoRAs now searchable in dropdown

app.py

@@ -1532,6 +1532,24 @@ def _download_custom_lora(url, scale=1.0, trigger="", description="", tags=""):
 
     On success the LoRA is also added to the community registry so other
     users can discover it via the searchable dropdown."""
+    # Handle cached LoRAs — load directly from local path, skip download.
+    if url.startswith("cache:"):
+        cache_path = url[len("cache:"):]
+        try:
+            key = _load_lora_from_cache(cache_path)
+        except gr.Error as _e:
+            return gr.update(value=f"**❌ {_e}**", visible=True)
+        except Exception as _e:
+            return gr.update(value=f"**❌ Unexpected error loading cached LoRA: {_e}**", visible=True)
+        n = len(_CUSTOM_LoRA[key])
+        fname = os.path.basename(cache_path)
+        note = f" (scale {scale:g}" + (f", trigger `{trigger}`)" if trigger else ")")
+        choices = _community_lora_choices()
+        _log(f"cached LoRA {fname} loaded ({n} modules)")
+        return (
+            gr.update(value=f"**✅ Loaded `{fname}`** — {n} modules, will apply on Generate{note}.", visible=True),
+            gr.update(choices=choices, value=url),
+        )
     try:
         repo, file = _parse_hf_link(url)
         if file is None:
@@ -1600,8 +1618,9 @@ def _community_lora_choices():
     """Return (label, value) pairs for the community LoRA dropdown.
 
     Sources: the JSON registry **plus** any ``.safetensors`` files already cached
-    in ``/data/loras/`` that aren't in the registry yet (from previous sessions
-    where the download happened before the registry existed)."""
+    in ``/data/loras/`` that aren't in the registry yet.  Cached files get a
+    ``cache:`` prefixed value so the download/load path can load them directly
+    without going through the URL → download flow."""
     import glob as _glob, os
     registry = _load_community_registry()
     known_urls = {e.get("url", "") for e in registry}
@@ -1617,22 +1636,70 @@ def _community_lora_choices():
             label += f" [{', '.join(tags[:3])}]"
         choices.append((label, entry.get("url", "")))
     # Auto-discover cached .safetensors files not yet in the registry.
-    for path in _glob.glob(os.path.join(_LORA_CACHE_DIR, "*.safetensors")):
+    for path in sorted(_glob.glob(os.path.join(_LORA_CACHE_DIR, "*.safetensors"))):
         fname = os.path.basename(path)
-        # Filename encoding: repo__file.safetensors (non-alnum → _)
-        # Try to reverse: strip .safetensors, split on __
+        # Check if this file is already represented in the registry by matching
+        # any URL that contains this filename.
+        if any(fname in url for url in known_urls):
+            continue
+        # Extract a readable name from the filename (strip .safetensors, replace _ with space)
         stem = fname[:-len(".safetensors")]
-        parts = stem.split("__", 1)
-        if len(parts) == 2:
-            repo = parts[0].replace("_", "/")  # best-effort reverse
-            file = parts[1]
-            url = f"https://huggingface.co/{repo}/resolve/main/{file}"
-            if url not in known_urls and (repo, file) not in known_keys:
-                name = repo.split("/")[-1]
-                choices.append((f"{name} (cached)", url))
+        label = stem.replace("_", " ")
+        choices.append((f"📦 {label}", f"cache:{path}"))
     return choices
 
 
+def _load_lora_from_cache(path):
+    """Load a cached .safetensors LoRA directly by file path.  Returns (repo, file) key
+    and populates ``_CUSTOM_LoRA`` so it can be merged on generate."""
+    import torch
+    from safetensors.torch import load_file as _load_sd
+    _t0 = time.time()
+    fname = os.path.basename(path)
+    # Use the filename as a synthetic (repo, file) key.
+    key = ("__cache__", fname)
+    if key in _CUSTOM_LoRA:
+        return key
+    try:
+        _raw = _load_sd(path)
+    except Exception as _e:
+        raise gr.Error(f"Couldn't load cached LoRA `{fname}`: {_e}")
+    # Detect format and convert.
+    _has_comfy = any(".lora_A." in _k for _k in _raw)
+    _has_kohya = any(".lora_down.weight" in _k or _k.startswith("lora_unet_") for _k in _raw)
+    _has_lokr = any(".lokr_w1" in _k or ".lokr_w1_a" in _k for _k in _raw)
+    if _has_comfy:
+        _sd = _convert_comfyui_h3_lora(_raw)
+    elif _has_lokr:
+        _sd = _convert_lokr_h3_lora(_raw)
+    elif _has_kohya:
+        _sd = _convert_kohya_h3_lora(_raw)
+    else:
+        raise gr.Error(f"`{fname}` doesn't look like a MiniMax-H3 LoRA.")
+    _pairs: dict[str, dict[str, torch.Tensor]] = {}
+    for _k, _v in _sd.items():
+        if ".lora_A." in _k:
+            _pairs.setdefault(_k.split(".lora_A.")[0], {})["A"] = _v
+        elif ".lora_B." in _k:
+            _pairs.setdefault(_k.split(".lora_B.")[0], {})["B"] = _v
+    _loaded = []
+    for _base, _pair in _pairs.items():
+        if "A" not in _pair or "B" not in _pair:
+            continue
+        _parts = _base.split(".")
+        _obj = PIPE.transformer
+        for _p in _parts:
+            _obj = _obj[int(_p)] if _p.isdigit() else getattr(_obj, _p)
+        _loaded.append((_obj, _pair["A"].to(_obj.weight.dtype), _pair["B"].to(_obj.weight.dtype)))
+    if not _loaded:
+        raise gr.Error(f"`{fname}` converted to no usable modules.")
+    del _sd, _pairs, _raw
+    import gc as _gc; _gc.collect()
+    _CUSTOM_LoRA[key] = _loaded
+    _log(f"cached LoRA {fname} loaded ({len(_loaded)} modules in {time.time() - _t0:.1f}s)")
+    return key
+
+
 def _submit_community_lora(url, scale, trigger, description, tags):
     """Add a LoRA to the community registry and return updated dropdown choices + status."""
     import json
@@ -1670,9 +1737,15 @@ def _submit_community_lora(url, scale, trigger, description, tags):
 
 
 def _load_selected_community_lora(evt: gr.SelectData):
-    """When a community LoRA is selected from the dropdown, return its URL / scale / trigger."""
+    """When a community LoRA is selected from the dropdown, return its URL / scale / trigger.
+
+    For cached LoRAs (value starts with ``cache:``) the URL field is set to the
+    cache path so the Download & Apply button can detect it."""
     registry = _load_community_registry()
     url = evt.value
+    # Cached LoRAs use cache:path — pass through so _download_custom_lora picks them up.
+    if url.startswith("cache:"):
+        return url, 1.0, ""
     for entry in registry:
         e_url = entry.get("url", "")
         if e_url == url or f"https://huggingface.co/{entry.get('repo', '')}/resolve/main/{entry.get('file', '')}" == url:
@@ -2040,19 +2113,35 @@ def _generate_impl(prompt, image_path=None, last_image_path=None, canvas=DEFAULT
     # User-supplied LoRA from the custom URL box: parse the link and require it was downloaded & verified.
     custom = []
     if custom_lora_url and str(custom_lora_url).strip():
-        _repo, _file = _parse_hf_link(custom_lora_url)
-        if _file is None:
-            _file = _resolve_repo_file(_repo)
-        if (_repo, _file) not in _CUSTOM_LoRA:
-            raise gr.Error(f"`{_repo}/{_file}` isn't downloaded yet — press 'Download & Verify' first.")
-        try:
-            _scale = float(custom_lora_scale) if custom_lora_scale not in (None, "") else 1.0
-        except (TypeError, ValueError):
-            raise gr.Error("Custom LoRA scale must be a number.")
-        if not 0.01 <= _scale <= 4.0:
-            raise gr.Error("Custom LoRA scale must be between 0.01 and 4.")
-        _trigger = str(custom_lora_trigger or "").strip()
-        custom = [(_repo, _file, _scale, _trigger)]
+        _url = str(custom_lora_url).strip()
+        # Handle cache: prefix — LoRA was loaded directly from bucket cache.
+        if _url.startswith("cache:"):
+            _cache_path = _url[len("cache:"):]
+            _key = ("__cache__", os.path.basename(_cache_path))
+            if _key not in _CUSTOM_LoRA:
+                raise gr.Error(f"Cached LoRA isn't loaded yet — press 'Download & Verify' first.")
+            try:
+                _scale = float(custom_lora_scale) if custom_lora_scale not in (None, "") else 1.0
+            except (TypeError, ValueError):
+                raise gr.Error("Custom LoRA scale must be a number.")
+            if not 0.01 <= _scale <= 4.0:
+                raise gr.Error("Custom LoRA scale must be between 0.01 and 4.")
+            _trigger = str(custom_lora_trigger or "").strip()
+            custom = [(_key[0], _key[1], _scale, _trigger)]
+        else:
+            _repo, _file = _parse_hf_link(_url)
+            if _file is None:
+                _file = _resolve_repo_file(_repo)
+            if (_repo, _file) not in _CUSTOM_LoRA:
+                raise gr.Error(f"`{_repo}/{_file}` isn't downloaded yet — press 'Download & Verify' first.")
+            try:
+                _scale = float(custom_lora_scale) if custom_lora_scale not in (None, "") else 1.0
+            except (TypeError, ValueError):
+                raise gr.Error("Custom LoRA scale must be a number.")
+            if not 0.01 <= _scale <= 4.0:
+                raise gr.Error("Custom LoRA scale must be between 0.01 and 4.")
+            _trigger = str(custom_lora_trigger or "").strip()
+            custom = [(_repo, _file, _scale, _trigger)]
 
     if nsfw_keys or custom:
         nsfw_keys += ("nsfw_aio",)