JSON LoRA catalog, local path imports, and UI polish

Move the LoRA list to an external bucket JSON with admin/active flags,
session add/save/remove, and sha256 dedupe. Also add nested local-path
LoRA loading, reference clipboard multi-upload, a larger download button,
and a standard UI font. Logging remains disabled.

Co-Authored-By: Oz <oz-agent@warp.dev>

.gitignore

@@ -0,0 +1,9 @@
+_originalspace*/
+_2do/
+*.webloc
+url*/
+_push*
+.DS_Store
+__pycache__/
+*.pyc
+lorasplayground.json

app.py

@@ -5,7 +5,6 @@ import time
 import random
 import uuid
 import zipfile
-import threading
 
 import gradio as gr
 import spaces
@@ -19,6 +18,7 @@ from config import (
     MODEL_REPO,
     MAX_SEED,
     MAX_LORA_SLOTS,
+    PERSISTENT_LORA_CATALOG_PATH,
 )
 from ui_theme import orange_red_theme
 from upscale import UPSCALE_MODELS, apply_realesrgan
@@ -29,6 +29,10 @@ from lora_registry import (
     get_style_by_title,
     update_weight_sliders,
     add_custom_lora,
+    save_session_lora_to_catalog,
+    fill_catalog_save_form,
+    remove_lora,
+    removable_catalog_titles,
 )
 
 from image_utils import (
@@ -50,6 +54,7 @@ from image_utils import (
     push_pil_to_reference,
     extend_editor_canvas,
     render_extend_schematic,
+    resolve_output_download_path,
 )
 from control_tools import (
     generate_depthmap,
@@ -117,6 +122,12 @@ def on_gallery_select(evt: gr.SelectData, gallery_value):
     return item[0] if isinstance(item, (list, tuple)) else item
 
 
+# ── Logging (disabled) ───────────────────────────────────────────────────────
+
+def _spawn_log(*_args, **_kwargs):
+    """No-op — logging intentionally disabled."""
+    return
+
 
 # ── GPU step (shared by single, batch, and bulk) ─────────────────────────────
 
@@ -365,12 +376,11 @@ with gr.Blocks() as demo:
     selected_output_state = gr.State(None)
 
     with gr.Column(elem_id="col-container"):
-        
         gr.Markdown("# **flux2klein lora playground**", elem_id="main-title")
         gr.Markdown(
             f"Apply one or more [LoRA](https://huggingface.co/models?other=base_model:adapter:black-forest-labs/FLUX.2-klein-9B) "
             f"adapters using [FLUX.2-Klein-{MODEL_VARIANT}]({MODEL_REPO}). "
-            f"**Model:** `{MODEL_VARIANT}` "
+            f"**Model:** `{MODEL_VARIANT}`"
         )
 
         with gr.Tabs() as main_tabs:
@@ -387,6 +397,7 @@ with gr.Blocks() as demo:
                         reference_images = gr.Gallery(
                             label="Reference Image(s) — optional", type="filepath",
                             columns=2, rows=1, height=140, allow_preview=True,
+                            sources=["upload", "clipboard"],
                             elem_id="reference_gallery",
                         )
                         reference_info = gr.Markdown("📷 No reference images")
@@ -451,15 +462,26 @@ with gr.Blocks() as demo:
                             height=420, allow_preview=True, preview=True,
                             object_fit="contain", show_label=True,
                         )
-                        used_seed = gr.Textbox(label="🌱 Seed used (last run)",
-                                               interactive=False, max_lines=1)
+                        with gr.Row(equal_height=True):
+                            used_seed = gr.Textbox(
+                                label="🌱 Seed used (last run)",
+                                interactive=False, max_lines=1, scale=1,
+                            )
+                            download_output_btn = gr.DownloadButton(
+                                label="⬇️ Download image",
+                                value=None,
+                                variant="primary",
+                                size="lg",
+                                scale=1,
+                                elem_id="download_output_btn",
+                            )
                         with gr.Row():
                             send_out_to_base_btn = gr.Button("↩ Send → Base", size="sm")
                             send_out_to_ref_btn  = gr.Button("↩ Send → Reference", size="sm")
                         gr.Markdown(
-                            "*Click a gallery thumbnail before Send→ to pick that specific "
-                            "image; otherwise the latest is used. PNGs contain seed, prompt, "
-                            "LoRAs and settings as `parameters` tEXt chunks (sd-webui / "
+                            "*Click a gallery thumbnail before Download / Send→ to pick that "
+                            "specific image; otherwise the latest is used. PNGs contain seed, "
+                            "prompt, LoRAs and settings as `parameters` tEXt chunks (sd-webui / "
                             "Civitai / ComfyUI readable).*"
                         )
 
@@ -478,18 +500,74 @@ with gr.Blocks() as demo:
                                 label=f"LoRA slot {i+1}", visible=False, interactive=True,
                             ))
 
-                with gr.Accordion("➕ Load Custom LoRA from HuggingFace", open=False):
-                    gr.Markdown("Add any FLUX.2-Klein-compatible LoRA. *Added LoRAs are only visible in your own session.*")
+                with gr.Accordion("➕ Load Custom LoRA (HF repo or local path)", open=False):
+                    gr.Markdown(
+                        "Add any FLUX.2-Klein-compatible LoRA from a **HuggingFace repo** "
+                        "(`user/repo`) or a **local path** (file or directory), e.g. "
+                        "`/loras-flux/my.safetensors` or `/loras-flux/foo/bar/male`. "
+                        "**Import is always session-only** — try it first, then optionally "
+                        f"save it to the catalog JSON (`{PERSISTENT_LORA_CATALOG_PATH}`). "
+                        "Duplicates are blocked by title, repo+filename, and sha256 when available."
+                    )
                     with gr.Row():
-                        lora_repo_id = gr.Textbox(label="Repo ID", placeholder="username/repo-name")
+                        lora_repo_id = gr.Textbox(
+                            label="HF repo ID or local path",
+                            placeholder="username/repo-name  or  /loras-flux/my.safetensors",
+                        )
                     with gr.Row():
-                        lora_weight_name = gr.Textbox(label="Weight filename (optional)",
-                                                      placeholder="pytorch_lora_weights.safetensors")
+                        lora_weight_name = gr.Textbox(
+                            label="Weight filename (optional if path is a .safetensors file)",
+                            placeholder="pytorch_lora_weights.safetensors",
+                        )
                         lora_adapter_name = gr.Textbox(label="Adapter name (optional)", placeholder="my-lora")
                     with gr.Row():
-                        add_lora_btn = gr.Button("Add LoRA", variant="primary")
+                        add_lora_btn = gr.Button("Add LoRA (session only)", variant="primary")
                         lora_status = gr.Textbox(label="Status", interactive=False)
 
+                    gr.Markdown("#### 💾 Save tried LoRA to catalog")
+                    gr.Markdown(
+                        "After testing a session LoRA, save it here so it appears for everyone "
+                        "on the next load. UI saves are **not** admin-approved; set "
+                        "`admin_approved: true` in the JSON yourself. Set `active: false` to "
+                        "archive/hide without deleting."
+                    )
+                    catalog_save_select = gr.Dropdown(
+                        label="Session LoRA to save",
+                        choices=[], value=None, interactive=True,
+                    )
+                    with gr.Row():
+                        catalog_save_title = gr.Textbox(
+                            label="Catalog title", placeholder="My LoRA name", scale=2,
+                        )
+                        catalog_save_weight = gr.Slider(
+                            label="Default weight", minimum=0.0, maximum=2.0,
+                            step=0.05, value=1.0, scale=1,
+                        )
+                    catalog_save_prompt = gr.Textbox(
+                        label="Default prompt (optional)", lines=2,
+                        placeholder="Optional prompt auto-appended when this LoRA is selected",
+                    )
+                    with gr.Row():
+                        catalog_save_btn = gr.Button(
+                            "💾 Save to catalog", variant="secondary",
+                        )
+                        catalog_save_status = gr.Textbox(label="Catalog status", interactive=False)
+
+                    gr.Markdown("#### 🗑️ Remove LoRA")
+                    gr.Markdown(
+                        "Remove a **session** custom LoRA, or a catalog entry that is **not** "
+                        "`admin_approved`. Admin-approved entries can only be archived via JSON "
+                        "(`active: false`)."
+                    )
+                    with gr.Row():
+                        catalog_remove_select = gr.Dropdown(
+                            label="LoRA to remove",
+                            choices=removable_catalog_titles(),
+                            value=None, interactive=True, scale=2,
+                        )
+                        catalog_remove_btn = gr.Button("🗑️ Remove", variant="stop", scale=1)
+                    catalog_remove_status = gr.Textbox(label="Remove status", interactive=False)
+
                 with gr.Accordion("📝 Custom Prompts", open=False):
                     gr.Markdown("Save reusable prompt snippets for this session.")
                     custom_prompt_selector = gr.CheckboxGroup(
@@ -674,10 +752,30 @@ with gr.Blocks() as demo:
     )
 
     # add_custom_lora is also imported from lora_registry.
+    # Always session-only; optional persist / remove are separate explicit actions.
     add_lora_btn.click(
         fn=add_custom_lora,
         inputs=[lora_repo_id, lora_weight_name, lora_adapter_name, dynamic_loras_state],
-        outputs=[lora_status, lora_selector, dynamic_loras_state],
+        outputs=[lora_status, lora_selector, dynamic_loras_state,
+                 catalog_save_select, catalog_remove_select],
+    )
+    catalog_save_select.change(
+        fn=fill_catalog_save_form,
+        inputs=[catalog_save_select, dynamic_loras_state],
+        outputs=[catalog_save_title, catalog_save_weight, catalog_save_prompt],
+    )
+    catalog_save_btn.click(
+        fn=save_session_lora_to_catalog,
+        inputs=[catalog_save_select, catalog_save_title, catalog_save_weight,
+                catalog_save_prompt, dynamic_loras_state],
+        outputs=[catalog_save_status, lora_selector, catalog_save_select,
+                 catalog_remove_select, dynamic_loras_state],
+    )
+    catalog_remove_btn.click(
+        fn=remove_lora,
+        inputs=[catalog_remove_select, dynamic_loras_state, lora_selector],
+        outputs=[catalog_remove_status, lora_selector, catalog_save_select,
+                 catalog_remove_select, dynamic_loras_state],
     )
 
     add_prompt_btn.click(
@@ -706,6 +804,32 @@ with gr.Blocks() as demo:
 
     output_gallery.select(fn=on_gallery_select, inputs=[output_gallery],
                           outputs=[selected_output_state])
+    # Keep the large Download button pointed at the selected gallery item
+    # (or the latest item when nothing valid is selected).
+    selected_output_state.change(
+        fn=resolve_output_download_path,
+        inputs=[selected_output_state, output_gallery],
+        outputs=[download_output_btn],
+    )
+    output_gallery.change(
+        fn=resolve_output_download_path,
+        inputs=[selected_output_state, output_gallery],
+        outputs=[download_output_btn],
+    )
+    # Native DownloadButton still saves the file; also open the served image
+    # URL in a new browser tab so it can be viewed immediately.
+    download_output_btn.click(
+        fn=None,
+        js="""() => {
+            const root = document.getElementById('download_output_btn');
+            if (!root) return;
+            const a = root.querySelector('a.download-link, a[href]');
+            const href = a && a.href;
+            if (href) {
+                window.open(href, '_blank', 'noopener,noreferrer');
+            }
+        }""",
+    )
     # Reset any stale gallery selection before a new run starts, so Send→Base
     # / Send→Ref after this run can't accidentally reuse a path from the
     # previous run's gallery contents.

config.py

@@ -23,3 +23,9 @@ MAX_SEED = int(np.iinfo(np.int32).max)
 # Maximum number of simultaneous LoRA weight sliders to pre-render in the UI.
 MAX_LORA_SLOTS = 6
 
+# External LoRA catalog (bucket-mounted JSON). Single source of truth for the
+# selectable list. If missing/empty, the app seeds it from built-in defaults.
+PERSISTENT_LORA_CATALOG_PATH = os.environ.get(
+    "PERSISTENT_LORA_CATALOG_PATH",
+    "/loras-flux/config/lorasplayground.json",
+)

image_utils.py

@@ -243,6 +243,16 @@ def _resolve_gallery_path(selected_path, gallery_value):
     return current_paths[-1]
 
 
+def resolve_output_download_path(selected_path, gallery_value):
+    """Path for the large Download button under the output gallery.
+
+    Same selection rules as Send→*: honour a still-valid gallery selection,
+    otherwise the latest generated image. Returns None when empty so the
+    DownloadButton stays inactive.
+    """
+    return _resolve_gallery_path(selected_path, gallery_value)
+
+
 def send_output_to_base(selected_path, gallery_value):
     path = _resolve_gallery_path(selected_path, gallery_value)
     if not path:

lora_registry.py

@@ -1,24 +1,32 @@
-"""LoRA catalog + per-session custom LoRA loader.
-
-Two layers of state:
-
-* LORA_STYLES (module-level constant) — the curated catalog, identical for
-  every visitor.
-* dynamic_loras (gr.State, per session) — a session-private dict of any
-  custom HuggingFace LoRAs the user has added via the UI. Other sessions
-  never see them.
-
-Adapter loading itself is tracked in LOADED_ADAPTERS, which is a *legitimate*
-module-level set: it mirrors what's been attached to the shared pipe object
-in generation.py so we don't re-download/re-attach the same weights twice.
+"""LoRA catalog + per-session custom LoRA loader (JSON-first).
+
+Single shared catalog lives in an external JSON file
+(``PERSISTENT_LORA_CATALOG_PATH``, default
+``/loras-flux/config/lorasplayground.json``).
+
+Layers:
+* EXTERNAL_LORA_STYLES — full catalog from JSON (including archived).
+  UI listing only shows entries with ``active: true``.
+* dynamic_loras (gr.State) — session-private try-outs.
+* LOADED_ADAPTERS — names already attached to the shared pipe.
+
+JSON entry fields:
+  title, adapter_name, repo, weights, default_prompt, default_weight,
+  admin_approved (bool), active (bool; false = archived/hidden from UI),
+  sha256 (optional hex digest of the weight file), image (optional).
 """
 from __future__ import annotations
 
+import hashlib
+import json
+import os
+import threading
 import uuid
+from pathlib import Path
 
 import gradio as gr
 
-from config import MAX_LORA_SLOTS
+from config import MAX_LORA_SLOTS, PERSISTENT_LORA_CATALOG_PATH
 
 
 FACE_SWAP_PROMPT = """head_swap: start with Picture 1 as the base image, keeping its lighting, environment, and background. Remove the head from Picture 1 completely and replace it with the head from Picture 2.
@@ -33,25 +41,33 @@ FROM PICTURE 2 (strictly preserve identity):
 - Skin: texture, tone, complexion
 The replaced head must seamlessly match Picture 1's lighting and expression while maintaining the complete identity from Picture 2. High quality, photorealistic, sharp details, 4k."""
 
-# NOTE: MAX_LORA_SLOTS is imported from config.py — do NOT re-declare it here.
+_DEFAULT_LORA_IMAGE = (
+    "https://huggingface.co/spaces/prithivMLmods/FLUX.2-Klein-LoRA-Studio/"
+    "resolve/main/examples/image.webp"
+)
 
-LORA_STYLES = [
-    {
-        "image": "https://huggingface.co/spaces/prithivMLmods/FLUX.2-Klein-LoRA-Studio/resolve/main/examples/image.webp",
-        "title": "None",
-        "adapter_name": None,
-        "repo": None,
-        "weights": None,
-        "default_prompt": None,
-        "default_weight": 1.0,
-    },
+# Seed used only when the external JSON is missing/empty. After first write,
+# the JSON is the single source of truth — nothing here is merged at runtime.
+_SEED_LORA_STYLES = [
     {
         "title": "Klein-Delight-Style",
         "adapter_name": "klein-delight",
         "repo": "linoyts/Flux2-Klein-Delight-LoRA",
         "weights": "pytorch_lora_weights.safetensors",
-        "default_prompt": "Relight the image to remove all existing lighting conditions and replace them with neutral, uniform illumination. Apply soft, evenly distributed lighting with no directional shadows, no harsh highlights, and no dramatic contrast. Maintain the original identity of all subjects exactly—preserve facial structure, skin tone, proportions, expressions, hair, clothing, and textures. Do not alter pose, camera angle, background geometry, or image composition. Lighting should appear balanced, and studio-neutral, similar to diffuse overcast or a soft lightbox setup. Ensure consistent exposure across the entire image with realistic depth and subtle shading only where necessary for form.",
+        "default_prompt": (
+            "Relight the image to remove all existing lighting conditions and replace them "
+            "with neutral, uniform illumination. Apply soft, evenly distributed lighting with "
+            "no directional shadows, no harsh highlights, and no dramatic contrast. Maintain "
+            "the original identity of all subjects exactly—preserve facial structure, skin tone, "
+            "proportions, expressions, hair, clothing, and textures. Do not alter pose, camera "
+            "angle, background geometry, or image composition. Lighting should appear balanced, "
+            "and studio-neutral, similar to diffuse overcast or a soft lightbox setup. Ensure "
+            "consistent exposure across the entire image with realistic depth and subtle shading "
+            "only where necessary for form."
+        ),
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Klein-Consistency",
@@ -60,6 +76,8 @@ LORA_STYLES = [
         "weights": "Klein-consistency.safetensors",
         "default_prompt": None,
         "default_weight": 0.3,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Best-Face-Swap",
@@ -68,6 +86,8 @@ LORA_STYLES = [
         "weights": "bfs_head_v1_flux-klein_9b_step3750_rank64.safetensors",
         "default_prompt": FACE_SWAP_PROMPT,
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "NSFW v2",
@@ -76,14 +96,23 @@ LORA_STYLES = [
         "weights": "Flux Klein - NSFW v2.safetensors",
         "default_prompt": None,
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Ultimate Upscaler Klein-9b",
         "adapter_name": "Ultimate Upscaler",
         "repo": "loras",
         "weights": "Flux2-Klein-Image-RestoreV1.safetensors",
-        "default_prompt": "restore the image quality, remove any compression artefacts, remove any haze and soft edges, enrich the original with new intricate detail in all textures and surfaces creating a professional photorealistic photograph with natural lighting and skin texture.",
+        "default_prompt": (
+            "restore the image quality, remove any compression artefacts, remove any haze "
+            "and soft edges, enrich the original with new intricate detail in all textures "
+            "and surfaces creating a professional photorealistic photograph with natural "
+            "lighting and skin texture."
+        ),
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "High Resolution",
@@ -92,6 +121,8 @@ LORA_STYLES = [
         "weights": "HighResolution9B.safetensors",
         "default_prompt": "High Resolution",
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "InstaPic",
@@ -100,6 +131,8 @@ LORA_STYLES = [
         "weights": "InstaPic V3.safetensors",
         "default_prompt": "instapic",
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Realistic Nudes",
@@ -108,6 +141,8 @@ LORA_STYLES = [
         "weights": "realistic_nudes_klein_v3.safetensors",
         "default_prompt": None,
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Perky Pointy Puffy Breasts",
@@ -116,6 +151,8 @@ LORA_STYLES = [
         "weights": "PerkyPointyPuffy_v1.1_small_pointy_breasts_large_puffy_nipples.safetensors",
         "default_prompt": "Small pointy breasts with large puffy nipples",
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Flat Chested",
@@ -124,6 +161,8 @@ LORA_STYLES = [
         "weights": "Flux2-Klein-9b-FlatChested-v1.safetensors",
         "default_prompt": "flat chested",
         "default_weight": 1.5,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "Controllight",
@@ -132,6 +171,8 @@ LORA_STYLES = [
         "weights": "controllight.safetensors",
         "default_prompt": None,
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "RefControl - Depth",
@@ -140,6 +181,8 @@ LORA_STYLES = [
         "weights": "flux2_klein_9b_refcontrol_depth.safetensors",
         "default_prompt": "refcontrol",
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
     {
         "title": "RefControl - Pose",
@@ -148,31 +191,272 @@ LORA_STYLES = [
         "weights": "refcontrol_v2_poses.safetensors",
         "default_prompt": "apply pose from image 1 with reference from image 2",
         "default_weight": 1.0,
+        "admin_approved": True,
+        "active": True,
     },
 ]
 
+# Back-compat alias — older imports still work; runtime catalog is JSON-only.
+LORA_STYLES: list[dict] = []
 
-# LOADED_ADAPTERS is the only piece of LoRA state that's legitimately global:
-# it just tracks which adapter names have been loaded onto the shared `pipe`
-# at least once, so we don't re-download/re-attach weights on every call.
-# It is NOT used to decide what a user can select — that comes from each
-# session's own `dynamic_loras_state` (a gr.State dict), so one user's custom
-# HuggingFace LoRA never shows up in another user's checklist.
 LOADED_ADAPTERS: set[str] = set()
+_CATALOG_LOCK = threading.Lock()
+EXTERNAL_LORA_STYLES: list[dict] = []  # full JSON list (active + archived)
+
+_WEIGHT_EXTS = (".safetensors", ".bin")
+_DEFAULT_WEIGHT_CANDIDATES = (
+    "pytorch_lora_weights.safetensors",
+    "lora.safetensors",
+    "adapter_model.safetensors",
+)
+_HASH_CHUNK = 1024 * 1024
+
+
+def _sanitize_name(value: str, fallback: str = "custom") -> str:
+    cleaned = "".join(c if c.isalnum() or c in "-_" else "_" for c in (value or ""))
+    return cleaned.strip("_") or fallback
+
+
+def _as_bool(value, default: bool = False) -> bool:
+    if value is None:
+        return default
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+    return default
+
+
+def _file_sha256(path: str | Path) -> str | None:
+    p = Path(path)
+    if not p.is_file():
+        return None
+    h = hashlib.sha256()
+    try:
+        with open(p, "rb") as f:
+            while True:
+                chunk = f.read(_HASH_CHUNK)
+                if not chunk:
+                    break
+                h.update(chunk)
+        return h.hexdigest()
+    except OSError as e:
+        print(f"[lora_registry] sha256 failed for {p}: {e}")
+        return None
+
+
+def _weight_path(repo: str, weights: str) -> Path | None:
+    if not repo or not weights:
+        return None
+    if str(repo).startswith("/"):
+        candidate = Path(repo) / weights
+        if candidate.is_file():
+            return candidate
+    candidate = Path(repo) / weights
+    if candidate.is_file():
+        return candidate
+    if str(repo).endswith(_WEIGHT_EXTS) and Path(repo).is_file():
+        return Path(repo)
+    return None
+
+
+def _compute_entry_sha256(entry: dict) -> str | None:
+    if entry.get("sha256"):
+        return str(entry["sha256"]).lower()
+    path = _weight_path(entry.get("repo", ""), entry.get("weights", ""))
+    if path is None:
+        return None
+    return _file_sha256(path)
+
+
+def _normalize_catalog_entry(raw) -> dict | None:
+    if not isinstance(raw, dict):
+        return None
+    title = (raw.get("title") or "").strip()
+    repo = raw.get("repo")
+    weights = raw.get("weights")
+    if not title or not repo or not weights:
+        return None
+    adapter = (raw.get("adapter_name") or "").strip() or _sanitize_name(title)
+    try:
+        default_weight = float(raw.get("default_weight", 1.0))
+    except (TypeError, ValueError):
+        default_weight = 1.0
+    prompt = raw.get("default_prompt")
+    if isinstance(prompt, str):
+        prompt = prompt.strip() or None
+    else:
+        prompt = None
+
+    if "active" in raw:
+        active = _as_bool(raw.get("active"), True)
+    else:
+        active = not _as_bool(raw.get("archived"), False)
+
+    sha = raw.get("sha256") or raw.get("hash") or raw.get("sha256_hex")
+    if isinstance(sha, str):
+        sha = sha.strip().lower() or None
+    else:
+        sha = None
+
+    return {
+        "image": raw.get("image") or _DEFAULT_LORA_IMAGE,
+        "title": title,
+        "adapter_name": adapter,
+        "repo": str(repo),
+        "weights": str(weights),
+        "default_prompt": prompt,
+        "default_weight": default_weight,
+        "admin_approved": _as_bool(raw.get("admin_approved"), False),
+        "active": active,
+        "sha256": sha,
+    }
+
+
+def _serialize_entry(e: dict) -> dict:
+    out = {
+        "title": e["title"],
+        "adapter_name": e["adapter_name"],
+        "repo": e["repo"],
+        "weights": e["weights"],
+        "default_prompt": e.get("default_prompt"),
+        "default_weight": float(e.get("default_weight", 1.0)),
+        "admin_approved": bool(e.get("admin_approved", False)),
+        "active": bool(e.get("active", True)),
+    }
+    if e.get("sha256"):
+        out["sha256"] = e["sha256"]
+    if e.get("image") and e["image"] != _DEFAULT_LORA_IMAGE:
+        out["image"] = e["image"]
+    return out
+
+
+def _read_catalog_file(path: str | None = None) -> list[dict]:
+    catalog_path = Path(path or PERSISTENT_LORA_CATALOG_PATH)
+    if not catalog_path.is_file():
+        return []
+    try:
+        with open(catalog_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"[lora_registry] Could not read catalog {catalog_path}: {e}")
+        return []
+
+    if isinstance(data, dict):
+        items = data.get("loras") or data.get("styles") or data.get("items") or []
+    elif isinstance(data, list):
+        items = data
+    else:
+        return []
+
+    out, seen_titles = [], set()
+    for raw in items:
+        entry = _normalize_catalog_entry(raw)
+        if not entry or entry["title"] in seen_titles:
+            continue
+        seen_titles.add(entry["title"])
+        out.append(entry)
+    return out
+
+
+def _write_catalog_file(entries: list[dict], path: str | None = None) -> str:
+    catalog_path = Path(path or PERSISTENT_LORA_CATALOG_PATH)
+    catalog_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "version": 2,
+        "loras": [_serialize_entry(e) for e in entries],
+    }
+    tmp_path = catalog_path.with_suffix(catalog_path.suffix + ".tmp")
+    with open(tmp_path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)
+        f.write("\n")
+    os.replace(tmp_path, catalog_path)
+    return str(catalog_path)
+
+
+def _seed_catalog_if_needed(path: str | None = None) -> list[dict]:
+    catalog_path = Path(path or PERSISTENT_LORA_CATALOG_PATH)
+    entries = _read_catalog_file(str(catalog_path))
+    if entries:
+        dirty = False
+        for e in entries:
+            if not e.get("sha256"):
+                digest = _compute_entry_sha256(e)
+                if digest:
+                    e["sha256"] = digest
+                    dirty = True
+        if dirty:
+            try:
+                _write_catalog_file(entries, str(catalog_path))
+            except Exception as ex:
+                print(f"[lora_registry] Could not backfill sha256: {ex}")
+        return entries
+
+    seeded = []
+    for raw in _SEED_LORA_STYLES:
+        entry = _normalize_catalog_entry(raw)
+        if not entry:
+            continue
+        digest = _compute_entry_sha256(entry)
+        if digest:
+            entry["sha256"] = digest
+        seeded.append(entry)
+    try:
+        written = _write_catalog_file(seeded, str(catalog_path))
+        print(f"[lora_registry] Seeded catalog with {len(seeded)} LoRA(s) → {written}")
+    except Exception as e:
+        print(f"[lora_registry] Could not seed catalog at {catalog_path}: {e}")
+    return seeded
+
+
+def load_external_catalog(path: str | None = None) -> list[dict]:
+    global EXTERNAL_LORA_STYLES, LORA_STYLES
+    with _CATALOG_LOCK:
+        EXTERNAL_LORA_STYLES = _seed_catalog_if_needed(path)
+        LORA_STYLES = [e for e in EXTERNAL_LORA_STYLES if e.get("active", True)]
+        print(
+            f"[lora_registry] Catalog: {len(LORA_STYLES)} active / "
+            f"{len(EXTERNAL_LORA_STYLES)} total from "
+            f"{path or PERSISTENT_LORA_CATALOG_PATH}"
+        )
+        return list(EXTERNAL_LORA_STYLES)
+
+
+load_external_catalog()
+
+
+def _active_catalog() -> list[dict]:
+    return [e for e in EXTERNAL_LORA_STYLES if e.get("active", True)]
+
 
+def _find_duplicate(entries: list[dict], *, title=None, sha256=None, repo=None, weights=None):
+    if sha256:
+        sha = str(sha256).lower()
+        for e in entries:
+            if e.get("sha256") and e["sha256"].lower() == sha:
+                return e
+    if title:
+        for e in entries:
+            if e.get("title") == title:
+                return e
+    if repo and weights:
+        for e in entries:
+            if e.get("repo") == repo and e.get("weights") == weights:
+                return e
+    return None
 
-# ── Catalog lookup helpers ────────────────────────────────────────────────────
 
 def get_all_styles(dynamic_loras):
-    all_styles = list(LORA_STYLES)
+    all_styles = list(_active_catalog())
     for dynamic_lora in (dynamic_loras or {}).values():
         all_styles.append(dynamic_lora)
     return all_styles
 
 
 def get_selectable_styles(dynamic_loras):
-    """Return all styles except 'None' for the checkbox selector."""
-    return [s for s in get_all_styles(dynamic_loras) if s["adapter_name"] is not None]
+    return [s for s in get_all_styles(dynamic_loras) if s.get("adapter_name") is not None]
 
 
 def get_style_by_title(title, dynamic_loras):
@@ -189,16 +473,7 @@ def get_style_by_adapter_name(adapter_name, dynamic_loras):
     return None
 
 
-# ── LoRA selection → update weight sliders + LoRA prompt display ──────────────
-
 def update_weight_sliders(selected_titles, dynamic_loras):
-    """Given a list of selected LoRA titles, return updated visibility/label/value
-    for each of the MAX_LORA_SLOTS pre-rendered sliders, plus an update for the
-    LoRA prompt display box (visible when any selected LoRA has a default prompt).
-
-    The user's own prompt is never touched here — LoRA prompts are shown
-    separately and appended at inference time.
-    """
     selected_styles = [
         get_style_by_title(t, dynamic_loras)
         for t in (selected_titles or [])
@@ -226,57 +501,437 @@ def update_weight_sliders(selected_titles, dynamic_loras):
     return slider_updates + [lora_prompt_update]
 
 
-# ── Dynamic HF LoRA loader (per-session) ─────────────────────────────────────
+def _looks_like_local_path(value: str) -> bool:
+    return bool(value) and value.startswith("/")
+
+
+def _resolve_local_lora(path_str: str, weight_name: str | None):
+    path = Path(os.path.expanduser(path_str)).resolve()
+    requested = weight_name.strip() if weight_name and weight_name.strip() else None
+
+    if path.is_file():
+        if path.suffix.lower() not in _WEIGHT_EXTS:
+            raise ValueError(f"Not a LoRA weight file: {path.name}")
+        return str(path.parent), path.name, path.stem
+
+    if not path.is_dir():
+        raise FileNotFoundError(f"Local path not found: {path}")
+
+    if requested:
+        candidate = path / requested
+        if not candidate.is_file():
+            available = sorted(
+                p.name for p in path.iterdir()
+                if p.is_file() and p.suffix.lower() in _WEIGHT_EXTS
+            )
+            raise FileNotFoundError(
+                f"'{requested}' not in {path}. Available: {', '.join(available) or 'None'}"
+            )
+        return str(path), requested, Path(requested).stem
+
+    for name in _DEFAULT_WEIGHT_CANDIDATES:
+        if (path / name).is_file():
+            return str(path), name, path.name
+
+    available = sorted(
+        p.name for p in path.iterdir()
+        if p.is_file() and p.suffix.lower() in _WEIGHT_EXTS
+    )
+    if len(available) == 1:
+        return str(path), available[0], Path(available[0]).stem
+    if not available:
+        raise FileNotFoundError(f"No .safetensors/.bin weights found in {path}")
+    raise FileNotFoundError(
+        f"Multiple weights in {path}; set Weight filename. Available: {', '.join(available)}"
+    )
+
+
+def _resolve_hf_lora(repo_id: str, weight_name: str | None):
+    from huggingface_hub import model_info
+
+    info = model_info(repo_id)
+    actual_weight = weight_name.strip() if weight_name and weight_name.strip() else None
+    if not actual_weight:
+        for name in _DEFAULT_WEIGHT_CANDIDATES:
+            if any(f.filename == name for f in info.siblings):
+                actual_weight = name
+                break
+    if not actual_weight:
+        available = [
+            f.filename for f in info.siblings
+            if f.filename.endswith(_WEIGHT_EXTS)
+        ]
+        raise FileNotFoundError(
+            f"No weight found. Available: {', '.join(available) or 'None'}"
+        )
+
+    sha = None
+    for sib in info.siblings:
+        if sib.filename == actual_weight:
+            lfs = getattr(sib, "lfs", None) or {}
+            if isinstance(lfs, dict):
+                sha = lfs.get("sha256") or lfs.get("oid")
+            break
+
+    display = repo_id.split("/")[-1] if "/" in repo_id else repo_id
+    return repo_id, actual_weight, display, (str(sha).lower() if sha else None)
+
+
+def session_custom_lora_titles(dynamic_loras) -> list[str]:
+    return [s["title"] for s in (dynamic_loras or {}).values() if s.get("title")]
+
+
+def removable_catalog_titles() -> list[str]:
+    return [
+        e["title"] for e in EXTERNAL_LORA_STYLES
+        if not e.get("admin_approved", False)
+    ]
+
+
+def _unique_adapter_name(base: str) -> str:
+    existing = {
+        s["adapter_name"]
+        for s in EXTERNAL_LORA_STYLES
+        if s.get("adapter_name")
+    } | set(LOADED_ADAPTERS)
+    if base not in existing:
+        return base
+    for i in range(2, 1000):
+        candidate = f"{base}_{i}"
+        if candidate not in existing:
+            return candidate
+    return f"{base}_{uuid.uuid4().hex[:6]}"
+
+
+def _empty_add_result(msg, dynamic_loras):
+    save_choices = session_custom_lora_titles(dynamic_loras)
+    remove_choices = save_choices + removable_catalog_titles()
+    return (
+        msg,
+        gr.update(),
+        dynamic_loras,
+        gr.update(choices=save_choices),
+        gr.update(choices=remove_choices),
+    )
+
 
 def add_custom_lora(repo_id, weight_name, adapter_name, dynamic_loras_state):
-    """Adds a custom LoRA to *this session's* state only — other users never see
-    it in their selector. The adapter_name attached to the shared pipe is
-    still made globally unique (via a short random suffix) since the pipe
-    object itself is one shared resource across all sessions.
-    """
     dynamic_loras = dict(dynamic_loras_state or {})
     if not repo_id or not repo_id.strip():
-        return "Please enter a valid HuggingFace repo ID.", gr.update(), dynamic_loras
+        return _empty_add_result(
+            "Please enter a HuggingFace repo ID or a local path "
+            "(e.g. /loras-flux/my.safetensors).",
+            dynamic_loras,
+        )
+
     repo_id = repo_id.strip()
     requested_name = adapter_name.strip() if adapter_name and adapter_name.strip() else None
     try:
-        from huggingface_hub import model_info
-        info = model_info(repo_id)
-        actual_weight = weight_name.strip() if weight_name and weight_name.strip() else None
-        if not actual_weight:
-            for name in ["pytorch_lora_weights.safetensors", "lora.safetensors", "adapter_model.safetensors"]:
-                if any(f.filename == name for f in info.siblings):
-                    actual_weight = name
-                    break
-        if not actual_weight:
-            available = [f.filename for f in info.siblings if f.filename.endswith(('.safetensors', '.bin'))]
+        sha = None
+        if _looks_like_local_path(repo_id):
+            resolved_repo, actual_weight, auto_name = _resolve_local_lora(repo_id, weight_name)
+            source_label = resolved_repo
+            sha = _file_sha256(Path(resolved_repo) / actual_weight)
+        else:
+            resolved_repo, actual_weight, auto_name, sha = _resolve_hf_lora(repo_id, weight_name)
+            source_label = resolved_repo
+
+        with _CATALOG_LOCK:
+            dup = _find_duplicate(
+                EXTERNAL_LORA_STYLES,
+                sha256=sha,
+                repo=resolved_repo,
+                weights=actual_weight,
+            )
+        if dup:
+            where = "active catalog" if dup.get("active", True) else "archived catalog"
             return (
-                f"No weight found. Available: {', '.join(available) or 'None'}",
+                f"⚠️ Already in {where} as '{dup['title']}'"
+                + (f" (sha256 {dup['sha256'][:12]}…)" if dup.get("sha256") else ""),
                 gr.update(),
                 dynamic_loras,
+                gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+                gr.update(choices=session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()),
             )
 
-        base_name = (
-            "".join(c if c.isalnum() or c in "-_" else "_" for c in requested_name)
-            if requested_name else "custom"
-        )
-
-        static_names = {s["adapter_name"] for s in LORA_STYLES if s["adapter_name"]}
+        for s in dynamic_loras.values():
+            if sha and s.get("sha256") and s["sha256"] == sha:
+                return (
+                    f"⚠️ Already added this session as '{s['title']}' (same sha256).",
+                    gr.update(),
+                    dynamic_loras,
+                    gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+                    gr.update(choices=session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()),
+                )
+            if s.get("repo") == resolved_repo and s.get("weights") == actual_weight:
+                return (
+                    f"⚠️ Already added this session as '{s['title']}'.",
+                    gr.update(),
+                    dynamic_loras,
+                    gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+                    gr.update(choices=session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()),
+                )
+
+        base_name = _sanitize_name(requested_name or auto_name, fallback="custom")
+        static_names = {
+            s["adapter_name"] for s in EXTERNAL_LORA_STYLES if s.get("adapter_name")
+        }
         final_adapter_name = f"{base_name}_{uuid.uuid4().hex[:6]}"
         while final_adapter_name in static_names or final_adapter_name in LOADED_ADAPTERS:
             final_adapter_name = f"{base_name}_{uuid.uuid4().hex[:6]}"
 
         custom_style = {
-            "image": "https://huggingface.co/spaces/prithivMLmods/FLUX.2-Klein-LoRA-Studio/resolve/main/examples/image.webp",
+            "image": _DEFAULT_LORA_IMAGE,
             "title": f"Custom: {base_name}",
             "adapter_name": final_adapter_name,
-            "repo": repo_id,
+            "repo": resolved_repo,
             "weights": actual_weight,
             "default_prompt": None,
             "default_weight": 1.0,
+            "admin_approved": False,
+            "active": True,
+            "sha256": sha,
+            "session_only": True,
         }
         dynamic_loras[final_adapter_name] = custom_style
         new_choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
-        return f"✅ Added: {base_name} from {repo_id}", gr.update(choices=new_choices), dynamic_loras
+        save_choices = session_custom_lora_titles(dynamic_loras)
+        remove_choices = save_choices + removable_catalog_titles()
+        hash_note = f", sha256={sha[:12]}…" if sha else ""
+        return (
+            f"✅ Added (session only): {base_name} from {source_label} "
+            f"({actual_weight}{hash_note}). Try it, then save or remove below.",
+            gr.update(choices=new_choices),
+            dynamic_loras,
+            gr.update(choices=save_choices, value=custom_style["title"]),
+            gr.update(choices=remove_choices, value=custom_style["title"]),
+        )
     except Exception as e:
-        return f"❌ Failed: {str(e)}", gr.update(), dynamic_loras
+        return _empty_add_result(f"❌ Failed: {e}", dynamic_loras)
+
+
+def remove_lora(selected_title, dynamic_loras_state, currently_selected):
+    dynamic_loras = dict(dynamic_loras_state or {})
+    if not selected_title:
+        choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+        remove_choices = session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()
+        return (
+            "Pick a LoRA to remove.",
+            gr.update(choices=choices, value=currently_selected or []),
+            gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+            gr.update(choices=remove_choices),
+            dynamic_loras,
+        )
+
+    session_key = None
+    for k, v in dynamic_loras.items():
+        if v.get("title") == selected_title:
+            session_key = k
+            break
+    if session_key is not None:
+        dynamic_loras.pop(session_key, None)
+        new_sel = [t for t in (currently_selected or []) if t != selected_title]
+        choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+        save_choices = session_custom_lora_titles(dynamic_loras)
+        remove_choices = save_choices + removable_catalog_titles()
+        return (
+            f"🗑️ Removed session LoRA '{selected_title}'.",
+            gr.update(choices=choices, value=new_sel),
+            gr.update(choices=save_choices, value=None),
+            gr.update(choices=remove_choices, value=None),
+            dynamic_loras,
+        )
+
+    with _CATALOG_LOCK:
+        entries = _read_catalog_file()
+        global EXTERNAL_LORA_STYLES
+        EXTERNAL_LORA_STYLES = list(entries)
+        idx = next((i for i, e in enumerate(entries) if e["title"] == selected_title), None)
+        if idx is None:
+            choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+            remove_choices = session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()
+            return (
+                f"❌ '{selected_title}' not found in session or catalog.",
+                gr.update(choices=choices),
+                gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+                gr.update(choices=remove_choices),
+                dynamic_loras,
+            )
+        if entries[idx].get("admin_approved", False):
+            choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+            remove_choices = session_custom_lora_titles(dynamic_loras) + removable_catalog_titles()
+            return (
+                f"❌ '{selected_title}' is admin-approved and cannot be removed from the UI. "
+                f"Set active=false in the JSON to archive it.",
+                gr.update(choices=choices),
+                gr.update(choices=session_custom_lora_titles(dynamic_loras)),
+                gr.update(choices=remove_choices),
+                dynamic_loras,
+            )
+        entries.pop(idx)
+        try:
+            path = _write_catalog_file(entries)
+        except Exception as e:
+            return (
+                f"❌ Failed to write catalog: {e}",
+                gr.update(),
+                gr.update(),
+                gr.update(),
+                dynamic_loras,
+            )
+        EXTERNAL_LORA_STYLES = list(entries)
+        LORA_STYLES[:] = [e for e in EXTERNAL_LORA_STYLES if e.get("active", True)]
+
+    new_sel = [t for t in (currently_selected or []) if t != selected_title]
+    choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+    save_choices = session_custom_lora_titles(dynamic_loras)
+    remove_choices = save_choices + removable_catalog_titles()
+    return (
+        f"🗑️ Removed catalog LoRA '{selected_title}' → {path}",
+        gr.update(choices=choices, value=new_sel),
+        gr.update(choices=save_choices, value=None),
+        gr.update(choices=remove_choices, value=None),
+        dynamic_loras,
+    )
+
+
+def save_session_lora_to_catalog(
+    selected_title,
+    catalog_title,
+    default_weight,
+    default_prompt,
+    dynamic_loras_state,
+):
+    dynamic_loras = dict(dynamic_loras_state or {})
+    save_choices = session_custom_lora_titles(dynamic_loras)
+    remove_choices = save_choices + removable_catalog_titles()
+    selector_choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+
+    def _fail(msg):
+        return (
+            msg,
+            gr.update(choices=selector_choices),
+            gr.update(choices=save_choices),
+            gr.update(choices=remove_choices),
+            dynamic_loras,
+        )
+
+    if not selected_title:
+        return _fail("Pick a session LoRA to save (add one above first).")
+
+    source = None
+    source_key = None
+    for k, style in dynamic_loras.items():
+        if style.get("title") == selected_title:
+            source = style
+            source_key = k
+            break
+    if source is None:
+        return _fail(f"❌ '{selected_title}' is not a session custom LoRA.")
+
+    title = (catalog_title or "").strip() or selected_title.removeprefix("Custom: ").strip()
+    if not title:
+        title = source.get("adapter_name") or "Custom LoRA"
+
+    try:
+        weight = float(default_weight) if default_weight is not None else float(
+            source.get("default_weight", 1.0)
+        )
+    except (TypeError, ValueError):
+        weight = 1.0
+
+    prompt = (default_prompt or "").strip() or source.get("default_prompt") or None
+    adapter_base = _sanitize_name(
+        title, fallback=_sanitize_name(source.get("adapter_name", "custom"))
+    )
+    sha = source.get("sha256") or _compute_entry_sha256(source)
+
+    with _CATALOG_LOCK:
+        entries = _read_catalog_file()
+        global EXTERNAL_LORA_STYLES
+        EXTERNAL_LORA_STYLES = list(entries)
+
+        dup = _find_duplicate(
+            entries, sha256=sha, title=title,
+            repo=source["repo"], weights=source["weights"],
+        )
+        if dup and dup["title"] != title:
+            return _fail(
+                f"❌ Duplicate of existing catalog entry '{dup['title']}'"
+                + (" (sha256 match)" if sha and dup.get("sha256") == sha else "")
+            )
+        if dup and dup.get("admin_approved", False) and dup["title"] == title:
+            return _fail(
+                f"❌ '{title}' is admin-approved — edit the JSON directly to change it."
+            )
+
+        existing_idx = next((i for i, e in enumerate(entries) if e["title"] == title), None)
+        if existing_idx is None:
+            adapter_name = _unique_adapter_name(adapter_base)
+            prev_approved = False
+            prev_active = True
+        else:
+            adapter_name = entries[existing_idx].get("adapter_name") or _unique_adapter_name(adapter_base)
+            prev_approved = bool(entries[existing_idx].get("admin_approved", False))
+            prev_active = bool(entries[existing_idx].get("active", True))
+
+        entry = {
+            "image": source.get("image") or _DEFAULT_LORA_IMAGE,
+            "title": title,
+            "adapter_name": adapter_name,
+            "repo": source["repo"],
+            "weights": source["weights"],
+            "default_prompt": prompt,
+            "default_weight": weight,
+            "admin_approved": prev_approved,
+            "active": prev_active,
+            "sha256": sha,
+        }
+
+        if existing_idx is None:
+            entries.append(entry)
+            action = "Saved"
+        else:
+            entries[existing_idx] = entry
+            action = "Updated"
+
+        try:
+            path = _write_catalog_file(entries)
+        except Exception as e:
+            return _fail(f"❌ Failed to write catalog: {e}")
+
+        EXTERNAL_LORA_STYLES = list(entries)
+        LORA_STYLES[:] = [e for e in EXTERNAL_LORA_STYLES if e.get("active", True)]
+
+    if source_key is not None:
+        dynamic_loras.pop(source_key, None)
+
+    selector_choices = [s["title"] for s in get_selectable_styles(dynamic_loras)]
+    save_choices = session_custom_lora_titles(dynamic_loras)
+    remove_choices = save_choices + removable_catalog_titles()
+    hash_note = f", sha256={sha[:12]}…" if sha else ""
+    return (
+        f"✅ {action} '{title}' → {path} (weight={weight}{hash_note})",
+        gr.update(choices=selector_choices),
+        gr.update(choices=save_choices, value=None),
+        gr.update(choices=remove_choices, value=None),
+        dynamic_loras,
+    )
+
+
+def fill_catalog_save_form(selected_title, dynamic_loras_state):
+    if not selected_title:
+        return gr.update(), gr.update(), gr.update()
+    style = None
+    for s in (dynamic_loras_state or {}).values():
+        if s.get("title") == selected_title:
+            style = s
+            break
+    if not style:
+        return gr.update(), gr.update(), gr.update()
+    suggested = selected_title.removeprefix("Custom: ").strip() or selected_title
+    return (
+        gr.update(value=suggested),
+        gr.update(value=float(style.get("default_weight", 1.0))),
+        gr.update(value=style.get("default_prompt") or ""),
+    )

ui_theme.py

@@ -24,7 +24,7 @@ class OrangeRedTheme(Soft):
         neutral_hue: colors.Color | str = colors.slate,
         text_size: sizes.Size | str = sizes.text_lg,
         font: fonts.Font | str | Iterable[fonts.Font | str] = (
-            fonts.GoogleFont("Permanent Marker"), "Arial", "sans-serif",
+            "system-ui", "Segoe UI", "Roboto", "Helvetica Neue", "Arial", "sans-serif",
         ),
         font_mono: fonts.Font | str | Iterable[fonts.Font | str] = (
             fonts.GoogleFont("Ubuntu Mono"), "ui-monospace", "monospace",