Upload 3 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: MiniMax-H3 · reference → video + audio · Custom lora + CivitAI + scene continuation (fixed)
+title: MiniMax-H3 · reference → video + audio · Shared lora library + CivitAI + scene continuation
 emoji: 🎭
 colorFrom: pink
 colorTo: purple
@@ -7,7 +7,7 @@ sdk: gradio
 sdk_version: 6.20.0
 app_file: app.py
 pinned: true
-short_description: Video + soundtrack, your lora + CivitAI, structured prompts
+short_description: Video + soundtrack, shared lora library, structured prompts
 suggested_hardware: zero-a10g
 tags:
   - video
@@ -41,6 +41,13 @@ dialogue verbatim inside `<d>` tags, then `overall_soundscape` and `non_diegetic
 with the picture, so naming that someone speaks without giving the words produces correct mouth shapes with nothing
 in them; the builder makes that hard to get wrong.
 
+**A shared lora library that survives a restart.** Every adapter anyone adds is kept in a storage bucket — name,
+link, trigger words and strength — in two lists, ordinary and nsfw. Tick what you want and press one button: the
+slots are filled, their strengths are set, and the trigger words are appended to the prompt, so an adapter that needs
+its token to do anything never silently does nothing. Paste a CivitAI or Hugging Face link and the title and the
+trigger words are read off it for you. The list is common to everyone who opens the Space and is still there after it
+sleeps and wakes, so nobody has to hunt down last week's link a second time.
+
 **Custom lora, five slots.** A Hugging Face repo, a file inside one, a **CivitAI download link**, or an uploaded
 file. Adapters have to be trained against the `transformer_ref/` partition — a `transformer/` adapter is a different
 partition and will not match.
@@ -156,6 +163,8 @@ the placement (once), the two reference encoders, the denoise loop and the two d
 | `H3_GPU_SIZE` | `xlarge` | ZeroGPU allocation size. `large` does not fit. |
 | `H3_LOKR_RANK` | `32` | Rank the LoKr converter targets. Raise it if the log reports a weak layer. |
 | `CIVITAI_TOKEN` | unset | Used for CivitAI downloads and search, and required for gated or adult entries. |
+| `LORA_LIBRARY_BUCKET` | `amisima/minimax-h3-reference-4-step-lora-storage` | The storage bucket the shared lora library is kept in. Attach it to the Space under *Settings → Storage Buckets* and no token is needed; otherwise an `HF_TOKEN` with write access is. |
+| `LORA_LIBRARY_DIR` | unset | Overrides where the library file is read and written, when the mount path is not found on its own. |
 | `CIVITAI_API_HOST` | unset | Pins the search host; otherwise `civitai.red` is asked first and `civitai.com` is the fallback. |
 
 ## Where diffusers comes from

app.py

@@ -22,6 +22,8 @@ from functools import cache
 import spaces
 import gradio as gr
 
+import lora_library
+
 MODEL_REPO = os.environ.get("H3_MODEL_REPO", "MiniMaxAI/MiniMax-H3")
 CONDITIONER_SPACE = os.environ.get("H3_CONDITIONER", "multimodalart/qwen3vl-conditioner")
 # `lazy` moves all 72.16 GiB onto the card on the first GPU call and leaves it there; `offload` hands placement to
@@ -2066,17 +2068,18 @@ THEME = gr.themes.Soft(primary_hue="blue", secondary_hue="cyan", neutral_hue="sl
 
 HERO = """
 <div id="h3-hero">
-  <h1>MiniMax-H3 &middot; reference &rarr; video + soundtrack &middot; Custom lora + CivitAI search,
+  <h1>MiniMax-H3 &middot; reference &rarr; video + soundtrack &middot; Shared lora library + CivitAI search,
   structured prompt builder, scene continuation, GPU cost, profiles, clip stitching</h1>
   <p>33B model generating video and a fully synchronized soundtrack (ambience, foley, speech) from your own subject,
   voice or camera move. The prompt builder writes the labelled sections H3 was actually trained on, dialogue tags
-  and all.
+  and all, and the shared lora library remembers every adapter anyone adds &mdash; link, trigger words and strength
+  &mdash; and fills the slots in one press.
   <a href="https://huggingface.co/MiniMaxAI/MiniMax-H3" target="_blank" rel="noopener">model</a> &middot;
   <a href="https://www.minimax.io/blog/minimax-h3" target="_blank" rel="noopener">blog</a> &middot;
   <a href="https://huggingface.co/spaces/multimodalart/minimax-h3" target="_blank" rel="noopener">text / image to video</a></p>
   <div class="pills">
     <span>33B</span><span>joint video + audio</span><span>Turbo lora: 4&ndash;8 steps</span>
-    <span>ComfyUI lora accepted</span><span>up to 9 references</span><span>5 custom lora slots</span><span>structured prompt builder</span><span>named profiles</span><span>CivitAI search + links</span><span>scene continuation</span><span>kohya + LoKr auto-convert</span><span>GPU cost estimate</span><span>clip stitching with audio</span>
+    <span>ComfyUI lora accepted</span><span>up to 9 references</span><span>5 custom lora slots</span><span>shared lora library</span><span>trigger words in the prompt</span><span>structured prompt builder</span><span>named profiles</span><span>CivitAI search + links</span><span>scene continuation</span><span>kohya + LoKr auto-convert</span><span>GPU cost estimate</span><span>clip stitching with audio</span>
   </div>
 </div>
 """
@@ -2277,6 +2280,9 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
                         type="filepath",
                     )
 
+                lora_library.library_tab(lora_slots=lora_references, scale_slots=lora_scales,
+                                         prompt_box=prompt)
+
                 with gr.Tab("🎛️ Output"):
                     canvas = gr.Dropdown(label="Canvas", choices=list(CANVASES), value=DEFAULT_CANVAS)
                     match = gr.Checkbox(label="Match the reference soundtrack", value=True, visible=False)

lora_library.py

@@ -0,0 +1,816 @@
+"""Shared lora library, stored in a Hugging Face storage bucket.
+
+The list lives in `hf://buckets/<owner>/<bucket>/library.json` and holds two
+sections, "normal" and "nsfw". Each entry keeps a name, the link, its trigger
+words and a strength. A bucket is mutable object storage rather than a git
+repo, so the file is simply overwritten on every change and survives a restart
+of the Space.
+
+Writing needs an `HF_TOKEN` with write access. When the bucket is mounted into
+the Space as a volume, set `LORA_LIBRARY_DIR` to the mount path and the file is
+read and written directly, with no token involved.
+
+Used from app.py with a single line inside `with gr.Blocks(...) as demo:`
+
+    lora_library.library_tab(lora_box=user_loras_text, prompt_box=prompt)
+
+or, for a build with fixed lora slots,
+
+    lora_library.library_tab(lora_slots=lora_refs, scale_slots=lora_scales,
+                             prompt_box=prompt)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+
+import gradio as gr
+import requests
+
+BUCKET = os.environ.get("LORA_LIBRARY_BUCKET", "amisima/minimax-h3-reference-4-step-lora-storage")
+LIBRARY_FILE = os.environ.get("LORA_LIBRARY_FILE", "library.json")
+LOCAL_DIR = os.environ.get("LORA_LIBRARY_DIR", "").strip()
+# Fallback for a Space whose huggingface_hub is too old to speak to buckets.
+DATASET_REPO = os.environ.get("LORA_LIBRARY_REPO", BUCKET)
+
+_CIVITAI_DOWNLOAD_RE = re.compile(r"/api/download/models/(\d+)")
+_HF_URL_RE = re.compile(r"^https?://(?:www\.)?huggingface\.co/(?:datasets/)?([^/\s]+)/([^/\s?#]+)")
+
+
+# ---------------------------------------------------------------------------
+# storage
+# ---------------------------------------------------------------------------
+
+def _token() -> str:
+    return (os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN") or "").strip()
+
+
+def _bucket_path() -> str:
+    return f"buckets/{BUCKET.strip('/')}/{LIBRARY_FILE}"
+
+
+_mount_cache: dict[str, str] = {}
+
+
+def _runtime_volume_paths() -> list[str]:
+    """Ask the Hub where this Space has its volumes mounted.
+
+    A bucket attached in the Space settings lands at whatever mount path was
+    typed in there, so guessing is hopeless. The plain REST endpoint is used
+    rather than the Python client, because the client on an older Space does
+    not know about volumes at all.
+    """
+    space_id = os.environ.get("SPACE_ID") or os.environ.get("SPACE_REPO_ID") or ""
+    if not space_id:
+        return []
+    headers = {"User-Agent": "Mozilla/5.0"}
+    token = _token()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try:
+        response = requests.get(
+            f"https://huggingface.co/api/spaces/{space_id}/runtime",
+            headers=headers, timeout=20,
+        )
+        response.raise_for_status()
+        data = response.json()
+    except Exception as error:  # noqa: BLE001
+        print(f"[lora-library] could not read the Space runtime: "
+              f"{type(error).__name__}: {error}", flush=True)
+        return []
+
+    wanted = BUCKET.strip("/").lower()
+    preferred, others = [], []
+
+    def walk(node):
+        if isinstance(node, dict):
+            mount = node.get("mountPath") or node.get("mount_path")
+            if isinstance(mount, str) and mount.startswith("/"):
+                source = str(node.get("source") or node.get("repoId") or "").strip("/").lower()
+                (preferred if source.endswith(wanted) else others).append(mount)
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for value in node:
+                walk(value)
+
+    walk(data)
+    return preferred + others
+
+
+def _mount_table_paths() -> list[str]:
+    """Mount points that look like an attached volume rather than the OS."""
+    system = ("/proc", "/sys", "/dev", "/run", "/etc", "/usr", "/lib", "/bin",
+              "/sbin", "/boot", "/var/lib", "/var/run")
+    found = []
+    try:
+        with open("/proc/mounts", "r", encoding="utf-8", errors="ignore") as handle:
+            for line in handle:
+                parts = line.split()
+                if len(parts) < 3:
+                    continue
+                point, fstype = parts[1], parts[2]
+                if point == "/" or any(point.startswith(prefix) for prefix in system):
+                    continue
+                if fstype in ("nfs", "nfs4", "fuse", "virtiofs", "9p") or fstype.startswith("fuse"):
+                    found.insert(0, point)
+                elif point.count("/") == 1:
+                    found.append(point)
+    except Exception:  # noqa: BLE001
+        return []
+    return found
+
+
+def _volume_mount_path() -> str:
+    if "path" in _mount_cache:
+        return str(_mount_cache["path"])
+    _mount_cache["path"] = ""
+    for path in _runtime_volume_paths() + _mount_table_paths():
+        if path and os.path.isdir(path) and os.access(path, os.W_OK):
+            _mount_cache["path"] = path
+            print(f"[lora-library] using the volume mounted at {path}", flush=True)
+            break
+    return str(_mount_cache["path"])
+
+
+def _mounted_file() -> str:
+    """The library file on a locally mounted bucket, or "" when there is none."""
+    bucket_name = BUCKET.strip("/").split("/")[-1]
+    candidates = [LOCAL_DIR] if LOCAL_DIR else []
+    candidates.append(_volume_mount_path())
+    candidates += [
+        f"/bucket/{bucket_name}", "/bucket",
+        f"/buckets/{bucket_name}", "/buckets",
+        f"/mnt/bucket/{bucket_name}", "/mnt/bucket",
+        f"/data/{bucket_name}", "/data",
+        f"/mnt/data/{bucket_name}", "/mnt/data",
+        f"/storage/{bucket_name}", "/storage",
+    ]
+    for directory in candidates:
+        if directory and os.path.isdir(directory) and os.access(directory, os.W_OK):
+            return os.path.join(directory, LIBRARY_FILE)
+    return ""
+
+
+def _hub_has_buckets() -> bool:
+    """Buckets need huggingface_hub 1.5 or newer; older Spaces have to fall back."""
+    try:
+        from huggingface_hub import HfFileSystem  # noqa: F401
+    except Exception:  # noqa: BLE001
+        return False
+    try:
+        from importlib.metadata import version as _version
+
+        parts = _version("huggingface_hub").split(".")
+        return (int(parts[0]), int(parts[1])) >= (1, 5)
+    except Exception:  # noqa: BLE001
+        return True
+
+
+def _filesystem():
+    from huggingface_hub import HfFileSystem
+
+    token = _token()
+    return HfFileSystem(token=token) if token else HfFileSystem()
+
+
+def _empty() -> dict:
+    return {"normal": [], "nsfw": []}
+
+
+def _clean(data) -> dict:
+    out = _empty()
+    if not isinstance(data, dict):
+        return out
+    for section in ("normal", "nsfw"):
+        for item in data.get(section) or []:
+            if not isinstance(item, dict):
+                continue
+            url = str(item.get("url") or "").strip()
+            if not url:
+                continue
+            try:
+                strength = float(item.get("strength", 1.0))
+            except (TypeError, ValueError):
+                strength = 1.0
+            out[section].append({
+                "name": str(item.get("name") or "").strip() or url.split("/")[-1][:60],
+                "url": url,
+                "trigger": str(item.get("trigger") or "").strip(),
+                "strength": strength,
+                "added": str(item.get("added") or ""),
+            })
+    return out
+
+
+# Every backend is tried in turn, and whichever one answers is remembered so the
+# reader and the writer never end up looking in two different places.
+_active = {"backend": "", "detail": ""}
+
+
+def _read_mounted():
+    mounted = _mounted_file()
+    if not mounted:
+        return None
+    if not os.path.exists(mounted):
+        return _empty()
+    with open(mounted, "r", encoding="utf-8") as handle:
+        return _clean(json.load(handle))
+
+
+def _write_mounted(payload: str) -> None:
+    mounted = _mounted_file()
+    if not mounted:
+        raise RuntimeError("no mounted bucket")
+    with open(mounted, "w", encoding="utf-8") as handle:
+        handle.write(payload)
+
+
+def _read_bucket():
+    if not _hub_has_buckets():
+        raise RuntimeError("huggingface_hub is too old for buckets (needs 1.5+)")
+    filesystem = _filesystem()
+    path = _bucket_path()
+    if not filesystem.exists(path):
+        return _empty()
+    with filesystem.open(path, "r") as handle:
+        return _clean(json.loads(handle.read()))
+
+
+def _write_bucket(payload: str) -> None:
+    if not _hub_has_buckets():
+        raise RuntimeError("huggingface_hub is too old for buckets (needs 1.5+)")
+    if not _token():
+        raise RuntimeError("no HF_TOKEN")
+    filesystem = _filesystem()
+    with filesystem.open(_bucket_path(), "w") as handle:
+        handle.write(payload)
+
+
+def _read_dataset():
+    url = (f"https://huggingface.co/datasets/{DATASET_REPO}/resolve/main/"
+           f"{LIBRARY_FILE}?cb={int(time.time())}")
+    headers = {"User-Agent": "Mozilla/5.0"}
+    token = _token()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    response = requests.get(url, headers=headers, timeout=25)
+    if response.status_code == 404:
+        return _empty()
+    response.raise_for_status()
+    return _clean(response.json())
+
+
+def _write_dataset(payload: str) -> None:
+    if not _token():
+        raise RuntimeError("no HF_TOKEN")
+    import io
+
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=_token())
+    api.create_repo(repo_id=DATASET_REPO, repo_type="dataset", exist_ok=True, private=True)
+    api.upload_file(
+        path_or_fileobj=io.BytesIO(payload.encode("utf-8")),
+        path_in_repo=LIBRARY_FILE,
+        repo_id=DATASET_REPO,
+        repo_type="dataset",
+        commit_message="update lora library",
+    )
+
+
+def _mounted_name() -> str:
+    mounted = _mounted_file()
+    return f"mounted bucket ({os.path.dirname(mounted)})" if mounted else "mounted bucket"
+
+
+# ---------------------------------------------------------------------------
+# buckets from a Space whose huggingface_hub is pinned below 1.5
+# ---------------------------------------------------------------------------
+# Some builds pin an old huggingface_hub on purpose (diffusers / ComfyUI
+# compatibility) and upgrading it in place would break the Space. A modern copy
+# is installed into a directory of its own and driven from a subprocess, so the
+# running app never imports it.
+
+_ISOLATED_DIR = os.environ.get("LORA_LIBRARY_HUB_DIR", "/tmp/lora_library_hub")
+_isolated_state: dict[str, object] = {}
+
+
+def _isolated_ready() -> bool:
+    if "ok" in _isolated_state:
+        return bool(_isolated_state["ok"])
+    _isolated_state["ok"] = False
+    if os.path.isdir(os.path.join(_ISOLATED_DIR, "huggingface_hub")):
+        _isolated_state["ok"] = True
+        return True
+    print("[lora-library] installing a private huggingface_hub for bucket access…", flush=True)
+    import subprocess
+    import sys
+
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--no-cache-dir", "--quiet",
+             "--target", _ISOLATED_DIR, "huggingface_hub>=1.5"],
+            check=True, timeout=600,
+        )
+        _isolated_state["ok"] = os.path.isdir(os.path.join(_ISOLATED_DIR, "huggingface_hub"))
+    except Exception as error:  # noqa: BLE001
+        print(f"[lora-library] private huggingface_hub install failed: "
+              f"{type(error).__name__}: {error}", flush=True)
+    return bool(_isolated_state["ok"])
+
+
+def _isolated_run(mode: str, payload_path: str = "") -> str:
+    import subprocess
+    import sys
+
+    if not _isolated_ready():
+        raise RuntimeError("could not install a huggingface_hub new enough for buckets")
+    script = (
+        "import sys, json, os\n"
+        f"sys.path.insert(0, {_ISOLATED_DIR!r})\n"
+        "from huggingface_hub import HfFileSystem\n"
+        "token = os.environ.get('HF_TOKEN') or os.environ.get('HUGGINGFACE_HUB_TOKEN') or None\n"
+        "fs = HfFileSystem(token=token)\n"
+        f"path = {_bucket_path()!r}\n"
+        f"mode = {mode!r}\n"
+        f"payload_path = {payload_path!r}\n"
+        "if mode == 'read':\n"
+        "    if fs.exists(path):\n"
+        "        with fs.open(path, 'r') as handle:\n"
+        "            sys.stdout.write(handle.read())\n"
+        "    else:\n"
+        "        sys.stdout.write('{}')\n"
+        "else:\n"
+        "    with open(payload_path, 'r', encoding='utf-8') as handle:\n"
+        "        body = handle.read()\n"
+        "    with fs.open(path, 'w') as handle:\n"
+        "        handle.write(body)\n"
+        "    sys.stdout.write('ok')\n"
+    )
+    environment = dict(os.environ)
+    environment.pop("PYTHONPATH", None)
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        capture_output=True, text=True, timeout=180, env=environment,
+    )
+    if result.returncode != 0:
+        raise RuntimeError((result.stderr or "").strip().splitlines()[-1:] or "subprocess failed")
+    return result.stdout
+
+
+def _read_isolated():
+    return _clean(json.loads(_isolated_run("read") or "{}"))
+
+
+def _write_isolated(payload: str) -> None:
+    import tempfile
+
+    if not _token():
+        raise RuntimeError("no HF_TOKEN")
+    handle = tempfile.NamedTemporaryFile("w", suffix=".json", delete=False, encoding="utf-8")
+    handle.write(payload)
+    handle.close()
+    try:
+        _isolated_run("write", handle.name)
+    finally:
+        os.unlink(handle.name)
+
+
+_BACKENDS = [
+    ("mounted bucket", _read_mounted, _write_mounted),
+    (f"bucket {BUCKET}", _read_bucket, _write_bucket),
+    (f"bucket {BUCKET} (private hub)", _read_isolated, _write_isolated),
+    (f"dataset {DATASET_REPO}", _read_dataset, _write_dataset),
+]
+
+
+def load_library() -> dict:
+    """Read from the backend that last worked, or find one that does."""
+    ordered = _BACKENDS
+    if _active["backend"]:
+        ordered = ([b for b in _BACKENDS if b[0] == _active["backend"]]
+                   + [b for b in _BACKENDS if b[0] != _active["backend"]])
+    first_error = ""
+    for name, reader, _writer in ordered:
+        try:
+            data = reader()
+        except Exception as error:  # noqa: BLE001
+            first_error = first_error or f"{name}: {type(error).__name__}: {error}"
+            print(f"[lora-library] read from {name} failed: {error}", flush=True)
+            continue
+        if data is None:
+            continue
+        if data["normal"] or data["nsfw"] or not _active["backend"]:
+            _active["backend"], _active["detail"] = name, ""
+        return data
+    _active["detail"] = first_error
+    return _empty()
+
+
+def save_library(library: dict) -> str:
+    """Write, then read back to prove it landed. Returns "" or a message."""
+    payload = json.dumps(_clean(library), ensure_ascii=False, indent=1)
+    wanted = {item["url"] for item in _clean(library)["normal"] + _clean(library)["nsfw"]}
+
+    problems = []
+    for name, reader, writer in _BACKENDS:
+        try:
+            writer(payload)
+        except Exception as error:  # noqa: BLE001
+            problems.append(f"{name}: {type(error).__name__}: {error}")
+            continue
+        try:
+            written = reader() or _empty()
+        except Exception as error:  # noqa: BLE001
+            problems.append(f"{name}: written, but could not be read back ({error})")
+            continue
+        got = {item["url"] for item in written["normal"] + written["nsfw"]}
+        if wanted - got:
+            problems.append(f"{name}: written, but it did not come back")
+            continue
+        _active["backend"], _active["detail"] = name, ""
+        return ""
+
+    detail = "; ".join(problems) or "no storage backend is available"
+    _active["detail"] = detail
+    return (f"**nothing was saved.** {detail}\n\n"
+            f"Easiest fix: attach the `{BUCKET}` bucket to this Space under "
+            "*Settings → Storage Buckets* (any mount path will do) — then no token is needed "
+            "at all. Otherwise add an `HF_TOKEN` with write access under "
+            "*Settings → Variables and secrets*.")
+
+
+def storage_note() -> str:
+    if _active["backend"] and not _active["detail"]:
+        name = _mounted_name() if _active["backend"] == "mounted bucket" else _active["backend"]
+        return f"storage: {name}"
+    if _active["detail"]:
+        return f"storage: not working yet — {_active['detail']}"
+    return "storage: not contacted yet"
+
+
+# ---------------------------------------------------------------------------
+# reading a link
+# ---------------------------------------------------------------------------
+
+def lookup_link(url: str):
+    """(name, trigger words) for a civitai / huggingface link."""
+    url = (url or "").strip().strip('"').strip("'")
+    if not url:
+        return "", ""
+
+    match = _CIVITAI_DOWNLOAD_RE.search(url)
+    if match:
+        headers = {"User-Agent": "Mozilla/5.0"}
+        civitai_token = os.environ.get("CIVITAI_TOKEN", "").strip()
+        if civitai_token:
+            headers["Authorization"] = f"Bearer {civitai_token}"
+        for host in ("civitai.red", "civitai.com"):
+            try:
+                response = requests.get(
+                    f"https://{host}/api/v1/model-versions/{match.group(1)}",
+                    headers=headers, timeout=20,
+                )
+                response.raise_for_status()
+                data = response.json()
+            except Exception:  # noqa: BLE001
+                continue
+            model_name = (data.get("model") or {}).get("name") or ""
+            version_name = data.get("name") or ""
+            label = f"{model_name} · {version_name}".strip(" ·")
+            words = [w for w in (data.get("trainedWords") or []) if w]
+            return label, ", ".join(words[:8])
+        return "", ""
+
+    hf_match = _HF_URL_RE.match(url)
+    if hf_match:
+        return f"{hf_match.group(1)}/{hf_match.group(2)}", ""
+
+    return url.split("?")[0].split("/")[-1], ""
+
+
+# ---------------------------------------------------------------------------
+# helpers
+# ---------------------------------------------------------------------------
+
+def _labels(entries: list[dict]) -> list[str]:
+    labels = []
+    for index, item in enumerate(entries, start=1):
+        label = f"{index}. {item['name']}  ·  strength {item['strength']:g}"
+        if item.get("trigger"):
+            label += f"  ·  trigger: {item['trigger']}"
+        labels.append(label[:220])
+    return labels
+
+
+def _picked(entries: list[dict], labels: list[str], chosen) -> list[dict]:
+    index_by_label = {label: i for i, label in enumerate(labels)}
+    out = []
+    for label in chosen or []:
+        index = index_by_label.get(label)
+        if index is not None and index < len(entries):
+            out.append(entries[index])
+    return out
+
+
+def _autofind(predicate):
+    try:
+        from gradio.context import Context
+
+        root = getattr(Context, "root_block", None)
+        if root is None:
+            return None
+        for component in root.blocks.values():
+            if isinstance(component, gr.Textbox):
+                label = str(getattr(component, "label", "") or "")
+                if predicate(label.lower()):
+                    return component
+    except Exception:  # noqa: BLE001
+        return None
+    return None
+
+
+def _is_lora_box(label: str) -> bool:
+    return "lora" in label and "search" not in label and "civitai" not in label
+
+
+def _is_prompt_box(label: str) -> bool:
+    if "prompt" not in label:
+        return False
+    return not any(word in label for word in
+                   ("negative", "segment", "relay", "scene", "enhance", "search"))
+
+
+def _with_triggers(prompt_text: str, triggers: list[str]) -> str:
+    text = prompt_text or ""
+    missing = [t for t in triggers if t and t.lower() not in text.lower()]
+    if not missing:
+        return text
+    return f"{text.rstrip().rstrip(',')}, {', '.join(missing)}".strip(" ,")
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+def library_tab(lora_box=None, prompt_box=None, lora_slots=None, scale_slots=None,
+                label: str = "📚 lora library"):
+    """Draw the library tab. Either hand it a multi-line lora textbox
+    (`lora_box`), or a list of fixed slots (`lora_slots` + `scale_slots`)."""
+    slots = list(lora_slots or [])
+    scales = list(scale_slots or [])
+    if not slots and lora_box is None:
+        lora_box = _autofind(_is_lora_box)
+    if prompt_box is None:
+        prompt_box = _autofind(_is_prompt_box)
+
+    has_slots = bool(slots)
+    has_box = (not has_slots) and lora_box is not None
+    has_prompt = prompt_box is not None
+
+    library = load_library()
+
+    with gr.Tab(label):
+        gr.Markdown(
+            f"a shared list, kept in the `{BUCKET}` bucket, so it survives a restart. "
+            "tick what you want and it goes straight into the lora "
+            + ("slots" if has_slots else "box") + ", trigger words and all."
+        )
+
+        state = gr.State(library)
+        normal_labels = gr.State(_labels(library["normal"]))
+        nsfw_labels = gr.State(_labels(library["nsfw"]))
+
+        normal_pick = gr.CheckboxGroup(
+            choices=_labels(library["normal"]), value=[],
+            label="ordinary", interactive=True,
+        )
+        nsfw_pick = gr.CheckboxGroup(
+            choices=_labels(library["nsfw"]), value=[],
+            label="nsfw", interactive=True,
+        )
+
+        with gr.Row():
+            add_button = gr.Button(
+                "➕ add the ticked ones to the lora " + ("slots" if has_slots else "box"),
+                variant="primary",
+            )
+            refresh_button = gr.Button("🔄 refresh")
+
+        use_triggers = gr.Checkbox(
+            value=True, label="append the trigger words to the prompt",
+        )
+        status = gr.Markdown("")
+        storage_line = gr.Markdown(storage_note())
+
+        with gr.Accordion("➕ add a lora to the library", open=False):
+            new_url = gr.Textbox(label="link (civitai / huggingface / direct .safetensors)", lines=1)
+            lookup_button = gr.Button("🔎 read the name and triggers off the link")
+            new_name = gr.Textbox(label="name", lines=1)
+            new_trigger = gr.Textbox(label="trigger words", lines=1)
+            with gr.Row():
+                new_strength = gr.Number(value=1.0, label="strength", precision=2)
+                new_nsfw = gr.Checkbox(value=False, label="nsfw")
+            save_button = gr.Button("💾 save to the library", variant="primary")
+
+        with gr.Accordion("🗑 remove", open=False):
+            delete_button = gr.Button("remove the ones ticked above")
+
+        # ------------------------------------------------------------ events
+
+        def _pack(data, message):
+            normal, nsfw = _labels(data["normal"]), _labels(data["nsfw"])
+            return (
+                data, normal, nsfw,
+                gr.update(choices=normal, value=[]),
+                gr.update(choices=nsfw, value=[]),
+                message,
+                storage_note(),
+            )
+
+        def _refresh():
+            data = load_library()
+            return _pack(data, f"loaded: {len(data['normal'])} ordinary, "
+                               f"{len(data['nsfw'])} nsfw")
+
+        refresh_targets = [state, normal_labels, nsfw_labels, normal_pick, nsfw_pick,
+                           status, storage_line]
+        refresh_button.click(_refresh, None, refresh_targets)
+
+        lookup_button.click(lambda url: lookup_link(url), new_url, [new_name, new_trigger])
+
+        def _save(data, url, name, trigger, strength, nsfw):
+            url = (url or "").strip().strip('"').strip("'")
+            # Start from what storage actually holds, so two people adding a lora
+            # at the same time do not overwrite each other.
+            data = load_library()
+            if not url:
+                return _pack(data, "paste a link first.")
+            for existing in data["normal"] + data["nsfw"]:
+                if existing["url"] == url:
+                    return _pack(data, f"already on the list: {existing['name']}")
+            if not (name or "").strip():
+                name = lookup_link(url)[0] or url.split("?")[0].split("/")[-1]
+            try:
+                strength = float(strength)
+            except (TypeError, ValueError):
+                strength = 1.0
+            data["nsfw" if nsfw else "normal"].append({
+                "name": name.strip(),
+                "url": url,
+                "trigger": (trigger or "").strip(),
+                "strength": strength,
+                "added": time.strftime("%Y-%m-%d"),
+            })
+            error = save_library(data)
+            # Show what came back out of storage, not what went in.
+            return _pack(load_library() if not error else data,
+                         error or f"added and saved: {name.strip()}")
+
+        save_button.click(
+            _save,
+            [state, new_url, new_name, new_trigger, new_strength, new_nsfw],
+            refresh_targets,
+        )
+
+        def _delete(data, normal, nsfw, normal_chosen, nsfw_chosen):
+            data = _clean(data)
+            doomed = {item["url"] for item in
+                      _picked(data["normal"], normal, normal_chosen)
+                      + _picked(data["nsfw"], nsfw, nsfw_chosen)}
+            if not doomed:
+                return _pack(data, "nothing is ticked.")
+            fresh = load_library()
+            for section in ("normal", "nsfw"):
+                fresh[section] = [i for i in fresh[section] if i["url"] not in doomed]
+            error = save_library(fresh)
+            return _pack(load_library() if not error else data,
+                         error or f"removed: {len(doomed)}")
+
+        delete_button.click(
+            _delete,
+            [state, normal_labels, nsfw_labels, normal_pick, nsfw_pick],
+            refresh_targets,
+        )
+
+        # ------------------------------------------- adding to the lora slots
+
+        if has_slots:
+            add_inputs = [state, normal_labels, nsfw_labels, normal_pick, nsfw_pick, use_triggers]
+            add_outputs = [status]
+            if has_prompt:
+                add_inputs.append(prompt_box)
+                add_outputs.append(prompt_box)
+            add_outputs = add_outputs + slots + scales
+
+            def _add_slots(data, normal, nsfw, normal_chosen, nsfw_chosen, triggers_on,
+                           prompt_text=""):
+                data = _clean(data)
+                chosen = (_picked(data["normal"], normal, normal_chosen)
+                          + _picked(data["nsfw"], nsfw, nsfw_chosen))
+                blank = [gr.update() for _ in slots] + [gr.update() for _ in scales]
+                if not chosen:
+                    return tuple(["nothing is ticked."]
+                                 + ([gr.update()] if has_prompt else []) + blank)
+
+                used = chosen[:len(slots)]
+                spare = chosen[len(slots):]
+                ref_updates = [
+                    gr.update(value=used[i]["url"]) if i < len(used) else gr.update()
+                    for i in range(len(slots))
+                ]
+                scale_updates = [
+                    gr.update(value=used[i]["strength"]) if i < len(used) else gr.update()
+                    for i in range(len(scales))
+                ]
+
+                message = f"**in the slots:** {', '.join(i['name'] for i in used)}"
+                if spare:
+                    message += (f"  \nno room for: {', '.join(i['name'] for i in spare)} "
+                                f"(there are {len(slots)} slots)")
+                trigger_words = [i["trigger"] for i in used if i.get("trigger")]
+
+                out = [message]
+                if has_prompt:
+                    out.append(gr.update(value=_with_triggers(prompt_text, trigger_words))
+                               if triggers_on and trigger_words else gr.update())
+                elif trigger_words:
+                    out[0] += f"  \n**trigger words for the prompt:** {', '.join(trigger_words)}"
+                return tuple(out + ref_updates + scale_updates)
+
+            add_button.click(_add_slots, add_inputs, add_outputs)
+
+        # --------------------------------------------- adding to the lora box
+
+        else:
+            add_inputs = [state, normal_labels, nsfw_labels, normal_pick, nsfw_pick, use_triggers]
+            add_outputs = [status]
+            if has_box:
+                add_inputs.append(lora_box)
+                add_outputs.append(lora_box)
+            if has_prompt:
+                add_inputs.append(prompt_box)
+                add_outputs.append(prompt_box)
+
+            def _add_box(data, normal, nsfw, normal_chosen, nsfw_chosen, triggers_on, *boxes):
+                data = _clean(data)
+                chosen = (_picked(data["normal"], normal, normal_chosen)
+                          + _picked(data["nsfw"], nsfw, nsfw_chosen))
+
+                position = 0
+                lora_text = boxes[position] if has_box else ""
+                if has_box:
+                    position += 1
+                prompt_text = boxes[position] if has_prompt else ""
+
+                if not chosen:
+                    out = ["nothing is ticked."]
+                    out += [gr.update()] * (int(has_box) + int(has_prompt))
+                    return tuple(out) if len(out) > 1 else out[0]
+
+                text = (lora_text or "").rstrip()
+                added, skipped, trigger_words = [], [], []
+                for item in chosen:
+                    if item["url"] in text:
+                        skipped.append(item["name"])
+                    else:
+                        text = f"{text}\n{item['url']} | {item['strength']:g}".strip()
+                        added.append(item["name"])
+                    if item.get("trigger"):
+                        trigger_words.append(item["trigger"])
+
+                message = ""
+                if added:
+                    message += f"**added:** {', '.join(added)}"
+                if skipped:
+                    message += f"  \nalready in the box: {', '.join(skipped)}"
+                if trigger_words and not has_prompt:
+                    message += f"  \n**trigger words for the prompt:** {', '.join(trigger_words)}"
+                if not has_box:
+                    lines = "\n".join(f"{i['url']} | {i['strength']:g}" for i in chosen)
+                    message = f"copy these lines into the lora box:\n\n```\n{lines}\n```\n\n{message}"
+
+                out = [message]
+                if has_box:
+                    out.append(gr.update(value=text))
+                if has_prompt:
+                    out.append(gr.update(value=_with_triggers(prompt_text, trigger_words))
+                               if triggers_on and trigger_words else gr.update())
+                return tuple(out) if len(out) > 1 else out[0]
+
+            add_button.click(_add_box, add_inputs, add_outputs)
+
+        try:
+            from gradio.context import Context
+
+            root = getattr(Context, "root_block", None)
+            if root is not None:
+                root.load(_refresh, None, refresh_targets)
+        except Exception:  # noqa: BLE001
+            pass
+
+    return state