fix(sidebar): escape folder names and paths to support double quotes

- Import and use escapeHtml and escapeAttribute in SidebarManager.js - Escape data-path and title attributes in folder tree and breadcrumbs - Use CSS.escape() for attribute selectors in updateTreeSelection - Fixes issue #843 where folders with double quotes broke navigation
fix(autocomplete): add wheel event handler for canvas zoom support
2026-03-21 21:22:11 -03:00 · 2026-03-11 23:33:11 +08:00 · 2026-03-11 20:58:01 +08:00 · 2026-03-09 19:29:13 +08:00 · 2026-03-09 15:49:37 +08:00 · 2026-03-08 21:03:14 +08:00
108 changed files with 11787 additions and 3005 deletions
--- a/.github/workflows/update-supporters.yml
+++ b/.github/workflows/update-supporters.yml
@@ -0,0 +1,31 @@
+name: Update Supporters in README
+
+on:
+  push:
+    paths:
+      - 'data/supporters.json'
+    branches:
+      - main
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  update-readme:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+          
+      - name: Update README
+        run: python scripts/update_supporters.py
+        
+      - name: Commit and push changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "docs: auto-update supporters list in README"
+          file_pattern: "README.md"
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -135,7 +135,7 @@ npm run test:coverage       # Generate coverage report
 - ALWAYS use English for comments (per copilot-instructions.md)
 - Dual mode: ComfyUI plugin (folder_paths) vs standalone (settings.json)
 - Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
- Run `python scripts/sync_translation_keys.py` after UI string updates
+- Run `python scripts/sync_translation_keys.py` after adding UI strings to `locales/en.json`
 - Symlinks require normalized paths

 ## Frontend UI Architecture
--- a/README.md
+++ b/README.md
--- a/data/supporters.json
+++ b/data/supporters.json
@@ -0,0 +1,627 @@
+{
+  "specialThanks": [
+    "dispenser",
+    "EbonEagle",
+    "DanielMagPizza",
+    "Scott R"
+  ],
+  "allSupporters": [
+    "Insomnia Art Designs",
+    "megakirbs",
+    "Brennok",
+    "wackop",
+    "2018cfh",
+    "Takkan",
+    "stone9k",
+    "$MetaSamsara",
+    "itismyelement",
+    "onesecondinosaur",
+    "Carl G.",
+    "Rosenthal",
+    "Francisco Tatis",
+    "Tobi_Swagg",
+    "Andrew Wilson",
+    "Greybush",
+    "Gooohokrbe",
+    "Ricky Carter",
+    "JongWon Han",
+    "OldBones",
+    "VantAI",
+    "runte3221",
+    "FreelancerZ",
+    "Julian V",
+    "Edgar Tejeda",
+    "Birdy",
+    "Liam MacDougal",
+    "Fraser Cross",
+    "Polymorphic Indeterminate",
+    "Marc Whiffen",
+    "Kiba",
+    "Jorge Hussni",
+    "Reno Lam",
+    "Skalabananen",
+    "esthe",
+    "sig",
+    "Christian Byrne",
+    "DM",
+    "Sen314",
+    "Estragon",
+    "J\\B/ 8r0wns0n",
+    "Snaggwort",
+    "Arlecchino Shion",
+    "ClockDaemon",
+    "KD",
+    "Omnidex",
+    "Tyler Trebuchon",
+    "Release Cabrakan",
+    "confiscated Zyra",
+    "SG",
+    "carozzz",
+    "James Dooley",
+    "zenbound",
+    "Buzzard",
+    "jmack",
+    "Adam Shaw",
+    "Tee Gee",
+    "Mark Corneglio",
+    "SarcasticHashtag",
+    "Anthony Rizzo",
+    "tarek helmi",
+    "Cosmosis",
+    "iamresist",
+    "RedrockVP",
+    "Wolffen",
+    "FloPro4Sho",
+    "James Todd",
+    "Steven Pfeiffer",
+    "Tim",
+    "Timmy",
+    "Johnny",
+    "Lisster",
+    "Michael Wong",
+    "Illrigger",
+    "whudunit",
+    "Tom Corrigan",
+    "JackieWang",
+    "fnkylove",
+    "Steven Owens",
+    "Yushio",
+    "Vik71it",
+    "lh qwe",
+    "Echo",
+    "Lilleman",
+    "Robert Stacey",
+    "PM",
+    "Todd Keck",
+    "Briton Heilbrun",
+    "Mozzel",
+    "Gingko Biloba",
+    "Felipe dos Santos",
+    "Penfore",
+    "BadassArabianMofo",
+    "Sterilized",
+    "Pascal Dahle",
+    "Markus",
+    "quarz",
+    "Greg",
+    "Douglas Gaspar",
+    "JSST",
+    "AlexDuKaNa",
+    "George",
+    "lmsupporter",
+    "Phil",
+    "Charles Blakemore",
+    "IamAyam",
+    "wfpearl",
+    "Rob Williams",
+    "Baekdoosixt",
+    "Jonathan Ross",
+    "Jack B Nimble",
+    "Nazono_hito",
+    "Melville Parrish",
+    "daniel dove",
+    "Lustre",
+    "JW Sin",
+    "contrite831",
+    "Alex",
+    "bh",
+    "Marlon Daniels",
+    "Starkselle",
+    "Aaron Bleuer",
+    "LacesOut!",
+    "Graham Colehour",
+    "M Postkasse",
+    "Tomohiro Baba",
+    "David Ortega",
+    "ASLPro3D",
+    "Jacob Hoehler",
+    "FinalyFree",
+    "Weasyl",
+    "Lex Song",
+    "Cory Paza",
+    "Tak",
+    "Gonzalo Andre Allendes Lopez",
+    "Zach Gonser",
+    "Big Red",
+    "Jimmy Ledbetter",
+    "Luc Job",
+    "dl0901dm",
+    "Philip Hempel",
+    "corde",
+    "Nick Walker",
+    "Bishoujoker",
+    "conner",
+    "aai",
+    "Yaboi",
+    "Tori",
+    "wildnut",
+    "Princess Bright Eyes",
+    "Damon Cunliffe",
+    "CryptoTraderJK",
+    "Davaitamin",
+    "AbstractAss",
+    "ViperC",
+    "Aleksander Wujczyk",
+    "AM Kuro",
+    "jean jahren",
+    "Ran C",
+    "tedcor",
+    "S Sang",
+    "MagnaInsomnia",
+    "Akira_HentAI",
+    "Karl P.",
+    "Gordon Cole",
+    "yuxz69",
+    "MadSpin",
+    "andrew.tappan",
+    "dw",
+    "N/A",
+    "The Spawn",
+    "graysock",
+    "Greenmoustache",
+    "zounic",
+    "Gamalonia",
+    "fancypants",
+    "Vir",
+    "Joboshy",
+    "Digital",
+    "JaxMax",
+    "takyamtom",
+    "Bohemian Corporal",
+    "奚明 刘",
+    "Dan",
+    "Seth Christensen",
+    "Jwk0205",
+    "Bro Xie",
+    "Draven T",
+    "yer fey",
+    "batblue",
+    "carey6409",
+    "Olive",
+    "太郎 ゲーム",
+    "Some Guy Named Barry",
+    "jinxedx",
+    "Aquatic Coffee",
+    "Max Marklund",
+    "AELOX",
+    "Dankin",
+    "Nicfit23",
+    "Noora",
+    "ethanfel",
+    "wamekukyouzin",
+    "drum matthieu",
+    "Dogmaster",
+    "Matt Wenzel",
+    "Mattssn",
+    "Frank Nitty",
+    "John Saveas",
+    "Focuschannel",
+    "Christopher Michel",
+    "Serge Bekenkamp",
+    "LeoZero",
+    "Antonio Pontes",
+    "ApathyJones",
+    "nahinahi9",
+    "Anthony Faxlandez",
+    "Dustin Chen",
+    "dan",
+    "Blackfish95",
+    "Mouthlessman",
+    "Steam Steam",
+    "Paul Kroll",
+    "otaku fra",
+    "semicolon drainpipe",
+    "Thesharingbrother",
+    "Fotek Design",
+    "Bas Imagineer",
+    "Pat Hen",
+    "ResidentDeviant",
+    "Adam Taylor",
+    "JC",
+    "Weird_With_A_Beard",
+    "Prompt Pirate",
+    "Pozadine1",
+    "uwutismxd",
+    "Qarob",
+    "AIGooner",
+    "inbijiburu",
+    "decoy",
+    "Luc",
+    "ProtonPrince",
+    "DiffDuck",
+    "elu3199",
+    "Nick “Loadstone” D",
+    "Hasturkun",
+    "Jon Sandman",
+    "Ubivis",
+    "CloudValley",
+    "thesoftwaredruid",
+    "wundershark",
+    "mr_dinosaur",
+    "Tyrswood",
+    "linnfrey",
+    "zenobeus",
+    "Jackthemind",
+    "Stryker",
+    "Pkrsky",
+    "raf8osz",
+    "blikkies",
+    "Josef Lanzl",
+    "Griffin Dahlberg",
+    "준희 김",
+    "Error_Rule34_Not_found",
+    "Gerald Welly",
+    "Shock Shockor",
+    "Roslynd",
+    "Geolog",
+    "Goldwaters",
+    "Neco28",
+    "Zude",
+    "Cristian Vazquez",
+    "Kyler",
+    "Magic Noob",
+    "aRtFuL_DodGeR",
+    "X",
+    "DougPeterson",
+    "Jeff",
+    "Bruce",
+    "CrimsonDX",
+    "Kevin John Duck",
+    "Kevin Christopher",
+    "Ouro Boros",
+    "DarkSunset",
+    "dd",
+    "Billy Gladky",
+    "Probis",
+    "shrshpp",
+    "Dušan Ryban",
+    "ItsGeneralButtNaked",
+    "sjon kreutz",
+    "Nimess",
+    "John Statham",
+    "Youguang",
+    "Nihongasuki",
+    "Metryman55",
+    "andrewzpong",
+    "FrxzenSnxw",
+    "BossGame",
+    "Ray Wing",
+    "Ranzitho",
+    "Gus",
+    "地獄の禄",
+    "MJG",
+    "David LaVallee",
+    "ae",
+    "Tr4shP4nda",
+    "WRL_SPR",
+    "capn",
+    "Joseph",
+    "lrdchs",
+    "Mirko Katzula",
+    "dan",
+    "Piccio08",
+    "kumakichi",
+    "cppbel",
+    "starbugx",
+    "Moon Knight",
+    "몽타주",
+    "Kland",
+    "Hailshem",
+    "ryoma",
+    "John Martin",
+    "Chris",
+    "Brian M",
+    "Nerezza",
+    "sanborondon",
+    "moranqianlong",
+    "Taylor Funk",
+    "aezin",
+    "Thought2Form",
+    "jcay015",
+    "Kevin Picco",
+    "Erik Lopez",
+    "Mateo Curić",
+    "Haru Yotu",
+    "Eris3D",
+    "m",
+    "Pierce McBride",
+    "Joshua Gray",
+    "Mikko Hemilä",
+    "Matura Arbeit",
+    "Jamie Ogletree",
+    "TBitz33",
+    "Emil Bernhoff",
+    "a _",
+    "SendingRavens",
+    "James Coleman",
+    "Martial",
+    "battu",
+    "Emil Andersson",
+    "Chad Idk",
+    "Michael Docherty",
+    "Yuji Kaneko",
+    "elitassj",
+    "Jacob Winter",
+    "Jordan Shaw",
+    "Sam",
+    "Rops Alot",
+    "SRDB",
+    "g unit",
+    "Ace Ventura",
+    "David",
+    "Meilo",
+    "Pen Bouryoung",
+    "shinonomeiro",
+    "Snille",
+    "MaartenAlbers",
+    "khanh duy",
+    "xybrightsummer",
+    "jreedatchison",
+    "PhilW",
+    "momokai",
+    "Janik",
+    "kudari",
+    "Naomi Hale Danchi",
+    "dc7431",
+    "ken",
+    "Inversity",
+    "Crocket",
+    "AIVORY3D",
+    "epicgamer0020690",
+    "Joshua Porrata",
+    "Cruel",
+    "keemun",
+    "SuBu",
+    "RedPIXel",
+    "MRBlack",
+    "Kevinj",
+    "Wind",
+    "Nexus",
+    "Mitchell Robson",
+    "Ramneek“Guy”Ashok",
+    "squid_actually",
+    "Nat_20",
+    "Kiyoe",
+    "Edward Weeks",
+    "kyoumei",
+    "RadStorm04",
+    "JohnDoe42054",
+    "BillyHill",
+    "humptynutz",
+    "emyth",
+    "michael.isaza",
+    "Kalnei",
+    "chriphost",
+    "KitKatM",
+    "socrasteeze",
+    "ResidentDeviant",
+    "Scott",
+    "gzmzmvp",
+    "Welkor",
+    "hayden",
+    "Richard",
+    "ahoystan",
+    "Leland Saunders",
+    "Andrew",
+    "Bob Barker",
+    "Robert Wegemund",
+    "Littlehuggy",
+    "Gregory Kozhemiak",
+    "mrjuan",
+    "Aeternyx",
+    "Brian Buie",
+    "YOU SINWOO",
+    "Sadlip",
+    "ja s",
+    "Eric Whitney",
+    "Doug Mason",
+    "Joey Callahan",
+    "Ivan Tadic",
+    "y2Rxy7FdXzWo",
+    "Jeremy Townsend",
+    "Mike Simone",
+    "Sean voets",
+    "Owen Gwosdz",
+    "Morgandel",
+    "Thomas Wanner",
+    "Kyron Mahan",
+    "Theerat Jiramate",
+    "Noah",
+    "Jacob McDaniel",
+    "kevin stoddard",
+    "Sloan Steddy",
+    "Jack Dole",
+    "Ezokewn",
+    "Temikus",
+    "Artokun",
+    "Michael Taylor",
+    "Derek Baker",
+    "Michael Anthony Scott",
+    "Atilla Berke Pekduyar",
+    "Maso",
+    "Nathan",
+    "Decx _",
+    "Kevin Wallace",
+    "Matheus Couto",
+    "Paul Hartsuyker",
+    "ChicRic",
+    "mercur",
+    "J C",
+    "Distortik",
+    "Yves Poezevara",
+    "Teriak47",
+    "Just me",
+    "Raf Stahelin",
+    "Вячеслав Маринин",
+    "Cola Matthew",
+    "OniNoKen",
+    "Iain Wisely",
+    "Zertens",
+    "NOHOW",
+    "Apo",
+    "nekotxt",
+    "choowkee",
+    "Clusters",
+    "ibrahim",
+    "Highlandrise",
+    "philcoraz",
+    "mztn",
+    "ImagineerNL",
+    "MrAcrtosSursus",
+    "al300680",
+    "pixl",
+    "Robin",
+    "chahknoir",
+    "Marcus thronico",
+    "nd",
+    "keno94d",
+    "James Melzer",
+    "Bartleby",
+    "Renvertere",
+    "Rahuy",
+    "Hermann003",
+    "D",
+    "Foolish",
+    "RevyHiep",
+    "Captain_Swag",
+    "obkircher",
+    "Tree Tagger",
+    "gwyar",
+    "D",
+    "edgecase",
+    "Neoxena",
+    "mrmhalo",
+    "dg",
+    "Whitepinetrader",
+    "Maarten Harms",
+    "OrganicArtifact",
+    "四糸凜音",
+    "MudkipMedkitz",
+    "Israel",
+    "deanbrian",
+    "POPPIN",
+    "Muratoraccio",
+    "SelfishMedic",
+    "Ginnie",
+    "Alex Wortman",
+    "Cody",
+    "adderleighn",
+    "Raku",
+    "smart.edge5178",
+    "emadsultan",
+    "InformedViewz",
+    "CHKeeho80",
+    "Bubbafett",
+    "leaf",
+    "Menard",
+    "Skyfire83",
+    "Adam Rinehart",
+    "D",
+    "Pitpe11",
+    "TheD1rtyD03",
+    "EnragedAntelope",
+    "moonpetal",
+    "SomeDude",
+    "g9p0o",
+    "nanana",
+    "TheHolySheep",
+    "Monte Won",
+    "SpringBootisTrash",
+    "carsten",
+    "ikok",
+    "Buecyb99",
+    "4IXplr0r3r",
+    "Coeur+de+cochon",
+    "David Schenck",
+    "han b",
+    "Nico",
+    "Wolfe7D1",
+    "Banana Joe",
+    "_ G3n",
+    "Donovan Jenkins",
+    "Ink Temptation",
+    "edk",
+    "Michael Eid",
+    "beersandbacon",
+    "Maximilian Pyko",
+    "Invis",
+    "Kalli Core",
+    "Justin Houston",
+    "james",
+    "elleshar666",
+    "OrochiNights",
+    "Michael Zhu",
+    "ACTUALLY_the_Real_Willem_Dafoe",
+    "gonzalo",
+    "Seraphy",
+    "雨の心 落",
+    "AllTimeNoobie",
+    "jumpd",
+    "John C",
+    "Kauffy",
+    "Rim",
+    "Dismem",
+    "EpicElric",
+    "John J Linehan",
+    "Xan Dionysus",
+    "Nathan lee",
+    "Mewtora",
+    "Elliot E",
+    "Middo",
+    "Forbidden Atelier",
+    "Edward Kennedy",
+    "Justin Blaylock",
+    "Adictedtohumping",
+    "Devil Lude",
+    "Nick Kage",
+    "Towelie",
+    "Vane Holzer",
+    "psytrax",
+    "Cyrus Fett",
+    "Jean-françois SEMA",
+    "Kurt",
+    "hexxish",
+    "giani kidd",
+    "CptNeo",
+    "notedfakes",
+    "Chase Kwon",
+    "Goober719",
+    "Eric Ketchum",
+    "Chad Barnes",
+    "NICHOLAS BAXLEY",
+    "Michael Scott",
+    "James Ming",
+    "vanditking",
+    "kripitonga",
+    "Rizzi",
+    "nimin",
+    "OMAR LUCIANO",
+    "Jo+Example",
+    "BrentBertram",
+    "eumelzocker",
+    "dxjaymz",
+    "L C",
+    "Dude"
+  ],
+  "totalCount": 620
+}
--- a/docs/features/recipe-batch-import-requirements.md
+++ b/docs/features/recipe-batch-import-requirements.md
@@ -0,0 +1,170 @@
+# Recipe Batch Import Feature Requirements
+
+## Overview
+Enable users to import multiple images as recipes in a single operation, rather than processing them individually. This feature addresses the need for efficient bulk recipe creation from existing image collections.
+
+## User Stories
+
+### US-1: Directory Batch Import
+As a user with a folder of reference images or workflow screenshots, I want to import all images from a directory at once so that I don't have to import them one by one.
+
+**Acceptance Criteria:**
+- User can specify a local directory path containing images
+- System discovers all supported image files in the directory
+- Each image is analyzed for metadata and converted to a recipe
+- Results show which images succeeded, failed, or were skipped
+
+### US-2: URL Batch Import
+As a user with a list of image URLs (e.g., from Civitai or other sources), I want to import multiple images by URL in one operation.
+
+**Acceptance Criteria:**
+- User can provide multiple image URLs (one per line or as a list)
+- System downloads and processes each image
+- URL-specific metadata (like Civitai info) is preserved when available
+- Failed URLs are reported with clear error messages
+
+### US-3: Concurrent Processing Control
+As a user with varying system resources, I want to control how many images are processed simultaneously to balance speed and system load.
+
+**Acceptance Criteria:**
+- User can configure the number of concurrent operations (1-10)
+- System provides sensible defaults based on common hardware configurations
+- Processing respects the concurrency limit to prevent resource exhaustion
+
+### US-4: Import Results Summary
+As a user performing a batch import, I want to see a clear summary of the operation results so I understand what succeeded and what needs attention.
+
+**Acceptance Criteria:**
+- Total count of images processed is displayed
+- Number of successfully imported recipes is shown
+- Number of failed imports with error details is provided
+- Number of skipped images (no metadata) is indicated
+- Results can be exported or saved for reference
+
+### US-5: Progress Visibility
+As a user importing a large batch, I want to see the progress of the operation so I know it's working and can estimate completion time.
+
+**Acceptance Criteria:**
+- Progress indicator shows current status (e.g., "Processing image 5 of 50")
+- Real-time updates as each image completes
+- Ability to view partial results before completion
+- Clear indication when the operation is finished
+
+## Functional Requirements
+
+### FR-1: Image Discovery
+The system shall discover image files in a specified directory recursively or non-recursively based on user preference.
+
+**Supported formats:** JPG, JPEG, PNG, WebP, GIF, BMP
+
+### FR-2: Metadata Extraction
+For each image, the system shall:
+- Extract EXIF metadata if present
+- Parse embedded workflow data (ComfyUI PNG metadata)
+- Fetch external metadata for known URL patterns (e.g., Civitai)
+- Generate recipes from extracted information
+
+### FR-3: Concurrent Processing
+The system shall support concurrent processing of multiple images with:
+- Configurable concurrency limit (default: 3)
+- Resource-aware execution
+- Graceful handling of individual failures without stopping the batch
+
+### FR-4: Error Handling
+The system shall handle various error conditions:
+- Invalid directory paths
+- Inaccessible files
+- Network errors for URL imports
+- Images without extractable metadata
+- Malformed or corrupted image files
+
+### FR-5: Recipe Persistence
+Successfully analyzed images shall be persisted as recipes with:
+- Extracted generation parameters
+- Preview image association
+- Tags and metadata
+- Source information (file path or URL)
+
+## Non-Functional Requirements
+
+### NFR-1: Performance
+- Batch operations should complete in reasonable time (< 5 seconds per image on average)
+- UI should remain responsive during batch operations
+- Memory usage should scale gracefully with batch size
+
+### NFR-2: Scalability
+- Support batches of 1-1000 images
+- Handle mixed success/failure scenarios gracefully
+- No hard limits on concurrent operations (configurable)
+
+### NFR-3: Usability
+- Clear error messages for common failure cases
+- Intuitive UI for configuring import options
+- Accessible from the main Recipes interface
+
+### NFR-4: Reliability
+- Failed individual imports should not crash the entire batch
+- Partial results should be preserved on unexpected termination
+- All operations should be idempotent (re-importing same image doesn't create duplicates)
+
+## API Requirements
+
+### Batch Import Endpoints
+The system should expose endpoints for:
+
+1. **Directory Import**
+   - Accept directory path and configuration options
+   - Return operation ID for status tracking
+   - Async or sync operation support
+
+2. **URL Import**
+   - Accept list of URLs and configuration options
+   - Support URL validation before processing
+   - Return operation ID for status tracking
+
+3. **Status/Progress**
+   - Query operation status by ID
+   - Get current progress and partial results
+   - Retrieve final results after completion
+
+## UI/UX Requirements
+
+### UIR-1: Entry Point
+Batch import should be accessible from the Recipes page via a clearly labeled button in the toolbar.
+
+### UIR-2: Import Modal
+A modal dialog should provide:
+- Tab or section for Directory import
+- Tab or section for URL import
+- Configuration options (concurrency, options)
+- Start/Stop controls
+- Results display area
+
+### UIR-3: Results Display
+Results should be presented with:
+- Summary statistics (total, success, failed, skipped)
+- Expandable details for each category
+- Export or copy functionality for results
+- Clear visual distinction between success/failure/skip
+
+## Future Considerations
+
+- **Scheduled Imports**: Ability to schedule batch imports for later execution
+- **Import Templates**: Save import configurations for reuse
+- **Cloud Storage**: Import from cloud storage services (Google Drive, Dropbox)
+- **Duplicate Detection**: Advanced duplicate detection based on image hash
+- **Tag Suggestions**: AI-powered tag suggestions for imported recipes
+- **Batch Editing**: Apply tags or organization to multiple imported recipes at once
+
+## Dependencies
+
+- Recipe analysis service (metadata extraction)
+- Recipe persistence service (storage)
+- Image download capability (for URL imports)
+- Recipe scanner (for refresh after import)
+- Civitai client (for enhanced URL metadata)
+
+---
+
+*Document Version: 1.0*
+*Status: Requirements Definition*
--- a/docs/ui-ux-optimization/progress-tracker.md
+++ b/docs/ui-ux-optimization/progress-tracker.md
@@ -0,0 +1,196 @@
+# Settings Modal Optimization Progress Tracker
+
+## Project Overview
+**Goal**: Optimize Settings Modal UI/UX with left navigation sidebar
+**Started**: 2026-02-23
+**Current Phase**: P2 - Search Bar (Completed)
+
+---
+
+## Phase 0: Left Navigation Sidebar (P0)
+
+### Status: Completed ✓
+
+### Completion Notes
+- All CSS changes implemented
+- HTML structure restructured successfully  
+- JavaScript navigation functionality added
+- Translation keys added and synchronized
+- Ready for testing and review
+
+### Tasks
+
+#### 1. CSS Changes
+- [x] Add two-column layout styles
+  - [x] `.settings-modal` flex layout
+  - [x] `.settings-nav` sidebar styles
+  - [x] `.settings-content` content area styles
+  - [x] `.settings-nav-item` navigation item styles
+  - [x] `.settings-nav-item.active` active state styles
+- [x] Adjust modal width to 950px
+- [x] Add smooth scroll behavior
+- [x] Add responsive styles for mobile
+- [x] Ensure dark theme compatibility
+
+#### 2. HTML Changes
+- [x] Restructure modal HTML
+  - [x] Wrap content in two-column container
+  - [x] Add navigation sidebar structure
+  - [x] Add navigation items for each section
+  - [x] Add ID anchors to each section
+- [x] Update section grouping if needed
+
+#### 3. JavaScript Changes
+- [x] Add navigation click handlers
+- [x] Implement smooth scroll to section
+- [x] Add scroll spy for active nav highlighting
+- [x] Handle nav item click events
+- [x] Update SettingsManager initialization
+
+#### 4. Translation Keys
+- [x] Add translation keys for navigation groups
+  - [x] `settings.nav.general`
+  - [x] `settings.nav.interface`
+  - [x] `settings.nav.download`
+  - [x] `settings.nav.advanced`
+
+#### 4. Testing
+- [x] Verify navigation clicks work
+- [x] Verify active highlighting works
+- [x] Verify smooth scrolling works
+- [ ] Test on mobile viewport (deferred to final QA)
+- [ ] Test dark/light theme (deferred to final QA)
+- [x] Verify all existing settings work
+- [x] Verify save/load functionality
+
+### Blockers
+None currently
+
+### Notes
+- Started implementation on 2026-02-23
+- Following existing design system and CSS variables
+
+---
+
+## Phase 1: Section Collapse/Expand (P1)
+
+### Status: Completed ✓
+
+### Completion Notes
+- All sections now have collapse/expand functionality
+- Chevron icon rotates smoothly on toggle
+- State persistence via localStorage working correctly
+- CSS animations for smooth height transitions
+- Settings order reorganized to match sidebar navigation
+
+### Tasks
+- [x] Add collapse/expand toggle to section headers
+- [x] Add chevron icon with rotation animation
+- [x] Implement localStorage for state persistence
+- [x] Add CSS animations for smooth transitions
+- [x] Reorder settings sections to match sidebar navigation
+
+---
+
+## Phase 2: Search Bar (P1)
+
+### Status: Completed ✓
+
+### Completion Notes
+- Search input added to settings modal header with icon and clear button
+- Real-time filtering with debounced input (150ms delay)
+- Highlight matching terms with accent color background
+- Handle empty search results with user-friendly message
+- Keyboard shortcuts: Escape to clear search
+- Sections with matches are automatically expanded
+- All translation keys added and synchronized across languages
+
+### Tasks
+- [x] Add search input to header area
+- [x] Implement real-time filtering
+- [x] Add highlight for matched terms
+- [x] Handle empty search results
+
+---
+
+## Phase 3: Visual Hierarchy (P2)
+
+### Status: Planned
+
+### Tasks
+- [ ] Add accent border to section headers
+- [ ] Bold setting labels
+- [ ] Increase section spacing
+
+---
+
+## Phase 4: Quick Actions (P3)
+
+### Status: Planned
+
+### Tasks
+- [ ] Add reset to defaults button
+- [ ] Add export config button
+- [ ] Add import config button
+- [ ] Implement corresponding functionality
+
+---
+
+## Change Log
+
+### 2026-02-23 (P2)
+- Completed Phase 2: Search Bar
+- Added search input to settings modal header with search icon and clear button
+- Implemented real-time filtering with 150ms debounce for performance
+- Added visual highlighting for matched search terms using accent color
+- Implemented empty search results state with user-friendly message
+- Added keyboard shortcuts (Escape to clear search)
+- Sections with matching content are automatically expanded during search
+- Updated SettingsManager.js with search initialization and filtering logic
+- Added comprehensive CSS styles for search input, highlights, and responsive design
+- Added translation keys for search feature (placeholder, clear, no results)
+- Synchronized translations across all language files
+
+### 2026-02-23 (P1)
+- Completed Phase 1: Section Collapse/Expand
+- Added collapse/expand functionality to all settings sections
+- Implemented chevron icon with smooth rotation animation
+- Added localStorage persistence for collapse state
+- Reorganized settings sections to match sidebar navigation order
+- Updated SettingsManager.js with section collapse initialization
+- Added CSS styles for smooth transitions and animations
+
+### 2026-02-23 (P0)
+- Created project documentation
+- Started Phase 0 implementation
+- Analyzed existing code structure
+- Implemented two-column layout with left navigation sidebar
+- Added CSS styles for navigation and responsive design
+- Restructured HTML to support new layout
+- Added JavaScript navigation functionality with scroll spy
+- Added translation keys for navigation groups
+- Synchronized translations across all language files
+- Tested in browser - navigation working correctly
+
+---
+
+## Testing Checklist
+
+### Functional Testing
+- [ ] All settings save correctly
+- [ ] All settings load correctly
+- [ ] Navigation scrolls to correct section
+- [ ] Active nav updates on scroll
+- [ ] Mobile responsive layout
+
+### Visual Testing
+- [ ] Design matches existing UI
+- [ ] Dark theme looks correct
+- [ ] Light theme looks correct
+- [ ] Animations are smooth
+- [ ] No layout shifts or jumps
+
+### Cross-browser Testing
+- [ ] Chrome/Chromium
+- [ ] Firefox
+- [ ] Safari (if available)
--- a/docs/ui-ux-optimization/settings-modal-optimization-proposal.md
+++ b/docs/ui-ux-optimization/settings-modal-optimization-proposal.md
@@ -0,0 +1,331 @@
+# Settings Modal UI/UX Optimization
+
+## Overview
+当前Settings Modal采用单列表长页面设计，随着设置项不断增加，已难以高效浏览和定位。本方案采用 **macOS Settings 模式**（左侧导航 + 右侧单Section独占显示），在保持原有设计语言的前提下，重构信息架构，大幅提升用户体验。
+
+## Goals
+1. **提升浏览效率**：用户能够快速定位和修改设置
+2. **保持设计一致性**：延续现有的颜色、间距、动画系统
+3. **简化交互模型**：移除冗余元素（SETTINGS label、折叠功能）
+4. **清晰的视觉层次**：Section级导航，右侧独占显示
+5. **向后兼容**：不影响现有功能逻辑
+
+## Design Principles
+- **macOS Settings模式**：点击左侧导航，右侧仅显示该Section内容
+- **贴近原有设计语言**：使用现有CSS变量和样式模式
+- **最小化风格改动**：在提升UX的同时保持视觉风格稳定
+- **简化优于复杂**：移除不必要的折叠/展开交互
+
+---
+
+## New Design Architecture
+
+### Layout Structure
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Settings                                    [×]            │
+├──────────────┬──────────────────────────────────────────────┤
+│  NAVIGATION  │  CONTENT                                     │
+│              │                                              │
+│  General   → │  ┌─────────────────────────────────────────┐ │
+│  Interface   │  │ General                                 │ │
+│  Download    │  │ ═══════════════════════════════════════ │ │
+│  Advanced    │  │                                           │ │
+│              │  │ ┌─────────────────────────────────────┐   │ │
+│              │  │ │ Civitai API Key                     │   │ │
+│              │  │ │ [                         ] [?]     │   │ │
+│              │  │ └─────────────────────────────────────┘   │ │
+│              │  │                                           │ │
+│              │  │ ┌─────────────────────────────────────┐   │ │
+│              │  │ │ Settings Location                   │   │ │
+│              │  │ │ [/path/to/settings]     [Browse]    │   │ │
+│              │  │ └─────────────────────────────────────┘   │ │
+│              │  └─────────────────────────────────────────┘ │
+│              │                                              │
+│              │  [Cancel]                    [Save Changes]  │
+└──────────────┴──────────────────────────────────────────────┘
+```
+
+### Key Design Decisions
+
+#### 1. 移除冗余元素
+- ❌ 删除 sidebar 中的 "SETTINGS" label
+- ❌ **取消折叠/展开功能**（增加交互成本，无实际收益）
+- ❌ 不再在左侧导航显示具体设置项（减少认知负荷）
+
+#### 2. 导航简化
+- 左侧仅显示 **4个Section**（General / Interface / Download / Advanced）
+- 当前选中项用 accent 色 background highlight
+- 无需滚动监听，点击即切换
+
+#### 3. 右侧单Section独占
+- 点击左侧导航，右侧仅显示该Section的所有设置项
+- Section标题作为页面标题（大号字体 + accent色下划线）
+- 所有设置项平铺展示，无需折叠
+
+#### 4. 视觉层次
+```
+Section Header (20px, bold, accent underline)
+├── Setting Group (card container, subtle border)
+│   ├── Setting Label (14px, semibold)
+│   ├── Setting Description (12px, muted color)
+│   └── Setting Control (input/select/toggle)
+```
+
+---
+
+## Optimization Phases
+
+### Phase 0: macOS Settings模式重构 (P0)
+**Status**: Ready for Development
+**Priority**: High
+
+#### Goals
+- 重构为两栏布局（左侧导航 + 右侧内容）
+- 实现Section级导航切换
+- 优化视觉层次和间距
+- 移除冗余元素
+
+#### Implementation Details
+
+##### Layout Specifications
+| Element | Specification |
+|---------|--------------|
+| Modal Width | 800px (比原700px稍宽) |
+| Modal Height | 600px (固定高度) |
+| Left Sidebar | 200px 固定宽度 |
+| Right Content | flex: 1，自动填充 |
+| Content Padding | --space-3 (24px) |
+
+##### Navigation Structure
+```
+General (通用)
+├── Language
+├── Civitai API Key
+└── Settings Location
+
+Interface (界面)
+├── Layout Settings
+├── Video Settings
+└── Content Filtering
+
+Download (下载)
+├── Folder Settings
+├── Download Path Templates
+├── Example Images
+└── Update Flags
+
+Advanced (高级)
+├── Priority Tags
+├── Auto-organize exclusions
+├── Metadata refresh skip paths
+├── Metadata Archive Database
+├── Proxy Settings
+└── Misc
+```
+
+##### CSS Style Guide
+
+**Section Header**
+```css
+.settings-section-header {
+  font-size: 20px;
+  font-weight: 600;
+  padding-bottom: var(--space-2);
+  border-bottom: 2px solid var(--lora-accent);
+  margin-bottom: var(--space-3);
+}
+```
+
+**Setting Group (Card)**
+```css
+.settings-group {
+  background: var(--card-bg);
+  border: 1px solid var(--lora-border);
+  border-radius: var(--border-radius-sm);
+  padding: var(--space-3);
+  margin-bottom: var(--space-3);
+}
+```
+
+**Setting Item**
+```css
+.setting-item {
+  margin-bottom: var(--space-3);
+}
+
+.setting-item:last-child {
+  margin-bottom: 0;
+}
+
+.setting-label {
+  font-size: 14px;
+  font-weight: 500;
+  margin-bottom: var(--space-1);
+}
+
+.setting-description {
+  font-size: 12px;
+  color: var(--text-muted);
+  margin-bottom: var(--space-2);
+}
+```
+
+**Sidebar Navigation**
+```css
+.settings-nav-item {
+  padding: var(--space-2) var(--space-3);
+  border-radius: var(--border-radius-xs);
+  cursor: pointer;
+  transition: background 0.2s ease;
+}
+
+.settings-nav-item:hover {
+  background: rgba(255, 255, 255, 0.05);
+}
+
+.settings-nav-item.active {
+  background: var(--lora-accent);
+  color: white;
+}
+```
+
+#### Files to Modify
+
+1. **static/css/components/modal/settings-modal.css**
+   - [ ] 新增两栏布局样式
+   - [ ] 新增侧边栏导航样式
+   - [ ] 新增Section标题样式
+   - [ ] 调整设置项卡片样式
+   - [ ] 移除折叠相关的CSS
+
+2. **templates/components/modals/settings_modal.html**
+   - [ ] 重构为两栏HTML结构
+   - [ ] 添加4个导航项
+   - [ ] 将Section改为独立内容区域
+   - [ ] 移除折叠按钮HTML
+
+3. **static/js/managers/SettingsManager.js**
+   - [ ] 添加导航点击切换逻辑
+   - [ ] 添加Section显示/隐藏控制
+   - [ ] 移除折叠/展开相关代码
+   - [ ] 默认显示第一个Section
+
+---
+
+### Phase 1: 搜索功能 (P1)
+**Status**: Planned
+**Priority**: Medium
+
+#### Goals
+- 快速定位特定设置项
+- 支持关键词搜索设置标签和描述
+
+#### Implementation
+- 搜索框保持在顶部右侧
+- 实时过滤：显示匹配的Section和设置项
+- 高亮匹配的关键词
+- 无结果时显示友好提示
+
+---
+
+### Phase 2: 操作按钮优化 (P2)
+**Status**: Planned
+**Priority**: Low
+
+#### Goals
+- 增强功能完整性
+- 提供批量操作能力
+
+#### Implementation
+- 底部固定操作栏（position: sticky）
+- [Cancel] 和 [Save Changes] 按钮
+- 可选：重置为默认、导出配置、导入配置
+
+---
+
+## Migration Notes
+
+### Removed Features
+| Feature | Reason |
+|---------|--------|
+| Section折叠/展开 | 单Section独占显示后不再需要 |
+| 滚动监听高亮 | 改为点击切换，无需监听滚动 |
+| 长页面平滑滚动 | 内容不再超长，无需滚动 |
+| "SETTINGS" label | 冗余信息，移除以简化UI |
+
+### Preserved Features
+- 所有设置项功能和逻辑
+- 表单验证
+- 设置项描述和提示
+- 原有的CSS变量系统
+
+---
+
+## Success Criteria
+
+### Phase 0
+- [ ] Modal显示为两栏布局
+- [ ] 左侧显示4个Section导航
+- [ ] 点击导航切换右侧显示的Section
+- [ ] 当前选中导航项高亮显示
+- [ ] Section标题有accent色下划线
+- [ ] 设置项以卡片形式分组展示
+- [ ] 移除所有折叠/展开功能
+- [ ] 移动端响应式正常（单栏堆叠）
+- [ ] 所有现有设置功能正常工作
+- [ ] 设计风格与原有UI一致
+
+### Phase 1
+- [ ] 搜索框可输入关键词
+- [ ] 实时过滤显示匹配项
+- [ ] 高亮匹配的关键词
+
+### Phase 2
+- [ ] 底部有固定操作按钮栏
+- [ ] Cancel和Save Changes按钮工作正常
+
+---
+
+## Timeline
+
+| Phase | Estimated Time | Status |
+|-------|---------------|--------|
+| P0    | 3-4 hours     | Ready for Development |
+| P1    | 2-3 hours     | Planned |
+| P2    | 1-2 hours     | Planned |
+
+---
+
+## Reference
+
+### Design Inspiration
+- **macOS System Settings**: 左侧导航 + 右侧单Section独占
+- **VS Code Settings**: 清晰的视觉层次和搜索体验
+- **Linear**: 简洁的两栏布局设计
+
+### CSS Variables Reference
+```css
+/* Colors */
+--lora-accent: #007AFF;
+--lora-border: rgba(255, 255, 255, 0.1);
+--card-bg: rgba(255, 255, 255, 0.05);
+--text-color: #ffffff;
+--text-muted: rgba(255, 255, 255, 0.6);
+
+/* Spacing */
+--space-1: 8px;
+--space-2: 12px;
+--space-3: 16px;
+--space-4: 24px;
+
+/* Border Radius */
+--border-radius-xs: 4px;
+--border-radius-sm: 8px;
+```
+
+---
+
+**Last Updated**: 2025-02-24
+**Author**: AI Assistant
+**Status**: Ready for Implementation
--- a/docs/ui-ux-optimization/settings-modal-progress.md
+++ b/docs/ui-ux-optimization/settings-modal-progress.md
@@ -0,0 +1,191 @@
+# Settings Modal Optimization Progress
+
+**Project**: Settings Modal UI/UX Optimization  
+**Status**: Phase 0 - Ready for Development  
+**Last Updated**: 2025-02-24
+
+---
+
+## Phase 0: macOS Settings模式重构
+
+### Overview
+重构Settings Modal为macOS Settings模式：左侧Section导航 + 右侧单Section独占显示。移除冗余元素，优化视觉层次。
+
+### Tasks
+
+#### 1. CSS Updates ✅
+**File**: `static/css/components/modal/settings-modal.css`
+
+- [x] **Layout Styles**
+  - [x] Modal固定尺寸 800x600px
+  - [x] 左侧 sidebar 固定宽度 200px
+  - [x] 右侧 content flex: 1 自动填充
+
+- [x] **Navigation Styles**
+  - [x] `.settings-nav` 容器样式
+  - [x] `.settings-nav-item` 基础样式（更大字体，更醒目的active状态）
+  - [x] `.settings-nav-item.active` 高亮样式（accent背景）
+  - [x] `.settings-nav-item:hover` 悬停效果
+  - [x] 隐藏 "SETTINGS" label
+  - [x] 隐藏 group titles
+
+- [x] **Content Area Styles**
+  - [x] `.settings-section` 默认隐藏（仅当前显示）
+  - [x] `.settings-section.active` 显示状态
+  - [x] `.settings-section-header` 标题样式（20px + accent下划线）
+  - [x] 添加 fadeIn 动画效果
+
+- [x] **Cleanup**
+  - [x] 移除折叠相关样式
+  - [x] 移除 `.settings-section-toggle` 按钮样式
+  - [x] 移除展开/折叠动画样式
+
+**Status**: ✅ Completed
+
+---
+
+#### 2. HTML Structure Update ✅
+**File**: `templates/components/modals/settings_modal.html`
+
+- [x] **Navigation Items**
+  - [x] General (通用)
+  - [x] Interface (界面)
+  - [x] Download (下载)
+  - [x] Advanced (高级)
+  - [x] 移除 "SETTINGS" label
+  - [x] 移除 group titles
+
+- [x] **Content Sections**
+  - [x] 重组为4个Section (general/interface/download/advanced)
+  - [x] 每个section添加 `data-section` 属性
+  - [x] 添加Section标题（带accent下划线）
+  - [x] 移除所有折叠按钮（chevron图标）
+  - [x] 平铺显示所有设置项
+
+**Status**: ✅ Completed
+
+---
+
+#### 3. JavaScript Logic Update ✅
+**File**: `static/js/managers/SettingsManager.js`
+
+- [x] **Navigation Logic**
+  - [x] `initializeNavigation()` 改为Section切换模式
+  - [x] 点击导航项显示对应Section
+  - [x] 更新导航高亮状态
+  - [x] 默认显示第一个Section
+
+- [x] **Remove Legacy Code**
+  - [x] 移除 `initializeSectionCollapse()` 方法
+  - [x] 移除滚动监听相关代码
+  - [x] 移除 `localStorage` 折叠状态存储
+
+- [x] **Search Function**
+  - [x] 更新搜索功能以适配新显示模式
+  - [x] 搜索时自动切换到匹配的Section
+  - [x] 高亮匹配的关键词
+
+**Status**: ✅ Completed
+
+---
+
+### Testing Checklist
+
+#### Visual Testing
+- [ ] 两栏布局正确显示
+- [ ] 左侧导航4个Section正确显示
+- [ ] 点击导航切换右侧内容
+- [ ] 当前导航项高亮显示（accent背景）
+- [ ] Section标题有accent色下划线
+- [ ] 设置项以卡片形式分组
+- [ ] 无"SETTINGS" label
+- [ ] 无折叠/展开按钮
+
+#### Functional Testing
+- [ ] 所有设置项可正常编辑
+- [ ] 设置保存功能正常
+- [ ] 设置加载功能正常
+- [ ] 表单验证正常工作
+- [ ] 帮助提示（tooltip）正常显示
+
+#### Responsive Testing
+- [ ] 桌面端（>768px）两栏布局
+- [ ] 移动端（<768px）单栏堆叠
+- [ ] 移动端导航可正常切换
+
+#### Cross-Browser Testing
+- [ ] Chrome/Edge
+- [ ] Firefox
+- [ ] Safari（如适用）
+
+---
+
+## Phase 1: 搜索功能
+
+### Tasks
+- [ ] 搜索框UI更新
+- [ ] 搜索逻辑实现
+- [ ] 实时过滤显示
+- [ ] 关键词高亮
+
+**Estimated Time**: 2-3 hours  
+**Status**: 📋 Planned
+
+---
+
+## Phase 2: 操作按钮优化
+
+### Tasks
+- [ ] 底部操作栏样式
+- [ ] 固定定位（sticky）
+- [ ] Cancel/Save按钮功能
+- [ ] 可选：Reset/Export/Import
+
+**Estimated Time**: 1-2 hours  
+**Status**: 📋 Planned
+
+---
+
+## Progress Summary
+
+| Phase | Progress | Status |
+|-------|----------|--------|
+| Phase 0 | 100% | ✅ Completed |
+| Phase 1 | 0% | 📋 Planned |
+| Phase 2 | 0% | 📋 Planned |
+
+**Overall Progress**: 100% (Phase 0)
+
+---
+
+## Development Log
+
+### 2025-02-24
+- ✅ 创建优化提案文档（macOS Settings模式）
+- ✅ 创建进度追踪文档
+- ✅ Phase 0 开发完成
+  - ✅ CSS重构完成：新增macOS Settings样式，移除折叠相关样式
+  - ✅ HTML重构完成：重组为4个Section，移除所有折叠按钮
+  - ✅ JavaScript重构完成：实现Section切换逻辑，更新搜索功能
+
+---
+
+## Notes
+
+### Design Decisions
+- 采用macOS Settings模式而非长页面滚动模式
+- 左侧仅显示4个Section，不显示具体设置项
+- 移除折叠/展开功能，简化交互
+- Section标题使用accent色下划线强调
+
+### Technical Notes
+- 优先使用现有CSS变量
+- 保持向后兼容，不破坏现有设置存储逻辑
+- 移动端响应式：小屏幕单栏堆叠
+
+### Blockers
+None
+
+---
+
+**Next Action**: Start Phase 0 - CSS Updates
--- a/locales/de.json
+++ b/locales/de.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "Abbrechen",
+        "confirm": "Bestätigen",
        "actions": {
            "save": "Speichern",
            "cancel": "Abbrechen",
+            "confirm": "Bestätigen",
            "delete": "Löschen",
            "move": "Verschieben",
            "refresh": "Aktualisieren",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "Voreinstellungsname...",
            "baseModel": "Basis-Modell",
            "modelTags": "Tags (Top 20)",
-            "modelTypes": "Model Types",
+            "modelTypes": "Modelltypen",
            "license": "Lizenz",
            "noCreditRequired": "Kein Credit erforderlich",
            "allowSellingGeneratedContent": "Verkauf erlaubt",
@@ -258,17 +261,27 @@
            "contentFiltering": "Inhaltsfilterung",
            "videoSettings": "Video-Einstellungen",
            "layoutSettings": "Layout-Einstellungen",
-            "folderSettings": "Ordner-Einstellungen",
-            "priorityTags": "Prioritäts-Tags",
-            "downloadPathTemplates": "Download-Pfad-Vorlagen",
-            "exampleImages": "Beispielbilder",
-            "updateFlags": "Update-Markierungen",
-            "autoOrganize": "Auto-organize",
            "misc": "Verschiedenes",
-            "metadataArchive": "Metadaten-Archiv-Datenbank",
-            "storageLocation": "Einstellungsort",
+            "folderSettings": "Standard-Roots",
+            "extraFolderPaths": "Zusätzliche Ordnerpfade",
+            "downloadPathTemplates": "Download-Pfad-Vorlagen",
+            "priorityTags": "Prioritäts-Tags",
+            "updateFlags": "Update-Markierungen",
+            "exampleImages": "Beispielbilder",
+            "autoOrganize": "Auto-Organisierung",
+            "metadata": "Metadaten",
            "proxySettings": "Proxy-Einstellungen"
        },
+        "nav": {
+            "general": "Allgemein",
+            "interface": "Oberfläche",
+            "library": "Bibliothek"
+        },
+        "search": {
+            "placeholder": "Einstellungen durchsuchen...",
+            "clear": "Suche löschen",
+            "noResults": "Keine Einstellungen gefunden für \"{query}\""
+        },
        "storage": {
            "locationLabel": "Portabler Modus",
            "locationHelp": "Aktiviere, um settings.json im Repository zu belassen; deaktiviere, um es im Benutzerkonfigurationsordner zu speichern."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "Zwischen den konfigurierten Bibliotheken wechseln, um die Standardordner zu aktualisieren. Eine Änderung der Auswahl lädt die Seite neu.",
            "loadingLibraries": "Bibliotheken werden geladen...",
            "noLibraries": "Keine Bibliotheken konfiguriert",
-            "defaultLoraRoot": "Standard-LoRA-Stammordner",
+            "defaultLoraRoot": "LoRA-Stammordner",
            "defaultLoraRootHelp": "Legen Sie den Standard-LoRA-Stammordner für Downloads, Importe und Verschiebungen fest",
-            "defaultCheckpointRoot": "Standard-Checkpoint-Stammordner",
+            "defaultCheckpointRoot": "Checkpoint-Stammordner",
            "defaultCheckpointRootHelp": "Legen Sie den Standard-Checkpoint-Stammordner für Downloads, Importe und Verschiebungen fest",
-            "defaultUnetRoot": "Standard-Diffusion-Modell-Stammordner",
+            "defaultUnetRoot": "Diffusion-Modell-Stammordner",
            "defaultUnetRootHelp": "Legen Sie den Standard-Diffusion-Modell-(UNET)-Stammordner für Downloads, Importe und Verschiebungen fest",
-            "defaultEmbeddingRoot": "Standard-Embedding-Stammordner",
+            "defaultEmbeddingRoot": "Embedding-Stammordner",
            "defaultEmbeddingRootHelp": "Legen Sie den Standard-Embedding-Stammordner für Downloads, Importe und Verschiebungen fest",
            "noDefault": "Kein Standard"
        },
+        "extraFolderPaths": {
+            "title": "Zusätzliche Ordnerpfade",
+            "help": "Fügen Sie zusätzliche Modellordner außerhalb der Standardpfade von ComfyUI hinzu. Diese Pfade werden separat gespeichert und zusammen mit den Standardordnern gescannt.",
+            "description": "Konfigurieren Sie zusätzliche Ordner zum Scannen von Modellen. Diese Pfade sind spezifisch für LoRA Manager und werden mit den Standardpfaden von ComfyUI zusammengeführt.",
+            "modelTypes": {
+                "lora": "LoRA-Pfade",
+                "checkpoint": "Checkpoint-Pfade",
+                "unet": "Diffusionsmodell-Pfade",
+                "embedding": "Embedding-Pfade"
+            },
+            "pathPlaceholder": "/pfad/zu/extra/modellen",
+            "saveSuccess": "Zusätzliche Ordnerpfade aktualisiert.",
+            "saveError": "Fehler beim Aktualisieren der zusätzlichen Ordnerpfade: {message}",
+            "validation": {
+                "duplicatePath": "Dieser Pfad ist bereits konfiguriert"
+            }
+        },
        "priorityTags": {
            "title": "Prioritäts-Tags",
            "description": "Passen Sie die Tag-Prioritätsreihenfolge für jeden Modelltyp an (z. B. character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "Wenigste"
            },
            "refresh": {
-                "title": "Rezeptliste aktualisieren"
+                "title": "Rezeptliste aktualisieren",
+                "quick": "Änderungen synchronisieren",
+                "quickTooltip": "Änderungen synchronisieren - schnelle Aktualisierung ohne Cache-Neubau",
+                "full": "Cache neu aufbauen",
+                "fullTooltip": "Cache neu aufbauen - vollständiger Rescan aller Rezeptdateien"
            },
            "filteredByLora": "Gefiltert nach LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "Im Listenmodus nicht verfügbar",
        "dragDrop": {
            "unableToResolveRoot": "Zielpfad für das Verschieben konnte nicht ermittelt werden.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Verschieben wird für dieses Element nicht unterstützt.",
+            "createFolderHint": "Loslassen, um einen neuen Ordner zu erstellen",
+            "newFolderName": "Neuer Ordnername",
+            "folderNameHint": "Eingabetaste zum Bestätigen, Escape zum Abbrechen",
+            "emptyFolderName": "Bitte geben Sie einen Ordnernamen ein",
+            "invalidFolderName": "Ordnername enthält ungültige Zeichen",
+            "noDragState": "Kein ausstehender Ziehvorgang gefunden"
+        },
+        "empty": {
+            "noFolders": "Keine Ordner gefunden",
+            "dragHint": "Elemente hierher ziehen, um Ordner zu erstellen"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "WeChat QR-Code anzeigen",
            "hideWechatQR": "WeChat QR-Code ausblenden"
        },
-        "footer": "Vielen Dank, dass Sie LoRA Manager verwenden! ❤️"
+        "footer": "Vielen Dank, dass Sie LoRA Manager verwenden! ❤️",
+        "supporters": {
+            "title": "Danke an alle Unterstützer",
+            "subtitle": "Danke an {count} Unterstützer, die dieses Projekt möglich gemacht haben",
+            "specialThanks": "Besonderer Dank",
+            "allSupporters": "Alle Unterstützer",
+            "totalCount": "{count} Unterstützer insgesamt"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "Fehler beim Laden der {modelType}s: {message}",
            "refreshComplete": "Aktualisierung abgeschlossen",
            "refreshFailed": "Fehler beim Aktualisieren der Rezepte: {message}",
+            "syncComplete": "Synchronisation abgeschlossen",
+            "syncFailed": "Fehler beim Synchronisieren der Rezepte: {message}",
            "updateFailed": "Fehler beim Aktualisieren des Rezepts: {error}",
            "updateError": "Fehler beim Aktualisieren des Rezepts: {message}",
            "nameSaved": "Rezept \"{name}\" erfolgreich gespeichert",
--- a/locales/en.json
+++ b/locales/en.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "Cancel",
+        "confirm": "Confirm",
        "actions": {
            "save": "Save",
            "cancel": "Cancel",
+            "confirm": "Confirm",
            "delete": "Delete",
            "move": "Move",
            "refresh": "Refresh",
@@ -258,17 +261,27 @@
            "contentFiltering": "Content Filtering",
            "videoSettings": "Video Settings",
            "layoutSettings": "Layout Settings",
-            "folderSettings": "Folder Settings",
-            "priorityTags": "Priority Tags",
+            "misc": "Miscellaneous",
+            "folderSettings": "Default Roots",
+            "extraFolderPaths": "Extra Folder Paths",
            "downloadPathTemplates": "Download Path Templates",
-            "exampleImages": "Example Images",
+            "priorityTags": "Priority Tags",
            "updateFlags": "Update Flags",
+            "exampleImages": "Example Images",
            "autoOrganize": "Auto-organize",
-            "misc": "Misc.",
-            "metadataArchive": "Metadata Archive Database",
-            "storageLocation": "Settings Location",
+            "metadata": "Metadata",
            "proxySettings": "Proxy Settings"
        },
+        "nav": {
+            "general": "General",
+            "interface": "Interface",
+            "library": "Library"
+        },
+        "search": {
+            "placeholder": "Search settings...",
+            "clear": "Clear search",
+            "noResults": "No settings found matching \"{query}\""
+        },
        "storage": {
            "locationLabel": "Portable mode",
            "locationHelp": "Enable to keep settings.json inside the repository; disable to store it in your user config directory."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "Switch between configured libraries to update default folders. Changing the selection reloads the page.",
            "loadingLibraries": "Loading libraries...",
            "noLibraries": "No libraries configured",
-            "defaultLoraRoot": "Default LoRA Root",
+            "defaultLoraRoot": "LoRA Root",
            "defaultLoraRootHelp": "Set default LoRA root directory for downloads, imports and moves",
-            "defaultCheckpointRoot": "Default Checkpoint Root",
+            "defaultCheckpointRoot": "Checkpoint Root",
            "defaultCheckpointRootHelp": "Set default checkpoint root directory for downloads, imports and moves",
-            "defaultUnetRoot": "Default Diffusion Model Root",
+            "defaultUnetRoot": "Diffusion Model Root",
            "defaultUnetRootHelp": "Set default diffusion model (UNET) root directory for downloads, imports and moves",
-            "defaultEmbeddingRoot": "Default Embedding Root",
+            "defaultEmbeddingRoot": "Embedding Root",
            "defaultEmbeddingRootHelp": "Set default embedding root directory for downloads, imports and moves",
            "noDefault": "No Default"
        },
+        "extraFolderPaths": {
+            "title": "Extra Folder Paths",
+            "help": "Add additional model folders outside of ComfyUI's standard paths. These paths are stored separately and scanned alongside the default folders.",
+            "description": "Configure additional folders to scan for models. These paths are specific to LoRA Manager and will be merged with ComfyUI's default paths.",
+            "modelTypes": {
+                "lora": "LoRA Paths",
+                "checkpoint": "Checkpoint Paths",
+                "unet": "Diffusion Model Paths",
+                "embedding": "Embedding Paths"
+            },
+            "pathPlaceholder": "/path/to/extra/models",
+            "saveSuccess": "Extra folder paths updated.",
+            "saveError": "Failed to update extra folder paths: {message}",
+            "validation": {
+                "duplicatePath": "This path is already configured"
+            }
+        },
        "priorityTags": {
            "title": "Priority Tags",
            "description": "Customize the tag priority order for each model type (e.g., character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "Least"
            },
            "refresh": {
-                "title": "Refresh recipe list"
+                "title": "Refresh recipe list",
+                "quick": "Sync Changes",
+                "quickTooltip": "Sync changes - quick refresh without rebuilding cache",
+                "full": "Rebuild Cache",
+                "fullTooltip": "Rebuild cache - full rescan of all recipe files"
            },
            "filteredByLora": "Filtered by LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "Not available in list view",
        "dragDrop": {
            "unableToResolveRoot": "Unable to determine destination path for move.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Move is not supported for this item.",
+            "createFolderHint": "Release to create new folder",
+            "newFolderName": "New folder name",
+            "folderNameHint": "Press Enter to confirm, Escape to cancel",
+            "emptyFolderName": "Please enter a folder name",
+            "invalidFolderName": "Folder name contains invalid characters",
+            "noDragState": "No pending drag operation found"
+        },
+        "empty": {
+            "noFolders": "No folders found",
+            "dragHint": "Drag items here to create folders"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "Show WeChat QR Code",
            "hideWechatQR": "Hide WeChat QR Code"
        },
-        "footer": "Thank you for using LoRA Manager! ❤️"
+        "footer": "Thank you for using LoRA Manager! ❤️",
+        "supporters": {
+            "title": "Thank You To Our Supporters",
+            "subtitle": "Thanks to {count} supporters who made this project possible",
+            "specialThanks": "Special Thanks",
+            "allSupporters": "All Supporters",
+            "totalCount": "{count} supporters in total"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "Failed to load {modelType}s: {message}",
            "refreshComplete": "Refresh complete",
            "refreshFailed": "Failed to refresh recipes: {message}",
+            "syncComplete": "Sync complete",
+            "syncFailed": "Failed to sync recipes: {message}",
            "updateFailed": "Failed to update recipe: {error}",
            "updateError": "Error updating recipe: {message}",
            "nameSaved": "Recipe \"{name}\" saved successfully",
--- a/locales/es.json
+++ b/locales/es.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "Cancelar",
+        "confirm": "Confirmar",
        "actions": {
            "save": "Guardar",
            "cancel": "Cancelar",
+            "confirm": "Confirmar",
            "delete": "Eliminar",
            "move": "Mover",
            "refresh": "Actualizar",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "Nombre del preajuste...",
            "baseModel": "Modelo base",
            "modelTags": "Etiquetas (Top 20)",
-            "modelTypes": "Model Types",
+            "modelTypes": "Tipos de modelos",
            "license": "Licencia",
            "noCreditRequired": "Sin crédito requerido",
            "allowSellingGeneratedContent": "Venta permitida",
@@ -258,17 +261,27 @@
            "contentFiltering": "Filtrado de contenido",
            "videoSettings": "Configuración de video",
            "layoutSettings": "Configuración de diseño",
-            "folderSettings": "Configuración de carpetas",
-            "priorityTags": "Etiquetas prioritarias",
-            "downloadPathTemplates": "Plantillas de rutas de descarga",
-            "exampleImages": "Imágenes de ejemplo",
-            "updateFlags": "Indicadores de actualización",
-            "autoOrganize": "Auto-organize",
            "misc": "Varios",
-            "metadataArchive": "Base de datos de archivo de metadatos",
-            "storageLocation": "Ubicación de ajustes",
+            "folderSettings": "Raíces predeterminadas",
+            "extraFolderPaths": "Rutas de carpetas adicionales",
+            "downloadPathTemplates": "Plantillas de rutas de descarga",
+            "priorityTags": "Etiquetas prioritarias",
+            "updateFlags": "Indicadores de actualización",
+            "exampleImages": "Imágenes de ejemplo",
+            "autoOrganize": "Organización automática",
+            "metadata": "Metadatos",
            "proxySettings": "Configuración de proxy"
        },
+        "nav": {
+            "general": "General",
+            "interface": "Interfaz",
+            "library": "Biblioteca"
+        },
+        "search": {
+            "placeholder": "Buscar ajustes...",
+            "clear": "Limpiar búsqueda",
+            "noResults": "No se encontraron ajustes que coincidan con \"{query}\""
+        },
        "storage": {
            "locationLabel": "Modo portátil",
            "locationHelp": "Activa para mantener settings.json dentro del repositorio; desactívalo para guardarlo en tu directorio de configuración de usuario."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "Alterna entre las bibliotecas configuradas para actualizar las carpetas predeterminadas. Cambiar la selección recarga la página.",
            "loadingLibraries": "Cargando bibliotecas...",
            "noLibraries": "No hay bibliotecas configuradas",
-            "defaultLoraRoot": "Raíz predeterminada de LoRA",
+            "defaultLoraRoot": "Raíz de LoRA",
            "defaultLoraRootHelp": "Establecer el directorio raíz predeterminado de LoRA para descargas, importaciones y movimientos",
-            "defaultCheckpointRoot": "Raíz predeterminada de checkpoint",
+            "defaultCheckpointRoot": "Raíz de checkpoint",
            "defaultCheckpointRootHelp": "Establecer el directorio raíz predeterminado de checkpoint para descargas, importaciones y movimientos",
-            "defaultUnetRoot": "Raíz predeterminada de Diffusion Model",
+            "defaultUnetRoot": "Raíz de Diffusion Model",
            "defaultUnetRootHelp": "Establecer el directorio raíz predeterminado de Diffusion Model (UNET) para descargas, importaciones y movimientos",
-            "defaultEmbeddingRoot": "Raíz predeterminada de embedding",
+            "defaultEmbeddingRoot": "Raíz de embedding",
            "defaultEmbeddingRootHelp": "Establecer el directorio raíz predeterminado de embedding para descargas, importaciones y movimientos",
            "noDefault": "Sin predeterminado"
        },
+        "extraFolderPaths": {
+            "title": "Rutas de carpetas adicionales",
+            "help": "Agregue carpetas de modelos adicionales fuera de las rutas estándar de ComfyUI. Estas rutas se almacenan por separado y se escanean junto con las carpetas predeterminadas.",
+            "description": "Configure carpetas adicionales para escanear modelos. Estas rutas son específicas de LoRA Manager y se fusionarán con las rutas predeterminadas de ComfyUI.",
+            "modelTypes": {
+                "lora": "Rutas de LoRA",
+                "checkpoint": "Rutas de Checkpoint",
+                "unet": "Rutas de modelo de difusión",
+                "embedding": "Rutas de Embedding"
+            },
+            "pathPlaceholder": "/ruta/a/modelos/extra",
+            "saveSuccess": "Rutas de carpetas adicionales actualizadas.",
+            "saveError": "Error al actualizar las rutas de carpetas adicionales: {message}",
+            "validation": {
+                "duplicatePath": "Esta ruta ya está configurada"
+            }
+        },
        "priorityTags": {
            "title": "Etiquetas prioritarias",
            "description": "Personaliza el orden de prioridad de etiquetas para cada tipo de modelo (p. ej., character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "Menos"
            },
            "refresh": {
-                "title": "Actualizar lista de recetas"
+                "title": "Actualizar lista de recetas",
+                "quick": "Sincronizar cambios",
+                "quickTooltip": "Sincronizar cambios - actualización rápida sin reconstruir caché",
+                "full": "Reconstruir caché",
+                "fullTooltip": "Reconstruir caché - reescaneo completo de todos los archivos de recetas"
            },
            "filteredByLora": "Filtrado por LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "No disponible en vista de lista",
        "dragDrop": {
            "unableToResolveRoot": "No se puede determinar la ruta de destino para el movimiento.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "El movimiento no es compatible con este elemento.",
+            "createFolderHint": "Suelta para crear una nueva carpeta",
+            "newFolderName": "Nombre de la nueva carpeta",
+            "folderNameHint": "Presiona Enter para confirmar, Escape para cancelar",
+            "emptyFolderName": "Por favor, introduce un nombre de carpeta",
+            "invalidFolderName": "El nombre de la carpeta contiene caracteres no válidos",
+            "noDragState": "No se encontró ninguna operación de arrastre pendiente"
+        },
+        "empty": {
+            "noFolders": "No se encontraron carpetas",
+            "dragHint": "Arrastra elementos aquí para crear carpetas"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "Mostrar código QR de WeChat",
            "hideWechatQR": "Ocultar código QR de WeChat"
        },
-        "footer": "¡Gracias por usar el gestor de LoRA! ❤️"
+        "footer": "¡Gracias por usar el gestor de LoRA! ❤️",
+        "supporters": {
+            "title": "Gracias a todos los seguidores",
+            "subtitle": "Gracias a {count} seguidores que hicieron este proyecto posible",
+            "specialThanks": "Agradecimientos especiales",
+            "allSupporters": "Todos los seguidores",
+            "totalCount": "{count} seguidores en total"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "Error al cargar {modelType}s: {message}",
            "refreshComplete": "Actualización completa",
            "refreshFailed": "Error al actualizar recetas: {message}",
+            "syncComplete": "Sincronización completa",
+            "syncFailed": "Error al sincronizar recetas: {message}",
            "updateFailed": "Error al actualizar receta: {error}",
            "updateError": "Error actualizando receta: {message}",
            "nameSaved": "Receta \"{name}\" guardada exitosamente",
--- a/locales/fr.json
+++ b/locales/fr.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "Annuler",
+        "confirm": "Confirmer",
        "actions": {
            "save": "Enregistrer",
            "cancel": "Annuler",
+            "confirm": "Confirmer",
            "delete": "Supprimer",
            "move": "Déplacer",
            "refresh": "Actualiser",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "Nom du préréglage...",
            "baseModel": "Modèle de base",
            "modelTags": "Tags (Top 20)",
-            "modelTypes": "Model Types",
+            "modelTypes": "Types de modèles",
            "license": "Licence",
            "noCreditRequired": "Crédit non requis",
            "allowSellingGeneratedContent": "Vente autorisée",
@@ -258,17 +261,27 @@
            "contentFiltering": "Filtrage du contenu",
            "videoSettings": "Paramètres vidéo",
            "layoutSettings": "Paramètres d'affichage",
-            "folderSettings": "Paramètres des dossiers",
-            "priorityTags": "Étiquettes prioritaires",
-            "downloadPathTemplates": "Modèles de chemin de téléchargement",
-            "exampleImages": "Images d'exemple",
-            "updateFlags": "Indicateurs de mise à jour",
-            "autoOrganize": "Auto-organize",
            "misc": "Divers",
-            "metadataArchive": "Base de données d'archive des métadonnées",
-            "storageLocation": "Emplacement des paramètres",
+            "folderSettings": "Racines par défaut",
+            "extraFolderPaths": "Chemins de dossiers supplémentaires",
+            "downloadPathTemplates": "Modèles de chemin de téléchargement",
+            "priorityTags": "Étiquettes prioritaires",
+            "updateFlags": "Indicateurs de mise à jour",
+            "exampleImages": "Images d'exemple",
+            "autoOrganize": "Organisation automatique",
+            "metadata": "Métadonnées",
            "proxySettings": "Paramètres du proxy"
        },
+        "nav": {
+            "general": "Général",
+            "interface": "Interface",
+            "library": "Bibliothèque"
+        },
+        "search": {
+            "placeholder": "Rechercher dans les paramètres...",
+            "clear": "Effacer la recherche",
+            "noResults": "Aucun paramètre trouvé correspondant à \"{query}\""
+        },
        "storage": {
            "locationLabel": "Mode portable",
            "locationHelp": "Activez pour garder settings.json dans le dépôt ; désactivez pour le placer dans votre dossier de configuration utilisateur."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "Basculer entre les bibliothèques configurées pour mettre à jour les dossiers par défaut. Changer la sélection recharge la page.",
            "loadingLibraries": "Chargement des bibliothèques...",
            "noLibraries": "Aucune bibliothèque configurée",
-            "defaultLoraRoot": "Racine LoRA par défaut",
+            "defaultLoraRoot": "Racine LoRA",
            "defaultLoraRootHelp": "Définir le répertoire racine LoRA par défaut pour les téléchargements, imports et déplacements",
-            "defaultCheckpointRoot": "Racine Checkpoint par défaut",
+            "defaultCheckpointRoot": "Racine Checkpoint",
            "defaultCheckpointRootHelp": "Définir le répertoire racine checkpoint par défaut pour les téléchargements, imports et déplacements",
-            "defaultUnetRoot": "Racine Diffusion Model par défaut",
+            "defaultUnetRoot": "Racine Diffusion Model",
            "defaultUnetRootHelp": "Définir le répertoire racine Diffusion Model (UNET) par défaut pour les téléchargements, imports et déplacements",
-            "defaultEmbeddingRoot": "Racine Embedding par défaut",
+            "defaultEmbeddingRoot": "Racine Embedding",
            "defaultEmbeddingRootHelp": "Définir le répertoire racine embedding par défaut pour les téléchargements, imports et déplacements",
            "noDefault": "Aucun par défaut"
        },
+        "extraFolderPaths": {
+            "title": "Chemins de dossiers supplémentaires",
+            "help": "Ajoutez des dossiers de modèles supplémentaires en dehors des chemins standard de ComfyUI. Ces chemins sont stockés séparément et analysés aux côtés des dossiers par défaut.",
+            "description": "Configurez des dossiers supplémentaires pour l'analyse de modèles. Ces chemins sont spécifiques à LoRA Manager et seront fusionnés avec les chemins par défaut de ComfyUI.",
+            "modelTypes": {
+                "lora": "Chemins LoRA",
+                "checkpoint": "Chemins Checkpoint",
+                "unet": "Chemins de modèle de diffusion",
+                "embedding": "Chemins Embedding"
+            },
+            "pathPlaceholder": "/chemin/vers/modèles/supplémentaires",
+            "saveSuccess": "Chemins de dossiers supplémentaires mis à jour.",
+            "saveError": "Échec de la mise à jour des chemins de dossiers supplémentaires: {message}",
+            "validation": {
+                "duplicatePath": "Ce chemin est déjà configuré"
+            }
+        },
        "priorityTags": {
            "title": "Étiquettes prioritaires",
            "description": "Personnalisez l'ordre de priorité des étiquettes pour chaque type de modèle (par ex. : character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "Moins"
            },
            "refresh": {
-                "title": "Actualiser la liste des recipes"
+                "title": "Actualiser la liste des recipes",
+                "quick": "Synchroniser les changements",
+                "quickTooltip": "Synchroniser les changements - actualisation rapide sans reconstruire le cache",
+                "full": "Reconstruire le cache",
+                "fullTooltip": "Reconstruire le cache - rescan complet de tous les fichiers de recipes"
            },
            "filteredByLora": "Filtré par LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "Non disponible en vue liste",
        "dragDrop": {
            "unableToResolveRoot": "Impossible de déterminer le chemin de destination pour le déplacement.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Le déplacement n'est pas pris en charge pour cet élément.",
+            "createFolderHint": "Relâcher pour créer un nouveau dossier",
+            "newFolderName": "Nom du nouveau dossier",
+            "folderNameHint": "Appuyez sur Entrée pour confirmer, Échap pour annuler",
+            "emptyFolderName": "Veuillez saisir un nom de dossier",
+            "invalidFolderName": "Le nom du dossier contient des caractères invalides",
+            "noDragState": "Aucune opération de glissement en attente trouvée"
+        },
+        "empty": {
+            "noFolders": "Aucun dossier trouvé",
+            "dragHint": "Faites glisser des éléments ici pour créer des dossiers"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "Afficher le QR Code WeChat",
            "hideWechatQR": "Masquer le QR Code WeChat"
        },
-        "footer": "Merci d'utiliser le Gestionnaire LoRA ! ❤️"
+        "footer": "Merci d'utiliser le Gestionnaire LoRA ! ❤️",
+        "supporters": {
+            "title": "Merci à tous les supporters",
+            "subtitle": "Merci aux {count} supporters qui ont rendu ce projet possible",
+            "specialThanks": "Remerciements spéciaux",
+            "allSupporters": "Tous les supporters",
+            "totalCount": "{count} supporters au total"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "Échec du chargement des {modelType}s : {message}",
            "refreshComplete": "Actualisation terminée",
            "refreshFailed": "Échec de l'actualisation des recipes : {message}",
+            "syncComplete": "Synchronisation terminée",
+            "syncFailed": "Échec de la synchronisation des recipes : {message}",
            "updateFailed": "Échec de la mise à jour de la recipe : {error}",
            "updateError": "Erreur lors de la mise à jour de la recipe : {message}",
            "nameSaved": "Recipe \"{name}\" sauvegardée avec succès",
--- a/locales/he.json
+++ b/locales/he.json
@@ -1,17 +1,20 @@
 {
    "common": {
+        "cancel": "ביטול",
+        "confirm": "אישור",
        "actions": {
-            "save": "שמור",
+            "save": "שמירה",
            "cancel": "ביטול",
-            "delete": "מחק",
-            "move": "העבר",
-            "refresh": "רענן",
-            "back": "חזור",
+            "confirm": "אישור",
+            "delete": "מחיקה",
+            "move": "העברה",
+            "refresh": "רענון",
+            "back": "חזרה",
            "next": "הבא",
-            "backToTop": "חזור למעלה",
+            "backToTop": "חזרה למעלה",
            "settings": "הגדרות",
            "help": "עזרה",
-            "add": "הוסף"
+            "add": "הוספה"
        },
        "status": {
            "loading": "טוען...",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "שם קביעה מראש...",
            "baseModel": "מודל בסיס",
            "modelTags": "תגיות (20 המובילות)",
-            "modelTypes": "Model Types",
+            "modelTypes": "סוגי מודלים",
            "license": "רישיון",
            "noCreditRequired": "ללא קרדיט נדרש",
            "allowSellingGeneratedContent": "אפשר מכירה",
@@ -258,17 +261,27 @@
            "contentFiltering": "סינון תוכן",
            "videoSettings": "הגדרות וידאו",
            "layoutSettings": "הגדרות פריסה",
-            "folderSettings": "הגדרות תיקייה",
-            "priorityTags": "תגיות עדיפות",
-            "downloadPathTemplates": "תבניות נתיב הורדה",
-            "exampleImages": "תמונות דוגמה",
-            "updateFlags": "תגי עדכון",
-            "autoOrganize": "Auto-organize",
            "misc": "שונות",
-            "metadataArchive": "מסד נתונים של ארכיון מטא-דאטה",
-            "storageLocation": "מיקום ההגדרות",
+            "folderSettings": "תיקיות ברירת מחדל",
+            "extraFolderPaths": "נתיבי תיקיות נוספים",
+            "downloadPathTemplates": "תבניות נתיב הורדה",
+            "priorityTags": "תגיות עדיפות",
+            "updateFlags": "תגי עדכון",
+            "exampleImages": "תמונות דוגמה",
+            "autoOrganize": "ארגון אוטומטי",
+            "metadata": "מטא-נתונים",
            "proxySettings": "הגדרות פרוקסי"
        },
+        "nav": {
+            "general": "כללי",
+            "interface": "ממשק",
+            "library": "ספרייה"
+        },
+        "search": {
+            "placeholder": "חיפוש בהגדרות...",
+            "clear": "נקה חיפוש",
+            "noResults": "לא נמצאו הגדרות תואמות ל-\"{query}\""
+        },
        "storage": {
            "locationLabel": "מצב נייד",
            "locationHelp": "הפעל כדי לשמור את settings.json בתוך המאגר; בטל כדי לשמור אותו בתיקיית ההגדרות של המשתמש."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "החלפה בין הספריות המוגדרות לעדכן את תיקיות ברירת המחדל. שינוי הבחירה ירענן את הדף.",
            "loadingLibraries": "טוען ספריות...",
            "noLibraries": "לא הוגדרו ספריות",
-            "defaultLoraRoot": "תיקיית שורש ברירת מחדל של LoRA",
+            "defaultLoraRoot": "תיקיית שורש LoRA",
            "defaultLoraRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של LoRA להורדות, ייבוא והעברות",
-            "defaultCheckpointRoot": "תיקיית שורש ברירת מחדל של Checkpoint",
+            "defaultCheckpointRoot": "תיקיית שורש Checkpoint",
            "defaultCheckpointRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של checkpoint להורדות, ייבוא והעברות",
-            "defaultUnetRoot": "תיקיית שורש ברירת מחדל של Diffusion Model",
+            "defaultUnetRoot": "תיקיית שורש Diffusion Model",
            "defaultUnetRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של Diffusion Model (UNET) להורדות, ייבוא והעברות",
-            "defaultEmbeddingRoot": "תיקיית שורש ברירת מחדל של Embedding",
+            "defaultEmbeddingRoot": "תיקיית שורש Embedding",
            "defaultEmbeddingRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של embedding להורדות, ייבוא והעברות",
            "noDefault": "אין ברירת מחדל"
        },
+        "extraFolderPaths": {
+            "title": "נתיבי תיקיות נוספים",
+            "help": "הוסף תיקיות מודלים נוספות מחוץ לנתיבים הסטנדרטיים של ComfyUI. נתיבים אלה נשמרים בנפרד ונסרקים לצד תיקיות ברירת המחדל.",
+            "description": "הגדר תיקיות נוספות לסריקת מודלים. נתיבים אלה ספציפיים ל-LoRA Manager וימוזגו עם נתיבי ברירת המחדל של ComfyUI.",
+            "modelTypes": {
+                "lora": "נתיבי LoRA",
+                "checkpoint": "נתיבי Checkpoint",
+                "unet": "נתיבי מודל דיפוזיה",
+                "embedding": "נתיבי Embedding"
+            },
+            "pathPlaceholder": "/נתיב/למודלים/נוספים",
+            "saveSuccess": "נתיבי תיקיות נוספים עודכנו.",
+            "saveError": "נכשל בעדכון נתיבי תיקיות נוספים: {message}",
+            "validation": {
+                "duplicatePath": "נתיב זה כבר מוגדר"
+            }
+        },
        "priorityTags": {
            "title": "תגיות עדיפות",
            "description": "התאם את סדר העדיפות של התגיות עבור כל סוג מודל (לדוגמה: character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "הכי פחות"
            },
            "refresh": {
-                "title": "רענן רשימת מתכונים"
+                "title": "רענן רשימת מתכונים",
+                "quick": "סנכרן שינויים",
+                "quickTooltip": "סנכרן שינויים - רענון מהיר ללא בניית מטמון מחדש",
+                "full": "בנה מטמון מחדש",
+                "fullTooltip": "בנה מטמון מחדש - סריקה מחדש מלאה של כל קבצי המתכונים"
            },
            "filteredByLora": "מסונן לפי LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "לא זמין בתצוגת רשימה",
        "dragDrop": {
            "unableToResolveRoot": "לא ניתן לקבוע את נתיב היעד להעברה.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "העברה אינה נתמכת עבור פריט זה.",
+            "createFolderHint": "שחרר כדי ליצור תיקייה חדשה",
+            "newFolderName": "שם תיקייה חדשה",
+            "folderNameHint": "הקש Enter לאישור, Escape לביטול",
+            "emptyFolderName": "אנא הזן שם תיקייה",
+            "invalidFolderName": "שם התיקייה מכיל תווים לא חוקיים",
+            "noDragState": "לא נמצאה פעולת גרירה ממתינה"
+        },
+        "empty": {
+            "noFolders": "לא נמצאו תיקיות",
+            "dragHint": "גרור פריטים לכאן כדי ליצור תיקיות"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "הצג קוד QR של WeChat",
            "hideWechatQR": "הסתר קוד QR של WeChat"
        },
-        "footer": "תודה על השימוש במנהל LoRA! ❤️"
+        "footer": "תודה על השימוש במנהל LoRA! ❤️",
+        "supporters": {
+            "title": "תודה לכל התומכים",
+            "subtitle": "תודה ל־{count} תומכים שהפכו את הפרויקט הזה לאפשרי",
+            "specialThanks": "תודה מיוחדת",
+            "allSupporters": "כל התומכים",
+            "totalCount": "{count} תומכים בסך הכל"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "טעינת {modelType}s נכשלה: {message}",
            "refreshComplete": "הרענון הושלם",
            "refreshFailed": "רענון המתכונים נכשל: {message}",
+            "syncComplete": "הסנכרון הושלם",
+            "syncFailed": "סנכרון המתכונים נכשל: {message}",
            "updateFailed": "עדכון המתכון נכשל: {error}",
            "updateError": "שגיאה בעדכון המתכון: {message}",
            "nameSaved": "המתכון \"{name}\" נשמר בהצלחה",
--- a/locales/ja.json
+++ b/locales/ja.json
@@ -1,14 +1,17 @@
 {
    "common": {
+        "cancel": "キャンセル",
+        "confirm": "確認",
        "actions": {
            "save": "保存",
            "cancel": "キャンセル",
+            "confirm": "確認",
            "delete": "削除",
            "move": "移動",
            "refresh": "更新",
            "back": "戻る",
            "next": "次へ",
-            "backToTop": "トップに戻る",
+            "backToTop": "トップへ戻る",
            "settings": "設定",
            "help": "ヘルプ",
            "add": "追加"
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "プリセット名...",
            "baseModel": "ベースモデル",
            "modelTags": "タグ（上位20）",
-            "modelTypes": "Model Types",
+            "modelTypes": "モデルタイプ",
            "license": "ライセンス",
            "noCreditRequired": "クレジット不要",
            "allowSellingGeneratedContent": "販売許可",
@@ -258,17 +261,27 @@
            "contentFiltering": "コンテンツフィルタリング",
            "videoSettings": "動画設定",
            "layoutSettings": "レイアウト設定",
-            "folderSettings": "フォルダ設定",
-            "priorityTags": "優先タグ",
-            "downloadPathTemplates": "ダウンロードパステンプレート",
-            "exampleImages": "例画像",
-            "updateFlags": "アップデートフラグ",
-            "autoOrganize": "Auto-organize",
            "misc": "その他",
-            "metadataArchive": "メタデータアーカイブデータベース",
-            "storageLocation": "設定の場所",
+            "folderSettings": "デフォルトルート",
+            "extraFolderPaths": "追加フォルダーパス",
+            "downloadPathTemplates": "ダウンロードパステンプレート",
+            "priorityTags": "優先タグ",
+            "updateFlags": "アップデートフラグ",
+            "exampleImages": "例画像",
+            "autoOrganize": "自動整理",
+            "metadata": "メタデータ",
            "proxySettings": "プロキシ設定"
        },
+        "nav": {
+            "general": "一般",
+            "interface": "インターフェース",
+            "library": "ライブラリ"
+        },
+        "search": {
+            "placeholder": "設定を検索...",
+            "clear": "検索をクリア",
+            "noResults": "\"{query}\" に一致する設定が見つかりません"
+        },
        "storage": {
            "locationLabel": "ポータブルモード",
            "locationHelp": "有効にすると settings.json をリポジトリ内に保持し、無効にするとユーザー設定ディレクトリに格納します。"
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "設定済みのライブラリを切り替えてデフォルトのフォルダを更新します。選択を変更するとページが再読み込みされます。",
            "loadingLibraries": "ライブラリを読み込み中...",
            "noLibraries": "ライブラリが設定されていません",
-            "defaultLoraRoot": "デフォルトLoRAルート",
+            "defaultLoraRoot": "LoRAルート",
            "defaultLoraRootHelp": "ダウンロード、インポート、移動用のデフォルトLoRAルートディレクトリを設定",
-            "defaultCheckpointRoot": "デフォルトCheckpointルート",
+            "defaultCheckpointRoot": "Checkpointルート",
            "defaultCheckpointRootHelp": "ダウンロード、インポート、移動用のデフォルトcheckpointルートディレクトリを設定",
-            "defaultUnetRoot": "デフォルトDiffusion Modelルート",
+            "defaultUnetRoot": "Diffusion Modelルート",
            "defaultUnetRootHelp": "ダウンロード、インポート、移動用のデフォルトDiffusion Model (UNET)ルートディレクトリを設定",
-            "defaultEmbeddingRoot": "デフォルトEmbeddingルート",
+            "defaultEmbeddingRoot": "Embeddingルート",
            "defaultEmbeddingRootHelp": "ダウンロード、インポート、移動用のデフォルトembeddingルートディレクトリを設定",
            "noDefault": "デフォルトなし"
        },
+        "extraFolderPaths": {
+            "title": "追加フォルダーパス",
+            "help": "ComfyUIの標準パスの外部に追加のモデルフォルダを追加します。これらのパスは別々に保存され、デフォルトのフォルダと一緒にスキャンされます。",
+            "description": "モデルをスキャンするための追加フォルダを設定します。これらのパスはLoRA Manager固有であり、ComfyUIのデフォルトパスとマージされます。",
+            "modelTypes": {
+                "lora": "LoRAパス",
+                "checkpoint": "Checkpointパス",
+                "unet": "Diffusionモデルパス",
+                "embedding": "Embeddingパス"
+            },
+            "pathPlaceholder": "/追加モデルへのパス",
+            "saveSuccess": "追加フォルダーパスを更新しました。",
+            "saveError": "追加フォルダーパスの更新に失敗しました: {message}",
+            "validation": {
+                "duplicatePath": "このパスはすでに設定されています"
+            }
+        },
        "priorityTags": {
            "title": "優先タグ",
            "description": "各モデルタイプのタグ優先順位をカスタマイズします (例: character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "少ない順"
            },
            "refresh": {
-                "title": "レシピリストを更新"
+                "title": "レシピリストを更新",
+                "quick": "変更を同期",
+                "quickTooltip": "変更を同期 - キャッシュを再構築せずにクイック更新",
+                "full": "キャッシュを再構築",
+                "fullTooltip": "キャッシュを再構築 - すべてのレシピファイルを完全に再スキャン"
            },
            "filteredByLora": "LoRAでフィルタ済み",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "リストビューでは利用できません",
        "dragDrop": {
            "unableToResolveRoot": "移動先のパスを特定できません。",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "この項目の移動はサポートされていません。",
+            "createFolderHint": "放して新しいフォルダを作成",
+            "newFolderName": "新しいフォルダ名",
+            "folderNameHint": "Enterで確定、Escでキャンセル",
+            "emptyFolderName": "フォルダ名を入力してください",
+            "invalidFolderName": "フォルダ名に無効な文字が含まれています",
+            "noDragState": "保留中のドラッグ操作が見つかりません"
+        },
+        "empty": {
+            "noFolders": "フォルダが見つかりません",
+            "dragHint": "ここへアイテムをドラッグしてフォルダを作成します"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "WeChat QRコードを表示",
            "hideWechatQR": "WeChat QRコードを非表示"
        },
-        "footer": "LoRA Managerをご利用いただきありがとうございます！ ❤️"
+        "footer": "LoRA Managerをご利用いただきありがとうございます！ ❤️",
+        "supporters": {
+            "title": "サポーターの皆様に感謝",
+            "subtitle": "{count} 名のサポーターの皆様に、このプロジェクトを実現していただきありがとうございます",
+            "specialThanks": "特別感謝",
+            "allSupporters": "全サポーター",
+            "totalCount": "サポーター {count} 名"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "{modelType}の読み込みに失敗しました：{message}",
            "refreshComplete": "更新完了",
            "refreshFailed": "レシピの更新に失敗しました：{message}",
+            "syncComplete": "同期完了",
+            "syncFailed": "レシピの同期に失敗しました：{message}",
            "updateFailed": "レシピの更新に失敗しました：{error}",
            "updateError": "レシピ更新エラー：{message}",
            "nameSaved": "レシピ\"{name}\"が正常に保存されました",
--- a/locales/ko.json
+++ b/locales/ko.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "취소",
+        "confirm": "확인",
        "actions": {
            "save": "저장",
            "cancel": "취소",
+            "confirm": "확인",
            "delete": "삭제",
            "move": "이동",
            "refresh": "새로고침",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "프리셋 이름...",
            "baseModel": "베이스 모델",
            "modelTags": "태그 (상위 20개)",
-            "modelTypes": "Model Types",
+            "modelTypes": "모델 유형",
            "license": "라이선스",
            "noCreditRequired": "크레딧 표기 없음",
            "allowSellingGeneratedContent": "판매 허용",
@@ -258,17 +261,27 @@
            "contentFiltering": "콘텐츠 필터링",
            "videoSettings": "비디오 설정",
            "layoutSettings": "레이아웃 설정",
-            "folderSettings": "폴더 설정",
-            "priorityTags": "우선순위 태그",
-            "downloadPathTemplates": "다운로드 경로 템플릿",
-            "exampleImages": "예시 이미지",
-            "updateFlags": "업데이트 표시",
-            "autoOrganize": "Auto-organize",
            "misc": "기타",
-            "metadataArchive": "메타데이터 아카이브 데이터베이스",
-            "storageLocation": "설정 위치",
+            "folderSettings": "기본 루트",
+            "extraFolderPaths": "추가 폴다 경로",
+            "downloadPathTemplates": "다운로드 경로 템플릿",
+            "priorityTags": "우선순위 태그",
+            "updateFlags": "업데이트 표시",
+            "exampleImages": "예시 이미지",
+            "autoOrganize": "자동 정리",
+            "metadata": "메타데이터",
            "proxySettings": "프록시 설정"
        },
+        "nav": {
+            "general": "일반",
+            "interface": "인터페이스",
+            "library": "라이브러리"
+        },
+        "search": {
+            "placeholder": "설정 검색...",
+            "clear": "검색 지우기",
+            "noResults": "\"{query}\"와 일치하는 설정을 찾을 수 없습니다"
+        },
        "storage": {
            "locationLabel": "휴대용 모드",
            "locationHelp": "활성화하면 settings.json을 리포지토리에 유지하고, 비활성화하면 사용자 구성 디렉터리에 저장합니다."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "구성된 라이브러리를 전환하여 기본 폴더를 업데이트합니다. 선택을 변경하면 페이지가 다시 로드됩니다.",
            "loadingLibraries": "라이브러리를 불러오는 중...",
            "noLibraries": "구성된 라이브러리가 없습니다",
-            "defaultLoraRoot": "기본 LoRA 루트",
+            "defaultLoraRoot": "LoRA 루트",
            "defaultLoraRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 LoRA 루트 디렉토리를 설정합니다",
-            "defaultCheckpointRoot": "기본 Checkpoint 루트",
+            "defaultCheckpointRoot": "Checkpoint 루트",
            "defaultCheckpointRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Checkpoint 루트 디렉토리를 설정합니다",
-            "defaultUnetRoot": "기본 Diffusion Model 루트",
+            "defaultUnetRoot": "Diffusion Model 루트",
            "defaultUnetRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Diffusion Model (UNET) 루트 디렉토리를 설정합니다",
-            "defaultEmbeddingRoot": "기본 Embedding 루트",
+            "defaultEmbeddingRoot": "Embedding 루트",
            "defaultEmbeddingRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Embedding 루트 디렉토리를 설정합니다",
            "noDefault": "기본값 없음"
        },
+        "extraFolderPaths": {
+            "title": "추가 폴다 경로",
+            "help": "ComfyUI의 표준 경로 외부에 추가 모델 폴드를 추가하세요. 이러한 경로는 별도로 저장되며 기본 폴와 함께 스캔됩니다.",
+            "description": "모델을 스캔하기 위한 추가 폴를 설정하세요. 이러한 경로는 LoRA Manager 특유의 것이며 ComfyUI의 기본 경로와 병합됩니다.",
+            "modelTypes": {
+                "lora": "LoRA 경로",
+                "checkpoint": "Checkpoint 경로",
+                "unet": "Diffusion 모델 경로",
+                "embedding": "Embedding 경로"
+            },
+            "pathPlaceholder": "/추가/모델/경로",
+            "saveSuccess": "추가 폴다 경로가 업데이트되었습니다.",
+            "saveError": "추가 폴다 경로 업데이트 실패: {message}",
+            "validation": {
+                "duplicatePath": "이 경로는 이미 구성되어 있습니다"
+            }
+        },
        "priorityTags": {
            "title": "우선순위 태그",
            "description": "모델 유형별 태그 우선순위를 사용자 지정합니다(예: character, concept, style(toon|toon_style)).",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "적은순"
            },
            "refresh": {
-                "title": "레시피 목록 새로고침"
+                "title": "레시피 목록 새로고침",
+                "quick": "변경 사항 동기화",
+                "quickTooltip": "변경 사항 동기화 - 캐시를 재구성하지 않고 빠른 새로고침",
+                "full": "캐시 재구성",
+                "fullTooltip": "캐시 재구성 - 모든 레시피 파일을 완전히 다시 스캔"
            },
            "filteredByLora": "LoRA로 필터링됨",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "목록 보기에서는 사용할 수 없습니다",
        "dragDrop": {
            "unableToResolveRoot": "이동할 대상 경로를 확인할 수 없습니다.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "이 항목은 이동을 지원하지 않습니다.",
+            "createFolderHint": "놓아서 새 폴더 만들기",
+            "newFolderName": "새 폴더 이름",
+            "folderNameHint": "Enter를 눌러 확인, Escape를 눌러 취소",
+            "emptyFolderName": "폴더 이름을 입력하세요",
+            "invalidFolderName": "폴더 이름에 잘못된 문자가 포함되어 있습니다",
+            "noDragState": "보류 중인 드래그 작업을 찾을 수 없습니다"
+        },
+        "empty": {
+            "noFolders": "폴더를 찾을 수 없습니다",
+            "dragHint": "항목을 여기로 드래그하여 폴더를 만듭니다"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "WeChat QR 코드 표시",
            "hideWechatQR": "WeChat QR 코드 숨기기"
        },
-        "footer": "LoRA Manager를 사용해주셔서 감사합니다! ❤️"
+        "footer": "LoRA Manager를 사용해주셔서 감사합니다! ❤️",
+        "supporters": {
+            "title": "후원자 분들께 감사드립니다",
+            "subtitle": "이 프로젝트를 가능하게 해준 {count}명의 후원자분들께 감사드립니다",
+            "specialThanks": "특별 감사",
+            "allSupporters": "모든 후원자",
+            "totalCount": "총 {count}명의 후원자"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "{modelType} 로딩 실패: {message}",
            "refreshComplete": "새로고침 완료",
            "refreshFailed": "레시피 새로고침 실패: {message}",
+            "syncComplete": "동기화 완료",
+            "syncFailed": "레시피 동기화 실패: {message}",
            "updateFailed": "레시피 업데이트 실패: {error}",
            "updateError": "레시피 업데이트 오류: {message}",
            "nameSaved": "레시피 \"{name}\"이 성공적으로 저장되었습니다",
@@ -1624,4 +1677,4 @@
            "retry": "다시 시도"
        }
    }
-}
+}
--- a/locales/ru.json
+++ b/locales/ru.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "Отмена",
+        "confirm": "Подтвердить",
        "actions": {
            "save": "Сохранить",
            "cancel": "Отмена",
+            "confirm": "Подтвердить",
            "delete": "Удалить",
            "move": "Переместить",
            "refresh": "Обновить",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "Имя пресета...",
            "baseModel": "Базовая модель",
            "modelTags": "Теги (Топ 20)",
-            "modelTypes": "Model Types",
+            "modelTypes": "Типы моделей",
            "license": "Лицензия",
            "noCreditRequired": "Без указания авторства",
            "allowSellingGeneratedContent": "Продажа разрешена",
@@ -258,17 +261,27 @@
            "contentFiltering": "Фильтрация контента",
            "videoSettings": "Настройки видео",
            "layoutSettings": "Настройки макета",
-            "folderSettings": "Настройки папок",
-            "priorityTags": "Приоритетные теги",
-            "downloadPathTemplates": "Шаблоны путей загрузки",
-            "exampleImages": "Примеры изображений",
-            "updateFlags": "Метки обновлений",
-            "autoOrganize": "Auto-organize",
            "misc": "Разное",
-            "metadataArchive": "Архив метаданных",
-            "storageLocation": "Расположение настроек",
+            "folderSettings": "Корневые папки",
+            "extraFolderPaths": "Дополнительные пути к папкам",
+            "downloadPathTemplates": "Шаблоны путей загрузки",
+            "priorityTags": "Приоритетные теги",
+            "updateFlags": "Метки обновлений",
+            "exampleImages": "Примеры изображений",
+            "autoOrganize": "Автоорганизация",
+            "metadata": "Метаданные",
            "proxySettings": "Настройки прокси"
        },
+        "nav": {
+            "general": "Общее",
+            "interface": "Интерфейс",
+            "library": "Библиотека"
+        },
+        "search": {
+            "placeholder": "Поиск в настройках...",
+            "clear": "Очистить поиск",
+            "noResults": "Настройки, соответствующие \"{query}\", не найдены"
+        },
        "storage": {
            "locationLabel": "Портативный режим",
            "locationHelp": "Включите, чтобы хранить settings.json в репозитории; выключите, чтобы сохранить его в папке конфигурации пользователя."
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "Переключайтесь между настроенными библиотеками, чтобы обновить папки по умолчанию. Изменение выбора перезагружает страницу.",
            "loadingLibraries": "Загрузка библиотек...",
            "noLibraries": "Библиотеки не настроены",
-            "defaultLoraRoot": "Корневая папка LoRA по умолчанию",
+            "defaultLoraRoot": "Корневая папка LoRA",
            "defaultLoraRootHelp": "Установить корневую папку LoRA по умолчанию для загрузок, импорта и перемещений",
-            "defaultCheckpointRoot": "Корневая папка Checkpoint по умолчанию",
+            "defaultCheckpointRoot": "Корневая папка Checkpoint",
            "defaultCheckpointRootHelp": "Установить корневую папку checkpoint по умолчанию для загрузок, импорта и перемещений",
-            "defaultUnetRoot": "Корневая папка Diffusion Model по умолчанию",
+            "defaultUnetRoot": "Корневая папка Diffusion Model",
            "defaultUnetRootHelp": "Установить корневую папку Diffusion Model (UNET) по умолчанию для загрузок, импорта и перемещений",
-            "defaultEmbeddingRoot": "Корневая папка Embedding по умолчанию",
+            "defaultEmbeddingRoot": "Корневая папка Embedding",
            "defaultEmbeddingRootHelp": "Установить корневую папку embedding по умолчанию для загрузок, импорта и перемещений",
            "noDefault": "Не задано"
        },
+        "extraFolderPaths": {
+            "title": "Дополнительные пути к папкам",
+            "help": "Добавьте дополнительные папки моделей за пределами стандартных путей ComfyUI. Эти пути хранятся отдельно и сканируются вместе с папками по умолчанию.",
+            "description": "Настройте дополнительные папки для сканирования моделей. Эти пути специфичны для LoRA Manager и будут объединены с путями по умолчанию ComfyUI.",
+            "modelTypes": {
+                "lora": "Пути LoRA",
+                "checkpoint": "Пути Checkpoint",
+                "unet": "Пути моделей диффузии",
+                "embedding": "Пути Embedding"
+            },
+            "pathPlaceholder": "/путь/к/дополнительным/моделям",
+            "saveSuccess": "Дополнительные пути к папкам обновлены.",
+            "saveError": "Не удалось обновить дополнительные пути к папкам: {message}",
+            "validation": {
+                "duplicatePath": "Этот путь уже настроен"
+            }
+        },
        "priorityTags": {
            "title": "Приоритетные теги",
            "description": "Настройте порядок приоритетов тегов для каждого типа моделей (например, character, concept, style(toon|toon_style)).",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "Меньше всего"
            },
            "refresh": {
-                "title": "Обновить список рецептов"
+                "title": "Обновить список рецептов",
+                "quick": "Синхронизировать изменения",
+                "quickTooltip": "Синхронизировать изменения - быстрое обновление без перестроения кэша",
+                "full": "Перестроить кэш",
+                "fullTooltip": "Перестроить кэш - полное повторное сканирование всех файлов рецептов"
            },
            "filteredByLora": "Фильтр по LoRA",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "Недоступно в виде списка",
        "dragDrop": {
            "unableToResolveRoot": "Не удалось определить путь назначения для перемещения.",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Перемещение этого элемента не поддерживается.",
+            "createFolderHint": "Отпустите, чтобы создать новую папку",
+            "newFolderName": "Имя новой папки",
+            "folderNameHint": "Нажмите Enter для подтверждения, Escape для отмены",
+            "emptyFolderName": "Пожалуйста, введите имя папки",
+            "invalidFolderName": "Имя папки содержит недопустимые символы",
+            "noDragState": "Ожидающая операция перетаскивания не найдена"
+        },
+        "empty": {
+            "noFolders": "Папки не найдены",
+            "dragHint": "Перетащите элементы сюда, чтобы создать папки"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "Показать QR-код WeChat",
            "hideWechatQR": "Скрыть QR-код WeChat"
        },
-        "footer": "Спасибо за использование LoRA Manager! ❤️"
+        "footer": "Спасибо за использование LoRA Manager! ❤️",
+        "supporters": {
+            "title": "Спасибо всем сторонникам",
+            "subtitle": "Спасибо {count} сторонникам, которые сделали этот проект возможным",
+            "specialThanks": "Особая благодарность",
+            "allSupporters": "Все сторонники",
+            "totalCount": "Всего {count} сторонников"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "Не удалось загрузить {modelType}s: {message}",
            "refreshComplete": "Обновление завершено",
            "refreshFailed": "Не удалось обновить рецепты: {message}",
+            "syncComplete": "Синхронизация завершена",
+            "syncFailed": "Не удалось синхронизировать рецепты: {message}",
            "updateFailed": "Не удалось обновить рецепт: {error}",
            "updateError": "Ошибка обновления рецепта: {message}",
            "nameSaved": "Рецепт \"{name}\" успешно сохранен",
--- a/locales/zh-CN.json
+++ b/locales/zh-CN.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "取消",
+        "confirm": "确认",
        "actions": {
            "save": "保存",
            "cancel": "取消",
+            "confirm": "确认",
            "delete": "删除",
            "move": "移动",
            "refresh": "刷新",
@@ -159,11 +162,11 @@
            "error": "清理示例图片文件夹失败：{message}"
        },
        "fetchMissingLicenses": {
-            "label": "Refresh license metadata",
-            "loading": "Refreshing license metadata for {typePlural}...",
-            "success": "Updated license metadata for {count} {typePlural}",
-            "none": "All {typePlural} already have license metadata",
-            "error": "Failed to refresh license metadata for {typePlural}: {message}"
+            "label": "刷新许可证元数据",
+            "loading": "正在刷新 {typePlural} 的许可证元数据...",
+            "success": "已更新 {count} 个 {typePlural} 的许可证元数据",
+            "none": "所有 {typePlural} 都已具备许可证元数据",
+            "error": "刷新 {typePlural} 的许可证元数据失败：{message}"
        },
        "repairRecipes": {
            "label": "修复配方数据",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "预设名称...",
            "baseModel": "基础模型",
            "modelTags": "标签（前20）",
-            "modelTypes": "Model Types",
+            "modelTypes": "模型类型",
            "license": "许可证",
            "noCreditRequired": "无需署名",
            "allowSellingGeneratedContent": "允许销售",
@@ -258,17 +261,27 @@
            "contentFiltering": "内容过滤",
            "videoSettings": "视频设置",
            "layoutSettings": "布局设置",
-            "folderSettings": "文件夹设置",
-            "priorityTags": "优先标签",
-            "downloadPathTemplates": "下载路径模板",
-            "exampleImages": "示例图片",
-            "updateFlags": "更新标记",
-            "autoOrganize": "Auto-organize",
            "misc": "其他",
-            "metadataArchive": "元数据归档数据库",
-            "storageLocation": "设置位置",
+            "folderSettings": "默认根目录",
+            "extraFolderPaths": "额外文件夹路径",
+            "downloadPathTemplates": "下载路径模板",
+            "priorityTags": "优先标签",
+            "updateFlags": "更新标记",
+            "exampleImages": "示例图片",
+            "autoOrganize": "自动整理",
+            "metadata": "元数据",
            "proxySettings": "代理设置"
        },
+        "nav": {
+            "general": "通用",
+            "interface": "界面",
+            "library": "库"
+        },
+        "search": {
+            "placeholder": "搜索设置...",
+            "clear": "清除搜索",
+            "noResults": "未找到匹配 \"{query}\" 的设置"
+        },
        "storage": {
            "locationLabel": "便携模式",
            "locationHelp": "开启可将 settings.json 保存在仓库中；关闭则保存在用户配置目录。"
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "在已配置的库之间切换以更新默认文件夹。更改选择将重新加载页面。",
            "loadingLibraries": "正在加载库...",
            "noLibraries": "尚未配置库",
-            "defaultLoraRoot": "默认 LoRA 根目录",
+            "defaultLoraRoot": "LoRA 根目录",
            "defaultLoraRootHelp": "设置下载、导入和移动时的默认 LoRA 根目录",
-            "defaultCheckpointRoot": "默认 Checkpoint 根目录",
+            "defaultCheckpointRoot": "Checkpoint 根目录",
            "defaultCheckpointRootHelp": "设置下载、导入和移动时的默认 Checkpoint 根目录",
-            "defaultUnetRoot": "默认 Diffusion Model 根目录",
+            "defaultUnetRoot": "Diffusion Model 根目录",
            "defaultUnetRootHelp": "设置下载、导入和移动时的默认 Diffusion Model (UNET) 根目录",
-            "defaultEmbeddingRoot": "默认 Embedding 根目录",
+            "defaultEmbeddingRoot": "Embedding 根目录",
            "defaultEmbeddingRootHelp": "设置下载、导入和移动时的默认 Embedding 根目录",
            "noDefault": "无默认"
        },
+        "extraFolderPaths": {
+            "title": "额外文件夹路径",
+            "help": "在 ComfyUI 的标准路径之外添加额外的模型文件夹。这些路径单独存储，并与默认文件夹一起扫描。",
+            "description": "配置额外的文件夹以扫描模型。这些路径是 LoRA Manager 特有的，将与 ComfyUI 的默认路径合并。",
+            "modelTypes": {
+                "lora": "LoRA 路径",
+                "checkpoint": "Checkpoint 路径",
+                "unet": "Diffusion 模型路径",
+                "embedding": "Embedding 路径"
+            },
+            "pathPlaceholder": "/额外/模型/路径",
+            "saveSuccess": "额外文件夹路径已更新。",
+            "saveError": "更新额外文件夹路径失败：{message}",
+            "validation": {
+                "duplicatePath": "此路径已配置"
+            }
+        },
        "priorityTags": {
            "title": "优先标签",
            "description": "为每种模型类型自定义标签优先级顺序 (例如: character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "最少"
            },
            "refresh": {
-                "title": "刷新配方列表"
+                "title": "刷新配方列表",
+                "quick": "同步变更",
+                "quickTooltip": "同步变更 - 快速刷新而不重建缓存",
+                "full": "重建缓存",
+                "fullTooltip": "重建缓存 - 重新扫描所有配方文件"
            },
            "filteredByLora": "按 LoRA 筛选",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "列表视图下不可用",
        "dragDrop": {
            "unableToResolveRoot": "无法确定移动的目标路径。",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Move is not supported for this item.",
+            "createFolderHint": "释放以创建新文件夹",
+            "newFolderName": "新文件夹名称",
+            "folderNameHint": "按 Enter 确认，Escape 取消",
+            "emptyFolderName": "请输入文件夹名称",
+            "invalidFolderName": "文件夹名称包含无效字符",
+            "noDragState": "未找到待处理的拖放操作"
+            },
+        "empty": {
+            "noFolders": "未找到文件夹",
+            "dragHint": "拖拽项目到此处以创建文件夹"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "显示微信二维码",
            "hideWechatQR": "隐藏微信二维码"
        },
-        "footer": "感谢使用 LoRA 管理器！❤️"
+        "footer": "感谢使用 LoRA 管理器！❤️",
+        "supporters": {
+            "title": "感谢所有支持者",
+            "subtitle": "感谢 {count} 位支持者让这个项目成为可能",
+            "specialThanks": "特别感谢",
+            "allSupporters": "所有支持者",
+            "totalCount": "共 {count} 位支持者"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "加载 {modelType} 失败：{message}",
            "refreshComplete": "刷新完成",
            "refreshFailed": "刷新配方失败：{message}",
+            "syncComplete": "同步完成",
+            "syncFailed": "同步配方失败：{message}",
            "updateFailed": "更新配方失败：{error}",
            "updateError": "更新配方出错：{message}",
            "nameSaved": "配方“{name}”保存成功",
--- a/locales/zh-TW.json
+++ b/locales/zh-TW.json
@@ -1,8 +1,11 @@
 {
    "common": {
+        "cancel": "取消",
+        "confirm": "確認",
        "actions": {
            "save": "儲存",
            "cancel": "取消",
+            "confirm": "確認",
            "delete": "刪除",
            "move": "移動",
            "refresh": "重新整理",
@@ -219,7 +222,7 @@
            "presetNamePlaceholder": "預設名稱...",
            "baseModel": "基礎模型",
            "modelTags": "標籤（前 20）",
-            "modelTypes": "Model Types",
+            "modelTypes": "模型類型",
            "license": "授權",
            "noCreditRequired": "無需署名",
            "allowSellingGeneratedContent": "允許銷售",
@@ -258,17 +261,27 @@
            "contentFiltering": "內容過濾",
            "videoSettings": "影片設定",
            "layoutSettings": "版面設定",
-            "folderSettings": "資料夾設定",
-            "priorityTags": "優先標籤",
-            "downloadPathTemplates": "下載路徑範本",
-            "exampleImages": "範例圖片",
-            "updateFlags": "更新標記",
-            "autoOrganize": "Auto-organize",
            "misc": "其他",
-            "metadataArchive": "中繼資料封存資料庫",
-            "storageLocation": "設定位置",
+            "folderSettings": "預設根目錄",
+            "extraFolderPaths": "額外資料夾路徑",
+            "downloadPathTemplates": "下載路徑範本",
+            "priorityTags": "優先標籤",
+            "updateFlags": "更新標記",
+            "exampleImages": "範例圖片",
+            "autoOrganize": "自動整理",
+            "metadata": "中繼資料",
            "proxySettings": "代理設定"
        },
+        "nav": {
+            "general": "通用",
+            "interface": "介面",
+            "library": "模型庫"
+        },
+        "search": {
+            "placeholder": "搜尋設定...",
+            "clear": "清除搜尋",
+            "noResults": "未找到符合 \"{query}\" 的設定"
+        },
        "storage": {
            "locationLabel": "可攜式模式",
            "locationHelp": "啟用可將 settings.json 保存在儲存庫中；停用則保存在使用者設定目錄。"
@@ -341,16 +354,33 @@
            "activeLibraryHelp": "在已設定的資料庫之間切換以更新預設資料夾。變更選項會重新載入頁面。",
            "loadingLibraries": "正在載入資料庫...",
            "noLibraries": "尚未設定任何資料庫",
-            "defaultLoraRoot": "預設 LoRA 根目錄",
+            "defaultLoraRoot": "LoRA 根目錄",
            "defaultLoraRootHelp": "設定下載、匯入和移動時的預設 LoRA 根目錄",
-            "defaultCheckpointRoot": "預設 Checkpoint 根目錄",
+            "defaultCheckpointRoot": "Checkpoint 根目錄",
            "defaultCheckpointRootHelp": "設定下載、匯入和移動時的預設 Checkpoint 根目錄",
-            "defaultUnetRoot": "預設 Diffusion Model 根目錄",
+            "defaultUnetRoot": "Diffusion Model 根目錄",
            "defaultUnetRootHelp": "設定下載、匯入和移動時的預設 Diffusion Model (UNET) 根目錄",
-            "defaultEmbeddingRoot": "預設 Embedding 根目錄",
+            "defaultEmbeddingRoot": "Embedding 根目錄",
            "defaultEmbeddingRootHelp": "設定下載、匯入和移動時的預設 Embedding 根目錄",
            "noDefault": "未設定預設"
        },
+        "extraFolderPaths": {
+            "title": "額外資料夾路徑",
+            "help": "在 ComfyUI 的標準路徑之外新增額外的模型資料夾。這些路徑單獨儲存，並與預設資料夾一起掃描。",
+            "description": "設定額外的資料夾以掃描模型。這些路徑是 LoRA Manager 特有的，將與 ComfyUI 的預設路徑合併。",
+            "modelTypes": {
+                "lora": "LoRA 路徑",
+                "checkpoint": "Checkpoint 路徑",
+                "unet": "Diffusion 模型路徑",
+                "embedding": "Embedding 路徑"
+            },
+            "pathPlaceholder": "/額外/模型/路徑",
+            "saveSuccess": "額外資料夾路徑已更新。",
+            "saveError": "更新額外資料夾路徑失敗：{message}",
+            "validation": {
+                "duplicatePath": "此路徑已設定"
+            }
+        },
        "priorityTags": {
            "title": "優先標籤",
            "description": "為每種模型類型自訂標籤的優先順序 (例如: character, concept, style(toon|toon_style))",
@@ -655,7 +685,11 @@
                "lorasCountAsc": "最少"
            },
            "refresh": {
-                "title": "重新整理配方列表"
+                "title": "重新整理配方列表",
+                "quick": "同步變更",
+                "quickTooltip": "同步變更 - 快速重新整理而不重建快取",
+                "full": "重建快取",
+                "fullTooltip": "重建快取 - 重新掃描所有配方檔案"
            },
            "filteredByLora": "已依 LoRA 篩選",
            "favorites": {
@@ -723,7 +757,17 @@
        "collapseAllDisabled": "列表檢視下不可用",
        "dragDrop": {
            "unableToResolveRoot": "無法確定移動的目標路徑。",
-            "moveUnsupported": "Move is not supported for this item."
+            "moveUnsupported": "Move is not supported for this item.",
+            "createFolderHint": "放開以建立新資料夾",
+            "newFolderName": "新資料夾名稱",
+            "folderNameHint": "按 Enter 確認，Escape 取消",
+            "emptyFolderName": "請輸入資料夾名稱",
+            "invalidFolderName": "資料夾名稱包含無效字元",
+            "noDragState": "未找到待處理的拖放操作"
+        },
+        "empty": {
+            "noFolders": "未找到資料夾",
+            "dragHint": "將項目拖到此處以建立資料夾"
        }
    },
    "statistics": {
@@ -1315,7 +1359,14 @@
            "showWechatQR": "顯示微信二維碼",
            "hideWechatQR": "隱藏微信二維碼"
        },
-        "footer": "感謝您使用 LoRA 管理器！❤️"
+        "footer": "感謝您使用 LoRA 管理器！❤️",
+        "supporters": {
+            "title": "感謝所有支持者",
+            "subtitle": "感謝 {count} 位支持者讓這個專案成為可能",
+            "specialThanks": "特別感謝",
+            "allSupporters": "所有支持者",
+            "totalCount": "共 {count} 位支持者"
+        }
    },
    "toast": {
        "general": {
@@ -1349,6 +1400,8 @@
            "loadFailed": "載入 {modelType} 失敗：{message}",
            "refreshComplete": "刷新完成",
            "refreshFailed": "刷新配方失敗：{message}",
+            "syncComplete": "同步完成",
+            "syncFailed": "同步配方失敗：{message}",
            "updateFailed": "更新配方失敗：{error}",
            "updateError": "更新配方錯誤：{message}",
            "nameSaved": "配方「{name}」已成功儲存",
--- a/py/config.py
+++ b/py/config.py
@@ -2,7 +2,7 @@ import os
 import platform
 import threading
 from pathlib import Path
-import folder_paths # type: ignore
+import folder_paths  # type: ignore
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Set, Tuple
 import logging
 import json
@@ -10,16 +10,23 @@ import urllib.parse
 import time

 from .utils.cache_paths import CacheType, get_cache_file_path, get_legacy_cache_paths
-from .utils.settings_paths import ensure_settings_file, get_settings_dir, load_settings_template
+from .utils.settings_paths import (
+    ensure_settings_file,
+    get_settings_dir,
+    load_settings_template,
+)

 # Use an environment variable to control standalone mode
-standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+standalone_mode = (
+    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+)

 logger = logging.getLogger(__name__)


 def _normalize_folder_paths_for_comparison(
-    folder_paths: Mapping[str, Iterable[str]]
+    folder_paths: Mapping[str, Iterable[str]],
 ) -> Dict[str, Set[str]]:
    """Normalize folder paths for comparison across libraries."""

@@ -49,7 +56,7 @@ def _normalize_folder_paths_for_comparison(


 def _normalize_library_folder_paths(
-    library_payload: Mapping[str, Any]
+    library_payload: Mapping[str, Any],
 ) -> Dict[str, Set[str]]:
    """Return normalized folder paths extracted from a library payload."""

@@ -74,11 +81,17 @@ def _get_template_folder_paths() -> Dict[str, Set[str]]:

 class Config:
    """Global configuration for LoRA Manager"""
-    
+
    def __init__(self):
-        self.templates_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'templates')
-        self.static_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'static')
-        self.i18n_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'locales')
+        self.templates_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "templates"
+        )
+        self.static_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "static"
+        )
+        self.i18n_path = os.path.join(
+            os.path.dirname(os.path.dirname(__file__)), "locales"
+        )
        # Path mapping dictionary, target to link mapping
        self._path_mappings: Dict[str, str] = {}
        # Normalized preview root directories used to validate preview access
@@ -91,9 +104,14 @@ class Config:
        self.embeddings_roots = None
        self.base_models_roots = self._init_checkpoint_paths()
        self.embeddings_roots = self._init_embedding_paths()
+        # Extra paths (only for LoRA Manager, not shared with ComfyUI)
+        self.extra_loras_roots: List[str] = []
+        self.extra_checkpoints_roots: List[str] = []
+        self.extra_unet_roots: List[str] = []
+        self.extra_embeddings_roots: List[str] = []
        # Scan symbolic links during initialization
        self._initialize_symlink_mappings()
-        
+
        if not standalone_mode:
            # Save the paths to settings.json when running in ComfyUI mode
            self.save_folder_paths_to_settings()
@@ -147,17 +165,21 @@ class Config:
                default_library = libraries.get("default", {})

            target_folder_paths = {
-                'loras': list(self.loras_roots),
-                'checkpoints': list(self.checkpoints_roots or []),
-                'unet': list(self.unet_roots or []),
-                'embeddings': list(self.embeddings_roots or []),
+                "loras": list(self.loras_roots),
+                "checkpoints": list(self.checkpoints_roots or []),
+                "unet": list(self.unet_roots or []),
+                "embeddings": list(self.embeddings_roots or []),
            }

-            normalized_target_paths = _normalize_folder_paths_for_comparison(target_folder_paths)
+            normalized_target_paths = _normalize_folder_paths_for_comparison(
+                target_folder_paths
+            )

            normalized_default_paths: Optional[Dict[str, Set[str]]] = None
            if isinstance(default_library, Mapping):
-                normalized_default_paths = _normalize_library_folder_paths(default_library)
+                normalized_default_paths = _normalize_library_folder_paths(
+                    default_library
+                )

            if (
                not comfy_library
@@ -180,13 +202,19 @@ class Config:
                default_lora_root = self.loras_roots[0]

            default_checkpoint_root = comfy_library.get("default_checkpoint_root", "")
-            if (not default_checkpoint_root and self.checkpoints_roots and
-                    len(self.checkpoints_roots) == 1):
+            if (
+                not default_checkpoint_root
+                and self.checkpoints_roots
+                and len(self.checkpoints_roots) == 1
+            ):
                default_checkpoint_root = self.checkpoints_roots[0]

            default_embedding_root = comfy_library.get("default_embedding_root", "")
-            if (not default_embedding_root and self.embeddings_roots and
-                    len(self.embeddings_roots) == 1):
+            if (
+                not default_embedding_root
+                and self.embeddings_roots
+                and len(self.embeddings_roots) == 1
+            ):
                default_embedding_root = self.embeddings_roots[0]

            metadata = dict(comfy_library.get("metadata", {}))
@@ -211,11 +239,12 @@ class Config:
        try:
            if os.path.islink(path):
                return True
-            if platform.system() == 'Windows':
+            if platform.system() == "Windows":
                try:
                    import ctypes
+
                    FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-                    attrs = ctypes.windll.kernel32.GetFileAttributesW(str(path))
+                    attrs = ctypes.windll.kernel32.GetFileAttributesW(str(path))  # type: ignore[attr-defined]
                    return attrs != -1 and (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
                except Exception as e:
                    logger.error(f"Error checking Windows reparse point: {e}")
@@ -228,18 +257,19 @@ class Config:
        """Check if a directory entry is a symlink, including Windows junctions."""
        if entry.is_symlink():
            return True
-        if platform.system() == 'Windows':
+        if platform.system() == "Windows":
            try:
                import ctypes
+
                FILE_ATTRIBUTE_REPARSE_POINT = 0x400
-                attrs = ctypes.windll.kernel32.GetFileAttributesW(entry.path)
+                attrs = ctypes.windll.kernel32.GetFileAttributesW(entry.path)  # type: ignore[attr-defined]
                return attrs != -1 and (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
            except Exception:
                pass
        return False

    def _normalize_path(self, path: str) -> str:
-        return os.path.normpath(path).replace(os.sep, '/')
+        return os.path.normpath(path).replace(os.sep, "/")

    def _get_symlink_cache_path(self) -> Path:
        canonical_path = get_cache_file_path(CacheType.SYMLINK, create_dir=True)
@@ -250,6 +280,11 @@ class Config:
        roots.extend(self.loras_roots or [])
        roots.extend(self.base_models_roots or [])
        roots.extend(self.embeddings_roots or [])
+        # Include extra paths for scanning symlinks
+        roots.extend(self.extra_loras_roots or [])
+        roots.extend(self.extra_checkpoints_roots or [])
+        roots.extend(self.extra_unet_roots or [])
+        roots.extend(self.extra_embeddings_roots or [])
        return roots

    def _build_symlink_fingerprint(self) -> Dict[str, object]:
@@ -268,19 +303,18 @@ class Config:
                            if self._entry_is_symlink(entry):
                                try:
                                    target = os.path.realpath(entry.path)
-                                    direct_symlinks.append([
-                                        self._normalize_path(entry.path),
-                                        self._normalize_path(target)
-                                    ])
+                                    direct_symlinks.append(
+                                        [
+                                            self._normalize_path(entry.path),
+                                            self._normalize_path(target),
+                                        ]
+                                    )
                                except OSError:
                                    pass
            except (OSError, PermissionError):
                pass

-        return {
-            "roots": unique_roots,
-            "direct_symlinks": sorted(direct_symlinks)
-        }
+        return {"roots": unique_roots, "direct_symlinks": sorted(direct_symlinks)}

    def _initialize_symlink_mappings(self) -> None:
        start = time.perf_counter()
@@ -297,10 +331,14 @@ class Config:
            cached_fingerprint = self._cached_fingerprint

            # Check 1: First-level symlinks unchanged (catches new symlinks at root)
-            fingerprint_valid = cached_fingerprint and current_fingerprint == cached_fingerprint
+            fingerprint_valid = (
+                cached_fingerprint and current_fingerprint == cached_fingerprint
+            )

            # Check 2: All cached mappings still valid (catches changes at any depth)
-            mappings_valid = self._validate_cached_mappings() if fingerprint_valid else False
+            mappings_valid = (
+                self._validate_cached_mappings() if fingerprint_valid else False
+            )

            if fingerprint_valid and mappings_valid:
                return
@@ -360,7 +398,9 @@ class Config:
        for target, link in cached_mappings.items():
            if not isinstance(target, str) or not isinstance(link, str):
                continue
-            normalized_mappings[self._normalize_path(target)] = self._normalize_path(link)
+            normalized_mappings[self._normalize_path(target)] = self._normalize_path(
+                link
+            )

        self._path_mappings = normalized_mappings

@@ -381,7 +421,9 @@ class Config:
                        parent_dir = loaded_path.parent
                        if parent_dir.name == "cache" and not any(parent_dir.iterdir()):
                            parent_dir.rmdir()
-                            logger.info("Removed empty legacy cache directory: %s", parent_dir)
+                            logger.info(
+                                "Removed empty legacy cache directory: %s", parent_dir
+                            )
                    except Exception:
                        pass

@@ -392,7 +434,9 @@ class Config:
                    exc,
                )
        else:
-            logger.info("Symlink cache loaded with %d mappings", len(self._path_mappings))
+            logger.info(
+                "Symlink cache loaded with %d mappings", len(self._path_mappings)
+            )

        return True

@@ -404,7 +448,7 @@ class Config:
        """
        for target, link in self._path_mappings.items():
            # Convert normalized paths back to OS paths
-            link_path = link.replace('/', os.sep)
+            link_path = link.replace("/", os.sep)

            # Check if symlink still exists
            if not self._is_link(link_path):
@@ -417,7 +461,9 @@ class Config:
                if actual_target != target:
                    logger.debug(
                        "Symlink target changed: %s -> %s (cached: %s)",
-                        link_path, actual_target, target
+                        link_path,
+                        actual_target,
+                        target,
                    )
                    return False
            except OSError:
@@ -436,7 +482,11 @@ class Config:
        try:
            with cache_path.open("w", encoding="utf-8") as handle:
                json.dump(payload, handle, ensure_ascii=False, indent=2)
-            logger.debug("Symlink cache saved to %s with %d mappings", cache_path, len(self._path_mappings))
+            logger.debug(
+                "Symlink cache saved to %s with %d mappings",
+                cache_path,
+                len(self._path_mappings),
+            )
        except Exception as exc:
            logger.info("Failed to write symlink cache %s: %s", cache_path, exc)

@@ -448,7 +498,7 @@ class Config:
        at the root level only (not nested symlinks in subdirectories).
        """
        start = time.perf_counter()
-        
+
        # Reset mappings before rescanning to avoid stale entries
        self._path_mappings.clear()
        self._seed_root_symlink_mappings()
@@ -462,7 +512,7 @@ class Config:

    def _scan_first_level_symlinks(self, root: str):
        """Scan only the first level of a directory for symlinks.
-        
+
        This avoids traversing the entire directory tree which can be extremely
        slow for large model collections. Only symlinks directly under the root
        are detected.
@@ -484,13 +534,13 @@ class Config:
                        self.add_path_mapping(entry.path, target_path)
                    except Exception as inner_exc:
                        logger.debug(
-                            "Error processing directory entry %s: %s", entry.path, inner_exc
+                            "Error processing directory entry %s: %s",
+                            entry.path,
+                            inner_exc,
                        )
        except Exception as e:
            logger.error(f"Error scanning links in {root}: {e}")

-
-
    def add_path_mapping(self, link_path: str, target_path: str):
        """Add a symbolic link path mapping
        target_path: actual target path
@@ -570,46 +620,60 @@ class Config:
            preview_roots.update(self._expand_preview_root(root))
        for root in self.embeddings_roots or []:
            preview_roots.update(self._expand_preview_root(root))
+        # Include extra paths for preview access
+        for root in self.extra_loras_roots or []:
+            preview_roots.update(self._expand_preview_root(root))
+        for root in self.extra_checkpoints_roots or []:
+            preview_roots.update(self._expand_preview_root(root))
+        for root in self.extra_unet_roots or []:
+            preview_roots.update(self._expand_preview_root(root))
+        for root in self.extra_embeddings_roots or []:
+            preview_roots.update(self._expand_preview_root(root))

        for target, link in self._path_mappings.items():
            preview_roots.update(self._expand_preview_root(target))
            preview_roots.update(self._expand_preview_root(link))

-        self._preview_root_paths = {path for path in preview_roots if path.is_absolute()}
+        self._preview_root_paths = {
+            path for path in preview_roots if path.is_absolute()
+        }
        logger.debug(
-            "Preview roots rebuilt: %d paths from %d lora roots, %d checkpoint roots, %d embedding roots, %d symlink mappings",
+            "Preview roots rebuilt: %d paths from %d lora roots (%d extra), %d checkpoint roots (%d extra), %d embedding roots (%d extra), %d symlink mappings",
            len(self._preview_root_paths),
            len(self.loras_roots or []),
+            len(self.extra_loras_roots or []),
            len(self.base_models_roots or []),
+            len(self.extra_checkpoints_roots or []),
            len(self.embeddings_roots or []),
+            len(self.extra_embeddings_roots or []),
            len(self._path_mappings),
        )

    def map_path_to_link(self, path: str) -> str:
        """Map a target path back to its symbolic link path"""
-        normalized_path = os.path.normpath(path).replace(os.sep, '/')
+        normalized_path = os.path.normpath(path).replace(os.sep, "/")
        # Check if the path is contained in any mapped target path
        for target_path, link_path in self._path_mappings.items():
            # Match whole path components to avoid prefix collisions (e.g., /a/b vs /a/bc)
            if normalized_path == target_path:
                return link_path
-            
-            if normalized_path.startswith(target_path + '/'):
+
+            if normalized_path.startswith(target_path + "/"):
                # If the path starts with the target path, replace with link path
                mapped_path = normalized_path.replace(target_path, link_path, 1)
                return mapped_path
        return normalized_path
-    
+
    def map_link_to_path(self, link_path: str) -> str:
        """Map a symbolic link path back to the actual path"""
-        normalized_link = os.path.normpath(link_path).replace(os.sep, '/')
+        normalized_link = os.path.normpath(link_path).replace(os.sep, "/")
        # Check if the path is contained in any mapped target path
        for target_path, link_path_mapped in self._path_mappings.items():
            # Match whole path components
            if normalized_link == link_path_mapped:
                return target_path

-            if normalized_link.startswith(link_path_mapped + '/'):
+            if normalized_link.startswith(link_path_mapped + "/"):
                # If the path starts with the link path, replace with actual path
                mapped_path = normalized_link.replace(link_path_mapped, target_path, 1)
                return mapped_path
@@ -622,8 +686,8 @@ class Config:
                continue
            if not os.path.exists(path):
                continue
-            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, '/')
-            normalized = os.path.normpath(path).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(path)).replace(os.sep, "/")
+            normalized = os.path.normpath(path).replace(os.sep, "/")
            if real_path not in dedup:
                dedup[real_path] = normalized
        return dedup
@@ -633,7 +697,9 @@ class Config:
        unique_paths = sorted(path_map.values(), key=lambda p: p.lower())

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

@@ -655,7 +721,7 @@ class Config:
                "Please fix your ComfyUI path configuration to separate these folders. "
                "Falling back to 'checkpoints' for backward compatibility. "
                "Overlapping real paths: %s",
-                [checkpoint_map.get(rp, rp) for rp in overlapping_real_paths]
+                [checkpoint_map.get(rp, rp) for rp in overlapping_real_paths],
            )
            # Remove overlapping paths from unet_map to prioritize checkpoints
            for rp in overlapping_real_paths:
@@ -675,7 +741,9 @@ class Config:
        self.unet_roots = [p for p in unique_paths if p in unet_values]

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

@@ -686,25 +754,83 @@ class Config:
        unique_paths = sorted(path_map.values(), key=lambda p: p.lower())

        for original_path in unique_paths:
-            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(
+                os.sep, "/"
+            )
            if real_path != original_path:
                self.add_path_mapping(original_path, real_path)

        return unique_paths

-    def _apply_library_paths(self, folder_paths: Mapping[str, Iterable[str]]) -> None:
+    def _apply_library_paths(
+        self,
+        folder_paths: Mapping[str, Iterable[str]],
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
+    ) -> None:
        self._path_mappings.clear()
        self._preview_root_paths = set()

-        lora_paths = folder_paths.get('loras', []) or []
-        checkpoint_paths = folder_paths.get('checkpoints', []) or []
-        unet_paths = folder_paths.get('unet', []) or []
-        embedding_paths = folder_paths.get('embeddings', []) or []
+        lora_paths = folder_paths.get("loras", []) or []
+        checkpoint_paths = folder_paths.get("checkpoints", []) or []
+        unet_paths = folder_paths.get("unet", []) or []
+        embedding_paths = folder_paths.get("embeddings", []) or []

        self.loras_roots = self._prepare_lora_paths(lora_paths)
-        self.base_models_roots = self._prepare_checkpoint_paths(checkpoint_paths, unet_paths)
+        self.base_models_roots = self._prepare_checkpoint_paths(
+            checkpoint_paths, unet_paths
+        )
        self.embeddings_roots = self._prepare_embedding_paths(embedding_paths)

+        # Process extra paths (only for LoRA Manager, not shared with ComfyUI)
+        extra_paths = extra_folder_paths or {}
+        extra_lora_paths = extra_paths.get("loras", []) or []
+        extra_checkpoint_paths = extra_paths.get("checkpoints", []) or []
+        extra_unet_paths = extra_paths.get("unet", []) or []
+        extra_embedding_paths = extra_paths.get("embeddings", []) or []
+
+        self.extra_loras_roots = self._prepare_lora_paths(extra_lora_paths)
+        # Save main paths before processing extra paths ( _prepare_checkpoint_paths overwrites them)
+        saved_checkpoints_roots = self.checkpoints_roots
+        saved_unet_roots = self.unet_roots
+        self.extra_checkpoints_roots = self._prepare_checkpoint_paths(
+            extra_checkpoint_paths, extra_unet_paths
+        )
+        self.extra_unet_roots = (
+            self.unet_roots if self.unet_roots is not None else []
+        )  # unet_roots was set by _prepare_checkpoint_paths
+        # Restore main paths
+        self.checkpoints_roots = saved_checkpoints_roots
+        self.unet_roots = saved_unet_roots
+        self.extra_embeddings_roots = self._prepare_embedding_paths(
+            extra_embedding_paths
+        )
+
+        # Log extra folder paths
+        if self.extra_loras_roots:
+            logger.info(
+                "Found extra LoRA roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_loras_roots)
+            )
+        if self.extra_checkpoints_roots:
+            logger.info(
+                "Found extra checkpoint roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_checkpoints_roots)
+            )
+        if self.extra_unet_roots:
+            logger.info(
+                "Found extra diffusion model roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_unet_roots)
+            )
+        if self.extra_embeddings_roots:
+            logger.info(
+                "Found extra embedding roots:"
+                + "\n - "
+                + "\n - ".join(self.extra_embeddings_roots)
+            )
+
        self._initialize_symlink_mappings()

    def _init_lora_paths(self) -> List[str]:
@@ -712,7 +838,10 @@ class Config:
        try:
            raw_paths = folder_paths.get_folder_paths("loras")
            unique_paths = self._prepare_lora_paths(raw_paths)
-            logger.info("Found LoRA roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found LoRA roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
                logger.warning("No valid loras folders found in ComfyUI configuration")
@@ -728,12 +857,19 @@ class Config:
        try:
            raw_checkpoint_paths = folder_paths.get_folder_paths("checkpoints")
            raw_unet_paths = folder_paths.get_folder_paths("unet")
-            unique_paths = self._prepare_checkpoint_paths(raw_checkpoint_paths, raw_unet_paths)
+            unique_paths = self._prepare_checkpoint_paths(
+                raw_checkpoint_paths, raw_unet_paths
+            )

-            logger.info("Found checkpoint roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found checkpoint roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
-                logger.warning("No valid checkpoint folders found in ComfyUI configuration")
+                logger.warning(
+                    "No valid checkpoint folders found in ComfyUI configuration"
+                )
                return []

            return unique_paths
@@ -746,10 +882,15 @@ class Config:
        try:
            raw_paths = folder_paths.get_folder_paths("embeddings")
            unique_paths = self._prepare_embedding_paths(raw_paths)
-            logger.info("Found embedding roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+            logger.info(
+                "Found embedding roots:"
+                + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]")
+            )

            if not unique_paths:
-                logger.warning("No valid embeddings folders found in ComfyUI configuration")
+                logger.warning(
+                    "No valid embeddings folders found in ComfyUI configuration"
+                )
                return []

            return unique_paths
@@ -761,13 +902,13 @@ class Config:
        if not preview_path:
            return ""

-        normalized = os.path.normpath(preview_path).replace(os.sep, '/')
-        encoded_path = urllib.parse.quote(normalized, safe='')
-        return f'/api/lm/previews?path={encoded_path}'
+        normalized = os.path.normpath(preview_path).replace(os.sep, "/")
+        encoded_path = urllib.parse.quote(normalized, safe="")
+        return f"/api/lm/previews?path={encoded_path}"

    def is_preview_path_allowed(self, preview_path: str) -> bool:
        """Return ``True`` if ``preview_path`` is within an allowed directory.
-        
+
        If the path is initially rejected, attempts to discover deep symlinks
        that were not scanned during initialization. If a symlink is found,
        updates the in-memory path mappings and retries the check.
@@ -838,14 +979,18 @@ class Config:
                        normalized_link = self._normalize_path(str(current))

                        self._path_mappings[normalized_target] = normalized_link
-                        self._preview_root_paths.update(self._expand_preview_root(normalized_target))
-                        self._preview_root_paths.update(self._expand_preview_root(normalized_link))
+                        self._preview_root_paths.update(
+                            self._expand_preview_root(normalized_target)
+                        )
+                        self._preview_root_paths.update(
+                            self._expand_preview_root(normalized_link)
+                        )

                        logger.debug(
                            "Discovered deep symlink: %s -> %s (preview path: %s)",
                            normalized_link,
                            normalized_target,
-                            preview_path
+                            preview_path,
                        )

                        return True
@@ -863,17 +1008,31 @@ class Config:

    def apply_library_settings(self, library_config: Mapping[str, object]) -> None:
        """Update runtime paths to match the provided library configuration."""
-        folder_paths = library_config.get('folder_paths') if isinstance(library_config, Mapping) else {}
+        folder_paths = (
+            library_config.get("folder_paths")
+            if isinstance(library_config, Mapping)
+            else {}
+        )
+        extra_folder_paths = (
+            library_config.get("extra_folder_paths")
+            if isinstance(library_config, Mapping)
+            else None
+        )
        if not isinstance(folder_paths, Mapping):
            folder_paths = {}
+        if not isinstance(extra_folder_paths, Mapping):
+            extra_folder_paths = None

-        self._apply_library_paths(folder_paths)
+        self._apply_library_paths(folder_paths, extra_folder_paths)

        logger.info(
-            "Applied library settings with %d lora roots, %d checkpoint roots, and %d embedding roots",
+            "Applied library settings with %d lora roots (%d extra), %d checkpoint roots (%d extra), and %d embedding roots (%d extra)",
            len(self.loras_roots or []),
+            len(self.extra_loras_roots or []),
            len(self.base_models_roots or []),
+            len(self.extra_checkpoints_roots or []),
            len(self.embeddings_roots or []),
+            len(self.extra_embeddings_roots or []),
        )

    def get_library_registry_snapshot(self) -> Dict[str, object]:
@@ -893,5 +1052,6 @@ class Config:
            logger.debug("Failed to collect library registry snapshot: %s", exc)
            return {"active_library": "", "libraries": {}}

+
 # Global config instance
 config = Config()
--- a/py/lora_manager.py
+++ b/py/lora_manager.py
@@ -5,16 +5,22 @@ import logging
 from .utils.logging_config import setup_logging

 # Check if we're in standalone mode
-standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+standalone_mode = (
+    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+)

 # Only setup logging prefix if not in standalone mode
 if not standalone_mode:
    setup_logging()

-from server import PromptServer # type: ignore
+from server import PromptServer  # type: ignore

 from .config import config
-from .services.model_service_factory import ModelServiceFactory, register_default_model_types
+from .services.model_service_factory import (
+    ModelServiceFactory,
+    register_default_model_types,
+)
 from .routes.recipe_routes import RecipeRoutes
 from .routes.stats_routes import StatsRoutes
 from .routes.update_routes import UpdateRoutes
@@ -61,9 +67,10 @@ class _SettingsProxy:

 settings = _SettingsProxy()

+
 class LoraManager:
    """Main entry point for LoRA Manager plugin"""
-    
+
    @classmethod
    def add_routes(cls):
        """Initialize and register all routes using the new refactored architecture"""
@@ -76,7 +83,8 @@ class LoraManager:
                (
                    idx
                    for idx, middleware in enumerate(app.middlewares)
-                    if getattr(middleware, "__name__", "") == "block_external_middleware"
+                    if getattr(middleware, "__name__", "")
+                    == "block_external_middleware"
                ),
                None,
            )
@@ -84,7 +92,9 @@ class LoraManager:
            if block_middleware_index is None:
                app.middlewares.append(relax_csp_for_remote_media)
            else:
-                app.middlewares.insert(block_middleware_index, relax_csp_for_remote_media)
+                app.middlewares.insert(
+                    block_middleware_index, relax_csp_for_remote_media
+                )

        # Increase allowed header sizes so browsers with large localhost cookie
        # jars (multiple UIs on 127.0.0.1) don't trip aiohttp's 8KB default
@@ -105,7 +115,7 @@ class LoraManager:
        app._handler_args = updated_handler_args

        # Configure aiohttp access logger to be less verbose
-        logging.getLogger('aiohttp.access').setLevel(logging.WARNING)
+        logging.getLogger("aiohttp.access").setLevel(logging.WARNING)

        # Add specific suppression for connection reset errors
        class ConnectionResetFilter(logging.Filter):
@@ -124,50 +134,89 @@ class LoraManager:
        asyncio_logger.addFilter(ConnectionResetFilter())

        # Add static route for example images if the path exists in settings
-        example_images_path = settings.get('example_images_path')
+        example_images_path = settings.get("example_images_path")
        logger.info(f"Example images path: {example_images_path}")
        if example_images_path and os.path.exists(example_images_path):
-            app.router.add_static('/example_images_static', example_images_path)
-            logger.info(f"Added static route for example images: /example_images_static -> {example_images_path}")
+            app.router.add_static("/example_images_static", example_images_path)
+            logger.info(
+                f"Added static route for example images: /example_images_static -> {example_images_path}"
+            )

        # Add static route for locales JSON files
        if os.path.exists(config.i18n_path):
-            app.router.add_static('/locales', config.i18n_path)
-            logger.info(f"Added static route for locales: /locales -> {config.i18n_path}")
+            app.router.add_static("/locales", config.i18n_path)
+            logger.info(
+                f"Added static route for locales: /locales -> {config.i18n_path}"
+            )

        # Add static route for plugin assets
-        app.router.add_static('/loras_static', config.static_path)
-        
+        app.router.add_static("/loras_static", config.static_path)
+
        # Register default model types with the factory
        register_default_model_types()
-        
+
        # Setup all model routes using the factory
        ModelServiceFactory.setup_all_routes(app)
-        
+
        # Setup non-model-specific routes
        stats_routes = StatsRoutes()
        stats_routes.setup_routes(app)
        RecipeRoutes.setup_routes(app)
-        UpdateRoutes.setup_routes(app)  
+        UpdateRoutes.setup_routes(app)
        MiscRoutes.setup_routes(app)
        ExampleImagesRoutes.setup_routes(app, ws_manager=ws_manager)
        PreviewRoutes.setup_routes(app)
-        
+
        # Setup WebSocket routes that are shared across all model types
-        app.router.add_get('/ws/fetch-progress', ws_manager.handle_connection)
-        app.router.add_get('/ws/download-progress', ws_manager.handle_download_connection)
-        app.router.add_get('/ws/init-progress', ws_manager.handle_init_connection)
-        
-        # Schedule service initialization 
+        app.router.add_get("/ws/fetch-progress", ws_manager.handle_connection)
+        app.router.add_get(
+            "/ws/download-progress", ws_manager.handle_download_connection
+        )
+        app.router.add_get("/ws/init-progress", ws_manager.handle_init_connection)
+
+        # Schedule service initialization
        app.on_startup.append(lambda app: cls._initialize_services())
-        
+
        # Add cleanup
        app.on_shutdown.append(cls._cleanup)
-        
+
    @classmethod
    async def _initialize_services(cls):
        """Initialize all services using the ServiceRegistry"""
        try:
+            # Apply library settings to load extra folder paths before scanning
+            # Only apply if extra paths haven't been loaded yet (preserves test mocks)
+            try:
+                from .services.settings_manager import get_settings_manager
+
+                settings_manager = get_settings_manager()
+                library_name = settings_manager.get_active_library_name()
+                libraries = settings_manager.get_libraries()
+                if library_name and library_name in libraries:
+                    library_config = libraries[library_name]
+                    # Only apply settings if extra paths are not already configured
+                    # This preserves values set by tests via monkeypatch
+                    extra_paths = library_config.get("extra_folder_paths", {})
+                    has_extra_paths = (
+                        config.extra_loras_roots
+                        or config.extra_checkpoints_roots
+                        or config.extra_unet_roots
+                        or config.extra_embeddings_roots
+                    )
+                    if not has_extra_paths and any(extra_paths.values()):
+                        config.apply_library_settings(library_config)
+                        logger.info(
+                            "Applied library settings for '%s' with extra paths: loras=%s, checkpoints=%s, embeddings=%s",
+                            library_name,
+                            extra_paths.get("loras", []),
+                            extra_paths.get("checkpoints", []),
+                            extra_paths.get("embeddings", []),
+                        )
+            except Exception as exc:
+                logger.warning(
+                    "Failed to apply library settings during initialization: %s", exc
+                )
+
            # Initialize CivitaiClient first to ensure it's ready for other services
            await ServiceRegistry.get_civitai_client()

@@ -175,163 +224,200 @@ class LoraManager:
            await ServiceRegistry.get_download_manager()

            from .services.metadata_service import initialize_metadata_providers
+
            await initialize_metadata_providers()
-            
+
            # Initialize WebSocket manager
            await ServiceRegistry.get_websocket_manager()
-            
+
            # Initialize scanners in background
            lora_scanner = await ServiceRegistry.get_lora_scanner()
            checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
            embedding_scanner = await ServiceRegistry.get_embedding_scanner()
-            
+
            # Initialize recipe scanner if needed
            recipe_scanner = await ServiceRegistry.get_recipe_scanner()
-            
+
            # Create low-priority initialization tasks
            init_tasks = [
-                asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init'),
-                asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init'),
-                asyncio.create_task(embedding_scanner.initialize_in_background(), name='embedding_cache_init'),
-                asyncio.create_task(recipe_scanner.initialize_in_background(), name='recipe_cache_init')
+                asyncio.create_task(
+                    lora_scanner.initialize_in_background(), name="lora_cache_init"
+                ),
+                asyncio.create_task(
+                    checkpoint_scanner.initialize_in_background(),
+                    name="checkpoint_cache_init",
+                ),
+                asyncio.create_task(
+                    embedding_scanner.initialize_in_background(),
+                    name="embedding_cache_init",
+                ),
+                asyncio.create_task(
+                    recipe_scanner.initialize_in_background(), name="recipe_cache_init"
+                ),
            ]

            await ExampleImagesMigration.check_and_run_migrations()
-            
+
            # Schedule post-initialization tasks to run after scanners complete
            asyncio.create_task(
-                cls._run_post_initialization_tasks(init_tasks), 
-                name='post_init_tasks'
+                cls._run_post_initialization_tasks(init_tasks), name="post_init_tasks"
            )
-            
-            logger.debug("LoRA Manager: All services initialized and background tasks scheduled")
-                
+
+            logger.debug(
+                "LoRA Manager: All services initialized and background tasks scheduled"
+            )
+
        except Exception as e:
-            logger.error(f"LoRA Manager: Error initializing services: {e}", exc_info=True)
-    
+            logger.error(
+                f"LoRA Manager: Error initializing services: {e}", exc_info=True
+            )
+
    @classmethod
    async def _run_post_initialization_tasks(cls, init_tasks):
        """Run post-initialization tasks after all scanners complete"""
        try:
-            logger.debug("LoRA Manager: Waiting for scanner initialization to complete...")
-            
+            logger.debug(
+                "LoRA Manager: Waiting for scanner initialization to complete..."
+            )
+
            # Wait for all scanner initialization tasks to complete
            await asyncio.gather(*init_tasks, return_exceptions=True)

-            logger.debug("LoRA Manager: Scanner initialization completed, starting post-initialization tasks...")
-            
+            logger.debug(
+                "LoRA Manager: Scanner initialization completed, starting post-initialization tasks..."
+            )
+
            # Run post-initialization tasks
            post_tasks = [
-                asyncio.create_task(cls._cleanup_backup_files(), name='cleanup_bak_files'),
+                asyncio.create_task(
+                    cls._cleanup_backup_files(), name="cleanup_bak_files"
+                ),
                # Add more post-initialization tasks here as needed
                # asyncio.create_task(cls._another_post_task(), name='another_task'),
            ]
-            
+
            # Run all post-initialization tasks
            results = await asyncio.gather(*post_tasks, return_exceptions=True)
-            
+
            # Log results
            for i, result in enumerate(results):
                task_name = post_tasks[i].get_name()
                if isinstance(result, Exception):
-                    logger.error(f"Post-initialization task '{task_name}' failed: {result}")
+                    logger.error(
+                        f"Post-initialization task '{task_name}' failed: {result}"
+                    )
                else:
-                    logger.debug(f"Post-initialization task '{task_name}' completed successfully")
-                    
+                    logger.debug(
+                        f"Post-initialization task '{task_name}' completed successfully"
+                    )
+
            logger.debug("LoRA Manager: All post-initialization tasks completed")
-            
+
        except Exception as e:
-            logger.error(f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True)
-    
+            logger.error(
+                f"LoRA Manager: Error in post-initialization tasks: {e}", exc_info=True
+            )
+
    @classmethod
    async def _cleanup_backup_files(cls):
        """Clean up .bak files in all model roots"""
        try:
            logger.debug("Starting cleanup of .bak files in model directories...")
-            
+
            # Collect all model roots
            all_roots = set()
            all_roots.update(config.loras_roots)
-            all_roots.update(config.base_models_roots) 
-            all_roots.update(config.embeddings_roots)
-            
+            all_roots.update(config.base_models_roots or [])
+            all_roots.update(config.embeddings_roots or [])
+
            total_deleted = 0
            total_size_freed = 0
-            
+
            for root_path in all_roots:
                if not os.path.exists(root_path):
                    continue
-                    
+
                try:
-                    deleted_count, size_freed = await cls._cleanup_backup_files_in_directory(root_path)
+                    (
+                        deleted_count,
+                        size_freed,
+                    ) = await cls._cleanup_backup_files_in_directory(root_path)
                    total_deleted += deleted_count
                    total_size_freed += size_freed
-                    
+
                    if deleted_count > 0:
-                        logger.debug(f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024*1024):.2f} MB)")
-                        
+                        logger.debug(
+                            f"Cleaned up {deleted_count} .bak files in {root_path} (freed {size_freed / (1024 * 1024):.2f} MB)"
+                        )
+
                except Exception as e:
                    logger.error(f"Error cleaning up .bak files in {root_path}: {e}")
-                    
+
                # Yield control periodically
                await asyncio.sleep(0.01)
-            
+
            if total_deleted > 0:
-                logger.debug(f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024*1024):.2f} MB total")
+                logger.debug(
+                    f"Backup cleanup completed: removed {total_deleted} .bak files, freed {total_size_freed / (1024 * 1024):.2f} MB total"
+                )
            else:
                logger.debug("Backup cleanup completed: no .bak files found")

        except Exception as e:
            logger.error(f"Error during backup file cleanup: {e}", exc_info=True)
-    
+
    @classmethod
    async def _cleanup_backup_files_in_directory(cls, directory_path: str):
        """Clean up .bak files in a specific directory recursively
-        
+
        Args:
            directory_path: Path to the directory to clean
-            
+
        Returns:
            Tuple[int, int]: (number of files deleted, total size freed in bytes)
        """
        deleted_count = 0
        size_freed = 0
        visited_paths = set()
-        
+
        def cleanup_recursive(path):
            nonlocal deleted_count, size_freed
-            
+
            try:
                real_path = os.path.realpath(path)
                if real_path in visited_paths:
                    return
                visited_paths.add(real_path)
-                
+
                with os.scandir(path) as it:
                    for entry in it:
                        try:
-                            if entry.is_file(follow_symlinks=True) and entry.name.endswith('.bak'):
+                            if entry.is_file(
+                                follow_symlinks=True
+                            ) and entry.name.endswith(".bak"):
                                file_size = entry.stat().st_size
                                os.remove(entry.path)
                                deleted_count += 1
                                size_freed += file_size
                                logger.debug(f"Deleted .bak file: {entry.path}")
-                                
+
                            elif entry.is_dir(follow_symlinks=True):
                                cleanup_recursive(entry.path)
-                                
+
                        except Exception as e:
-                            logger.warning(f"Could not delete .bak file {entry.path}: {e}")
-                            
+                            logger.warning(
+                                f"Could not delete .bak file {entry.path}: {e}"
+                            )
+
            except Exception as e:
                logger.error(f"Error scanning directory {path} for .bak files: {e}")
-        
+
        # Run the recursive cleanup in a thread pool to avoid blocking
        loop = asyncio.get_event_loop()
        await loop.run_in_executor(None, cleanup_recursive, directory_path)
-        
+
        return deleted_count, size_freed
-    
+
    @classmethod
    async def _cleanup_example_images_folders(cls):
        """Invoke the example images cleanup service for manual execution."""
@@ -339,21 +425,21 @@ class LoraManager:
            service = ExampleImagesCleanupService()
            result = await service.cleanup_example_image_folders()

-            if result.get('success'):
+            if result.get("success"):
                logger.debug(
                    "Manual example images cleanup completed: moved=%s",
-                    result.get('moved_total'),
+                    result.get("moved_total"),
                )
-            elif result.get('partial_success'):
+            elif result.get("partial_success"):
                logger.warning(
                    "Manual example images cleanup partially succeeded: moved=%s failures=%s",
-                    result.get('moved_total'),
-                    result.get('move_failures'),
+                    result.get("moved_total"),
+                    result.get("move_failures"),
                )
            else:
                logger.debug(
                    "Manual example images cleanup skipped or failed: %s",
-                    result.get('error', 'no changes'),
+                    result.get("error", "no changes"),
                )

            return result
@@ -361,9 +447,9 @@ class LoraManager:
        except Exception as e:  # pragma: no cover - defensive guard
            logger.error(f"Error during example images cleanup: {e}", exc_info=True)
            return {
-                'success': False,
-                'error': str(e),
-                'error_code': 'unexpected_error',
+                "success": False,
+                "error": str(e),
+                "error_code": "unexpected_error",
            }

    @classmethod
@@ -371,6 +457,6 @@ class LoraManager:
        """Cleanup resources using ServiceRegistry"""
        try:
            logger.info("LoRA Manager: Cleaning up services")
-                
+
        except Exception as e:
            logger.error(f"Error during cleanup: {e}", exc_info=True)
--- a/py/metadata_collector/init.py
+++ b/py/metadata_collector/init.py
@@ -4,7 +4,10 @@ import logging
 logger = logging.getLogger(__name__)

 # Check if running in standalone mode
-standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+standalone_mode = (
+    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+)

 if not standalone_mode:
    from .metadata_hook import MetadataHook
@@ -13,13 +16,13 @@ if not standalone_mode:
    def init():
        # Install hooks to collect metadata during execution
        MetadataHook.install()
-        
+
        # Initialize registry
        registry = MetadataRegistry()
-        
+
        logger.info("ComfyUI Metadata Collector initialized")
-        
-    def get_metadata(prompt_id=None):
+
+    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
        """Helper function to get metadata from the registry"""
        registry = MetadataRegistry()
        return registry.get_metadata(prompt_id)
@@ -27,7 +30,7 @@ else:
    # Standalone mode - provide dummy implementations
    def init():
        logger.info("ComfyUI Metadata Collector disabled in standalone mode")
-        
-    def get_metadata(prompt_id=None):
+
+    def get_metadata(prompt_id=None):  # type: ignore[no-redef]
        """Dummy implementation for standalone mode"""
        return {}
--- a/py/metadata_collector/metadata_registry.py
+++ b/py/metadata_collector/metadata_registry.py
@@ -1,50 +1,54 @@
 import time
-from nodes import NODE_CLASS_MAPPINGS
+from nodes import NODE_CLASS_MAPPINGS  # type: ignore
 from .node_extractors import NODE_EXTRACTORS, GenericNodeExtractor
 from .constants import METADATA_CATEGORIES, IMAGES

+
 class MetadataRegistry:
    """A singleton registry to store and retrieve workflow metadata"""
+
    _instance = None
-    
+
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._reset()
        return cls._instance
-    
+
    def _reset(self):
        self.current_prompt_id = None
        self.current_prompt = None
        self.metadata = {}
        self.prompt_metadata = {}
        self.executed_nodes = set()
-        
+
        # Node-level cache for metadata
        self.node_cache = {}
-        
+
        # Limit the number of stored prompts
        self.max_prompt_history = 3
-        
+
        # Categories we want to track and retrieve from cache
        self.metadata_categories = METADATA_CATEGORIES
-    
+
    def _clean_old_prompts(self):
        """Clean up old prompt metadata, keeping only recent ones"""
        if len(self.prompt_metadata) <= self.max_prompt_history:
            return
-            
+
        # Sort all prompt_ids by timestamp
        sorted_prompts = sorted(
            self.prompt_metadata.keys(),
-            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0)
+            key=lambda pid: self.prompt_metadata[pid].get("timestamp", 0),
        )
-        
+
        # Remove oldest records
-        prompts_to_remove = sorted_prompts[:len(sorted_prompts) - self.max_prompt_history]
+        prompts_to_remove = sorted_prompts[
+            : len(sorted_prompts) - self.max_prompt_history
+        ]
        for pid in prompts_to_remove:
            del self.prompt_metadata[pid]
-    
+
    def start_collection(self, prompt_id):
        """Begin metadata collection for a new prompt"""
        self.current_prompt_id = prompt_id
@@ -53,90 +57,96 @@ class MetadataRegistry:
            category: {} for category in METADATA_CATEGORIES
        }
        # Add additional metadata fields
-        self.prompt_metadata[prompt_id].update({
-            "execution_order": [],
-            "current_prompt": None,  # Will store the prompt object
-            "timestamp": time.time()
-        })
-        
+        self.prompt_metadata[prompt_id].update(
+            {
+                "execution_order": [],
+                "current_prompt": None,  # Will store the prompt object
+                "timestamp": time.time(),
+            }
+        )
+
        # Clean up old prompt data
        self._clean_old_prompts()
-    
+
    def set_current_prompt(self, prompt):
        """Set the current prompt object reference"""
        self.current_prompt = prompt
        if self.current_prompt_id and self.current_prompt_id in self.prompt_metadata:
            # Store the prompt in the metadata for later relationship tracing
            self.prompt_metadata[self.current_prompt_id]["current_prompt"] = prompt
-        
+
    def get_metadata(self, prompt_id=None):
        """Get collected metadata for a prompt"""
        key = prompt_id if prompt_id is not None else self.current_prompt_id
        if key not in self.prompt_metadata:
            return {}
-            
+
        metadata = self.prompt_metadata[key]
-        
+
        # If we have a current prompt object, check for non-executed nodes
        prompt_obj = metadata.get("current_prompt")
        if prompt_obj and hasattr(prompt_obj, "original_prompt"):
            original_prompt = prompt_obj.original_prompt
-            
+
            # Fill in missing metadata from cache for nodes that weren't executed
            self._fill_missing_metadata(key, original_prompt)
-            
+
        return self.prompt_metadata.get(key, {})
-    
+
    def _fill_missing_metadata(self, prompt_id, original_prompt):
        """Fill missing metadata from cache for non-executed nodes"""
        if not original_prompt:
            return
-            
+
        executed_nodes = self.executed_nodes
        metadata = self.prompt_metadata[prompt_id]
-        
+
        # Iterate through nodes in the original prompt
        for node_id, node_data in original_prompt.items():
            # Skip if already executed in this run
            if node_id in executed_nodes:
                continue
-                
+
            # Get the node type from the prompt (this is the key in NODE_CLASS_MAPPINGS)
            prompt_class_type = node_data.get("class_type")
            if not prompt_class_type:
                continue
-                
+
            # Convert to actual class name (which is what we use in our cache)
            class_type = prompt_class_type
            if prompt_class_type in NODE_CLASS_MAPPINGS:
                class_obj = NODE_CLASS_MAPPINGS[prompt_class_type]
                class_type = class_obj.__name__
-            
+
            # Create cache key using the actual class name
            cache_key = f"{node_id}:{class_type}"
-            
+
            # Check if this node type is relevant for metadata collection
            if class_type in NODE_EXTRACTORS:
                # Check if we have cached metadata for this node
                if cache_key in self.node_cache:
                    cached_data = self.node_cache[cache_key]
-                    
+
                    # Apply cached metadata to the current metadata
                    for category in self.metadata_categories:
                        if category in cached_data and node_id in cached_data[category]:
                            if node_id not in metadata[category]:
-                                metadata[category][node_id] = cached_data[category][node_id]
-    
+                                metadata[category][node_id] = cached_data[category][
+                                    node_id
+                                ]
+
    def record_node_execution(self, node_id, class_type, inputs, outputs):
        """Record information about a node's execution"""
        if not self.current_prompt_id:
            return
-            
+
        # Add to execution order and mark as executed
        if node_id not in self.executed_nodes:
            self.executed_nodes.add(node_id)
-            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(node_id)
-        
+            self.prompt_metadata[self.current_prompt_id]["execution_order"].append(
+                node_id
+            )
+
        # Process inputs to simplify working with them
        processed_inputs = {}
        for input_name, input_values in inputs.items():
@@ -145,63 +155,61 @@ class MetadataRegistry:
                processed_inputs[input_name] = input_values[0]
            else:
                processed_inputs[input_name] = input_values
-            
+
        # Extract node-specific metadata
        extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
        extractor.extract(
-            node_id, 
-            processed_inputs, 
-            outputs, 
-            self.prompt_metadata[self.current_prompt_id]
+            node_id,
+            processed_inputs,
+            outputs,
+            self.prompt_metadata[self.current_prompt_id],
        )
-        
+
        # Cache this node's metadata
        self._cache_node_metadata(node_id, class_type)
-    
+
    def update_node_execution(self, node_id, class_type, outputs):
        """Update node metadata with output information"""
        if not self.current_prompt_id:
            return
-        
+
        # Process outputs to make them more usable
        processed_outputs = outputs
-            
+
        # Use the same extractor to update with outputs
        extractor = NODE_EXTRACTORS.get(class_type, GenericNodeExtractor)
-        if hasattr(extractor, 'update'):
+        if hasattr(extractor, "update"):
            extractor.update(
-                node_id, 
-                processed_outputs, 
-                self.prompt_metadata[self.current_prompt_id]
+                node_id, processed_outputs, self.prompt_metadata[self.current_prompt_id]
            )
-            
+
        # Update the cached metadata for this node
        self._cache_node_metadata(node_id, class_type)
-            
+
    def _cache_node_metadata(self, node_id, class_type):
        """Cache the metadata for a specific node"""
        if not self.current_prompt_id or not node_id or not class_type:
            return
-            
+
        # Create a cache key combining node_id and class_type
        cache_key = f"{node_id}:{class_type}"
-        
+
        # Create a shallow copy of the node's metadata
        node_metadata = {}
        current_metadata = self.prompt_metadata[self.current_prompt_id]
-        
+
        for category in self.metadata_categories:
            if category in current_metadata and node_id in current_metadata[category]:
                if category not in node_metadata:
                    node_metadata[category] = {}
                node_metadata[category][node_id] = current_metadata[category][node_id]
-        
+
        # Save new metadata or clear stale cache entries when metadata is empty
        if any(node_metadata.values()):
            self.node_cache[cache_key] = node_metadata
        else:
            self.node_cache.pop(cache_key, None)
-    
+
    def clear_unused_cache(self):
        """Clean up node_cache entries that are no longer in use"""
        # Collect all node_ids currently in prompt_metadata
@@ -210,18 +218,18 @@ class MetadataRegistry:
            for category in self.metadata_categories:
                if category in prompt_data:
                    active_node_ids.update(prompt_data[category].keys())
-        
+
        # Find cache keys that are no longer needed
        keys_to_remove = []
        for cache_key in self.node_cache:
-            node_id = cache_key.split(':')[0]
+            node_id = cache_key.split(":")[0]
            if node_id not in active_node_ids:
                keys_to_remove.append(cache_key)
-        
+
        # Remove cache entries that are no longer needed
        for key in keys_to_remove:
            del self.node_cache[key]
-    
+
    def clear_metadata(self, prompt_id=None):
        """Clear metadata for a specific prompt or reset all data"""
        if prompt_id is not None:
@@ -232,25 +240,25 @@ class MetadataRegistry:
        else:
            # Reset all data
            self._reset()
-    
+
    def get_first_decoded_image(self, prompt_id=None):
        """Get the first decoded image result"""
        key = prompt_id if prompt_id is not None else self.current_prompt_id
        if key not in self.prompt_metadata:
            return None
-            
+
        metadata = self.prompt_metadata[key]
        if IMAGES in metadata and "first_decode" in metadata[IMAGES]:
            image_data = metadata[IMAGES]["first_decode"]["image"]
-            
+
            # If it's an image batch or tuple, handle various formats
            if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
                # Return first element of list/tuple
                return image_data[0]
-            
+
            # If it's a tensor, return as is for processing in the route handler
            return image_data
-        
+
        # If no image is found in the current metadata, try to find it in the cache
        # This handles the case where VAEDecode was cached by ComfyUI and not executed
        prompt_obj = metadata.get("current_prompt")
@@ -270,8 +278,11 @@ class MetadataRegistry:
                            if IMAGES in cached_data and node_id in cached_data[IMAGES]:
                                image_data = cached_data[IMAGES][node_id]["image"]
                                # Handle different image formats
-                                if isinstance(image_data, (list, tuple)) and len(image_data) > 0:
+                                if (
+                                    isinstance(image_data, (list, tuple))
+                                    and len(image_data) > 0
+                                ):
                                    return image_data[0]
                                return image_data
-        
+
        return None
--- a/py/nodes/lora_loader.py
+++ b/py/nodes/lora_loader.py
@@ -1,7 +1,8 @@
 import logging
 import re
-from nodes import LoraLoader
-from ..utils.utils import get_lora_info
+import comfy.utils # type: ignore
+import comfy.sd # type: ignore
+from ..utils.utils import get_lora_info_absolute
 from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list, nunchaku_load_lora

 logger = logging.getLogger(__name__)
@@ -52,18 +53,20 @@ class LoraLoaderLM:
        # First process lora_stack if available
        if lora_stack:
            for lora_path, model_strength, clip_strength in lora_stack:
+                # Extract lora name and convert to absolute path
+                # lora_stack stores relative paths, but load_torch_file needs absolute paths
+                lora_name = extract_lora_name(lora_path)
+                absolute_lora_path, trigger_words = get_lora_info_absolute(lora_name)
+                
                # Apply the LoRA using the appropriate loader
                if is_nunchaku_model:
                    # Use our custom function for Flux models
                    model = nunchaku_load_lora(model, lora_path, model_strength)
                    # clip remains unchanged for Nunchaku models
                else:
-                    # Use default loader for standard models
-                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
-                
-                # Extract lora name for trigger words lookup
-                lora_name = extract_lora_name(lora_path)
-                _, trigger_words = get_lora_info(lora_name)
+                    # Use lower-level API to load LoRA directly without folder_paths validation
+                    lora = comfy.utils.load_torch_file(absolute_lora_path, safe_load=True)
+                    model, clip = comfy.sd.load_lora_for_models(model, clip, lora, model_strength, clip_strength)
                
                all_trigger_words.extend(trigger_words)
                # Add clip strength to output if different from model strength (except for Nunchaku models)
@@ -84,7 +87,7 @@ class LoraLoaderLM:
            clip_strength = float(lora.get('clipStrength', model_strength))
            
            # Get lora path and trigger words
-            lora_path, trigger_words = get_lora_info(lora_name)
+            lora_path, trigger_words = get_lora_info_absolute(lora_name)
            
            # Apply the LoRA using the appropriate loader
            if is_nunchaku_model:
@@ -92,8 +95,9 @@ class LoraLoaderLM:
                model = nunchaku_load_lora(model, lora_path, model_strength)
                # clip remains unchanged
            else:
-                # Use default loader for standard models
-                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                # Use lower-level API to load LoRA directly without folder_paths validation
+                lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+                model, clip = comfy.sd.load_lora_for_models(model, clip, lora, model_strength, clip_strength)
            
            # Include clip strength in output if different from model strength and not a Nunchaku model
            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
@@ -193,18 +197,20 @@ class LoraTextLoaderLM:
        # First process lora_stack if available
        if lora_stack:
            for lora_path, model_strength, clip_strength in lora_stack:
+                # Extract lora name and convert to absolute path
+                # lora_stack stores relative paths, but load_torch_file needs absolute paths
+                lora_name = extract_lora_name(lora_path)
+                absolute_lora_path, trigger_words = get_lora_info_absolute(lora_name)
+                
                # Apply the LoRA using the appropriate loader
                if is_nunchaku_model:
                    # Use our custom function for Flux models
                    model = nunchaku_load_lora(model, lora_path, model_strength)
                    # clip remains unchanged for Nunchaku models
                else:
-                    # Use default loader for standard models
-                    model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
-                
-                # Extract lora name for trigger words lookup
-                lora_name = extract_lora_name(lora_path)
-                _, trigger_words = get_lora_info(lora_name)
+                    # Use lower-level API to load LoRA directly without folder_paths validation
+                    lora = comfy.utils.load_torch_file(absolute_lora_path, safe_load=True)
+                    model, clip = comfy.sd.load_lora_for_models(model, clip, lora, model_strength, clip_strength)
                
                all_trigger_words.extend(trigger_words)
                # Add clip strength to output if different from model strength (except for Nunchaku models)
@@ -221,7 +227,7 @@ class LoraTextLoaderLM:
            clip_strength = lora['clip_strength']
            
            # Get lora path and trigger words
-            lora_path, trigger_words = get_lora_info(lora_name)
+            lora_path, trigger_words = get_lora_info_absolute(lora_name)
            
            # Apply the LoRA using the appropriate loader
            if is_nunchaku_model:
@@ -229,8 +235,9 @@ class LoraTextLoaderLM:
                model = nunchaku_load_lora(model, lora_path, model_strength)
                # clip remains unchanged
            else:
-                # Use default loader for standard models
-                model, clip = LoraLoader().load_lora(model, clip, lora_path, model_strength, clip_strength)
+                # Use lower-level API to load LoRA directly without folder_paths validation
+                lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+                model, clip = comfy.sd.load_lora_for_models(model, clip, lora, model_strength, clip_strength)
            
            # Include clip strength in output if different from model strength and not a Nunchaku model
            if not is_nunchaku_model and abs(model_strength - clip_strength) > 0.001:
--- a/py/nodes/save_image.py
+++ b/py/nodes/save_image.py
@@ -1,8 +1,9 @@
 import json
 import os
 import re
+from typing import Any, Dict, Optional
 import numpy as np
-import folder_paths # type: ignore
+import folder_paths  # type: ignore
 from ..services.service_registry import ServiceRegistry
 from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
@@ -12,6 +13,7 @@ import logging

 logger = logging.getLogger(__name__)

+
 class SaveImageLM:
    NAME = "Save Image (LoraManager)"
    CATEGORY = "Lora Manager/utils"
@@ -23,42 +25,60 @@ class SaveImageLM:
        self.prefix_append = ""
        self.compress_level = 4
        self.counter = 0
-    
+
    # Add pattern format regex for filename substitution
    pattern_format = re.compile(r"(%[^%]+%)")
-    
+
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "images": ("IMAGE",),
-                "filename_prefix": ("STRING", {
-                    "default": "ComfyUI", 
-                    "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc."
-                }),
-                "file_format": (["png", "jpeg", "webp"], {
-                    "tooltip": "Image format to save as. PNG preserves quality, JPEG is smaller, WebP balances size and quality."
-                }),
+                "filename_prefix": (
+                    "STRING",
+                    {
+                        "default": "ComfyUI",
+                        "tooltip": "Base filename for saved images. Supports format patterns like %seed%, %width%, %height%, %model%, etc.",
+                    },
+                ),
+                "file_format": (
+                    ["png", "jpeg", "webp"],
+                    {
+                        "tooltip": "Image format to save as. PNG preserves quality, JPEG is smaller, WebP balances size and quality."
+                    },
+                ),
            },
            "optional": {
-                "lossless_webp": ("BOOLEAN", {
-                    "default": False,
-                    "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss."
-                }),
-                "quality": ("INT", {
-                    "default": 100, 
-                    "min": 1, 
-                    "max": 100,
-                    "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files."
-                }),
-                "embed_workflow": ("BOOLEAN", {
-                    "default": False,
-                    "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats."
-                }),
-                "add_counter_to_filename": ("BOOLEAN", {
-                    "default": True,
-                    "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images."
-                }),
+                "lossless_webp": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "When enabled, saves WebP images with lossless compression. Results in larger files but no quality loss.",
+                    },
+                ),
+                "quality": (
+                    "INT",
+                    {
+                        "default": 100,
+                        "min": 1,
+                        "max": 100,
+                        "tooltip": "Compression quality for JPEG and lossy WebP formats (1-100). Higher values mean better quality but larger files.",
+                    },
+                ),
+                "embed_workflow": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "Embeds the complete workflow data into the image metadata. Only works with PNG and WebP formats.",
+                    },
+                ),
+                "add_counter_to_filename": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Adds an incremental counter to filenames to prevent overwriting previous images.",
+                    },
+                ),
            },
            "hidden": {
                "id": "UNIQUE_ID",
@@ -75,57 +95,59 @@ class SaveImageLM:
    def get_lora_hash(self, lora_name):
        """Get the lora hash from cache"""
        scanner = ServiceRegistry.get_service_sync("lora_scanner")
-        
+
        # Use the new direct filename lookup method
-        hash_value = scanner.get_hash_by_filename(lora_name)
-        if hash_value:
-            return hash_value
-            
+        if scanner is not None:
+            hash_value = scanner.get_hash_by_filename(lora_name)
+            if hash_value:
+                return hash_value
+
        return None

    def get_checkpoint_hash(self, checkpoint_path):
        """Get the checkpoint hash from cache"""
        scanner = ServiceRegistry.get_service_sync("checkpoint_scanner")
-        
+
        if not checkpoint_path:
            return None
-            
+
        # Extract basename without extension
        checkpoint_name = os.path.basename(checkpoint_path)
        checkpoint_name = os.path.splitext(checkpoint_name)[0]
-        
+
        # Try direct filename lookup first
-        hash_value = scanner.get_hash_by_filename(checkpoint_name)
-        if hash_value:
-            return hash_value
-                
+        if scanner is not None:
+            hash_value = scanner.get_hash_by_filename(checkpoint_name)
+            if hash_value:
+                return hash_value
+
        return None

    def format_metadata(self, metadata_dict):
        """Format metadata in the requested format similar to userComment example"""
        if not metadata_dict:
            return ""
-        
+
        # Helper function to only add parameter if value is not None
        def add_param_if_not_none(param_list, label, value):
            if value is not None:
                param_list.append(f"{label}: {value}")
-        
+
        # Extract the prompt and negative prompt
-        prompt = metadata_dict.get('prompt', '')
-        negative_prompt = metadata_dict.get('negative_prompt', '')
-        
+        prompt = metadata_dict.get("prompt", "")
+        negative_prompt = metadata_dict.get("negative_prompt", "")
+
        # Extract loras from the prompt if present
-        loras_text = metadata_dict.get('loras', '')
+        loras_text = metadata_dict.get("loras", "")
        lora_hashes = {}
-        
+
        # If loras are found, add them on a new line after the prompt
        if loras_text:
            prompt_with_loras = f"{prompt}\n{loras_text}"
-            
+
            # Extract lora names from the format <lora:name:strength>
-            lora_matches = re.findall(r'<lora:([^:]+):([^>]+)>', loras_text)
-            
+            lora_matches = re.findall(r"<lora:([^:]+):([^>]+)>", loras_text)
+
            # Get hash for each lora
            for lora_name, strength in lora_matches:
                hash_value = self.get_lora_hash(lora_name)
@@ -133,112 +155,114 @@ class SaveImageLM:
                    lora_hashes[lora_name] = hash_value
        else:
            prompt_with_loras = prompt
-        
+
        # Format the first part (prompt and loras)
        metadata_parts = [prompt_with_loras]
-        
+
        # Add negative prompt
        if negative_prompt:
            metadata_parts.append(f"Negative prompt: {negative_prompt}")
-        
+
        # Format the second part (generation parameters)
        params = []
-        
+
        # Add standard parameters in the correct order
-        if 'steps' in metadata_dict:
-            add_param_if_not_none(params, "Steps", metadata_dict.get('steps'))
-        
+        if "steps" in metadata_dict:
+            add_param_if_not_none(params, "Steps", metadata_dict.get("steps"))
+
        # Combine sampler and scheduler information
        sampler_name = None
        scheduler_name = None
-        
-        if 'sampler' in metadata_dict:
-            sampler = metadata_dict.get('sampler')
+
+        if "sampler" in metadata_dict:
+            sampler = metadata_dict.get("sampler")
            # Convert ComfyUI sampler names to user-friendly names
            sampler_mapping = {
-                'euler': 'Euler',
-                'euler_ancestral': 'Euler a',
-                'dpm_2': 'DPM2',
-                'dpm_2_ancestral': 'DPM2 a',
-                'heun': 'Heun',
-                'dpm_fast': 'DPM fast',
-                'dpm_adaptive': 'DPM adaptive',
-                'lms': 'LMS',
-                'dpmpp_2s_ancestral': 'DPM++ 2S a',
-                'dpmpp_sde': 'DPM++ SDE',
-                'dpmpp_sde_gpu': 'DPM++ SDE',
-                'dpmpp_2m': 'DPM++ 2M',
-                'dpmpp_2m_sde': 'DPM++ 2M SDE',
-                'dpmpp_2m_sde_gpu': 'DPM++ 2M SDE',
-                'ddim': 'DDIM'
+                "euler": "Euler",
+                "euler_ancestral": "Euler a",
+                "dpm_2": "DPM2",
+                "dpm_2_ancestral": "DPM2 a",
+                "heun": "Heun",
+                "dpm_fast": "DPM fast",
+                "dpm_adaptive": "DPM adaptive",
+                "lms": "LMS",
+                "dpmpp_2s_ancestral": "DPM++ 2S a",
+                "dpmpp_sde": "DPM++ SDE",
+                "dpmpp_sde_gpu": "DPM++ SDE",
+                "dpmpp_2m": "DPM++ 2M",
+                "dpmpp_2m_sde": "DPM++ 2M SDE",
+                "dpmpp_2m_sde_gpu": "DPM++ 2M SDE",
+                "ddim": "DDIM",
            }
            sampler_name = sampler_mapping.get(sampler, sampler)
-        
-        if 'scheduler' in metadata_dict:
-            scheduler = metadata_dict.get('scheduler')
+
+        if "scheduler" in metadata_dict:
+            scheduler = metadata_dict.get("scheduler")
            scheduler_mapping = {
-                'normal': 'Simple',
-                'karras': 'Karras',
-                'exponential': 'Exponential',
-                'sgm_uniform': 'SGM Uniform',
-                'sgm_quadratic': 'SGM Quadratic'
+                "normal": "Simple",
+                "karras": "Karras",
+                "exponential": "Exponential",
+                "sgm_uniform": "SGM Uniform",
+                "sgm_quadratic": "SGM Quadratic",
            }
            scheduler_name = scheduler_mapping.get(scheduler, scheduler)
-        
+
        # Add combined sampler and scheduler information
        if sampler_name:
            if scheduler_name:
                params.append(f"Sampler: {sampler_name} {scheduler_name}")
            else:
                params.append(f"Sampler: {sampler_name}")
-        
+
        # CFG scale (Use guidance if available, otherwise fall back to cfg_scale or cfg)
-        if 'guidance' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get('guidance'))
-        elif 'cfg_scale' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg_scale'))
-        elif 'cfg' in metadata_dict:
-            add_param_if_not_none(params, "CFG scale", metadata_dict.get('cfg'))
-        
+        if "guidance" in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get("guidance"))
+        elif "cfg_scale" in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg_scale"))
+        elif "cfg" in metadata_dict:
+            add_param_if_not_none(params, "CFG scale", metadata_dict.get("cfg"))
+
        # Seed
-        if 'seed' in metadata_dict:
-            add_param_if_not_none(params, "Seed", metadata_dict.get('seed'))
-        
+        if "seed" in metadata_dict:
+            add_param_if_not_none(params, "Seed", metadata_dict.get("seed"))
+
        # Size
-        if 'size' in metadata_dict:
-            add_param_if_not_none(params, "Size", metadata_dict.get('size'))
-        
+        if "size" in metadata_dict:
+            add_param_if_not_none(params, "Size", metadata_dict.get("size"))
+
        # Model info
-        if 'checkpoint' in metadata_dict:
+        if "checkpoint" in metadata_dict:
            # Ensure checkpoint is a string before processing
-            checkpoint = metadata_dict.get('checkpoint')
+            checkpoint = metadata_dict.get("checkpoint")
            if checkpoint is not None:
                # Get model hash
                model_hash = self.get_checkpoint_hash(checkpoint)
-                
+
                # Extract basename without path
                checkpoint_name = os.path.basename(checkpoint)
                # Remove extension if present
                checkpoint_name = os.path.splitext(checkpoint_name)[0]
-                
+
                # Add model hash if available
                if model_hash:
-                    params.append(f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}")
+                    params.append(
+                        f"Model hash: {model_hash[:10]}, Model: {checkpoint_name}"
+                    )
                else:
                    params.append(f"Model: {checkpoint_name}")
-        
+
        # Add LoRA hashes if available
        if lora_hashes:
            lora_hash_parts = []
            for lora_name, hash_value in lora_hashes.items():
                lora_hash_parts.append(f"{lora_name}: {hash_value[:10]}")
-            
+
            if lora_hash_parts:
-                params.append(f"Lora hashes: \"{', '.join(lora_hash_parts)}\"")
-        
+                params.append(f'Lora hashes: "{", ".join(lora_hash_parts)}"')
+
        # Combine all parameters with commas
        metadata_parts.append(", ".join(params))
-        
+
        # Join all parts with a new line
        return "\n".join(metadata_parts)

@@ -248,36 +272,36 @@ class SaveImageLM:
        """Format filename with metadata values"""
        if not metadata_dict:
            return filename
-            
+
        result = re.findall(self.pattern_format, filename)
        for segment in result:
            parts = segment.replace("%", "").split(":")
            key = parts[0]
-            
-            if key == "seed" and 'seed' in metadata_dict:
-                filename = filename.replace(segment, str(metadata_dict.get('seed', '')))
-            elif key == "width" and 'size' in metadata_dict:
-                size = metadata_dict.get('size', 'x')
-                w = size.split('x')[0] if isinstance(size, str) else size[0]
+
+            if key == "seed" and "seed" in metadata_dict:
+                filename = filename.replace(segment, str(metadata_dict.get("seed", "")))
+            elif key == "width" and "size" in metadata_dict:
+                size = metadata_dict.get("size", "x")
+                w = size.split("x")[0] if isinstance(size, str) else size[0]
                filename = filename.replace(segment, str(w))
-            elif key == "height" and 'size' in metadata_dict:
-                size = metadata_dict.get('size', 'x')
-                h = size.split('x')[1] if isinstance(size, str) else size[1]
+            elif key == "height" and "size" in metadata_dict:
+                size = metadata_dict.get("size", "x")
+                h = size.split("x")[1] if isinstance(size, str) else size[1]
                filename = filename.replace(segment, str(h))
-            elif key == "pprompt" and 'prompt' in metadata_dict:
-                prompt = metadata_dict.get('prompt', '').replace("\n", " ")
+            elif key == "pprompt" and "prompt" in metadata_dict:
+                prompt = metadata_dict.get("prompt", "").replace("\n", " ")
                if len(parts) >= 2:
                    length = int(parts[1])
                    prompt = prompt[:length]
                filename = filename.replace(segment, prompt.strip())
-            elif key == "nprompt" and 'negative_prompt' in metadata_dict:
-                prompt = metadata_dict.get('negative_prompt', '').replace("\n", " ")
+            elif key == "nprompt" and "negative_prompt" in metadata_dict:
+                prompt = metadata_dict.get("negative_prompt", "").replace("\n", " ")
                if len(parts) >= 2:
                    length = int(parts[1])
                    prompt = prompt[:length]
                filename = filename.replace(segment, prompt.strip())
            elif key == "model":
-                model_value = metadata_dict.get('checkpoint')
+                model_value = metadata_dict.get("checkpoint")
                if isinstance(model_value, (bytes, os.PathLike)):
                    model_value = str(model_value)

@@ -291,6 +315,7 @@ class SaveImageLM:
                filename = filename.replace(segment, model)
            elif key == "date":
                from datetime import datetime
+
                now = datetime.now()
                date_table = {
                    "yyyy": f"{now.year:04d}",
@@ -311,46 +336,62 @@ class SaveImageLM:
                    for k, v in date_table.items():
                        date_format = date_format.replace(k, v)
                    filename = filename.replace(segment, date_format)
-                    
+
        return filename

-    def save_images(self, images, filename_prefix, file_format, id, prompt=None, extra_pnginfo=None, 
-                   lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
+    def save_images(
+        self,
+        images,
+        filename_prefix,
+        file_format,
+        id,
+        prompt=None,
+        extra_pnginfo=None,
+        lossless_webp=True,
+        quality=100,
+        embed_workflow=False,
+        add_counter_to_filename=True,
+    ):
        """Save images with metadata"""
        results = []

        # Get metadata using the metadata collector
        raw_metadata = get_metadata()
        metadata_dict = MetadataProcessor.to_dict(raw_metadata, id)
-            
+
        metadata = self.format_metadata(metadata_dict)
-        
+
        # Process filename_prefix with pattern substitution
        filename_prefix = self.format_filename(filename_prefix, metadata_dict)
-        
+
        # Get initial save path info once for the batch
-        full_output_folder, filename, counter, subfolder, processed_prefix = folder_paths.get_save_image_path(
-            filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
+        full_output_folder, filename, counter, subfolder, processed_prefix = (
+            folder_paths.get_save_image_path(
+                filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0]
+            )
        )
-        
+
        # Create directory if it doesn't exist
        if not os.path.exists(full_output_folder):
            os.makedirs(full_output_folder, exist_ok=True)
-        
+
        # Process each image with incrementing counter
        for i, image in enumerate(images):
            # Convert the tensor image to numpy array
-            img = 255. * image.cpu().numpy()
+            img = 255.0 * image.cpu().numpy()
            img = Image.fromarray(np.clip(img, 0, 255).astype(np.uint8))
-            
+
            # Generate filename with counter if needed
            base_filename = filename
            if add_counter_to_filename:
                # Use counter + i to ensure unique filenames for all images in batch
                current_counter = counter + i
                base_filename += f"_{current_counter:05}_"
-                
+
            # Set file extension and prepare saving parameters
+            file: str
+            save_kwargs: Dict[str, Any]
+            pnginfo: Optional[PngImagePlugin.PngInfo] = None
            if file_format == "png":
                file = base_filename + ".png"
                file_extension = ".png"
@@ -362,17 +403,24 @@ class SaveImageLM:
                file_extension = ".jpg"
                save_kwargs = {"quality": quality, "optimize": True}
            elif file_format == "webp":
-                file = base_filename + ".webp" 
+                file = base_filename + ".webp"
                file_extension = ".webp"
                # Add optimization param to control performance
-                save_kwargs = {"quality": quality, "lossless": lossless_webp, "method": 0}
-            
+                save_kwargs = {
+                    "quality": quality,
+                    "lossless": lossless_webp,
+                    "method": 0,
+                }
+            else:
+                raise ValueError(f"Unsupported file format: {file_format}")
+
            # Full save path
            file_path = os.path.join(full_output_folder, file)
-            
+
            # Save the image with metadata
            try:
                if file_format == "png":
+                    assert pnginfo is not None
                    if metadata:
                        pnginfo.add_text("parameters", metadata)
                    if embed_workflow and extra_pnginfo is not None:
@@ -384,7 +432,12 @@ class SaveImageLM:
                    # For JPEG, use piexif
                    if metadata:
                        try:
-                            exif_dict = {'Exif': {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}}
+                            exif_dict = {
+                                "Exif": {
+                                    piexif.ExifIFD.UserComment: b"UNICODE\0"
+                                    + metadata.encode("utf-16be")
+                                }
+                            }
                            exif_bytes = piexif.dump(exif_dict)
                            save_kwargs["exif"] = exif_bytes
                        except Exception as e:
@@ -396,37 +449,52 @@ class SaveImageLM:
                        exif_dict = {}

                        if metadata:
-                            exif_dict['Exif'] = {piexif.ExifIFD.UserComment: b'UNICODE\0' + metadata.encode('utf-16be')}
-                        
+                            exif_dict["Exif"] = {
+                                piexif.ExifIFD.UserComment: b"UNICODE\0"
+                                + metadata.encode("utf-16be")
+                            }
+
                        # Add workflow if needed
                        if embed_workflow and extra_pnginfo is not None:
-                            workflow_json = json.dumps(extra_pnginfo["workflow"]) 
-                            exif_dict['0th'] = {piexif.ImageIFD.ImageDescription: "Workflow:" + workflow_json}
-                            
+                            workflow_json = json.dumps(extra_pnginfo["workflow"])
+                            exif_dict["0th"] = {
+                                piexif.ImageIFD.ImageDescription: "Workflow:"
+                                + workflow_json
+                            }
+
                        exif_bytes = piexif.dump(exif_dict)
                        save_kwargs["exif"] = exif_bytes
                    except Exception as e:
                        logger.error(f"Error adding EXIF data: {e}")
-                    
+
                    img.save(file_path, format="WEBP", **save_kwargs)
-                
-                results.append({
-                    "filename": file,
-                    "subfolder": subfolder,
-                    "type": self.type
-                })
-                
+
+                results.append(
+                    {"filename": file, "subfolder": subfolder, "type": self.type}
+                )
+
            except Exception as e:
                logger.error(f"Error saving image: {e}")
-        
+
        return results

-    def process_image(self, images, id, filename_prefix="ComfyUI", file_format="png", prompt=None, extra_pnginfo=None,
-                     lossless_webp=True, quality=100, embed_workflow=False, add_counter_to_filename=True):
+    def process_image(
+        self,
+        images,
+        id,
+        filename_prefix="ComfyUI",
+        file_format="png",
+        prompt=None,
+        extra_pnginfo=None,
+        lossless_webp=True,
+        quality=100,
+        embed_workflow=False,
+        add_counter_to_filename=True,
+    ):
        """Process and save image with metadata"""
        # Make sure the output directory exists
        os.makedirs(self.output_dir, exist_ok=True)
-        
+
        # If images is already a list or array of images, do nothing; otherwise, convert to list
        if isinstance(images, (list, np.ndarray)):
            pass
@@ -436,19 +504,19 @@ class SaveImageLM:
                images = [images]
            else:  # Multiple images (batch, height, width, channels)
                images = [img for img in images]
-        
+
        # Save all images
        results = self.save_images(
-            images, 
-            filename_prefix, 
-            file_format, 
+            images,
+            filename_prefix,
+            file_format,
            id,
-            prompt, 
+            prompt,
            extra_pnginfo,
            lossless_webp,
            quality,
            embed_workflow,
-            add_counter_to_filename
+            add_counter_to_filename,
        )
-        
+
        return (images,)
--- a/py/nodes/utils.py
+++ b/py/nodes/utils.py
@@ -1,33 +1,35 @@
 class AnyType(str):
-  """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
+    """A special class that is always equal in not equal comparisons. Credit to pythongosssss"""
+
+    def __ne__(self, __value: object) -> bool:
+        return False

-  def __ne__(self, __value: object) -> bool:
-    return False

 # Credit to Regis Gaughan, III (rgthree)
 class FlexibleOptionalInputType(dict):
-  """A special class to make flexible nodes that pass data to our python handlers.
+    """A special class to make flexible nodes that pass data to our python handlers.

-  Enables both flexible/dynamic input types (like for Any Switch) or a dynamic number of inputs
-  (like for Any Switch, Context Switch, Context Merge, Power Lora Loader, etc).
+    Enables both flexible/dynamic input types (like for Any Switch) or a dynamic number of inputs
+    (like for Any Switch, Context Switch, Context Merge, Power Lora Loader, etc).

-  Note, for ComfyUI, all that's needed is the `__contains__` override below, which tells ComfyUI
-  that our node will handle the input, regardless of what it is.
+    Note, for ComfyUI, all that's needed is the `__contains__` override below, which tells ComfyUI
+    that our node will handle the input, regardless of what it is.

-  However, with https://github.com/comfyanonymous/ComfyUI/pull/2666 a large change would occur
-  requiring more details on the input itself. There, we need to return a list/tuple where the first
-  item is the type. This can be a real type, or use the AnyType for additional flexibility.
+    However, with https://github.com/comfyanonymous/ComfyUI/pull/2666 a large change would occur
+    requiring more details on the input itself. There, we need to return a list/tuple where the first
+    item is the type. This can be a real type, or use the AnyType for additional flexibility.

-  This should be forwards compatible unless more changes occur in the PR.
-  """
-  def __init__(self, type):
-    self.type = type
+    This should be forwards compatible unless more changes occur in the PR.
+    """

-  def __getitem__(self, key):
-    return (self.type, )
+    def __init__(self, type):
+        self.type = type

-  def __contains__(self, key):
-    return True
+    def __getitem__(self, key):
+        return (self.type,)
+
+    def __contains__(self, key):
+        return True


 any_type = AnyType("*")
@@ -37,25 +39,27 @@ import os
 import logging
 import copy
 import sys
-import folder_paths
+import folder_paths  # type: ignore

 logger = logging.getLogger(__name__)

+
 def extract_lora_name(lora_path):
    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
    # Get the basename without extension
    basename = os.path.basename(lora_path)
    return os.path.splitext(basename)[0]

+
 def get_loras_list(kwargs):
    """Helper to extract loras list from either old or new kwargs format"""
-    if 'loras' not in kwargs:
+    if "loras" not in kwargs:
        return []
-        
-    loras_data = kwargs['loras']
+
+    loras_data = kwargs["loras"]
    # Handle new format: {'loras': {'__value__': [...]}}
-    if isinstance(loras_data, dict) and '__value__' in loras_data:
-        return loras_data['__value__']
+    if isinstance(loras_data, dict) and "__value__" in loras_data:
+        return loras_data["__value__"]
    # Handle old format: {'loras': [...]}
    elif isinstance(loras_data, list):
        return loras_data
@@ -64,24 +68,26 @@ def get_loras_list(kwargs):
        logger.warning(f"Unexpected loras format: {type(loras_data)}")
        return []

+
 def load_state_dict_in_safetensors(path, device="cpu", filter_prefix=""):
-    """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""  
+    """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""
    import safetensors.torch
-    
+
    state_dict = {}
-    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:
+    with safetensors.torch.safe_open(path, framework="pt", device=device) as f:  # type: ignore[attr-defined]
        for k in f.keys():
            if filter_prefix and not k.startswith(filter_prefix):
                continue
            state_dict[k.removeprefix(filter_prefix)] = f.get_tensor(k)
    return state_dict

+
 def to_diffusers(input_lora):
    """Simplified version of to_diffusers for Flux LoRA conversion"""
    import torch
    from diffusers.utils.state_dict_utils import convert_unet_state_dict_to_peft
-    from diffusers.loaders import FluxLoraLoaderMixin
-    
+    from diffusers.loaders import FluxLoraLoaderMixin  # type: ignore[attr-defined]
+
    if isinstance(input_lora, str):
        tensors = load_state_dict_in_safetensors(input_lora, device="cpu")
    else:
@@ -91,22 +97,27 @@ def to_diffusers(input_lora):
    for k, v in tensors.items():
        if v.dtype not in [torch.float64, torch.float32, torch.bfloat16, torch.float16]:
            tensors[k] = v.to(torch.bfloat16)
-    
+
    new_tensors = FluxLoraLoaderMixin.lora_state_dict(tensors)
    new_tensors = convert_unet_state_dict_to_peft(new_tensors)

    return new_tensors

+
 def nunchaku_load_lora(model, lora_name, lora_strength):
-    """Load a Flux LoRA for Nunchaku model"""   
+    """Load a Flux LoRA for Nunchaku model"""
    # Get full path to the LoRA file. Allow both direct paths and registered LoRA names.
-    lora_path = lora_name if os.path.isfile(lora_name) else folder_paths.get_full_path("loras", lora_name)
+    lora_path = (
+        lora_name
+        if os.path.isfile(lora_name)
+        else folder_paths.get_full_path("loras", lora_name)
+    )
    if not lora_path or not os.path.isfile(lora_path):
        logger.warning("Skipping LoRA '%s' because it could not be found", lora_name)
        return model

    model_wrapper = model.model.diffusion_model
-    
+
    # Try to find copy_with_ctx in the same module as ComfyFluxWrapper
    module_name = model_wrapper.__class__.__module__
    module = sys.modules.get(module_name)
@@ -118,14 +129,16 @@ def nunchaku_load_lora(model, lora_name, lora_strength):
        ret_model_wrapper.loras = [*model_wrapper.loras, (lora_path, lora_strength)]
    else:
        # Fallback to legacy logic
-        logger.warning("Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic.")
+        logger.warning(
+            "Please upgrade ComfyUI-nunchaku to 1.1.0 or above for better LoRA support. Falling back to legacy loading logic."
+        )
        transformer = model_wrapper.model
-        
+
        # Save the transformer temporarily
        model_wrapper.model = None
        ret_model = copy.deepcopy(model)  # copy everything except the model
        ret_model_wrapper = ret_model.model.diffusion_model
-        
+
        # Restore the model and set it for the copy
        model_wrapper.model = transformer
        ret_model_wrapper.model = transformer
@@ -133,15 +146,15 @@ def nunchaku_load_lora(model, lora_name, lora_strength):

    # Convert the LoRA to diffusers format
    sd = to_diffusers(lora_path)
-    
+
    # Handle embedding adjustment if needed
    if "transformer.x_embedder.lora_A.weight" in sd:
        new_in_channels = sd["transformer.x_embedder.lora_A.weight"].shape[1]
        assert new_in_channels % 4 == 0
        new_in_channels = new_in_channels // 4
-        
+
        old_in_channels = ret_model.model.model_config.unet_config["in_channels"]
        if old_in_channels < new_in_channels:
            ret_model.model.model_config.unet_config["in_channels"] = new_in_channels
-    
-    return ret_model
+
+    return ret_model
--- a/py/recipes/factory.py
+++ b/py/recipes/factory.py
@@ -6,23 +6,24 @@ from .parsers import (
    ComfyMetadataParser,
    MetaFormatParser,
    AutomaticMetadataParser,
-    CivitaiApiMetadataParser
+    CivitaiApiMetadataParser,
 )
 from .base import RecipeMetadataParser

 logger = logging.getLogger(__name__)

+
 class RecipeParserFactory:
    """Factory for creating recipe metadata parsers"""
-    
+
    @staticmethod
-    def create_parser(metadata) -> RecipeMetadataParser:
+    def create_parser(metadata) -> RecipeMetadataParser | None:
        """
        Create appropriate parser based on the metadata content
-        
+
        Args:
            metadata: The metadata from the image (dict or str)
-            
+
        Returns:
            Appropriate RecipeMetadataParser implementation
        """
@@ -34,17 +35,18 @@ class RecipeParserFactory:
            except Exception as e:
                logger.debug(f"CivitaiApiMetadataParser check failed: {e}")
                pass
-            
+
            # Convert dict to string for other parsers that expect string input
            try:
                import json
+
                metadata_str = json.dumps(metadata)
            except Exception as e:
                logger.debug(f"Failed to convert dict to JSON string: {e}")
                return None
        else:
            metadata_str = metadata
-        
+
        # Try ComfyMetadataParser which requires valid JSON
        try:
            if ComfyMetadataParser().is_metadata_matching(metadata_str):
@@ -52,7 +54,7 @@ class RecipeParserFactory:
        except Exception:
            # If JSON parsing fails, move on to other parsers
            pass
-        
+
        # Check other parsers that expect string input
        if RecipeFormatParser().is_metadata_matching(metadata_str):
            return RecipeFormatParser()
--- a/py/recipes/parsers/civitai_image.py
+++ b/py/recipes/parsers/civitai_image.py
@@ -9,15 +9,16 @@ from ...services.metadata_service import get_default_metadata_provider

 logger = logging.getLogger(__name__)

+
 class CivitaiApiMetadataParser(RecipeMetadataParser):
    """Parser for Civitai image metadata format"""
-    
+
    def is_metadata_matching(self, metadata) -> bool:
        """Check if the metadata matches the Civitai image metadata format
-        
+
        Args:
            metadata: The metadata from the image (dict)
-            
+
        Returns:
            bool: True if this parser can handle the metadata
        """
@@ -28,7 +29,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
            # Check for common CivitAI image metadata fields
            civitai_image_fields = (
                "resources",
-                "civitaiResources", 
+                "civitaiResources",
                "additionalResources",
                "hashes",
                "prompt",
@@ -40,7 +41,7 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                "width",
                "height",
                "Model",
-                "Model hash"
+                "Model hash",
            )
            return any(key in payload for key in civitai_image_fields)

@@ -50,7 +51,9 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

        # Check for LoRA hash patterns
        hashes = metadata.get("hashes")
-        if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
+        if isinstance(hashes, dict) and any(
+            str(key).lower().startswith("lora:") for key in hashes
+        ):
            return True

        # Check nested meta object (common in CivitAI image responses)
@@ -61,22 +64,28 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

            # Also check for LoRA hash patterns in nested meta
            hashes = nested_meta.get("hashes")
-            if isinstance(hashes, dict) and any(str(key).lower().startswith("lora:") for key in hashes):
+            if isinstance(hashes, dict) and any(
+                str(key).lower().startswith("lora:") for key in hashes
+            ):
                return True

        return False
-    
-    async def parse_metadata(self, metadata, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
+
+    async def parse_metadata(  # type: ignore[override]
+        self, user_comment, recipe_scanner=None, civitai_client=None
+    ) -> Dict[str, Any]:
        """Parse metadata from Civitai image format
-        
+
        Args:
-            metadata: The metadata from the image (dict)
+            user_comment: The metadata from the image (dict)
            recipe_scanner: Optional recipe scanner service
            civitai_client: Optional Civitai API client (deprecated, use metadata_provider instead)
-            
+
        Returns:
            Dict containing parsed recipe data
        """
+        metadata: Dict[str, Any] = user_comment  # type: ignore[assignment]
+        metadata = user_comment
        try:
            # Get metadata provider instead of using civitai_client directly
            metadata_provider = await get_default_metadata_provider()
@@ -100,19 +109,19 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                    )
                ):
                    metadata = inner_meta
-            
+
            # Initialize result structure
            result = {
-                'base_model': None,
-                'loras': [],
-                'model': None,
-                'gen_params': {},
-                'from_civitai_image': True
+                "base_model": None,
+                "loras": [],
+                "model": None,
+                "gen_params": {},
+                "from_civitai_image": True,
            }
-            
+
            # Track already added LoRAs to prevent duplicates
            added_loras = {}  # key: model_version_id or hash, value: index in result["loras"]
-            
+
            # Extract hash information from hashes field for LoRA matching
            lora_hashes = {}
            if "hashes" in metadata and isinstance(metadata["hashes"], dict):
@@ -121,14 +130,14 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                    if key_str.lower().startswith("lora:"):
                        lora_name = key_str.split(":", 1)[1]
                        lora_hashes[lora_name] = hash_value
-            
+
            # Extract prompt and negative prompt
            if "prompt" in metadata:
                result["gen_params"]["prompt"] = metadata["prompt"]
-            
+
            if "negativePrompt" in metadata:
                result["gen_params"]["negative_prompt"] = metadata["negativePrompt"]
-            
+
            # Extract other generation parameters
            param_mapping = {
                "steps": "steps",
@@ -138,98 +147,117 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                "Size": "size",
                "clipSkip": "clip_skip",
            }
-            
+
            for civitai_key, our_key in param_mapping.items():
                if civitai_key in metadata and our_key in GEN_PARAM_KEYS:
                    result["gen_params"][our_key] = metadata[civitai_key]
-            
+
            # Extract base model information - directly if available
            if "baseModel" in metadata:
                result["base_model"] = metadata["baseModel"]
            elif "Model hash" in metadata and metadata_provider:
                model_hash = metadata["Model hash"]
-                model_info, error = await metadata_provider.get_model_by_hash(model_hash)
+                model_info, error = await metadata_provider.get_model_by_hash(
+                    model_hash
+                )
                if model_info:
                    result["base_model"] = model_info.get("baseModel", "")
            elif "Model" in metadata and isinstance(metadata.get("resources"), list):
                # Try to find base model in resources
                for resource in metadata.get("resources", []):
-                    if resource.get("type") == "model" and resource.get("name") == metadata.get("Model"):
+                    if resource.get("type") == "model" and resource.get(
+                        "name"
+                    ) == metadata.get("Model"):
                        # This is likely the checkpoint model
                        if metadata_provider and resource.get("hash"):
-                            model_info, error = await metadata_provider.get_model_by_hash(resource.get("hash"))
+                            (
+                                model_info,
+                                error,
+                            ) = await metadata_provider.get_model_by_hash(
+                                resource.get("hash")
+                            )
                            if model_info:
                                result["base_model"] = model_info.get("baseModel", "")
-            
+
            base_model_counts = {}
-            
+
            # Process standard resources array
            if "resources" in metadata and isinstance(metadata["resources"], list):
                for resource in metadata["resources"]:
                    # Modified to process resources without a type field as potential LoRAs
                    if resource.get("type", "lora") == "lora":
                        lora_hash = resource.get("hash", "")
-                        
+
                        # Try to get hash from the hashes field if not present in resource
                        if not lora_hash and resource.get("name"):
                            lora_hash = lora_hashes.get(resource["name"], "")
-                        
+
                        # Skip LoRAs without proper identification (hash or modelVersionId)
                        if not lora_hash and not resource.get("modelVersionId"):
-                            logger.debug(f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId")
+                            logger.debug(
+                                f"Skipping LoRA resource '{resource.get('name', 'Unknown')}' - no hash or modelVersionId"
+                            )
                            continue
-                        
+
                        # Skip if we've already added this LoRA by hash
                        if lora_hash and lora_hash in added_loras:
                            continue
-                        
+
                        lora_entry = {
-                            'name': resource.get("name", "Unknown LoRA"),
-                            'type': "lora",
-                            'weight': float(resource.get("weight", 1.0)),
-                            'hash': lora_hash,
-                            'existsLocally': False,
-                            'localPath': None,
-                            'file_name': resource.get("name", "Unknown"),
-                            'thumbnailUrl': '/loras_static/images/no-preview.png',
-                            'baseModel': '',
-                            'size': 0,
-                            'downloadUrl': '',
-                            'isDeleted': False
+                            "name": resource.get("name", "Unknown LoRA"),
+                            "type": "lora",
+                            "weight": float(resource.get("weight", 1.0)),
+                            "hash": lora_hash,
+                            "existsLocally": False,
+                            "localPath": None,
+                            "file_name": resource.get("name", "Unknown"),
+                            "thumbnailUrl": "/loras_static/images/no-preview.png",
+                            "baseModel": "",
+                            "size": 0,
+                            "downloadUrl": "",
+                            "isDeleted": False,
                        }
-                        
+
                        # Try to get info from Civitai if hash is available
-                        if lora_entry['hash'] and metadata_provider:
+                        if lora_entry["hash"] and metadata_provider:
                            try:
-                                civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                                
+                                civitai_info = (
+                                    await metadata_provider.get_model_by_hash(lora_hash)
+                                )
+
                                populated_entry = await self.populate_lora_from_civitai(
                                    lora_entry,
                                    civitai_info,
                                    recipe_scanner,
                                    base_model_counts,
-                                    lora_hash
+                                    lora_hash,
                                )
-                                
+
                                if populated_entry is None:
                                    continue  # Skip invalid LoRA types
-                                    
+
                                lora_entry = populated_entry
-                                
+
                                # If we have a version ID from Civitai, track it for deduplication
-                                if 'id' in lora_entry and lora_entry['id']:
-                                    added_loras[str(lora_entry['id'])] = len(result["loras"])
+                                if "id" in lora_entry and lora_entry["id"]:
+                                    added_loras[str(lora_entry["id"])] = len(
+                                        result["loras"]
+                                    )
                            except Exception as e:
-                                logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
-                        
+                                logger.error(
+                                    f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
+                                )
+
                        # Track by hash if we have it
                        if lora_hash:
                            added_loras[lora_hash] = len(result["loras"])
-                            
+
                        result["loras"].append(lora_entry)
-            
+
            # Process civitaiResources array
-            if "civitaiResources" in metadata and isinstance(metadata["civitaiResources"], list):
+            if "civitaiResources" in metadata and isinstance(
+                metadata["civitaiResources"], list
+            ):
                for resource in metadata["civitaiResources"]:
                    # Get resource type and identifier
                    resource_type = str(resource.get("type") or "").lower()
@@ -237,32 +265,39 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

                    if resource_type == "checkpoint":
                        checkpoint_entry = {
-                            'id': resource.get("modelVersionId", 0),
-                            'modelId': resource.get("modelId", 0),
-                            'name': resource.get("modelName", "Unknown Checkpoint"),
-                            'version': resource.get("modelVersionName", ""),
-                            'type': resource.get("type", "checkpoint"),
-                            'existsLocally': False,
-                            'localPath': None,
-                            'file_name': resource.get("modelName", ""),
-                            'hash': resource.get("hash", "") or "",
-                            'thumbnailUrl': '/loras_static/images/no-preview.png',
-                            'baseModel': '',
-                            'size': 0,
-                            'downloadUrl': '',
-                            'isDeleted': False
+                            "id": resource.get("modelVersionId", 0),
+                            "modelId": resource.get("modelId", 0),
+                            "name": resource.get("modelName", "Unknown Checkpoint"),
+                            "version": resource.get("modelVersionName", ""),
+                            "type": resource.get("type", "checkpoint"),
+                            "existsLocally": False,
+                            "localPath": None,
+                            "file_name": resource.get("modelName", ""),
+                            "hash": resource.get("hash", "") or "",
+                            "thumbnailUrl": "/loras_static/images/no-preview.png",
+                            "baseModel": "",
+                            "size": 0,
+                            "downloadUrl": "",
+                            "isDeleted": False,
                        }

                        if version_id and metadata_provider:
                            try:
-                                civitai_info = await metadata_provider.get_model_version_info(version_id)
+                                civitai_info = (
+                                    await metadata_provider.get_model_version_info(
+                                        version_id
+                                    )
+                                )

-                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
-                                    checkpoint_entry,
-                                    civitai_info
+                                checkpoint_entry = (
+                                    await self.populate_checkpoint_from_civitai(
+                                        checkpoint_entry, civitai_info
+                                    )
                                )
                            except Exception as e:
-                                logger.error(f"Error fetching Civitai info for checkpoint version {version_id}: {e}")
+                                logger.error(
+                                    f"Error fetching Civitai info for checkpoint version {version_id}: {e}"
+                                )

                        if result["model"] is None:
                            result["model"] = checkpoint_entry
@@ -275,31 +310,35 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

                    # Initialize lora entry
                    lora_entry = {
-                        'id': resource.get("modelVersionId", 0),
-                        'modelId': resource.get("modelId", 0),
-                        'name': resource.get("modelName", "Unknown LoRA"),
-                        'version': resource.get("modelVersionName", ""),
-                        'type': resource.get("type", "lora"),
-                        'weight': round(float(resource.get("weight", 1.0)), 2),
-                        'existsLocally': False,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
+                        "id": resource.get("modelVersionId", 0),
+                        "modelId": resource.get("modelId", 0),
+                        "name": resource.get("modelName", "Unknown LoRA"),
+                        "version": resource.get("modelVersionName", ""),
+                        "type": resource.get("type", "lora"),
+                        "weight": round(float(resource.get("weight", 1.0)), 2),
+                        "existsLocally": False,
+                        "thumbnailUrl": "/loras_static/images/no-preview.png",
+                        "baseModel": "",
+                        "size": 0,
+                        "downloadUrl": "",
+                        "isDeleted": False,
                    }

                    # Try to get info from Civitai if modelVersionId is available
                    if version_id and metadata_provider:
                        try:
                            # Use get_model_version_info instead of get_model_version
-                            civitai_info = await metadata_provider.get_model_version_info(version_id)
+                            civitai_info = (
+                                await metadata_provider.get_model_version_info(
+                                    version_id
+                                )
+                            )

                            populated_entry = await self.populate_lora_from_civitai(
                                lora_entry,
                                civitai_info,
                                recipe_scanner,
-                                base_model_counts
+                                base_model_counts,
                            )

                            if populated_entry is None:
@@ -307,74 +346,87 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

                            lora_entry = populated_entry
                        except Exception as e:
-                            logger.error(f"Error fetching Civitai info for model version {version_id}: {e}")
+                            logger.error(
+                                f"Error fetching Civitai info for model version {version_id}: {e}"
+                            )

                    # Track this LoRA in our deduplication dict
                    if version_id:
                        added_loras[version_id] = len(result["loras"])

                    result["loras"].append(lora_entry)
-            
+
            # Process additionalResources array
-            if "additionalResources" in metadata and isinstance(metadata["additionalResources"], list):
+            if "additionalResources" in metadata and isinstance(
+                metadata["additionalResources"], list
+            ):
                for resource in metadata["additionalResources"]:
                    # Skip resources that aren't LoRAs or LyCORIS
-                    if resource.get("type") not in ["lora", "lycoris"] and "type" not in resource:
+                    if (
+                        resource.get("type") not in ["lora", "lycoris"]
+                        and "type" not in resource
+                    ):
                        continue
-                        
+
                    lora_type = resource.get("type", "lora")
                    name = resource.get("name", "")
-                    
+
                    # Extract ID from URN format if available
                    version_id = None
                    if name and "civitai:" in name:
                        parts = name.split("@")
                        if len(parts) > 1:
                            version_id = parts[1]
-                            
+
                            # Skip if we've already added this LoRA
                            if version_id in added_loras:
                                continue
-                    
+
                    lora_entry = {
-                        'name': name,
-                        'type': lora_type,
-                        'weight': float(resource.get("strength", 1.0)),
-                        'hash': "",
-                        'existsLocally': False,
-                        'localPath': None,
-                        'file_name': name,
-                        'thumbnailUrl': '/loras_static/images/no-preview.png',
-                        'baseModel': '',
-                        'size': 0,
-                        'downloadUrl': '',
-                        'isDeleted': False
+                        "name": name,
+                        "type": lora_type,
+                        "weight": float(resource.get("strength", 1.0)),
+                        "hash": "",
+                        "existsLocally": False,
+                        "localPath": None,
+                        "file_name": name,
+                        "thumbnailUrl": "/loras_static/images/no-preview.png",
+                        "baseModel": "",
+                        "size": 0,
+                        "downloadUrl": "",
+                        "isDeleted": False,
                    }
-                    
+
                    # If we have a version ID and metadata provider, try to get more info
                    if version_id and metadata_provider:
                        try:
                            # Use get_model_version_info with the version ID
-                            civitai_info = await metadata_provider.get_model_version_info(version_id)
-                            
+                            civitai_info = (
+                                await metadata_provider.get_model_version_info(
+                                    version_id
+                                )
+                            )
+
                            populated_entry = await self.populate_lora_from_civitai(
                                lora_entry,
                                civitai_info,
                                recipe_scanner,
-                                base_model_counts
+                                base_model_counts,
                            )
-                            
+
                            if populated_entry is None:
                                continue  # Skip invalid LoRA types
-                                
+
                            lora_entry = populated_entry
-                            
+
                            # Track this LoRA for deduplication
                            if version_id:
                                added_loras[version_id] = len(result["loras"])
                        except Exception as e:
-                            logger.error(f"Error fetching Civitai info for model ID {version_id}: {e}")
-                    
+                            logger.error(
+                                f"Error fetching Civitai info for model ID {version_id}: {e}"
+                            )
+
                        result["loras"].append(lora_entry)

            # If we found LoRA hashes in the metadata but haven't already
@@ -390,30 +442,32 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                    continue

                lora_entry = {
-                    'name': lora_name,
-                    'type': "lora",
-                    'weight': 1.0,
-                    'hash': lora_hash,
-                    'existsLocally': False,
-                    'localPath': None,
-                    'file_name': lora_name,
-                    'thumbnailUrl': '/loras_static/images/no-preview.png',
-                    'baseModel': '',
-                    'size': 0,
-                    'downloadUrl': '',
-                    'isDeleted': False
+                    "name": lora_name,
+                    "type": "lora",
+                    "weight": 1.0,
+                    "hash": lora_hash,
+                    "existsLocally": False,
+                    "localPath": None,
+                    "file_name": lora_name,
+                    "thumbnailUrl": "/loras_static/images/no-preview.png",
+                    "baseModel": "",
+                    "size": 0,
+                    "downloadUrl": "",
+                    "isDeleted": False,
                }

                if metadata_provider:
                    try:
-                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
+                        civitai_info = await metadata_provider.get_model_by_hash(
+                            lora_hash
+                        )

                        populated_entry = await self.populate_lora_from_civitai(
                            lora_entry,
                            civitai_info,
                            recipe_scanner,
                            base_model_counts,
-                            lora_hash
+                            lora_hash,
                        )

                        if populated_entry is None:
@@ -421,80 +475,93 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):

                        lora_entry = populated_entry

-                        if 'id' in lora_entry and lora_entry['id']:
-                            added_loras[str(lora_entry['id'])] = len(result["loras"])
+                        if "id" in lora_entry and lora_entry["id"]:
+                            added_loras[str(lora_entry["id"])] = len(result["loras"])
                    except Exception as e:
-                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}")
+                        logger.error(
+                            f"Error fetching Civitai info for LoRA hash {lora_hash}: {e}"
+                        )

                added_loras[lora_hash] = len(result["loras"])
                result["loras"].append(lora_entry)

            # Check for LoRA info in the format "Lora_0 Model hash", "Lora_0 Model name", etc.
            lora_index = 0
-            while f"Lora_{lora_index} Model hash" in metadata and f"Lora_{lora_index} Model name" in metadata:
+            while (
+                f"Lora_{lora_index} Model hash" in metadata
+                and f"Lora_{lora_index} Model name" in metadata
+            ):
                lora_hash = metadata[f"Lora_{lora_index} Model hash"]
                lora_name = metadata[f"Lora_{lora_index} Model name"]
-                lora_strength_model = float(metadata.get(f"Lora_{lora_index} Strength model", 1.0))
-                
+                lora_strength_model = float(
+                    metadata.get(f"Lora_{lora_index} Strength model", 1.0)
+                )
+
                # Skip if we've already added this LoRA by hash
                if lora_hash and lora_hash in added_loras:
                    lora_index += 1
                    continue
-                
+
                lora_entry = {
-                    'name': lora_name,
-                    'type': "lora",
-                    'weight': lora_strength_model,
-                    'hash': lora_hash,
-                    'existsLocally': False,
-                    'localPath': None,
-                    'file_name': lora_name,
-                    'thumbnailUrl': '/loras_static/images/no-preview.png',
-                    'baseModel': '',
-                    'size': 0,
-                    'downloadUrl': '',
-                    'isDeleted': False
+                    "name": lora_name,
+                    "type": "lora",
+                    "weight": lora_strength_model,
+                    "hash": lora_hash,
+                    "existsLocally": False,
+                    "localPath": None,
+                    "file_name": lora_name,
+                    "thumbnailUrl": "/loras_static/images/no-preview.png",
+                    "baseModel": "",
+                    "size": 0,
+                    "downloadUrl": "",
+                    "isDeleted": False,
                }
-                
+
                # Try to get info from Civitai if hash is available
-                if lora_entry['hash'] and metadata_provider:
+                if lora_entry["hash"] and metadata_provider:
                    try:
-                        civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                        
+                        civitai_info = await metadata_provider.get_model_by_hash(
+                            lora_hash
+                        )
+
                        populated_entry = await self.populate_lora_from_civitai(
                            lora_entry,
                            civitai_info,
                            recipe_scanner,
                            base_model_counts,
-                            lora_hash
+                            lora_hash,
                        )
-                        
+
                        if populated_entry is None:
                            lora_index += 1
                            continue  # Skip invalid LoRA types
-                            
+
                        lora_entry = populated_entry
-                        
+
                        # If we have a version ID from Civitai, track it for deduplication
-                        if 'id' in lora_entry and lora_entry['id']:
-                            added_loras[str(lora_entry['id'])] = len(result["loras"])
+                        if "id" in lora_entry and lora_entry["id"]:
+                            added_loras[str(lora_entry["id"])] = len(result["loras"])
                    except Exception as e:
-                        logger.error(f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}")
-                
+                        logger.error(
+                            f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
+                        )
+
                # Track by hash if we have it
                if lora_hash:
                    added_loras[lora_hash] = len(result["loras"])
-                    
+
                result["loras"].append(lora_entry)
-                
+
                lora_index += 1
-            
+
            # If base model wasn't found earlier, use the most common one from LoRAs
            if not result["base_model"] and base_model_counts:
-                result["base_model"] = max(base_model_counts.items(), key=lambda x: x[1])[0]
-            
+                result["base_model"] = max(
+                    base_model_counts.items(), key=lambda x: x[1]
+                )[0]
+
            return result
-            
+
        except Exception as e:
            logger.error(f"Error parsing Civitai image metadata: {e}", exc_info=True)
            return {"error": str(e), "loras": []}
--- a/py/routes/checkpoint_routes.py
+++ b/py/routes/checkpoint_routes.py
@@ -1,5 +1,5 @@
 import logging
-from typing import Dict
+from typing import Dict, List, Set
 from aiohttp import web

 from .base_model_routes import BaseModelRoutes
@@ -82,12 +82,22 @@ class CheckpointRoutes(BaseModelRoutes):
            return web.json_response({"error": str(e)}, status=500)
    
    async def get_checkpoints_roots(self, request: web.Request) -> web.Response:
-        """Return the list of checkpoint roots from config"""
+        """Return the list of checkpoint roots from config (including extra paths)"""
        try:
-            roots = config.checkpoints_roots
+            # Merge checkpoints_roots with extra_checkpoints_roots, preserving order and removing duplicates
+            roots: List[str] = []
+            roots.extend(config.checkpoints_roots or [])
+            roots.extend(config.extra_checkpoints_roots or [])
+            # Remove duplicates while preserving order
+            seen: set = set()
+            unique_roots: List[str] = []
+            for root in roots:
+                if root and root not in seen:
+                    seen.add(root)
+                    unique_roots.append(root)
            return web.json_response({
                "success": True,
-                "roots": roots
+                "roots": unique_roots
            })
        except Exception as e:
            logger.error(f"Error getting checkpoint roots: {e}", exc_info=True)
@@ -97,12 +107,22 @@ class CheckpointRoutes(BaseModelRoutes):
            }, status=500)

    async def get_unet_roots(self, request: web.Request) -> web.Response:
-        """Return the list of unet roots from config"""
+        """Return the list of unet roots from config (including extra paths)"""
        try:
-            roots = config.unet_roots
+            # Merge unet_roots with extra_unet_roots, preserving order and removing duplicates
+            roots: List[str] = []
+            roots.extend(config.unet_roots or [])
+            roots.extend(config.extra_unet_roots or [])
+            # Remove duplicates while preserving order
+            seen: set = set()
+            unique_roots: List[str] = []
+            for root in roots:
+                if root and root not in seen:
+                    seen.add(root)
+                    unique_roots.append(root)
            return web.json_response({
                "success": True,
-                "roots": roots
+                "roots": unique_roots
            })
        except Exception as e:
            logger.error(f"Error getting unet roots: {e}", exc_info=True)
--- a/py/routes/handlers/misc_handlers.py
+++ b/py/routes/handlers/misc_handlers.py
@@ -9,6 +9,7 @@ objects that can be composed by the route controller.
 from __future__ import annotations

 import asyncio
+import json
 import logging
 import os
 import subprocess
@@ -192,6 +193,7 @@ class NodeRegistry:
                    "comfy_class": comfy_class,
                    "capabilities": capabilities,
                    "widget_names": widget_names,
+                    "mode": node.get("mode"),
                }
            logger.debug("Registered %s nodes in registry", len(nodes))
            self._registry_updated.set()
@@ -217,20 +219,149 @@ class HealthCheckHandler:
        return web.json_response({"status": "ok"})


+class SupportersHandler:
+    """Handler for supporters data."""
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        self._logger = logger or logging.getLogger(__name__)
+
+    def _load_supporters(self) -> dict:
+        """Load supporters data from JSON file."""
+        try:
+            current_file = os.path.abspath(__file__)
+            root_dir = os.path.dirname(
+                os.path.dirname(os.path.dirname(os.path.dirname(current_file)))
+            )
+            supporters_path = os.path.join(root_dir, "data", "supporters.json")
+
+            if os.path.exists(supporters_path):
+                with open(supporters_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+        except Exception as e:
+            self._logger.debug(f"Failed to load supporters data: {e}")
+
+        return {"specialThanks": [], "allSupporters": [], "totalCount": 0}
+
+    async def get_supporters(self, request: web.Request) -> web.Response:
+        """Return supporters data as JSON."""
+        try:
+            supporters = self._load_supporters()
+            return web.json_response({"success": True, "supporters": supporters})
+        except Exception as exc:
+            self._logger.error("Error loading supporters: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+
+class ExampleWorkflowsHandler:
+    """Handler for example workflow templates."""
+
+    def __init__(self, logger: logging.Logger | None = None) -> None:
+        self._logger = logger or logging.getLogger(__name__)
+
+    def _get_workflows_dir(self) -> str:
+        """Get the example workflows directory path."""
+        current_file = os.path.abspath(__file__)
+        root_dir = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.dirname(current_file)))
+        )
+        return os.path.join(root_dir, "example_workflows")
+
+    def _format_workflow_name(self, filename: str) -> str:
+        """Convert filename to human-readable name."""
+        name = os.path.splitext(filename)[0]
+        name = name.replace("_", " ")
+        return name
+
+    async def get_example_workflows(self, request: web.Request) -> web.Response:
+        """Return list of available example workflows."""
+        try:
+            workflows_dir = self._get_workflows_dir()
+            workflows = [
+                {
+                    "value": "Default",
+                    "label": "Default (Blank)",
+                    "path": None,
+                }
+            ]
+
+            if os.path.exists(workflows_dir):
+                for filename in sorted(os.listdir(workflows_dir)):
+                    if filename.endswith(".json"):
+                        workflows.append(
+                            {
+                                "value": filename,
+                                "label": self._format_workflow_name(filename),
+                                "path": f"example_workflows/{filename}",
+                            }
+                        )
+
+            return web.json_response({"success": True, "workflows": workflows})
+        except Exception as exc:
+            self._logger.error(
+                "Error listing example workflows: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_example_workflow(self, request: web.Request) -> web.Response:
+        """Return a specific example workflow JSON content."""
+        try:
+            filename = request.match_info.get("filename")
+            if not filename:
+                return web.json_response(
+                    {"success": False, "error": "Filename not provided"}, status=400
+                )
+
+            if filename == "Default":
+                return web.json_response(
+                    {
+                        "success": True,
+                        "workflow": {
+                            "last_node_id": 0,
+                            "last_link_id": 0,
+                            "nodes": [],
+                            "links": [],
+                            "groups": [],
+                            "config": {},
+                            "extra": {},
+                            "version": 0.4,
+                        },
+                    }
+                )
+
+            workflows_dir = self._get_workflows_dir()
+            filepath = os.path.join(workflows_dir, filename)
+
+            if not os.path.exists(filepath):
+                return web.json_response(
+                    {"success": False, "error": f"Workflow not found: {filename}"},
+                    status=404,
+                )
+
+            with open(filepath, "r", encoding="utf-8") as f:
+                workflow = json.load(f)
+
+            return web.json_response({"success": True, "workflow": workflow})
+        except Exception as exc:
+            self._logger.error("Error loading example workflow: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+
 class SettingsHandler:
    """Sync settings between backend and frontend."""

    # Settings keys that should NOT be synced to frontend.
    # All other settings are synced by default.
-    _NO_SYNC_KEYS = frozenset({
-        # Internal/performance settings (not used by frontend)
-        "hash_chunk_size_mb",
-        "download_stall_timeout_seconds",
-        # Complex internal structures retrieved via separate endpoints
-        "folder_paths",
-        "libraries",
-        "active_library",
-    })
+    _NO_SYNC_KEYS = frozenset(
+        {
+            # Internal/performance settings (not used by frontend)
+            "hash_chunk_size_mb",
+            "download_stall_timeout_seconds",
+            # Complex internal structures retrieved via separate endpoints
+            "folder_paths",
+            "libraries",
+            "active_library",
+        }
+    )

    _PROXY_KEYS = {
        "proxy_enabled",
@@ -1185,6 +1316,7 @@ class CustomWordsHandler:

    def __init__(self) -> None:
        from ...services.custom_words_service import get_custom_words_service
+
        self._service = get_custom_words_service()

    async def search_custom_words(self, request: web.Request) -> web.Response:
@@ -1193,6 +1325,7 @@ class CustomWordsHandler:
        Query parameters:
            search: The search term to match against.
            limit: Maximum number of results to return (default: 20).
+            offset: Number of results to skip (default: 0).
            category: Optional category filter. Can be:
                - A category name (e.g., "character", "artist", "general")
                - Comma-separated category IDs (e.g., "4,11" for character)
@@ -1202,6 +1335,7 @@ class CustomWordsHandler:
        try:
            search_term = request.query.get("search", "")
            limit = int(request.query.get("limit", "20"))
+            offset = max(0, int(request.query.get("offset", "0")))
            category_param = request.query.get("category", "")
            enriched_param = request.query.get("enriched", "").lower() == "true"

@@ -1211,13 +1345,14 @@ class CustomWordsHandler:
                categories = self._parse_category_param(category_param)

            results = self._service.search_words(
-                search_term, limit, categories=categories, enriched=enriched_param
+                search_term,
+                limit,
+                offset=offset,
+                categories=categories,
+                enriched=enriched_param,
            )

-            return web.json_response({
-                "success": True,
-                "words": results
-            })
+            return web.json_response({"success": True, "words": results})
        except Exception as exc:
            logger.error("Error searching custom words: %s", exc, exc_info=True)
            return web.json_response({"error": str(exc)}, status=500)
@@ -1481,6 +1616,8 @@ class MiscHandlerSet:
        metadata_archive: MetadataArchiveHandler,
        filesystem: FileSystemHandler,
        custom_words: CustomWordsHandler,
+        supporters: SupportersHandler,
+        example_workflows: ExampleWorkflowsHandler,
    ) -> None:
        self.health = health
        self.settings = settings
@@ -1493,6 +1630,8 @@ class MiscHandlerSet:
        self.metadata_archive = metadata_archive
        self.filesystem = filesystem
        self.custom_words = custom_words
+        self.supporters = supporters
+        self.example_workflows = example_workflows

    def to_route_mapping(
        self,
@@ -1521,6 +1660,9 @@ class MiscHandlerSet:
            "open_file_location": self.filesystem.open_file_location,
            "open_settings_location": self.filesystem.open_settings_location,
            "search_custom_words": self.custom_words.search_custom_words,
+            "get_supporters": self.supporters.get_supporters,
+            "get_example_workflows": self.example_workflows.get_example_workflows,
+            "get_example_workflow": self.example_workflows.get_example_workflow,
        }


--- a/py/routes/handlers/model_handlers.py
+++ b/py/routes/handlers/model_handlers.py
@@ -66,6 +66,23 @@ class ModelPageView:
        self._logger = logger
        self._app_version = self._get_app_version()

+    def _load_supporters(self) -> dict:
+        """Load supporters data from JSON file."""
+        try:
+            current_file = os.path.abspath(__file__)
+            root_dir = os.path.dirname(
+                os.path.dirname(os.path.dirname(os.path.dirname(current_file)))
+            )
+            supporters_path = os.path.join(root_dir, "data", "supporters.json")
+
+            if os.path.exists(supporters_path):
+                with open(supporters_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+        except Exception as e:
+            self._logger.debug(f"Failed to load supporters data: {e}")
+
+        return {"specialThanks": [], "allSupporters": [], "totalCount": 0}
+
    def _get_app_version(self) -> str:
        version = "1.0.0"
        short_hash = "stable"
@@ -383,10 +400,34 @@ class ModelManagementHandler:
                return web.json_response(
                    {"success": False, "error": "Model not found in cache"}, status=404
                )
-            if not model_data.get("sha256"):
-                return web.json_response(
-                    {"success": False, "error": "No SHA256 hash found"}, status=400
-                )
+
+            # Check if hash needs to be calculated (lazy hash for checkpoints)
+            sha256 = model_data.get("sha256")
+            hash_status = model_data.get("hash_status", "completed")
+
+            if not sha256 or hash_status != "completed":
+                # For checkpoints, calculate hash on-demand
+                scanner = self._service.scanner
+                if hasattr(scanner, "calculate_hash_for_model"):
+                    self._logger.info(
+                        f"Lazy hash calculation triggered for {file_path}"
+                    )
+                    sha256 = await scanner.calculate_hash_for_model(file_path)
+                    if not sha256:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "Failed to calculate SHA256 hash",
+                            },
+                            status=500,
+                        )
+                    # Update model_data with new hash
+                    model_data["sha256"] = sha256
+                    model_data["hash_status"] = "completed"
+                else:
+                    return web.json_response(
+                        {"success": False, "error": "No SHA256 hash found"}, status=400
+                    )

            await MetadataManager.hydrate_model_data(model_data)

@@ -506,6 +547,153 @@ class ModelManagementHandler:
            self._logger.error("Error replacing preview: %s", exc, exc_info=True)
            return web.Response(text=str(exc), status=500)

+    async def set_preview_from_url(self, request: web.Request) -> web.Response:
+        """Set a preview image from a remote URL (e.g., CivitAI)."""
+        try:
+            from ...utils.civitai_utils import rewrite_preview_url
+            from ...services.downloader import get_downloader
+
+            data = await request.json()
+            model_path = data.get("model_path")
+            image_url = data.get("image_url")
+            nsfw_level = data.get("nsfw_level", 0)
+
+            if not model_path:
+                return web.json_response(
+                    {"success": False, "error": "Model path is required"}, status=400
+                )
+
+            if not image_url:
+                return web.json_response(
+                    {"success": False, "error": "Image URL is required"}, status=400
+                )
+
+            # Rewrite URL to use optimized rendition if it's a Civitai URL
+            optimized_url, was_rewritten = rewrite_preview_url(
+                image_url, media_type="image"
+            )
+            if was_rewritten and optimized_url:
+                self._logger.info(
+                    f"Rewritten preview URL to optimized version: {optimized_url}"
+                )
+            else:
+                optimized_url = image_url
+
+            # Download the image using the Downloader service
+            self._logger.info(
+                f"Downloading preview from {optimized_url} for {model_path}"
+            )
+            downloader = await get_downloader()
+            success, preview_data, headers = await downloader.download_to_memory(
+                optimized_url, use_auth=False, return_headers=True
+            )
+
+            if not success:
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": f"Failed to download image: {preview_data}",
+                    },
+                    status=502,
+                )
+
+            # preview_data is bytes when success is True
+            preview_bytes = (
+                preview_data
+                if isinstance(preview_data, bytes)
+                else preview_data.encode("utf-8")
+            )
+
+            # Determine content type from response headers
+            content_type = (
+                headers.get("Content-Type", "image/jpeg") if headers else "image/jpeg"
+            )
+
+            # Extract original filename from URL
+            original_filename = None
+            if "?" in image_url:
+                url_path = image_url.split("?")[0]
+            else:
+                url_path = image_url
+            original_filename = url_path.split("/")[-1] if "/" in url_path else None
+
+            result = await self._preview_service.replace_preview(
+                model_path=model_path,
+                preview_data=preview_data,
+                content_type=content_type,
+                original_filename=original_filename,
+                nsfw_level=nsfw_level,
+                update_preview_in_cache=self._service.scanner.update_preview_in_cache,
+                metadata_loader=self._metadata_sync.load_local_metadata,
+            )
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "preview_url": config.get_preview_static_url(
+                        result["preview_path"]
+                    ),
+                    "preview_nsfw_level": result["preview_nsfw_level"],
+                }
+            )
+        except Exception as exc:
+            self._logger.error("Error setting preview from URL: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+            if not image_url:
+                return web.json_response(
+                    {"success": False, "error": "Image URL is required"}, status=400
+                )
+
+            # Download the image from the remote URL
+            self._logger.info(f"Downloading preview from {image_url} for {model_path}")
+            async with aiohttp.ClientSession() as session:
+                async with session.get(image_url) as response:
+                    if response.status != 200:
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": f"Failed to download image: HTTP {response.status}",
+                            },
+                            status=502,
+                        )
+
+                    content_type = response.headers.get("Content-Type", "image/jpeg")
+                    preview_data = await response.read()
+
+                    # Extract original filename from URL
+                    original_filename = None
+                    if "?" in image_url:
+                        url_path = image_url.split("?")[0]
+                    else:
+                        url_path = image_url
+                    original_filename = (
+                        url_path.split("/")[-1] if "/" in url_path else None
+                    )
+
+            result = await self._preview_service.replace_preview(
+                model_path=model_path,
+                preview_data=preview_bytes,
+                content_type=content_type,
+                original_filename=original_filename,
+                nsfw_level=nsfw_level,
+                update_preview_in_cache=self._service.scanner.update_preview_in_cache,
+                metadata_loader=self._metadata_sync.load_local_metadata,
+            )
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "preview_url": config.get_preview_static_url(
+                        result["preview_path"]
+                    ),
+                    "preview_nsfw_level": result["preview_nsfw_level"],
+                }
+            )
+        except Exception as exc:
+            self._logger.error("Error setting preview from URL: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
    async def save_metadata(self, request: web.Request) -> web.Response:
        try:
            data = await request.json()
@@ -796,9 +984,7 @@ class ModelQueryHandler:
                # Format response
                group = {"hash": sha256, "models": []}
                for model in sorted_models:
-                    group["models"].append(
-                        await self._service.format_response(model)
-                    )
+                    group["models"].append(await self._service.format_response(model))

                # Only include groups with 2+ models after filtering
                if len(group["models"]) > 1:
@@ -827,7 +1013,9 @@ class ModelQueryHandler:
            "favorites_only": request.query.get("favorites_only", "").lower() == "true",
        }

-    def _apply_duplicate_filters(self, models: List[Dict[str, Any]], filters: Dict[str, Any]) -> List[Dict[str, Any]]:
+    def _apply_duplicate_filters(
+        self, models: List[Dict[str, Any]], filters: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
        """Apply filters to a list of models within a duplicate group."""
        result = models

@@ -868,7 +1056,9 @@ class ModelQueryHandler:

        return result

-    def _sort_duplicate_group(self, models: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _sort_duplicate_group(
+        self, models: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
        """Sort models: originals first (left), copies (with -????. pattern) last (right)."""
        if len(models) <= 1:
            return models
@@ -1078,8 +1268,11 @@ class ModelQueryHandler:
    async def get_relative_paths(self, request: web.Request) -> web.Response:
        try:
            search = request.query.get("search", "").strip()
-            limit = min(int(request.query.get("limit", "15")), 50)
-            matching_paths = await self._service.search_relative_paths(search, limit)
+            limit = min(int(request.query.get("limit", "15")), 100)
+            offset = max(0, int(request.query.get("offset", "0")))
+            matching_paths = await self._service.search_relative_paths(
+                search, limit, offset
+            )
            return web.json_response(
                {"success": True, "relative_paths": matching_paths}
            )
@@ -1153,10 +1346,13 @@ class ModelDownloadHandler:
                data["source"] = source
            if file_params_json:
                import json
+
                try:
                    data["file_params"] = json.loads(file_params_json)
                except json.JSONDecodeError:
-                    self._logger.warning("Invalid file_params JSON: %s", file_params_json)
+                    self._logger.warning(
+                        "Invalid file_params JSON: %s", file_params_json
+                    )

            loop = asyncio.get_event_loop()
            future = loop.create_future()
@@ -1887,7 +2083,8 @@ class ModelUpdateHandler:
        from dataclasses import replace

        new_record = replace(
-            record, versions=list(version_map.values()),
+            record,
+            versions=list(version_map.values()),
        )

        # Optionally persist to database for caching
@@ -2102,6 +2299,7 @@ class ModelUpdateHandler:
        if version.early_access_ends_at:
            try:
                from datetime import datetime, timezone
+
                ea_date = datetime.fromisoformat(
                    version.early_access_ends_at.replace("Z", "+00:00")
                )
@@ -2109,7 +2307,7 @@ class ModelUpdateHandler:
            except (ValueError, AttributeError):
                # If date parsing fails, treat as active EA (conservative)
                is_early_access = True
-        elif getattr(version, 'is_early_access', False):
+        elif getattr(version, "is_early_access", False):
            # Fallback to basic EA flag from bulk API
            is_early_access = True

@@ -2189,6 +2387,7 @@ class ModelHandlerSet:
            "fetch_all_civitai": self.civitai.fetch_all_civitai,
            "relink_civitai": self.management.relink_civitai,
            "replace_preview": self.management.replace_preview,
+            "set_preview_from_url": self.management.set_preview_from_url,
            "save_metadata": self.management.save_metadata,
            "add_tags": self.management.add_tags,
            "rename_model": self.management.rename_model,
--- a/py/routes/misc_route_registrar.py
+++ b/py/routes/misc_route_registrar.py
@@ -26,6 +26,7 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    RouteDefinition("GET", "/api/lm/settings/libraries", "get_settings_libraries"),
    RouteDefinition("POST", "/api/lm/settings/libraries/activate", "activate_library"),
    RouteDefinition("GET", "/api/lm/health-check", "health_check"),
+    RouteDefinition("GET", "/api/lm/supporters", "get_supporters"),
    RouteDefinition("POST", "/api/lm/open-file-location", "open_file_location"),
    RouteDefinition("POST", "/api/lm/update-usage-stats", "update_usage_stats"),
    RouteDefinition("GET", "/api/lm/get-usage-stats", "get_usage_stats"),
@@ -37,12 +38,24 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    RouteDefinition("GET", "/api/lm/get-registry", "get_registry"),
    RouteDefinition("GET", "/api/lm/check-model-exists", "check_model_exists"),
    RouteDefinition("GET", "/api/lm/civitai/user-models", "get_civitai_user_models"),
-    RouteDefinition("POST", "/api/lm/download-metadata-archive", "download_metadata_archive"),
-    RouteDefinition("POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"),
-    RouteDefinition("GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"),
-    RouteDefinition("GET", "/api/lm/model-versions-status", "get_model_versions_status"),
+    RouteDefinition(
+        "POST", "/api/lm/download-metadata-archive", "download_metadata_archive"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/remove-metadata-archive", "remove_metadata_archive"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/model-versions-status", "get_model_versions_status"
+    ),
    RouteDefinition("POST", "/api/lm/settings/open-location", "open_settings_location"),
    RouteDefinition("GET", "/api/lm/custom-words/search", "search_custom_words"),
+    RouteDefinition("GET", "/api/lm/example-workflows", "get_example_workflows"),
+    RouteDefinition(
+        "GET", "/api/lm/example-workflows/{filename}", "get_example_workflow"
+    ),
 )


@@ -66,7 +79,11 @@ class MiscRouteRegistrar:
        definitions: Iterable[RouteDefinition] = MISC_ROUTE_DEFINITIONS,
    ) -> None:
        for definition in definitions:
-            self._bind(definition.method, definition.path, handler_lookup[definition.handler_name])
+            self._bind(
+                definition.method,
+                definition.path,
+                handler_lookup[definition.handler_name],
+            )

    def _bind(self, method: str, path: str, handler: Callable) -> None:
        add_method_name = self._METHOD_MAP[method.upper()]
--- a/py/routes/misc_routes.py
+++ b/py/routes/misc_routes.py
@@ -19,6 +19,7 @@ from ..services.downloader import get_downloader
 from ..utils.usage_stats import UsageStats
 from .handlers.misc_handlers import (
    CustomWordsHandler,
+    ExampleWorkflowsHandler,
    FileSystemHandler,
    HealthCheckHandler,
    LoraCodeHandler,
@@ -29,6 +30,7 @@ from .handlers.misc_handlers import (
    NodeRegistry,
    NodeRegistryHandler,
    SettingsHandler,
+    SupportersHandler,
    TrainedWordsHandler,
    UsageStatsHandler,
    build_service_registry_adapter,
@@ -37,9 +39,10 @@ from .misc_route_registrar import MiscRouteRegistrar

 logger = logging.getLogger(__name__)

-standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get(
-    "HF_HUB_DISABLE_TELEMETRY", "0"
-) == "0"
+standalone_mode = (
+    os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"
+    or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
+)


 class MiscRoutes:
@@ -74,7 +77,9 @@ class MiscRoutes:
        self._node_registry = node_registry or NodeRegistry()
        self._standalone_mode = standalone_mode_flag

-        self._handler_mapping: Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None = None
+        self._handler_mapping: (
+            Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]] | None
+        ) = None

    @staticmethod
    def setup_routes(app: web.Application) -> None:
@@ -86,7 +91,9 @@ class MiscRoutes:
        registrar = self._registrar_factory(app)
        registrar.register_routes(self._ensure_handler_mapping())

-    def _ensure_handler_mapping(self) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
+    def _ensure_handler_mapping(
+        self,
+    ) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
        if self._handler_mapping is None:
            handler_set = self._create_handler_set()
            self._handler_mapping = handler_set.to_route_mapping()
@@ -119,6 +126,8 @@ class MiscRoutes:
            metadata_provider_factory=self._metadata_provider_factory,
        )
        custom_words = CustomWordsHandler()
+        supporters = SupportersHandler()
+        example_workflows = ExampleWorkflowsHandler()

        return self._handler_set_factory(
            health=health,
@@ -132,6 +141,8 @@ class MiscRoutes:
            metadata_archive=metadata_archive,
            filesystem=filesystem,
            custom_words=custom_words,
+            supporters=supporters,
+            example_workflows=example_workflows,
        )


--- a/py/routes/model_route_registrar.py
+++ b/py/routes/model_route_registrar.py
@@ -1,4 +1,5 @@
 """Route registrar for model endpoints."""
+
 from __future__ import annotations

 from dataclasses import dataclass
@@ -27,6 +28,9 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    RouteDefinition("POST", "/api/lm/{prefix}/fetch-all-civitai", "fetch_all_civitai"),
    RouteDefinition("POST", "/api/lm/{prefix}/relink-civitai", "relink_civitai"),
    RouteDefinition("POST", "/api/lm/{prefix}/replace-preview", "replace_preview"),
+    RouteDefinition(
+        "POST", "/api/lm/{prefix}/set-preview-from-url", "set_preview_from_url"
+    ),
    RouteDefinition("POST", "/api/lm/{prefix}/save-metadata", "save_metadata"),
    RouteDefinition("POST", "/api/lm/{prefix}/add-tags", "add_tags"),
    RouteDefinition("POST", "/api/lm/{prefix}/rename", "rename_model"),
@@ -36,7 +40,9 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    RouteDefinition("POST", "/api/lm/{prefix}/move_models_bulk", "move_models_bulk"),
    RouteDefinition("GET", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
    RouteDefinition("POST", "/api/lm/{prefix}/auto-organize", "auto_organize_models"),
-    RouteDefinition("GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/auto-organize-progress", "get_auto_organize_progress"
+    ),
    RouteDefinition("GET", "/api/lm/{prefix}/top-tags", "get_top_tags"),
    RouteDefinition("GET", "/api/lm/{prefix}/base-models", "get_base_models"),
    RouteDefinition("GET", "/api/lm/{prefix}/model-types", "get_model_types"),
@@ -44,30 +50,60 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    RouteDefinition("GET", "/api/lm/{prefix}/roots", "get_model_roots"),
    RouteDefinition("GET", "/api/lm/{prefix}/folders", "get_folders"),
    RouteDefinition("GET", "/api/lm/{prefix}/folder-tree", "get_folder_tree"),
-    RouteDefinition("GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/unified-folder-tree", "get_unified_folder_tree"
+    ),
    RouteDefinition("GET", "/api/lm/{prefix}/find-duplicates", "find_duplicate_models"),
-    RouteDefinition("GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/find-filename-conflicts", "find_filename_conflicts"
+    ),
    RouteDefinition("GET", "/api/lm/{prefix}/get-notes", "get_model_notes"),
    RouteDefinition("GET", "/api/lm/{prefix}/preview-url", "get_model_preview_url"),
    RouteDefinition("GET", "/api/lm/{prefix}/civitai-url", "get_model_civitai_url"),
    RouteDefinition("GET", "/api/lm/{prefix}/metadata", "get_model_metadata"),
-    RouteDefinition("GET", "/api/lm/{prefix}/model-description", "get_model_description"),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/model-description", "get_model_description"
+    ),
    RouteDefinition("GET", "/api/lm/{prefix}/relative-paths", "get_relative_paths"),
-    RouteDefinition("GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"),
-    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/version/{modelVersionId}", "get_civitai_model_by_version"),
-    RouteDefinition("GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"),
-    RouteDefinition("POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"),
-    RouteDefinition("POST", "/api/lm/{prefix}/updates/fetch-missing-license", "fetch_missing_civitai_license_data"),
-    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"),
-    RouteDefinition("POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"),
-    RouteDefinition("GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"),
-    RouteDefinition("GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/civitai/versions/{model_id}", "get_civitai_versions"
+    ),
+    RouteDefinition(
+        "GET",
+        "/api/lm/{prefix}/civitai/model/version/{modelVersionId}",
+        "get_civitai_model_by_version",
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/civitai/model/hash/{hash}", "get_civitai_model_by_hash"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/{prefix}/updates/refresh", "refresh_model_updates"
+    ),
+    RouteDefinition(
+        "POST",
+        "/api/lm/{prefix}/updates/fetch-missing-license",
+        "fetch_missing_civitai_license_data",
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/{prefix}/updates/ignore", "set_model_update_ignore"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/{prefix}/updates/ignore-version", "set_version_update_ignore"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/updates/status/{model_id}", "get_model_update_status"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/{prefix}/updates/versions/{model_id}", "get_model_versions"
+    ),
    RouteDefinition("POST", "/api/lm/download-model", "download_model"),
    RouteDefinition("GET", "/api/lm/download-model-get", "download_model_get"),
    RouteDefinition("GET", "/api/lm/cancel-download-get", "cancel_download_get"),
    RouteDefinition("GET", "/api/lm/pause-download", "pause_download_get"),
    RouteDefinition("GET", "/api/lm/resume-download", "resume_download_get"),
-    RouteDefinition("GET", "/api/lm/download-progress/{download_id}", "get_download_progress"),
+    RouteDefinition(
+        "GET", "/api/lm/download-progress/{download_id}", "get_download_progress"
+    ),
    RouteDefinition("POST", "/api/lm/{prefix}/cancel-task", "cancel_task"),
    RouteDefinition("GET", "/{prefix}", "handle_models_page"),
 )
@@ -94,12 +130,18 @@ class ModelRouteRegistrar:
        definitions: Iterable[RouteDefinition] = COMMON_ROUTE_DEFINITIONS,
    ) -> None:
        for definition in definitions:
-            self._bind_route(definition.method, definition.build_path(prefix), handler_lookup[definition.handler_name])
+            self._bind_route(
+                definition.method,
+                definition.build_path(prefix),
+                handler_lookup[definition.handler_name],
+            )

    def add_route(self, method: str, path: str, handler: Callable) -> None:
        self._bind_route(method, path, handler)

-    def add_prefixed_route(self, method: str, path_template: str, prefix: str, handler: Callable) -> None:
+    def add_prefixed_route(
+        self, method: str, path_template: str, prefix: str, handler: Callable
+    ) -> None:
        self._bind_route(method, path_template.replace("{prefix}", prefix), handler)

    def _bind_route(self, method: str, path: str, handler: Callable) -> None:
--- a/py/routes/stats_routes.py
+++ b/py/routes/stats_routes.py
@@ -209,6 +209,80 @@ class StatsRoutes:
                'error': str(e)
            }, status=500)

+    async def get_model_usage_list(self, request: web.Request) -> web.Response:
+        """Get paginated model usage list for infinite scrolling"""
+        try:
+            await self.init_services()
+            
+            model_type = request.query.get('type', 'lora')
+            sort_order = request.query.get('sort', 'desc')
+            
+            try:
+                limit = int(request.query.get('limit', '50'))
+                offset = int(request.query.get('offset', '0'))
+            except ValueError:
+                limit = 50
+                offset = 0
+
+            # Get usage statistics
+            usage_data = await self.usage_stats.get_stats()
+            
+            # Select proper cache and usage dict based on type
+            if model_type == 'lora':
+                cache = await self.lora_scanner.get_cached_data()
+                type_usage_data = usage_data.get('loras', {})
+            elif model_type == 'checkpoint':
+                cache = await self.checkpoint_scanner.get_cached_data()
+                type_usage_data = usage_data.get('checkpoints', {})
+            elif model_type == 'embedding':
+                cache = await self.embedding_scanner.get_cached_data()
+                type_usage_data = usage_data.get('embeddings', {})
+            else:
+                return web.json_response({'success': False, 'error': f"Invalid model type: {model_type}"}, status=400)
+
+            # Create list of all models
+            all_models = []
+            for item in cache.raw_data:
+                sha256 = item.get('sha256')
+                usage_info = type_usage_data.get(sha256, {}) if sha256 else {}
+                usage_count = usage_info.get('total', 0) if isinstance(usage_info, dict) else 0
+                
+                all_models.append({
+                    'name': item.get('model_name', 'Unknown'),
+                    'usage_count': usage_count,
+                    'base_model': item.get('base_model', 'Unknown'),
+                    'preview_url': config.get_preview_static_url(item.get('preview_url', '')),
+                    'folder': item.get('folder', '')
+                })
+
+            # Sort the models
+            reverse = (sort_order == 'desc')
+            all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()), reverse=reverse)
+            if not reverse:
+                # If asc, sort by usage_count ascending, but keep name ascending
+                all_models.sort(key=lambda x: (x['usage_count'], x['name'].lower()))
+            else:
+                all_models.sort(key=lambda x: (-x['usage_count'], x['name'].lower()))
+
+            # Slice for pagination
+            paginated_models = all_models[offset:offset + limit]
+
+            return web.json_response({
+                'success': True,
+                'data': {
+                    'items': paginated_models,
+                    'total': len(all_models),
+                    'type': model_type
+                }
+            })
+
+        except Exception as e:
+            logger.error(f"Error getting model usage list: {e}", exc_info=True)
+            return web.json_response({
+                'success': False,
+                'error': str(e)
+            }, status=500)
+
    async def get_base_model_distribution(self, request: web.Request) -> web.Response:
        """Get base model distribution statistics"""
        try:
@@ -530,6 +604,7 @@ class StatsRoutes:
        # Register API routes
        app.router.add_get('/api/lm/stats/collection-overview', self.get_collection_overview)
        app.router.add_get('/api/lm/stats/usage-analytics', self.get_usage_analytics)
+        app.router.add_get('/api/lm/stats/model-usage-list', self.get_model_usage_list)
        app.router.add_get('/api/lm/stats/base-model-distribution', self.get_base_model_distribution)
        app.router.add_get('/api/lm/stats/tag-analytics', self.get_tag_analytics)
        app.router.add_get('/api/lm/stats/storage-analytics', self.get_storage_analytics)
--- a/py/services/base_model_service.py
+++ b/py/services/base_model_service.py
@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 import asyncio
+import re
 from typing import Any, Dict, List, Optional, Type, TYPE_CHECKING
 import logging
 import os
@@ -383,7 +384,9 @@ class BaseModelService(ABC):
        # Check user setting for hiding early access updates
        hide_early_access = False
        try:
-            hide_early_access = bool(self.settings.get("hide_early_access_updates", False))
+            hide_early_access = bool(
+                self.settings.get("hide_early_access_updates", False)
+            )
        except Exception:
            hide_early_access = False

@@ -413,7 +416,11 @@ class BaseModelService(ABC):
            bulk_method = getattr(self.update_service, "has_updates_bulk", None)
            if callable(bulk_method):
                try:
-                    resolved = await bulk_method(self.model_type, ordered_ids, hide_early_access=hide_early_access)
+                    resolved = await bulk_method(
+                        self.model_type,
+                        ordered_ids,
+                        hide_early_access=hide_early_access,
+                    )
                except Exception as exc:
                    logger.error(
                        "Failed to resolve update status in bulk for %s models (%s): %s",
@@ -426,7 +433,9 @@ class BaseModelService(ABC):

        if resolved is None:
            tasks = [
-                self.update_service.has_update(self.model_type, model_id, hide_early_access=hide_early_access)
+                self.update_service.has_update(
+                    self.model_type, model_id, hide_early_access=hide_early_access
+                )
                for model_id in ordered_ids
            ]
            results = await asyncio.gather(*tasks, return_exceptions=True)
@@ -588,13 +597,19 @@ class BaseModelService(ABC):
            normalized_type = normalize_sub_type(resolve_sub_type(entry))
            if not normalized_type:
                continue
-            
+
            # Filter by valid sub-types based on scanner type
-            if self.model_type == "lora" and normalized_type not in VALID_LORA_SUB_TYPES:
+            if (
+                self.model_type == "lora"
+                and normalized_type not in VALID_LORA_SUB_TYPES
+            ):
                continue
-            if self.model_type == "checkpoint" and normalized_type not in VALID_CHECKPOINT_SUB_TYPES:
+            if (
+                self.model_type == "checkpoint"
+                and normalized_type not in VALID_CHECKPOINT_SUB_TYPES
+            ):
                continue
-            
+
            type_counts[normalized_type] = type_counts.get(normalized_type, 0) + 1

        sorted_types = sorted(
@@ -807,38 +822,61 @@ class BaseModelService(ABC):

        return include_terms, exclude_terms

+    @staticmethod
+    def _remove_model_extension(path: str) -> str:
+        """Remove model file extension (.safetensors, .ckpt, .pt, .bin) for cleaner matching."""
+        return re.sub(r"\.(safetensors|ckpt|pt|bin)$", "", path, flags=re.IGNORECASE)
+
    @staticmethod
    def _relative_path_matches_tokens(
        path_lower: str, include_terms: List[str], exclude_terms: List[str]
    ) -> bool:
-        """Determine whether a relative path string satisfies include/exclude tokens."""
-        if any(term and term in path_lower for term in exclude_terms):
+        """Determine whether a relative path string satisfies include/exclude tokens.
+
+        Matches against the path without extension to avoid matching .safetensors
+        when searching for 's'.
+        """
+        # Use path without extension for matching
+        path_for_matching = BaseModelService._remove_model_extension(path_lower)
+
+        if any(term and term in path_for_matching for term in exclude_terms):
            return False

        for term in include_terms:
-            if term and term not in path_lower:
+            if term and term not in path_for_matching:
                return False

        return True

    @staticmethod
    def _relative_path_sort_key(relative_path: str, include_terms: List[str]) -> tuple:
-        """Sort paths by how well they satisfy the include tokens."""
-        path_lower = relative_path.lower()
+        """Sort paths by how well they satisfy the include tokens.
+
+        Sorts based on path without extension for consistent ordering.
+        """
+        # Use path without extension for sorting
+        path_for_sorting = BaseModelService._remove_model_extension(
+            relative_path.lower()
+        )
        prefix_hits = sum(
-            1 for term in include_terms if term and path_lower.startswith(term)
+            1 for term in include_terms if term and path_for_sorting.startswith(term)
        )
        match_positions = [
-            path_lower.find(term)
+            path_for_sorting.find(term)
            for term in include_terms
-            if term and term in path_lower
+            if term and term in path_for_sorting
        ]
        first_match_index = min(match_positions) if match_positions else 0

-        return (-prefix_hits, first_match_index, len(relative_path), path_lower)
+        return (
+            -prefix_hits,
+            first_match_index,
+            len(path_for_sorting),
+            path_for_sorting,
+        )

    async def search_relative_paths(
-        self, search_term: str, limit: int = 15
+        self, search_term: str, limit: int = 15, offset: int = 0
    ) -> List[str]:
        """Search model relative file paths for autocomplete functionality"""
        cache = await self.scanner.get_cached_data()
@@ -849,6 +887,7 @@ class BaseModelService(ABC):
        # Get model roots for path calculation
        model_roots = self.scanner.get_model_roots()

+        # Collect all matching paths first (needed for proper sorting and offset)
        for model in cache.raw_data:
            file_path = model.get("file_path", "")
            if not file_path:
@@ -877,12 +916,12 @@ class BaseModelService(ABC):
            ):
                matching_paths.append(relative_path)

-                if len(matching_paths) >= limit * 2:  # Get more for better sorting
-                    break
-
        # Sort by relevance (prefix and earliest hits first, then by length and alphabetically)
        matching_paths.sort(
            key=lambda relative: self._relative_path_sort_key(relative, include_terms)
        )

-        return matching_paths[:limit]
+        # Apply offset and limit
+        start = min(offset, len(matching_paths))
+        end = min(start + limit, len(matching_paths))
+        return matching_paths[start:end]
--- a/py/services/cache_entry_validator.py
+++ b/py/services/cache_entry_validator.py
@@ -125,16 +125,20 @@ class CacheEntryValidator:
            )

        # Special validation: sha256 must not be empty for required field
+        # BUT allow empty sha256 when hash_status is pending (lazy hash calculation)
        sha256 = working_entry.get('sha256', '')
+        hash_status = working_entry.get('hash_status', 'completed')
        if not sha256 or (isinstance(sha256, str) and not sha256.strip()):
-            errors.append("Required field 'sha256' is empty")
-            # Cannot repair empty sha256 - entry is invalid
-            return ValidationResult(
-                is_valid=False,
-                repaired=repaired,
-                errors=errors,
-                entry=working_entry if auto_repair else None
-            )
+            # Allow empty sha256 for lazy hash calculation (checkpoints)
+            if hash_status != 'pending':
+                errors.append("Required field 'sha256' is empty")
+                # Cannot repair empty sha256 - entry is invalid
+                return ValidationResult(
+                    is_valid=False,
+                    repaired=repaired,
+                    errors=errors,
+                    entry=working_entry if auto_repair else None
+                )

        # Normalize sha256 to lowercase if needed
        if isinstance(sha256, str):
--- a/py/services/checkpoint_scanner.py
+++ b/py/services/checkpoint_scanner.py
@@ -1,7 +1,12 @@
+import json
 import logging
+import os
+from datetime import datetime
 from typing import Any, Dict, List, Optional

 from ..utils.models import CheckpointMetadata
+from ..utils.file_utils import find_preview_file, normalize_path
+from ..utils.metadata_manager import MetadataManager
 from ..config import config
 from .model_scanner import ModelScanner
 from .model_hash_index import ModelHashIndex
@@ -21,6 +26,216 @@ class CheckpointScanner(ModelScanner):
            hash_index=ModelHashIndex()
        )

+    async def _create_default_metadata(self, file_path: str) -> Optional[CheckpointMetadata]:
+        """Create default metadata for checkpoint without calculating hash (lazy hash).
+        
+        Checkpoints are typically large (10GB+), so we skip hash calculation during initial
+        scanning to improve startup performance. Hash will be calculated on-demand when
+        fetching metadata from Civitai.
+        """
+        try:
+            real_path = os.path.realpath(file_path)
+            if not os.path.exists(real_path):
+                logger.error(f"File not found: {file_path}")
+                return None
+            
+            base_name = os.path.splitext(os.path.basename(file_path))[0]
+            dir_path = os.path.dirname(file_path)
+            
+            # Find preview image
+            preview_url = find_preview_file(base_name, dir_path)
+            
+            # Create metadata WITHOUT calculating hash
+            metadata = CheckpointMetadata(
+                file_name=base_name,
+                model_name=base_name,
+                file_path=normalize_path(file_path),
+                size=os.path.getsize(real_path),
+                modified=datetime.now().timestamp(),
+                sha256="",  # Empty hash - will be calculated on-demand
+                base_model="Unknown",
+                preview_url=normalize_path(preview_url),
+                tags=[],
+                modelDescription="",
+                sub_type="checkpoint",
+                from_civitai=False,  # Mark as local model since no hash yet
+                hash_status="pending"  # Mark hash as pending
+            )
+            
+            # Save the created metadata
+            logger.info(f"Creating checkpoint metadata (hash pending) for {file_path}")
+            await MetadataManager.save_metadata(file_path, metadata)
+            
+            return metadata
+            
+        except Exception as e:
+            logger.error(f"Error creating default checkpoint metadata for {file_path}: {e}")
+            return None
+
+    async def calculate_hash_for_model(self, file_path: str) -> Optional[str]:
+        """Calculate hash for a checkpoint on-demand.
+        
+        Args:
+            file_path: Path to the model file
+            
+        Returns:
+            SHA256 hash string, or None if calculation failed
+        """
+        from ..utils.file_utils import calculate_sha256
+        
+        try:
+            real_path = os.path.realpath(file_path)
+            if not os.path.exists(real_path):
+                logger.error(f"File not found for hash calculation: {file_path}")
+                return None
+            
+            # Load current metadata
+            metadata, _ = await MetadataManager.load_metadata(file_path, self.model_class)
+            if metadata is None:
+                logger.error(f"No metadata found for {file_path}")
+                return None
+            
+            # Check if hash is already calculated
+            if metadata.hash_status == "completed" and metadata.sha256:
+                return metadata.sha256
+            
+            # Update status to calculating
+            metadata.hash_status = "calculating"
+            await MetadataManager.save_metadata(file_path, metadata)
+            
+            # Calculate hash
+            logger.info(f"Calculating hash for checkpoint: {file_path}")
+            sha256 = await calculate_sha256(real_path)
+            
+            # Update metadata with hash
+            metadata.sha256 = sha256
+            metadata.hash_status = "completed"
+            await MetadataManager.save_metadata(file_path, metadata)
+            
+            # Update hash index
+            self._hash_index.add_entry(sha256.lower(), file_path)
+            
+            logger.info(f"Hash calculated for checkpoint: {file_path}")
+            return sha256
+            
+        except Exception as e:
+            logger.error(f"Error calculating hash for {file_path}: {e}")
+            # Update status to failed
+            try:
+                metadata, _ = await MetadataManager.load_metadata(file_path, self.model_class)
+                if metadata:
+                    metadata.hash_status = "failed"
+                    await MetadataManager.save_metadata(file_path, metadata)
+            except Exception:
+                pass
+            return None
+
+    async def calculate_all_pending_hashes(self, progress_callback=None) -> Dict[str, int]:
+        """Calculate hashes for all checkpoints with pending hash status.
+        
+        If cache is not initialized, scans filesystem directly for metadata files
+        with hash_status != 'completed'.
+        
+        Args:
+            progress_callback: Optional callback(progress, total, current_file)
+            
+        Returns:
+            Dict with 'completed', 'failed', 'total' counts
+        """
+        # Try to get from cache first
+        cache = await self.get_cached_data()
+        
+        if cache and cache.raw_data:
+            # Use cache if available
+            pending_models = [
+                item for item in cache.raw_data 
+                if item.get('hash_status') != 'completed' or not item.get('sha256')
+            ]
+        else:
+            # Cache not initialized, scan filesystem directly
+            pending_models = await self._find_pending_models_from_filesystem()
+        
+        if not pending_models:
+            return {'completed': 0, 'failed': 0, 'total': 0}
+        
+        total = len(pending_models)
+        completed = 0
+        failed = 0
+        
+        for i, model_data in enumerate(pending_models):
+            file_path = model_data.get('file_path')
+            if not file_path:
+                continue
+            
+            try:
+                sha256 = await self.calculate_hash_for_model(file_path)
+                if sha256:
+                    completed += 1
+                else:
+                    failed += 1
+            except Exception as e:
+                logger.error(f"Error calculating hash for {file_path}: {e}")
+                failed += 1
+            
+            if progress_callback:
+                try:
+                    await progress_callback(i + 1, total, file_path)
+                except Exception:
+                    pass
+        
+        return {
+            'completed': completed,
+            'failed': failed,
+            'total': total
+        }
+    
+    async def _find_pending_models_from_filesystem(self) -> List[Dict[str, Any]]:
+        """Scan filesystem for checkpoint metadata files with pending hash status."""
+        pending_models = []
+        
+        for root_path in self.get_model_roots():
+            if not os.path.exists(root_path):
+                continue
+            
+            for dirpath, _dirnames, filenames in os.walk(root_path):
+                for filename in filenames:
+                    if not filename.endswith('.metadata.json'):
+                        continue
+                    
+                    metadata_path = os.path.join(dirpath, filename)
+                    try:
+                        with open(metadata_path, 'r', encoding='utf-8') as f:
+                            data = json.load(f)
+                        
+                        # Check if hash is pending
+                        hash_status = data.get('hash_status', 'completed')
+                        sha256 = data.get('sha256', '')
+                        
+                        if hash_status != 'completed' or not sha256:
+                            # Find corresponding model file
+                            model_name = filename.replace('.metadata.json', '')
+                            model_path = None
+                            
+                            # Look for model file with matching name
+                            for ext in self.file_extensions:
+                                potential_path = os.path.join(dirpath, model_name + ext)
+                                if os.path.exists(potential_path):
+                                    model_path = potential_path
+                                    break
+                            
+                            if model_path:
+                                pending_models.append({
+                                    'file_path': model_path.replace(os.sep, '/'),
+                                    'hash_status': hash_status,
+                                    'sha256': sha256,
+                                    **{k: v for k, v in data.items() if k not in ['file_path', 'hash_status', 'sha256']}
+                                })
+                    except (json.JSONDecodeError, Exception) as e:
+                        logger.debug(f"Error reading metadata file {metadata_path}: {e}")
+                        continue
+        
+        return pending_models
+
    def _resolve_sub_type(self, root_path: Optional[str]) -> Optional[str]:
        """Resolve the sub-type based on the root path."""
        if not root_path:
@@ -51,5 +266,16 @@ class CheckpointScanner(ModelScanner):
        return entry

    def get_model_roots(self) -> List[str]:
-        """Get checkpoint root directories"""
-        return config.base_models_roots
+        """Get checkpoint root directories (including extra paths)"""
+        roots: List[str] = []
+        roots.extend(config.base_models_roots or [])
+        roots.extend(config.extra_checkpoints_roots or [])
+        roots.extend(config.extra_unet_roots or [])
+        # Remove duplicates while preserving order
+        seen: set = set()
+        unique_roots: List[str] = []
+        for root in roots:
+            if root not in seen:
+                seen.add(root)
+                unique_roots.append(root)
+        return unique_roots
--- a/py/services/civitai_client.py
+++ b/py/services/civitai_client.py
@@ -3,36 +3,42 @@ import copy
 import logging
 import os
 from typing import Any, Optional, Dict, Tuple, List, Sequence
-from .model_metadata_provider import CivitaiModelMetadataProvider, ModelMetadataProviderManager
+from .model_metadata_provider import (
+    CivitaiModelMetadataProvider,
+    ModelMetadataProviderManager,
+)
 from .downloader import get_downloader
 from .errors import RateLimitError, ResourceNotFoundError
 from ..utils.civitai_utils import resolve_license_payload

 logger = logging.getLogger(__name__)

+
 class CivitaiClient:
    _instance = None
    _lock = asyncio.Lock()
-    
+
    @classmethod
    async def get_instance(cls):
        """Get singleton instance of CivitaiClient"""
        async with cls._lock:
            if cls._instance is None:
                cls._instance = cls()
-                
+
                # Register this client as a metadata provider
                provider_manager = await ModelMetadataProviderManager.get_instance()
-                provider_manager.register_provider('civitai', CivitaiModelMetadataProvider(cls._instance), True)
-                
+                provider_manager.register_provider(
+                    "civitai", CivitaiModelMetadataProvider(cls._instance), True
+                )
+
            return cls._instance

    def __init__(self):
        # Check if already initialized for singleton pattern
-        if hasattr(self, '_initialized'):
+        if hasattr(self, "_initialized"):
            return
        self._initialized = True
-        
+
        self.base_url = "https://civitai.com/api/v1"

    async def _make_request(
@@ -75,8 +81,10 @@ class CivitaiClient:
            meta = image.get("meta")
            if isinstance(meta, dict) and "comfy" in meta:
                meta.pop("comfy", None)
-    
-    async def download_file(self, url: str, save_dir: str, default_filename: str, progress_callback=None) -> Tuple[bool, str]:
+
+    async def download_file(
+        self, url: str, save_dir: str, default_filename: str, progress_callback=None
+    ) -> Tuple[bool, str]:
        """Download file with resumable downloads and retry mechanism

        Args:
@@ -90,41 +98,48 @@ class CivitaiClient:
        """
        downloader = await get_downloader()
        save_path = os.path.join(save_dir, default_filename)
-        
+
        # Use unified downloader with CivitAI authentication
        success, result = await downloader.download_file(
            url=url,
            save_path=save_path,
            progress_callback=progress_callback,
            use_auth=True,  # Enable CivitAI authentication
-            allow_resume=True
+            allow_resume=True,
        )
-        
+
        return success, result

-    async def get_model_by_hash(self, model_hash: str) -> Tuple[Optional[Dict], Optional[str]]:
+    async def get_model_by_hash(
+        self, model_hash: str
+    ) -> Tuple[Optional[Dict], Optional[str]]:
        try:
            success, version = await self._make_request(
-                'GET',
+                "GET",
                f"{self.base_url}/model-versions/by-hash/{model_hash}",
-                use_auth=True
+                use_auth=True,
            )
            if not success:
                message = str(version)
                if "not found" in message.lower():
                    return None, "Model not found"

-                logger.error("Failed to fetch model info for %s: %s", model_hash[:10], message)
+                logger.error(
+                    "Failed to fetch model info for %s: %s", model_hash[:10], message
+                )
                return None, message

-            model_id = version.get('modelId')
-            if model_id:
-                model_data = await self._fetch_model_data(model_id)
-                if model_data:
-                    self._enrich_version_with_model_data(version, model_data)
+            if isinstance(version, dict):
+                model_id = version.get("modelId")
+                if model_id:
+                    model_data = await self._fetch_model_data(model_id)
+                    if model_data:
+                        self._enrich_version_with_model_data(version, model_data)

-            self._remove_comfy_metadata(version)
-            return version, None
+                self._remove_comfy_metadata(version)
+                return version, None
+            else:
+                return None, "Invalid response format"
        except RateLimitError:
            raise
        except Exception as exc:
@@ -136,19 +151,19 @@ class CivitaiClient:
            downloader = await get_downloader()
            success, content, headers = await downloader.download_to_memory(
                image_url,
-                use_auth=False  # Preview images don't need auth
+                use_auth=False,  # Preview images don't need auth
            )
            if success:
                # Ensure directory exists
                os.makedirs(os.path.dirname(save_path), exist_ok=True)
-                with open(save_path, 'wb') as f:
+                with open(save_path, "wb") as f:
                    f.write(content)
                return True
            return False
        except Exception as e:
            logger.error(f"Download Error: {str(e)}")
            return False
-            
+
    @staticmethod
    def _extract_error_message(payload: Any) -> str:
        """Return a human-readable error message from an API payload."""
@@ -175,19 +190,17 @@ class CivitaiClient:
        """Get all versions of a model with local availability info"""
        try:
            success, result = await self._make_request(
-                'GET',
-                f"{self.base_url}/models/{model_id}",
-                use_auth=True
+                "GET", f"{self.base_url}/models/{model_id}", use_auth=True
            )
            if success:
                # Also return model type along with versions
                return {
-                    'modelVersions': result.get('modelVersions', []),
-                    'type': result.get('type', ''),
-                    'name': result.get('name', '')
+                    "modelVersions": result.get("modelVersions", []),
+                    "type": result.get("type", ""),
+                    "name": result.get("name", ""),
                }
            message = self._extract_error_message(result)
-            if message and 'not found' in message.lower():
+            if message and "not found" in message.lower():
                raise ResourceNotFoundError(f"Resource not found for model {model_id}")
            if message:
                raise RuntimeError(message)
@@ -221,15 +234,15 @@ class CivitaiClient:
        try:
            query = ",".join(normalized_ids)
            success, result = await self._make_request(
-                'GET',
+                "GET",
                f"{self.base_url}/models",
                use_auth=True,
-                params={'ids': query},
+                params={"ids": query},
            )
            if not success:
                return None

-            items = result.get('items') if isinstance(result, dict) else None
+            items = result.get("items") if isinstance(result, dict) else None
            if not isinstance(items, list):
                return {}

@@ -237,19 +250,19 @@ class CivitaiClient:
            for item in items:
                if not isinstance(item, dict):
                    continue
-                model_id = item.get('id')
+                model_id = item.get("id")
                try:
                    normalized_id = int(model_id)
                except (TypeError, ValueError):
                    continue
                payload[normalized_id] = {
-                    'modelVersions': item.get('modelVersions', []),
-                    'type': item.get('type', ''),
-                    'name': item.get('name', ''),
-                    'allowNoCredit': item.get('allowNoCredit'),
-                    'allowCommercialUse': item.get('allowCommercialUse'),
-                    'allowDerivatives': item.get('allowDerivatives'),
-                    'allowDifferentLicense': item.get('allowDifferentLicense'),
+                    "modelVersions": item.get("modelVersions", []),
+                    "type": item.get("type", ""),
+                    "name": item.get("name", ""),
+                    "allowNoCredit": item.get("allowNoCredit"),
+                    "allowCommercialUse": item.get("allowCommercialUse"),
+                    "allowDerivatives": item.get("allowDerivatives"),
+                    "allowDifferentLicense": item.get("allowDifferentLicense"),
                }
            return payload
        except RateLimitError:
@@ -257,8 +270,10 @@ class CivitaiClient:
        except Exception as exc:
            logger.error(f"Error fetching model versions in bulk: {exc}")
            return None
-            
-    async def get_model_version(self, model_id: int = None, version_id: int = None) -> Optional[Dict]:
+
+    async def get_model_version(
+        self, model_id: int = None, version_id: int = None
+    ) -> Optional[Dict]:
        """Get specific model version with additional metadata."""
        try:
            if model_id is None and version_id is not None:
@@ -281,7 +296,7 @@ class CivitaiClient:
        if version is None:
            return None

-        model_id = version.get('modelId')
+        model_id = version.get("modelId")
        if not model_id:
            logger.error(f"No modelId found in version {version_id}")
            return None
@@ -293,7 +308,9 @@ class CivitaiClient:
        self._remove_comfy_metadata(version)
        return version

-    async def _get_version_with_model_id(self, model_id: int, version_id: Optional[int]) -> Optional[Dict]:
+    async def _get_version_with_model_id(
+        self, model_id: int, version_id: Optional[int]
+    ) -> Optional[Dict]:
        model_data = await self._fetch_model_data(model_id)
        if not model_data:
            return None
@@ -302,8 +319,12 @@ class CivitaiClient:
        if target_version is None:
            return None

-        target_version_id = target_version.get('id')
-        version = await self._fetch_version_by_id(target_version_id) if target_version_id else None
+        target_version_id = target_version.get("id")
+        version = (
+            await self._fetch_version_by_id(target_version_id)
+            if target_version_id
+            else None
+        )

        if version is None:
            model_hash = self._extract_primary_model_hash(target_version)
@@ -315,7 +336,9 @@ class CivitaiClient:
                )

        if version is None:
-            version = self._build_version_from_model_data(target_version, model_id, model_data)
+            version = self._build_version_from_model_data(
+                target_version, model_id, model_data
+            )

        self._enrich_version_with_model_data(version, model_data)
        self._remove_comfy_metadata(version)
@@ -323,9 +346,7 @@ class CivitaiClient:

    async def _fetch_model_data(self, model_id: int) -> Optional[Dict]:
        success, data = await self._make_request(
-            'GET',
-            f"{self.base_url}/models/{model_id}",
-            use_auth=True
+            "GET", f"{self.base_url}/models/{model_id}", use_auth=True
        )
        if success:
            return data
@@ -337,9 +358,7 @@ class CivitaiClient:
            return None

        success, version = await self._make_request(
-            'GET',
-            f"{self.base_url}/model-versions/{version_id}",
-            use_auth=True
+            "GET", f"{self.base_url}/model-versions/{version_id}", use_auth=True
        )
        if success:
            return version
@@ -352,9 +371,7 @@ class CivitaiClient:
            return None

        success, version = await self._make_request(
-            'GET',
-            f"{self.base_url}/model-versions/by-hash/{model_hash}",
-            use_auth=True
+            "GET", f"{self.base_url}/model-versions/by-hash/{model_hash}", use_auth=True
        )
        if success:
            return version
@@ -362,16 +379,17 @@ class CivitaiClient:
        logger.warning(f"Failed to fetch version by hash {model_hash}")
        return None

-    def _select_target_version(self, model_data: Dict, model_id: int, version_id: Optional[int]) -> Optional[Dict]:
-        model_versions = model_data.get('modelVersions', [])
+    def _select_target_version(
+        self, model_data: Dict, model_id: int, version_id: Optional[int]
+    ) -> Optional[Dict]:
+        model_versions = model_data.get("modelVersions", [])
        if not model_versions:
            logger.warning(f"No model versions found for model {model_id}")
            return None

        if version_id is not None:
            target_version = next(
-                (item for item in model_versions if item.get('id') == version_id),
-                None
+                (item for item in model_versions if item.get("id") == version_id), None
            )
            if target_version is None:
                logger.warning(
@@ -383,46 +401,50 @@ class CivitaiClient:
        return model_versions[0]

    def _extract_primary_model_hash(self, version_entry: Dict) -> Optional[str]:
-        for file_info in version_entry.get('files', []):
-            if file_info.get('type') == 'Model' and file_info.get('primary'):
-                hashes = file_info.get('hashes', {})
-                model_hash = hashes.get('SHA256')
+        for file_info in version_entry.get("files", []):
+            if file_info.get("type") == "Model" and file_info.get("primary"):
+                hashes = file_info.get("hashes", {})
+                model_hash = hashes.get("SHA256")
                if model_hash:
                    return model_hash
        return None

-    def _build_version_from_model_data(self, version_entry: Dict, model_id: int, model_data: Dict) -> Dict:
+    def _build_version_from_model_data(
+        self, version_entry: Dict, model_id: int, model_data: Dict
+    ) -> Dict:
        version = copy.deepcopy(version_entry)
-        version.pop('index', None)
-        version['modelId'] = model_id
-        version['model'] = {
-            'name': model_data.get('name'),
-            'type': model_data.get('type'),
-            'nsfw': model_data.get('nsfw'),
-            'poi': model_data.get('poi')
+        version.pop("index", None)
+        version["modelId"] = model_id
+        version["model"] = {
+            "name": model_data.get("name"),
+            "type": model_data.get("type"),
+            "nsfw": model_data.get("nsfw"),
+            "poi": model_data.get("poi"),
        }
        return version

    def _enrich_version_with_model_data(self, version: Dict, model_data: Dict) -> None:
-        model_info = version.get('model')
+        model_info = version.get("model")
        if not isinstance(model_info, dict):
            model_info = {}
-            version['model'] = model_info
+            version["model"] = model_info

-        model_info['description'] = model_data.get("description")
-        model_info['tags'] = model_data.get("tags", [])
-        version['creator'] = model_data.get("creator")
+        model_info["description"] = model_data.get("description")
+        model_info["tags"] = model_data.get("tags", [])
+        version["creator"] = model_data.get("creator")

        license_payload = resolve_license_payload(model_data)
        for field, value in license_payload.items():
            model_info[field] = value

-    async def get_model_version_info(self, version_id: str) -> Tuple[Optional[Dict], Optional[str]]:
+    async def get_model_version_info(
+        self, version_id: str
+    ) -> Tuple[Optional[Dict], Optional[str]]:
        """Fetch model version metadata from Civitai
-        
+
        Args:
            version_id: The Civitai model version ID
-            
+
        Returns:
            Tuple[Optional[Dict], Optional[str]]: A tuple containing:
                - The model version data or None if not found
@@ -430,25 +452,23 @@ class CivitaiClient:
        """
        try:
            url = f"{self.base_url}/model-versions/{version_id}"
-            
+
            logger.debug(f"Resolving DNS for model version info: {url}")
-            success, result = await self._make_request(
-                'GET',
-                url,
-                use_auth=True
-            )
-            
+            success, result = await self._make_request("GET", url, use_auth=True)
+
            if success:
-                logger.debug(f"Successfully fetched model version info for: {version_id}")
+                logger.debug(
+                    f"Successfully fetched model version info for: {version_id}"
+                )
                self._remove_comfy_metadata(result)
                return result, None
-            
+
            # Handle specific error cases
            if "not found" in str(result):
                error_msg = f"Model not found"
                logger.warning(f"Model version not found: {version_id} - {error_msg}")
                return None, error_msg
-            
+
            # Other error cases
            logger.error(f"Failed to fetch model info for {version_id}: {result}")
            return None, str(result)
@@ -464,27 +484,23 @@ class CivitaiClient:

        Args:
            image_id: The Civitai image ID
-            
+
        Returns:
            Optional[Dict]: The image data or None if not found
        """
        try:
            url = f"{self.base_url}/images?imageId={image_id}&nsfw=X"
-            
+
            logger.debug(f"Fetching image info for ID: {image_id}")
-            success, result = await self._make_request(
-                'GET',
-                url,
-                use_auth=True
-            )
-            
+            success, result = await self._make_request("GET", url, use_auth=True)
+
            if success:
                if result and "items" in result and len(result["items"]) > 0:
                    logger.debug(f"Successfully fetched image info for ID: {image_id}")
                    return result["items"][0]
                logger.warning(f"No image found with ID: {image_id}")
                return None
-            
+
            logger.error(f"Failed to fetch image info for ID: {image_id}: {result}")
            return None
        except RateLimitError:
@@ -501,11 +517,7 @@ class CivitaiClient:

        try:
            url = f"{self.base_url}/models?username={username}"
-            success, result = await self._make_request(
-                'GET',
-                url,
-                use_auth=True
-            )
+            success, result = await self._make_request("GET", url, use_auth=True)

            if not success:
                logger.error("Failed to fetch models for %s: %s", username, result)
--- a/py/services/custom_words_service.py
+++ b/py/services/custom_words_service.py
@@ -49,6 +49,7 @@ class CustomWordsService:
        if self._tag_index is None:
            try:
                from .tag_fts_index import get_tag_fts_index
+
                self._tag_index = get_tag_fts_index()
            except Exception as e:
                logger.warning(f"Failed to initialize TagFTSIndex: {e}")
@@ -59,14 +60,16 @@ class CustomWordsService:
        self,
        search_term: str,
        limit: int = 20,
+        offset: int = 0,
        categories: Optional[List[int]] = None,
-        enriched: bool = False
+        enriched: bool = False,
    ) -> List[Dict[str, Any]]:
        """Search tags using TagFTSIndex with category filtering.

        Args:
            search_term: The search term to match against.
            limit: Maximum number of results to return.
+            offset: Number of results to skip.
            categories: Optional list of category IDs to filter by.
            enriched: If True, always return enriched results with category
                       and post_count (default behavior now).
@@ -76,7 +79,9 @@ class CustomWordsService:
        """
        tag_index = self._get_tag_index()
        if tag_index is not None:
-            results = tag_index.search(search_term, categories=categories, limit=limit)
+            results = tag_index.search(
+                search_term, categories=categories, limit=limit, offset=offset
+            )
            return results

        logger.debug("TagFTSIndex not available, returning empty results")
--- a/py/services/embedding_scanner.py
+++ b/py/services/embedding_scanner.py
@@ -22,5 +22,15 @@ class EmbeddingScanner(ModelScanner):
        )

    def get_model_roots(self) -> List[str]:
-        """Get embedding root directories"""
-        return config.embeddings_roots
+        """Get embedding root directories (including extra paths)"""
+        roots: List[str] = []
+        roots.extend(config.embeddings_roots or [])
+        roots.extend(config.extra_embeddings_roots or [])
+        # Remove duplicates while preserving order
+        seen: set = set()
+        unique_roots: List[str] = []
+        for root in roots:
+            if root and root not in seen:
+                seen.add(root)
+                unique_roots.append(root)
+        return unique_roots
--- a/py/services/lora_scanner.py
+++ b/py/services/lora_scanner.py
@@ -25,8 +25,18 @@ class LoraScanner(ModelScanner):
        )
    
    def get_model_roots(self) -> List[str]:
-        """Get lora root directories"""
-        return config.loras_roots
+        """Get lora root directories (including extra paths)"""
+        roots: List[str] = []
+        roots.extend(config.loras_roots or [])
+        roots.extend(config.extra_loras_roots or [])
+        # Remove duplicates while preserving order
+        seen: set = set()
+        unique_roots: List[str] = []
+        for root in roots:
+            if root and root not in seen:
+                seen.add(root)
+                unique_roots.append(root)
+        return unique_roots

    async def diagnose_hash_index(self):
        """Diagnostic method to verify hash index functionality"""
--- a/py/services/model_scanner.py
+++ b/py/services/model_scanner.py
@@ -282,6 +282,11 @@ class ModelScanner:
        sub_type = get_value('sub_type', None)
        if sub_type:
            entry['sub_type'] = sub_type
+        
+        # Handle hash_status for lazy hash calculation (checkpoints)
+        hash_status = get_value('hash_status', 'completed')
+        if hash_status:
+            entry['hash_status'] = hash_status

        return entry

--- a/py/services/recipe_cache.py
+++ b/py/services/recipe_cache.py
@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from operator import itemgetter
 from natsort import natsorted

+
@dataclass
 class RecipeCache:
    """Cache structure for Recipe data"""
@@ -21,11 +22,18 @@ class RecipeCache:
        self.folder_tree = self.folder_tree or {}

    async def resort(self, name_only: bool = False):
-        """Resort all cached data views"""
+        """Resort all cached data views in a thread pool to avoid blocking the event loop."""
        async with self._lock:
-            self._resort_locked(name_only=name_only)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                self._resort_locked,
+                name_only,
+            )

-    async def update_recipe_metadata(self, recipe_id: str, metadata: Dict, *, resort: bool = True) -> bool:
+    async def update_recipe_metadata(
+        self, recipe_id: str, metadata: Dict, *, resort: bool = True
+    ) -> bool:
        """Update metadata for a specific recipe in all cached data

        Args:
@@ -37,7 +45,7 @@ class RecipeCache:
        """
        async with self._lock:
            for item in self.raw_data:
-                if str(item.get('id')) == str(recipe_id):
+                if str(item.get("id")) == str(recipe_id):
                    item.update(metadata)
                    if resort:
                        self._resort_locked()
@@ -52,7 +60,9 @@ class RecipeCache:
            if resort:
                self._resort_locked()

-    async def remove_recipe(self, recipe_id: str, *, resort: bool = False) -> Optional[Dict]:
+    async def remove_recipe(
+        self, recipe_id: str, *, resort: bool = False
+    ) -> Optional[Dict]:
        """Remove a recipe from the cache by ID.

        Args:
@@ -64,14 +74,16 @@ class RecipeCache:

        async with self._lock:
            for index, recipe in enumerate(self.raw_data):
-                if str(recipe.get('id')) == str(recipe_id):
+                if str(recipe.get("id")) == str(recipe_id):
                    removed = self.raw_data.pop(index)
                    if resort:
                        self._resort_locked()
                    return removed
        return None

-    async def bulk_remove(self, recipe_ids: Iterable[str], *, resort: bool = False) -> List[Dict]:
+    async def bulk_remove(
+        self, recipe_ids: Iterable[str], *, resort: bool = False
+    ) -> List[Dict]:
        """Remove multiple recipes from the cache."""

        id_set = {str(recipe_id) for recipe_id in recipe_ids}
@@ -79,21 +91,25 @@ class RecipeCache:
            return []

        async with self._lock:
-            removed = [item for item in self.raw_data if str(item.get('id')) in id_set]
+            removed = [item for item in self.raw_data if str(item.get("id")) in id_set]
            if not removed:
                return []

-            self.raw_data = [item for item in self.raw_data if str(item.get('id')) not in id_set]
+            self.raw_data = [
+                item for item in self.raw_data if str(item.get("id")) not in id_set
+            ]
            if resort:
                self._resort_locked()
            return removed

-    async def replace_recipe(self, recipe_id: str, new_data: Dict, *, resort: bool = False) -> bool:
+    async def replace_recipe(
+        self, recipe_id: str, new_data: Dict, *, resort: bool = False
+    ) -> bool:
        """Replace cached data for a recipe."""

        async with self._lock:
            for index, recipe in enumerate(self.raw_data):
-                if str(recipe.get('id')) == str(recipe_id):
+                if str(recipe.get("id")) == str(recipe_id):
                    self.raw_data[index] = new_data
                    if resort:
                        self._resort_locked()
@@ -105,7 +121,7 @@ class RecipeCache:

        async with self._lock:
            for recipe in self.raw_data:
-                if str(recipe.get('id')) == str(recipe_id):
+                if str(recipe.get("id")) == str(recipe_id):
                    return dict(recipe)
        return None

@@ -115,16 +131,13 @@ class RecipeCache:
        async with self._lock:
            return [dict(item) for item in self.raw_data]

-    def _resort_locked(self, *, name_only: bool = False) -> None:
+    def _resort_locked(self, name_only: bool = False) -> None:
        """Sort cached views. Caller must hold ``_lock``."""

        self.sorted_by_name = natsorted(
-            self.raw_data,
-            key=lambda x: x.get('title', '').lower()
+            self.raw_data, key=lambda x: x.get("title", "").lower()
        )
        if not name_only:
            self.sorted_by_date = sorted(
-                self.raw_data,
-                key=itemgetter('created_date', 'file_path'),
-                reverse=True
-            )
+                self.raw_data, key=itemgetter("created_date", "file_path"), reverse=True
+            )
--- a/py/services/recipe_scanner.py
+++ b/py/services/recipe_scanner.py
--- a/py/services/settings_manager.py
+++ b/py/services/settings_manager.py
@@ -54,6 +54,7 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
    "base_model_path_mappings": {},
    "download_path_templates": {},
    "folder_paths": {},
+    "extra_folder_paths": {},
    "example_images_path": "",
    "optimize_example_images": True,
    "auto_download_example_images": False,
@@ -402,6 +403,7 @@ class SettingsManager:
        active_library = libraries.get(active_name, {})
        folder_paths = copy.deepcopy(active_library.get("folder_paths", {}))
        self.settings["folder_paths"] = folder_paths
+        self.settings["extra_folder_paths"] = copy.deepcopy(active_library.get("extra_folder_paths", {}))
        self.settings["default_lora_root"] = active_library.get("default_lora_root", "")
        self.settings["default_checkpoint_root"] = active_library.get("default_checkpoint_root", "")
        self.settings["default_unet_root"] = active_library.get("default_unet_root", "")
@@ -417,6 +419,7 @@ class SettingsManager:
        self,
        *,
        folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
        default_lora_root: Optional[str] = None,
        default_checkpoint_root: Optional[str] = None,
        default_unet_root: Optional[str] = None,
@@ -432,6 +435,11 @@ class SettingsManager:
        else:
            payload.setdefault("folder_paths", {})

+        if extra_folder_paths is not None:
+            payload["extra_folder_paths"] = self._normalize_folder_paths(extra_folder_paths)
+        else:
+            payload.setdefault("extra_folder_paths", {})
+
        if default_lora_root is not None:
            payload["default_lora_root"] = default_lora_root
        else:
@@ -546,6 +554,7 @@ class SettingsManager:
        self,
        *,
        folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
        default_lora_root: Optional[str] = None,
        default_checkpoint_root: Optional[str] = None,
        default_unet_root: Optional[str] = None,
@@ -565,6 +574,12 @@ class SettingsManager:
                library["folder_paths"] = normalized_paths
                changed = True

+        if extra_folder_paths is not None:
+            normalized_extra_paths = self._normalize_folder_paths(extra_folder_paths)
+            if library.get("extra_folder_paths") != normalized_extra_paths:
+                library["extra_folder_paths"] = normalized_extra_paths
+                changed = True
+
        if default_lora_root is not None and library.get("default_lora_root") != default_lora_root:
            library["default_lora_root"] = default_lora_root
            changed = True
@@ -816,12 +831,14 @@ class SettingsManager:
        defaults['download_path_templates'] = {}
        defaults['priority_tags'] = DEFAULT_PRIORITY_TAG_CONFIG.copy()
        defaults.setdefault('folder_paths', {})
+        defaults.setdefault('extra_folder_paths', {})
        defaults['auto_organize_exclusions'] = []
        defaults['metadata_refresh_skip_paths'] = []

        library_name = defaults.get("active_library") or "default"
        default_library = self._build_library_payload(
            folder_paths=defaults.get("folder_paths", {}),
+            extra_folder_paths=defaults.get("extra_folder_paths", {}),
            default_lora_root=defaults.get("default_lora_root"),
            default_checkpoint_root=defaults.get("default_checkpoint_root"),
            default_embedding_root=defaults.get("default_embedding_root"),
@@ -927,6 +944,35 @@ class SettingsManager:
            self._save_settings()
        return skip_paths

+    def get_extra_folder_paths(self) -> Dict[str, List[str]]:
+        """Get extra folder paths for the active library.
+
+        These paths are only used by LoRA Manager and not shared with ComfyUI.
+        Returns a dictionary with keys like 'loras', 'checkpoints', 'embeddings', 'unet'.
+        """
+        extra_paths = self.settings.get("extra_folder_paths", {})
+        if not isinstance(extra_paths, dict):
+            return {}
+        return self._normalize_folder_paths(extra_paths)
+
+    def update_extra_folder_paths(
+        self,
+        extra_folder_paths: Mapping[str, Iterable[str]],
+    ) -> None:
+        """Update extra folder paths for the active library.
+
+        These paths are only used by LoRA Manager and not shared with ComfyUI.
+        Validates that extra paths don't overlap with other libraries' paths.
+        """
+        active_name = self.get_active_library_name()
+        self._validate_folder_paths(active_name, extra_folder_paths)
+
+        normalized_paths = self._normalize_folder_paths(extra_folder_paths)
+        self.settings["extra_folder_paths"] = normalized_paths
+        self._update_active_library_entry(extra_folder_paths=normalized_paths)
+        self._save_settings()
+        logger.info("Updated extra folder paths for library '%s'", active_name)
+
    def get_startup_messages(self) -> List[Dict[str, Any]]:
        return [message.copy() for message in self._startup_messages]

@@ -973,6 +1019,8 @@ class SettingsManager:
            self._prepare_portable_switch(value)
        if key == 'folder_paths' and isinstance(value, Mapping):
            self._update_active_library_entry(folder_paths=value)  # type: ignore[arg-type]
+        elif key == 'extra_folder_paths' and isinstance(value, Mapping):
+            self._update_active_library_entry(extra_folder_paths=value)  # type: ignore[arg-type]
        elif key == 'default_lora_root':
            self._update_active_library_entry(default_lora_root=str(value))
        elif key == 'default_checkpoint_root':
@@ -1284,6 +1332,7 @@ class SettingsManager:
        library_name: str,
        *,
        folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
        default_lora_root: Optional[str] = None,
        default_checkpoint_root: Optional[str] = None,
        default_unet_root: Optional[str] = None,
@@ -1300,11 +1349,15 @@ class SettingsManager:
        if folder_paths is not None:
            self._validate_folder_paths(name, folder_paths)

+        if extra_folder_paths is not None:
+            self._validate_folder_paths(name, extra_folder_paths)
+
        libraries = self.settings.setdefault("libraries", {})
        existing = libraries.get(name, {})

        payload = self._build_library_payload(
            folder_paths=folder_paths if folder_paths is not None else existing.get("folder_paths"),
+            extra_folder_paths=extra_folder_paths if extra_folder_paths is not None else existing.get("extra_folder_paths"),
            default_lora_root=default_lora_root if default_lora_root is not None else existing.get("default_lora_root"),
            default_checkpoint_root=(
                default_checkpoint_root
@@ -1343,6 +1396,7 @@ class SettingsManager:
        library_name: str,
        *,
        folder_paths: Mapping[str, Iterable[str]],
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
        default_lora_root: str = "",
        default_checkpoint_root: str = "",
        default_unet_root: str = "",
@@ -1359,6 +1413,7 @@ class SettingsManager:
        return self.upsert_library(
            library_name,
            folder_paths=folder_paths,
+            extra_folder_paths=extra_folder_paths,
            default_lora_root=default_lora_root,
            default_checkpoint_root=default_checkpoint_root,
            default_unet_root=default_unet_root,
@@ -1417,6 +1472,7 @@ class SettingsManager:
        self,
        folder_paths: Mapping[str, Iterable[str]],
        *,
+        extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
        default_lora_root: Optional[str] = None,
        default_checkpoint_root: Optional[str] = None,
        default_unet_root: Optional[str] = None,
@@ -1428,6 +1484,7 @@ class SettingsManager:
        self.upsert_library(
            active_name,
            folder_paths=folder_paths,
+            extra_folder_paths=extra_folder_paths,
            default_lora_root=default_lora_root,
            default_checkpoint_root=default_checkpoint_root,
            default_unet_root=default_unet_root,
--- a/py/services/tag_fts_index.py
+++ b/py/services/tag_fts_index.py
@@ -69,7 +69,9 @@ class TagFTSIndex:
    _DEFAULT_FILENAME = "tag_fts.sqlite"
    _CSV_FILENAME = "danbooru_e621_merged.csv"

-    def __init__(self, db_path: Optional[str] = None, csv_path: Optional[str] = None) -> None:
+    def __init__(
+        self, db_path: Optional[str] = None, csv_path: Optional[str] = None
+    ) -> None:
        """Initialize the FTS index.

        Args:
@@ -92,7 +94,9 @@ class TagFTSIndex:
            if directory:
                os.makedirs(directory, exist_ok=True)
        except Exception as exc:
-            logger.warning("Could not create FTS index directory %s: %s", directory, exc)
+            logger.warning(
+                "Could not create FTS index directory %s: %s", directory, exc
+            )

    def _resolve_default_db_path(self) -> str:
        """Resolve the default database path."""
@@ -173,13 +177,15 @@ class TagFTSIndex:
                    # Set schema version
                    conn.execute(
                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
-                        ("schema_version", str(SCHEMA_VERSION))
+                        ("schema_version", str(SCHEMA_VERSION)),
                    )
                    conn.commit()

                    self._schema_initialized = True
                    self._needs_rebuild = needs_rebuild
-                    logger.debug("Tag FTS index schema initialized at %s", self._db_path)
+                    logger.debug(
+                        "Tag FTS index schema initialized at %s", self._db_path
+                    )
                finally:
                    conn.close()
            except Exception as exc:
@@ -206,13 +212,20 @@ class TagFTSIndex:
            row = cursor.fetchone()
            if not row:
                # Old schema without version, needs rebuild
-                logger.info("Migrating tag FTS index to schema version %d (adding alias support)", SCHEMA_VERSION)
+                logger.info(
+                    "Migrating tag FTS index to schema version %d (adding alias support)",
+                    SCHEMA_VERSION,
+                )
                self._drop_old_tables(conn)
                return True

            current_version = int(row[0])
            if current_version < SCHEMA_VERSION:
-                logger.info("Migrating tag FTS index from version %d to %d", current_version, SCHEMA_VERSION)
+                logger.info(
+                    "Migrating tag FTS index from version %d to %d",
+                    current_version,
+                    SCHEMA_VERSION,
+                )
                self._drop_old_tables(conn)
                return True

@@ -246,7 +259,9 @@ class TagFTSIndex:
            return

        if not os.path.exists(self._csv_path):
-            logger.warning("CSV file not found at %s, cannot build tag index", self._csv_path)
+            logger.warning(
+                "CSV file not found at %s, cannot build tag index", self._csv_path
+            )
            return

        self._indexing_in_progress = True
@@ -314,22 +329,24 @@ class TagFTSIndex:
                    # Update metadata
                    conn.execute(
                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
-                        ("last_build_time", str(time.time()))
+                        ("last_build_time", str(time.time())),
                    )
                    conn.execute(
                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
-                        ("tag_count", str(total_inserted))
+                        ("tag_count", str(total_inserted)),
                    )
                    conn.execute(
                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
-                        ("schema_version", str(SCHEMA_VERSION))
+                        ("schema_version", str(SCHEMA_VERSION)),
                    )

                    conn.commit()
                    elapsed = time.time() - start_time
                    logger.info(
                        "Tag FTS index built: %d tags indexed (%d with aliases) in %.2fs",
-                        total_inserted, tags_with_aliases, elapsed
+                        total_inserted,
+                        tags_with_aliases,
+                        elapsed,
                    )
                finally:
                    conn.close()
@@ -350,7 +367,7 @@ class TagFTSIndex:
        # Insert into tags table (with aliases)
        conn.executemany(
            "INSERT OR IGNORE INTO tags (tag_name, category, post_count, aliases) VALUES (?, ?, ?, ?)",
-            rows
+            rows,
        )

        # Build a map of tag_name -> aliases for FTS insertion
@@ -362,7 +379,7 @@ class TagFTSIndex:
        placeholders = ",".join("?" * len(tag_names))
        cursor = conn.execute(
            f"SELECT rowid, tag_name FROM tags WHERE tag_name IN ({placeholders})",
-            tag_names
+            tag_names,
        )

        # Build FTS rows with (rowid, searchable_text) = (tags.rowid, "tag_name alias1 alias2 ...")
@@ -379,13 +396,17 @@ class TagFTSIndex:
                        alias = alias[1:]  # Remove leading slash
                    if alias:
                        alias_parts.append(alias)
-                searchable_text = f"{tag_name} {' '.join(alias_parts)}" if alias_parts else tag_name
+                searchable_text = (
+                    f"{tag_name} {' '.join(alias_parts)}" if alias_parts else tag_name
+                )
            else:
                searchable_text = tag_name
            fts_rows.append((rowid, searchable_text))

        if fts_rows:
-            conn.executemany("INSERT INTO tag_fts (rowid, searchable_text) VALUES (?, ?)", fts_rows)
+            conn.executemany(
+                "INSERT INTO tag_fts (rowid, searchable_text) VALUES (?, ?)", fts_rows
+            )

    def ensure_ready(self) -> bool:
        """Ensure the index is ready, building if necessary.
@@ -420,7 +441,8 @@ class TagFTSIndex:
        self,
        query: str,
        categories: Optional[List[int]] = None,
-        limit: int = 20
+        limit: int = 20,
+        offset: int = 0,
    ) -> List[Dict]:
        """Search tags using FTS5 with prefix matching.

@@ -431,6 +453,7 @@ class TagFTSIndex:
            query: The search query string.
            categories: Optional list of category IDs to filter by.
            limit: Maximum number of results to return.
+            offset: Number of results to skip.

        Returns:
            List of dictionaries with tag_name, category, post_count,
@@ -466,9 +489,9 @@ class TagFTSIndex:
                            )
                            AND t.category IN ({placeholders})
                            ORDER BY t.post_count DESC
-                            LIMIT ?
+                            LIMIT ? OFFSET ?
                        """
-                        params = [fts_query] + categories + [limit]
+                        params = [fts_query] + categories + [limit, offset]
                    else:
                        sql = """
                            SELECT t.tag_name, t.category, t.post_count, t.aliases
@@ -476,9 +499,9 @@ class TagFTSIndex:
                            JOIN tags t ON f.rowid = t.rowid
                            WHERE f.searchable_text MATCH ?
                            ORDER BY t.post_count DESC
-                            LIMIT ?
+                            LIMIT ? OFFSET ?
                        """
-                        params = [fts_query, limit]
+                        params = [fts_query, limit, offset]

                    cursor = conn.execute(sql, params)
                    results = []
@@ -502,7 +525,9 @@ class TagFTSIndex:
            logger.debug("Tag FTS search error for query '%s': %s", query, exc)
            return []

-    def _find_matched_alias(self, query: str, tag_name: str, aliases_str: str) -> Optional[str]:
+    def _find_matched_alias(
+        self, query: str, tag_name: str, aliases_str: str
+    ) -> Optional[str]:
        """Find which alias matched the query, if any.

        Args:
--- a/py/services/use_cases/bulk_metadata_refresh_use_case.py
+++ b/py/services/use_cases/bulk_metadata_refresh_use_case.py
@@ -47,8 +47,7 @@ class BulkMetadataRefreshUseCase:
        to_process: Sequence[Dict[str, Any]] = [
            model
            for model in cache.raw_data
-            if model.get("sha256")
-            and not model.get("skip_metadata_refresh", False)
+            if not model.get("skip_metadata_refresh", False)
            and not self._is_in_skip_path(model.get("folder", ""), skip_paths)
            and (not model.get("civitai") or not model["civitai"].get("id"))
            and not (
@@ -85,6 +84,36 @@ class BulkMetadataRefreshUseCase:
                return {"success": False, "message": "Operation cancelled", "processed": processed, "updated": success, "total": total_models}
            try:
                original_name = model.get("model_name")
+
+                # Handle lazy hash calculation for models with pending hash status
+                sha256 = model.get("sha256", "")
+                hash_status = model.get("hash_status", "completed")
+                file_path = model.get("file_path")
+
+                if not sha256 and hash_status == "pending" and file_path:
+                    self._logger.info(f"Calculating pending hash for {file_path}")
+                    # Check if scanner has calculate_hash_for_model method (CheckpointScanner)
+                    calculate_hash_method = getattr(self._service.scanner, "calculate_hash_for_model", None)
+                    if calculate_hash_method:
+                        sha256 = await calculate_hash_method(file_path)
+                        if sha256:
+                            model["sha256"] = sha256
+                            model["hash_status"] = "completed"
+                        else:
+                            self._logger.error(f"Failed to calculate hash for {file_path}")
+                            processed += 1
+                            continue
+                    else:
+                        self._logger.warning(f"Scanner does not support lazy hash calculation for {file_path}")
+                        processed += 1
+                        continue
+
+                # Skip models without valid hash
+                if not model.get("sha256"):
+                    self._logger.warning(f"Skipping model without hash: {file_path}")
+                    processed += 1
+                    continue
+
                await MetadataManager.hydrate_model_data(model)
                result, _ = await self._metadata_sync.fetch_and_update_model(
                    sha256=model["sha256"],
--- a/py/utils/models.py
+++ b/py/utils/models.py
@@ -28,6 +28,7 @@ class BaseModelMetadata:
    skip_metadata_refresh: bool = False  # Whether to skip this model during bulk metadata refresh
    metadata_source: Optional[str] = None  # Last provider that supplied metadata
    last_checked_at: float = 0  # Last checked timestamp
+    hash_status: str = "completed"  # Hash calculation status: pending | calculating | completed | failed
    _unknown_fields: Dict[str, Any] = field(default_factory=dict, repr=False, compare=False)  # Store unknown fields

    def __post_init__(self):
--- a/py/utils/usage_stats.py
+++ b/py/utils/usage_stats.py
@@ -57,6 +57,9 @@ class UsageStats:
            "last_save_time": 0
        }
        
+        # Track if stats have been modified since last save
+        self._is_dirty = False
+        
        # Queue for prompt_ids to process
        self.pending_prompt_ids = set()
        
@@ -180,27 +183,39 @@ class UsageStats:
    async def save_stats(self, force=False):
        """Save statistics to file"""
        try:
-            # Only save if it's been at least save_interval since last save or force is True
+            # Only save if:
+            # 1. force is True, OR
+            # 2. stats have been modified (is_dirty) AND save_interval has passed
            current_time = time.time()
-            if not force and (current_time - self.stats.get("last_save_time", 0)) < self.save_interval:
-                return False
-                
+            time_since_last_save = current_time - self.stats.get("last_save_time", 0)
+
+            if not force:
+                if not self._is_dirty:
+                    # No changes to save
+                    return False
+                if time_since_last_save < self.save_interval:
+                    # Too soon since last save
+                    return False
+
            # Use a lock to prevent concurrent writes
            async with self._lock:
                # Update last save time
                self.stats["last_save_time"] = current_time
-                
+
                # Create directory if it doesn't exist
                os.makedirs(os.path.dirname(self._stats_file_path), exist_ok=True)
-                
+
                # Write to a temporary file first, then move it to avoid corruption
                temp_path = f"{self._stats_file_path}.tmp"
                with open(temp_path, 'w', encoding='utf-8') as f:
                    json.dump(self.stats, f, indent=2, ensure_ascii=False)
-                
+
                # Replace the old file with the new one
                os.replace(temp_path, self._stats_file_path)
-                
+
+                # Clear dirty flag since we've saved
+                self._is_dirty = False
+
                logger.debug(f"Saved usage statistics to {self._stats_file_path}")
                return True
        except Exception as e:
@@ -218,25 +233,32 @@ class UsageStats:
            while True:
                # Wait a short interval before checking for new prompt_ids
                await asyncio.sleep(5)  # Check every 5 seconds
-                
+
                # Process any pending prompt_ids
                if self.pending_prompt_ids:
                    async with self._lock:
                        # Get a copy of the set and clear original
                        prompt_ids = self.pending_prompt_ids.copy()
                        self.pending_prompt_ids.clear()
-                    
+
                    # Process each prompt_id
-                    registry = MetadataRegistry()
-                    for prompt_id in prompt_ids:
-                        try:
-                            metadata = registry.get_metadata(prompt_id)
-                            await self._process_metadata(metadata)
-                        except Exception as e:
-                            logger.error(f"Error processing prompt_id {prompt_id}: {e}")
-                
-                # Periodically save stats
-                await self.save_stats()
+                    try:
+                        registry = MetadataRegistry()
+                    except NameError:
+                        # MetadataRegistry not available (standalone mode)
+                        registry = None
+                    
+                    if registry:
+                        for prompt_id in prompt_ids:
+                            try:
+                                metadata = registry.get_metadata(prompt_id)
+                                await self._process_metadata(metadata)
+                            except Exception as e:
+                                logger.error(f"Error processing prompt_id {prompt_id}: {e}")
+
+                # Periodically save stats (only if there are changes)
+                if self._is_dirty:
+                    await self.save_stats()
        except asyncio.CancelledError:
            # Task was cancelled, clean up
            await self.save_stats(force=True)
@@ -254,9 +276,10 @@ class UsageStats:
        """Process metadata from an execution"""
        if not metadata or not isinstance(metadata, dict):
            return
-            
+
        # Increment total executions count
        self.stats["total_executions"] += 1
+        self._is_dirty = True
        
        # Get today's date in YYYY-MM-DD format
        today = datetime.datetime.now().strftime("%Y-%m-%d")
@@ -373,7 +396,11 @@ class UsageStats:
        """Process a prompt execution immediately (synchronous approach)"""
        if not prompt_id:
            return
-            
+
+        if standalone_mode:
+            # Usage statistics are not available in standalone mode
+            return
+
        try:
            # Process metadata for this prompt_id
            registry = MetadataRegistry()
--- a/py/utils/utils.py
+++ b/py/utils/utils.py
@@ -50,6 +50,52 @@ def get_lora_info(lora_name):
        # No event loop is running, we can use asyncio.run()
        return asyncio.run(_get_lora_info_async())

+
+def get_lora_info_absolute(lora_name):
+    """Get the absolute lora path and trigger words from cache
+    
+    Returns:
+        tuple: (absolute_path, trigger_words) where absolute_path is the full 
+               file system path to the LoRA file, or original lora_name if not found
+    """
+    async def _get_lora_info_absolute_async():
+        scanner = await ServiceRegistry.get_lora_scanner()
+        cache = await scanner.get_cached_data()
+        
+        for item in cache.raw_data:
+            if item.get('file_name') == lora_name:
+                file_path = item.get('file_path')
+                if file_path:
+                    # Return absolute path directly
+                    # Get trigger words from civitai metadata
+                    civitai = item.get('civitai', {})
+                    trigger_words = civitai.get('trainedWords', []) if civitai else []
+                    return file_path, trigger_words
+        return lora_name, []
+    
+    try:
+        # Check if we're already in an event loop
+        loop = asyncio.get_running_loop()
+        # If we're in a running loop, we need to use a different approach
+        # Create a new thread to run the async code
+        import concurrent.futures
+        
+        def run_in_thread():
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(_get_lora_info_absolute_async())
+            finally:
+                new_loop.close()
+        
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_in_thread)
+            return future.result()
+            
+    except RuntimeError:
+        # No event loop is running, we can use asyncio.run()
+        return asyncio.run(_get_lora_info_absolute_async())
+
 def fuzzy_match(text: str, pattern: str, threshold: float = 0.85) -> bool:
        """
        Check if text matches pattern using fuzzy matching.
@@ -143,15 +189,23 @@ def calculate_recipe_fingerprint(loras):
        if lora.get("exclude", False):
            continue
            
-        hash_value = lora.get("hash", "").lower()
+        hash_value = lora.get("hash", "")
+        if isinstance(hash_value, str):
+            hash_value = hash_value.lower()
+        else:
+            hash_value = str(hash_value).lower() if hash_value else ""
        if not hash_value and lora.get("modelVersionId"):
            hash_value = str(lora.get("modelVersionId"))
-            
+
        if not hash_value:
            continue
-            
+
        # Normalize strength to 2 decimal places (check both strength and weight fields)
-        strength = round(float(lora.get("strength", lora.get("weight", 1.0))), 2)
+        strength_val = lora.get("strength", lora.get("weight", 1.0))
+        try:
+            strength = round(float(strength_val), 2)
+        except (ValueError, TypeError):
+            strength = 1.0
        
        valid_loras.append((hash_value, strength))
    
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "Revolutionize your workflow with the ultimate LoRA companion for ComfyUI!"
-version = "0.9.16"
+version = "1.0.0"
 license = {file = "LICENSE"}
 dependencies = [
    "aiohttp",
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,5 +1,5 @@
 [pytest]
-addopts = -v --import-mode=importlib
+addopts = -v --import-mode=importlib -m "not performance"
 testpaths = tests
 python_files = test_*.py
 python_classes = Test*
@@ -12,5 +12,6 @@ markers =
    asyncio: execute test within asyncio event loop
    no_settings_dir_isolation: allow tests to use real settings paths
    integration: integration tests requiring external resources
+    performance: performance benchmarks (slow, skip by default)
 # Skip problematic directories to avoid import conflicts
 norecursedirs = .git .tox dist build *.egg __pycache__ py .hypothesis
--- a/scripts/update_supporters.py
+++ b/scripts/update_supporters.py
@@ -0,0 +1,63 @@
+import json
+import os
+import re
+
+def update_readme():
+    # 1. Read JSON data
+    json_path = 'data/supporters.json'
+    if not os.path.exists(json_path):
+        print(f"Error: {json_path} not found.")
+        return
+
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    # 2. Generate Markdown content
+    special_thanks = data.get('specialThanks', [])
+    all_supporters = data.get('allSupporters', [])
+    total_count = data.get('totalCount', len(all_supporters))
+    
+    md_content = "\n### 🌟 Special Thanks\n\n"
+    if special_thanks:
+        md_content += ", ".join([f"**{name}**" for name in special_thanks]) + "\n\n"
+    else:
+        md_content += "*None yet*\n\n"
+    
+    md_content += f"### 💖 Supporters ({total_count})\n\n"
+    if all_supporters:
+        # Using a details block for the long list of supporters
+        md_content += "<details>\n<summary>Click to view all awesome supporters</summary>\n<br>\n\n"
+        md_content += ", ".join(all_supporters)
+        md_content += "\n\n</details>\n"
+    else:
+        md_content += "*No supporters listed yet*\n"
+
+    # 3. Read existing README.md
+    readme_path = 'README.md'
+    with open(readme_path, 'r', encoding='utf-8') as f:
+        readme = f.read()
+
+    # 4. Replace content between placeholders
+    start_tag = '<!-- SUPPORTERS-START -->'
+    end_tag = '<!-- SUPPORTERS-END -->'
+    
+    if start_tag not in readme or end_tag not in readme:
+        print(f"Error: Placeholders {start_tag} and {end_tag} not found in {readme_path}")
+        return
+
+    # Using non-regex replacement to avoid issues with special characters in names
+    parts = readme.split(start_tag)
+    before_start = parts[0]
+    after_start = parts[1].split(end_tag)
+    after_end = after_start[1]
+    
+    new_readme = f"{before_start}{start_tag}\n{md_content}\n{end_tag}{after_end}"
+
+    # 5. Write back to README.md
+    with open(readme_path, 'w', encoding='utf-8') as f:
+        f.write(new_readme)
+        
+    print(f"Successfully updated {readme_path} with {len(all_supporters)} supporters!")
+
+if __name__ == '__main__':
+    update_readme()
--- a/static/css/base.css
+++ b/static/css/base.css
@@ -68,6 +68,7 @@ body {
    --space-1: calc(8px * 1);
    --space-2: calc(8px * 2);
    --space-3: calc(8px * 3);
+    --space-4: calc(8px * 4);

    /* Z-index Scale */
    --z-base: 10;
@@ -77,6 +78,7 @@ body {

    /* Border Radius */
    --border-radius-base: 12px;
+    --border-radius-md: 12px;
    --border-radius-sm: 8px;
    --border-radius-xs: 4px;

--- a/static/css/components/card.css
+++ b/static/css/components/card.css
@@ -282,7 +282,7 @@
    display: flex;
    justify-content: space-between;
    align-items: flex-start;  /* Changed from flex-end to allow for text wrapping */
-    min-height: 32px;
+    min-height: auto;
    gap: var(--space-1);  /* Add gap between model info and actions */
 }

@@ -413,7 +413,7 @@
    font-size: 0.95em;
    word-break: break-word;
    display: block;
-    max-height: 3em; /* Increased to ensure two full lines */
+    max-height: 4.2em; /* Allow up to 3 lines */
    overflow: hidden;
    /* Add line height for consistency */
    line-height: 1.4;
--- a/static/css/components/lora-modal/lora-modal.css
+++ b/static/css/components/lora-modal/lora-modal.css
@@ -392,6 +392,7 @@
    border: 1px solid transparent;
    outline: none;
    flex: 1;
+    overflow-wrap: anywhere; /* Allow wrapping at any character, including hyphens */
 }

 .model-name-content:focus {
--- a/static/css/components/menu.css
+++ b/static/css/components/menu.css
@@ -130,7 +130,7 @@
    max-height: 400px;
    overflow-y: auto;
    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
-    z-index: 1000;
+    z-index: var(--z-overlay);
    display: none;
    backdrop-filter: blur(10px);
 }
--- a/static/css/components/modal/settings-modal.css
+++ b/static/css/components/modal/settings-modal.css
@@ -1,4 +1,4 @@
-/* Settings styles */
+/* Settings Modal - macOS Settings Style */
 .settings-toggle {
    width: 36px;
    height: 36px;
@@ -20,15 +20,207 @@
 }

 .settings-modal {
-    max-width: 700px; /* Further increased from 600px for more space */
+    width: 1000px;
+    height: calc(92vh - var(--header-height, 48px));
+    max-width: 95vw;
+    max-height: 90vh;
+    display: flex;
+    flex-direction: column;
+}
+
+.settings-modal .modal-body {
+    display: flex;
+    flex-direction: row;
+    flex: 1;
+    overflow: hidden;
+    min-height: 0;
+}
+
+/* Navigation Sidebar */
+.settings-nav {
+    width: 200px;
+    flex-shrink: 0;
+    border-right: 1px solid var(--lora-border);
+    padding: var(--space-2);
+    overflow-y: auto;
+}
+
+[data-theme="dark"] .settings-nav {
+    background: transparent;
+}
+
+.settings-nav-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+
+.settings-nav-group {
+    margin-bottom: var(--space-2);
+}
+
+/* Hide group titles - we use flat navigation */
+.settings-nav-group-title {
+    display: none;
+}
+
+/* Hide settings title */
+.settings-nav-title {
+    display: none;
+}
+
+.settings-nav-item {
+    display: block;
+    width: 100%;
+    padding: 10px 14px;
+    border: none;
+    background: transparent;
+    color: var(--text-color);
+    text-align: left;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    border-radius: var(--border-radius-xs);
+    transition: all 0.2s ease;
+    margin-bottom: 4px;
+}
+
+.settings-nav-item:hover {
+    background: rgba(var(--lora-accent-rgb, 79, 70, 229), 0.1);
+    color: var(--lora-accent);
+}
+
+.settings-nav-item.active {
+    background: var(--lora-accent);
+    color: white;
+    font-weight: 600;
+}
+
+/* Content Area */
+.settings-content {
+    flex: 1;
+    overflow-y: auto;
+    padding: var(--space-3);
+    scroll-behavior: smooth;
+}
+
+.settings-content .settings-form {
+    padding-bottom: var(--space-4);
 }

 .settings-header {
    display: flex;
    align-items: center;
-    justify-content: flex-start;
    gap: var(--space-1);
    margin-bottom: var(--space-2);
+    padding-right: 40px; /* Space for close button */
+    padding-left: calc(var(--space-2) + 14px); /* Align with nav item text */
+}
+
+.settings-header .settings-search-wrapper {
+    margin-left: auto;
+}
+
+/* Search Input Styles */
+.settings-search-wrapper {
+    position: relative;
+    display: flex;
+    align-items: center;
+    width: 240px;
+}
+
+.settings-search-icon {
+    position: absolute;
+    left: 10px;
+    color: var(--text-color);
+    opacity: 0.5;
+    font-size: 0.9em;
+    pointer-events: none;
+}
+
+.settings-search-input {
+    width: 100%;
+    padding: 6px 28px 6px 32px;
+    height: 32px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid var(--border-color);
+    background-color: var(--lora-surface);
+    color: var(--text-color);
+    font-size: 0.9em;
+    transition: all 0.2s ease;
+}
+
+.settings-search-input:focus {
+    border-color: var(--lora-accent);
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(var(--lora-accent-rgb, 79, 70, 229), 0.1);
+}
+
+.settings-search-input::placeholder {
+    color: var(--text-color);
+    opacity: 0.5;
+}
+
+.settings-search-clear {
+    position: absolute;
+    right: 6px;
+    width: 20px;
+    height: 20px;
+    border: none;
+    background: rgba(var(--border-color-rgb, 148, 163, 184), 0.3);
+    color: var(--text-color);
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.7em;
+    opacity: 0.6;
+    transition: all 0.2s ease;
+}
+
+.settings-search-clear:hover {
+    opacity: 1;
+    background: rgba(var(--border-color-rgb, 148, 163, 184), 0.5);
+}
+
+/* Search Highlight Styles */
+.settings-search-highlight {
+    background-color: rgba(var(--lora-accent-rgb, 79, 70, 229), 0.3);
+    color: var(--lora-accent);
+    padding: 0 2px;
+    border-radius: 2px;
+    font-weight: 500;
+}
+
+/* Section visibility during search */
+.settings-section.search-match,
+.setting-item.search-match {
+    display: block !important;
+}
+
+.settings-section.search-hidden,
+.setting-item.search-hidden {
+    display: none !important;
+}
+
+/* Empty search results state */
+.settings-search-empty {
+    text-align: center;
+    padding: var(--space-4);
+    color: var(--text-color);
+    opacity: 0.7;
+}
+
+.settings-search-empty i {
+    font-size: 2em;
+    margin-bottom: var(--space-2);
+    opacity: 0.5;
+}
+
+.settings-search-empty p {
+    margin: 0;
+    font-size: 0.95em;
 }

 .settings-header h2 {
@@ -248,11 +440,32 @@
    gap: var(--space-2);
 }

-.priority-tags-header {
+.priority-tags-header-row {
+    display: flex;
+    flex-direction: row;
    align-items: center;
    justify-content: flex-start;
 }

+.priority-tags-header-row .setting-info {
+    width: auto;
+    flex-shrink: 0;
+}
+
+.priority-tags-header {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: flex-start;
+    gap: 8px;
+    width: auto;
+}
+
+.priority-tags-header label {
+    display: inline-flex;
+    white-space: nowrap;
+}
+
 .priority-tags-info {
    display: flex;
    align-items: center;
@@ -360,25 +573,65 @@
    padding: 6px 0;
 }

-/* Settings Styles */
+/* Settings Section - macOS Settings Style */
 .settings-section {
-    margin-top: var(--space-3);
-    border-top: 1px solid var(--lora-border);
-    padding-top: var(--space-2);
+    display: none;
+    animation: fadeIn 0.2s ease-out;
 }

-.settings-section h3 {
-    font-size: 1.1em;
+.settings-section.active {
+    display: block;
+}
+
+@keyframes fadeIn {
+    from {
+        opacity: 0;
+        transform: translateX(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateX(0);
+    }
+}
+
+/* Remove old section header - replaced by subsection headers */
+.settings-section-header {
+    display: none;
+}
+
+/* Subsection styling */
+.settings-subsection {
+    margin-bottom: var(--space-5);
+}
+
+.settings-subsection:last-child {
+    margin-bottom: 0;
+}
+
+.settings-subsection-header {
+    display: flex;
+    align-items: center;
+    padding: var(--space-2) 0;
    margin-bottom: var(--space-2);
+    border-bottom: 1px solid var(--lora-border);
+}
+
+.settings-subsection-header h4 {
+    font-size: 18px;
+    font-weight: 700;
+    margin: 0;
    color: var(--text-color);
-    opacity: 0.9;
+}
+
+/* Remove toggle button styles */
+.settings-section-toggle {
+    display: none;
 }

 .setting-item {
    display: flex;
    flex-direction: column; /* Changed to column for help text placement */
-    margin-bottom: var(--space-3); /* Increased to provide more spacing between items */
-    padding: var(--space-1);
+    padding: var(--space-2);
    border-radius: var(--border-radius-xs);
 }

@@ -390,6 +643,8 @@
    background: rgba(255, 255, 255, 0.05);
 }

+
+
 /* Control row with label and input together */
 .setting-row {
    display: flex;
@@ -403,13 +658,16 @@
    margin-bottom: 0;
    width: 35%; /* Increased from 30% to prevent wrapping */
    flex-shrink: 0; /* Prevent shrinking */
+    display: flex; /* Allow label and info-icon to be on same line */
+    align-items: center;
 }

 .setting-info label {
-    display: block;
-    font-weight: 500;
+    font-weight: 400;
    margin-bottom: 0;
    white-space: nowrap; /* Prevent label wrapping */
+    /* Use text color with alpha instead of opacity to avoid affecting tooltip */
+    color: rgba(from var(--text-color) r g b / 0.85);
 }

 .setting-control {
@@ -701,6 +959,66 @@ input:checked + .toggle-slider:before {
    }
 }

+/* Responsive: Mobile - Single column layout */
+@media (max-width: 768px) {
+    .settings-modal {
+        width: 95vw;
+        max-height: 90vh;
+    }
+    
+    .settings-modal .modal-body {
+        flex-direction: column;
+    }
+    
+    .settings-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: var(--space-2);
+    }
+
+    .settings-header .settings-search-wrapper {
+        margin-left: 0;
+        width: 100%;
+    }
+    
+    .settings-nav {
+        width: 100%;
+        max-height: 200px;
+        border-right: none;
+        border-bottom: 1px solid var(--lora-border);
+        padding: var(--space-1);
+    }
+    
+    .settings-nav-list {
+        display: flex;
+        flex-wrap: wrap;
+        gap: var(--space-1);
+    }
+    
+    .settings-nav-group {
+        display: flex;
+        flex-wrap: wrap;
+        gap: var(--space-1);
+        margin-bottom: 0;
+    }
+    
+    .settings-nav-group-title {
+        display: none;
+    }
+    
+    .settings-nav-item {
+        width: auto;
+        white-space: nowrap;
+        font-size: 0.85em;
+        padding: 6px 10px;
+        margin-bottom: 0;
+    }
+    
+    .settings-content {
+        padding: var(--space-2);
+    }
+}
+
 /* Dark theme specific adjustments */
 [data-theme="dark"] .base-model-select,
 [data-theme="dark"] .path-value-input {
@@ -827,3 +1145,126 @@ input:checked + .toggle-slider:before {
        margin-top: var(--space-2);
    }
 }
+
+/* Info icon styling for settings labels - Minimal style */
+.info-icon {
+    color: var(--text-color);
+    margin-left: 6px;
+    font-size: 0.85em;
+    vertical-align: text-bottom;
+    cursor: help;
+    opacity: 0.4;
+    transition: opacity 0.2s ease;
+}
+
+.info-icon:hover {
+    opacity: 1;
+}
+
+/* Tooltip using data-tooltip attribute */
+.info-icon[data-tooltip] {
+    position: relative;
+}
+
+.info-icon[data-tooltip]::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    bottom: calc(100% + 8px);
+    background: rgba(0, 0, 0, 0.9);
+    color: white;
+    padding: 8px 12px;
+    border-radius: 6px;
+    font-size: 14px;
+    font-weight: normal;
+    font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+    white-space: normal;
+    max-width: 220px;
+    width: max-content;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.2s ease, visibility 0.2s ease;
+    pointer-events: none;
+    z-index: 10000;
+    line-height: 1.4;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    text-transform: none;
+}
+
+.info-icon[data-tooltip]:hover::after {
+    opacity: 1;
+    visibility: visible;
+}
+
+/* Fix tooltip overflow on left edge - when icon is near left side of modal */
+.settings-subsection-header .info-icon[data-tooltip]::after {
+    left: 0;
+    transform: translateX(0);
+}
+
+.settings-subsection-header .info-icon[data-tooltip]::before {
+    left: 12px;
+}
+
+/* Dark theme adjustments for tooltip - Fully opaque */
+[data-theme="dark"] .info-icon[data-tooltip]::after {
+    background: rgba(40, 40, 40, 0.95);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.5);
+}
+
+/* Extra Folder Paths - Single input layout */
+.extra-folder-path-row {
+    margin-bottom: var(--space-2);
+}
+
+.extra-folder-path-row:last-child {
+    margin-bottom: 0;
+}
+
+.extra-folder-paths-container {
+    margin-top: var(--space-2);
+}
+
+.extra-folder-path-row .path-controls {
+    display: flex;
+    gap: var(--space-2);
+    align-items: center;
+}
+
+.extra-folder-path-row .path-controls .extra-folder-path-input {
+    flex: 1;
+    min-width: 0;
+    padding: 6px 10px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid var(--border-color);
+    background-color: var(--lora-surface);
+    color: var(--text-color);
+    font-size: 0.9em;
+    height: 32px;
+    box-sizing: border-box;
+}
+
+.extra-folder-path-row .path-controls .extra-folder-path-input:focus {
+    border-color: var(--lora-accent);
+    outline: none;
+    box-shadow: 0 0 0 2px rgba(var(--lora-accent-rgb, 79, 70, 229), 0.1);
+}
+
+.extra-folder-path-row .path-controls .remove-path-btn {
+    width: 32px;
+    height: 32px;
+    border-radius: var(--border-radius-xs);
+    border: 1px solid var(--lora-error);
+    background: transparent;
+    color: var(--lora-error);
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.2s;
+    flex-shrink: 0;
+}
+
+.extra-folder-path-row .path-controls .remove-path-btn:hover {
+    background: var(--lora-error);
+    color: white;
+}
--- a/static/css/components/modal/support-modal.css
+++ b/static/css/components/modal/support-modal.css
@@ -1,6 +1,26 @@
 /* Support Modal Styles */
 .support-modal {
-    max-width: 570px;
+    max-width: 1000px;
+    width: 90vw;
+}
+
+/* Two-column layout */
+.support-container {
+    display: flex;
+    gap: var(--space-3);
+    min-height: 500px;
+}
+
+.support-left {
+    flex: 0 0 42%;
+    min-width: 0;
+}
+
+.support-right {
+    flex: 1;
+    min-width: 0;
+    border-left: 1px solid var(--lora-border);
+    padding-left: var(--space-4);
 }

 .support-header {
@@ -214,6 +234,11 @@
    .support-links {
        flex-direction: column;
    }
+    
+    .support-modal {
+        width: 95vw;
+        max-width: 95vw;
+    }
 }

 /* Civitai link styles */
@@ -239,4 +264,223 @@
 .folder-item:hover {
    border-color: var(--lora-accent);
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+/* Supporters Section Styles */
+.supporters-section {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.supporters-header {
+    margin-bottom: var(--space-4);
+}
+
+.supporters-title {
+    display: flex;
+    align-items: center;
+    gap: var(--space-2);
+    margin: 0 0 var(--space-1) 0;
+    font-size: 1.3em !important;
+    color: var(--lora-accent) !important;
+}
+
+.supporters-title i {
+    opacity: 0.9;
+}
+
+.supporters-subtitle {
+    margin: 0;
+    font-size: 0.95em;
+    color: var(--text-color);
+    opacity: 0.6;
+}
+
+.supporters-group {
+    margin-bottom: var(--space-3);
+}
+
+.supporters-group-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin: 0 0 var(--space-2) 0;
+    font-size: 1em;
+    color: var(--text-color);
+    opacity: 0.8;
+    font-weight: 500;
+}
+
+.supporters-group-title i {
+    color: var(--lora-accent);
+    opacity: 0.7;
+}
+
+/* Special Thanks - Clean Card Style */
+.special-thanks-group {
+    margin-bottom: var(--space-4);
+}
+
+.special-thanks-group .supporters-group-title {
+    margin-bottom: var(--space-3);
+}
+
+.special-thanks-group .supporters-group-title i {
+    color: #fbbf24;
+}
+
+.all-supporters-group .supporters-group-title i {
+    color: var(--lora-error);
+    opacity: 0.9;
+}
+
+.supporters-special-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: var(--space-2);
+}
+
+.supporter-special-card {
+    display: flex;
+    align-items: center;
+    padding: var(--space-2) var(--space-3);
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-left: 3px solid var(--lora-accent);
+    border-radius: var(--border-radius-sm);
+    transition: all 0.2s ease;
+    cursor: default;
+}
+
+.supporter-special-card:hover {
+    border-color: var(--lora-accent);
+    border-left-color: var(--lora-accent);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+    transform: translateX(4px);
+}
+
+.supporter-special-card .supporter-special-name {
+    font-size: 1em;
+    font-weight: 500;
+    color: var(--text-color);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.supporter-special-card:hover .supporter-special-name {
+    color: var(--lora-accent);
+}
+
+/* All Supporters - Elegant Text Flow */
+.all-supporters-group {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    position: relative; /* Base for masks */
+}
+
+/* Optional: Fading effect for credits feel at top and bottom */
+.all-supporters-group::before,
+.all-supporters-group::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    height: 40px;
+    pointer-events: none;
+    z-index: 2;
+}
+
+.all-supporters-group::before {
+    top: 30px; /* Below the title */
+    background: linear-gradient(to bottom, var(--lora-surface), transparent);
+}
+
+.all-supporters-group::after {
+    bottom: 0;
+    background: linear-gradient(to top, var(--lora-surface), transparent);
+}
+
+.all-supporters-group .supporters-group-title {
+    margin-bottom: var(--space-2);
+}
+
+.supporters-all-list {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: baseline;
+    line-height: 2.2;
+    max-height: 550px;
+    overflow-y: auto;
+    padding: var(--space-2) 0 40px 0; /* Extra padding at bottom for final visibility */
+    color: var(--text-color);
+    scroll-behavior: auto; /* Ensure manual scroll is immediate */
+}
+
+/* Subtle scrollbar for credits look */
+.supporters-all-list::-webkit-scrollbar {
+    width: 4px;
+}
+
+.supporters-all-list::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+.supporters-all-list::-webkit-scrollbar-thumb {
+    background: rgba(0, 0, 0, 0.05);
+    border-radius: 4px;
+}
+
+.supporters-all-list:hover::-webkit-scrollbar-thumb {
+    background: rgba(0, 0, 0, 0.15);
+}
+
+.supporter-name-item {
+    font-size: 0.95em;
+    color: var(--text-color);
+    opacity: 0.85;
+    transition: all 0.2s ease;
+    white-space: nowrap;
+    cursor: default;
+}
+
+.supporter-name-item:hover {
+    opacity: 1;
+    color: var(--lora-accent);
+}
+
+.supporter-separator {
+    margin: 0 10px;
+    color: var(--text-color);
+    opacity: 0.25;
+    font-weight: 300;
+    user-select: none;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .support-container {
+        flex-direction: column;
+    }
+    
+    .support-left {
+        flex: 1;
+    }
+    
+    .support-right {
+        border-left: none;
+        border-top: 1px solid var(--lora-border);
+        padding-left: 0;
+        padding-top: var(--space-3);
+    }
+    
+    .supporters-all-list {
+        max-height: 200px;
+    }
+    
+    .supporters-special-grid {
+        grid-template-columns: 1fr;
+    }
 }
--- a/static/css/components/modal/update-modal.css
+++ b/static/css/components/modal/update-modal.css
@@ -250,12 +250,11 @@
 .changelog-content {
    max-height: 550px;
    overflow-y: auto;
-    padding-left: var(--space-3);
 }

 .changelog-item {
    margin-bottom: var(--space-2);
-    padding-bottom: var(--space-2);
+    padding: var(--space-2);
    border-bottom: 1px solid var(--lora-border);
 }

@@ -302,8 +301,7 @@

 .changelog-item.latest {
    background-color: rgba(66, 153, 225, 0.05);
-    border-radius: var(--border-radius-sm);
-    padding: var(--space-2);
+    border-radius: var(--border-radius-sm); 
    border: 1px solid rgba(66, 153, 225, 0.2);
 }

--- a/static/css/components/sidebar.css
+++ b/static/css/components/sidebar.css
@@ -573,3 +573,171 @@
 .sidebar-tree-container::-webkit-scrollbar-thumb:hover {
    background: var(--text-muted);
 }
+
+/* ===== Drag and Drop - Create Folder Zone ===== */
+
+/* Empty state drag hint */
+.sidebar-empty-hint {
+    margin-top: 12px;
+    font-size: 0.8em;
+    color: var(--text-muted);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    padding: 8px;
+    border-radius: var(--border-radius-xs);
+    background: oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.05);
+    border: 1px dashed oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.2);
+}
+
+.sidebar-empty-hint i {
+    font-size: 0.9em;
+    opacity: 0.8;
+    margin: 0;
+    display: inline;
+}
+
+/* Create folder drop zone */
+.sidebar-create-folder-zone {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    right: 16px;
+    padding: 16px;
+    border: 2px dashed oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.4);
+    border-radius: var(--border-radius-xs);
+    background: oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.08);
+    opacity: 0;
+    transform: translateY(10px);
+    transition: all 0.2s ease;
+    pointer-events: none;
+    z-index: 10;
+}
+
+.sidebar-create-folder-zone.active {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+.sidebar-create-folder-content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 8px;
+    color: var(--lora-accent);
+    font-size: 0.85em;
+    text-align: center;
+}
+
+.sidebar-create-folder-content i {
+    font-size: 1.5em;
+    opacity: 0.8;
+}
+
+/* Create folder input container */
+.sidebar-create-folder-input-container {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    right: 16px;
+    padding: 12px;
+    background: var(--bg-color);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-xs);
+    box-shadow: 0 3px 8px rgba(0, 0, 0, 0.15);
+    z-index: 20;
+    animation: slideUp 0.2s ease;
+}
+
+@keyframes slideUp {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.sidebar-create-folder-input-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.sidebar-create-folder-input-wrapper > i {
+    color: var(--lora-accent);
+    font-size: 1em;
+}
+
+.sidebar-create-folder-input {
+    flex: 1;
+    padding: 6px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-xs);
+    background: var(--bg-color);
+    color: var(--text-color);
+    font-size: 0.85em;
+    outline: none;
+    transition: all 0.2s ease;
+}
+
+.sidebar-create-folder-input:focus {
+    border-color: var(--lora-accent);
+    box-shadow: 0 0 0 2px oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.15);
+}
+
+.sidebar-create-folder-btn {
+    width: 28px;
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border: none;
+    border-radius: var(--border-radius-xs);
+    cursor: pointer;
+    transition: all 0.2s ease;
+    background: transparent;
+    color: var(--text-muted);
+}
+
+.sidebar-create-folder-btn:hover {
+    background: var(--lora-surface);
+    color: var(--text-color);
+}
+
+.sidebar-create-folder-confirm:hover {
+    background: oklch(from var(--success-color) l c h / 0.15);
+    color: var(--success-color);
+}
+
+.sidebar-create-folder-cancel:hover {
+    background: oklch(from var(--error-color) l c h / 0.15);
+    color: var(--error-color);
+}
+
+.sidebar-create-folder-hint {
+    margin-top: 6px;
+    font-size: 0.75em;
+    color: var(--text-muted);
+    text-align: center;
+    opacity: 0.8;
+}
+
+/* Dragging state for sidebar */
+.folder-sidebar.dragging-active {
+    border-color: oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.5);
+    box-shadow: 0 0 0 3px oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.1),
+                0 2px 8px rgba(0, 0, 0, 0.08);
+}
+
+.folder-sidebar.dragging-active .sidebar-tree-container {
+    background: oklch(var(--lora-accent-l) var(--lora-accent-c) var(--lora-accent-h) / 0.02);
+}
+
+/* Tree container positioning for create folder elements */
+.sidebar-tree-container {
+    position: relative;
+}
--- a/static/css/components/statistics.css
+++ b/static/css/components/statistics.css
@@ -196,6 +196,9 @@
    display: flex;
    flex-direction: column;
    gap: 8px;
+    max-height: 400px;
+    overflow-y: auto;
+    padding-right: 4px;
 }

 .model-item {
--- a/static/js/api/apiConfig.js
+++ b/static/js/api/apiConfig.js
@@ -86,6 +86,7 @@ export function getApiEndpoints(modelType) {

        // Preview management
        replacePreview: `/api/lm/${modelType}/replace-preview`,
+        setPreviewFromUrl: `/api/lm/${modelType}/set-preview-from-url`,

        // Query operations
        scan: `/api/lm/${modelType}/scan`,
--- a/static/js/api/baseModelApi.js
+++ b/static/js/api/baseModelApi.js
@@ -307,6 +307,56 @@ export class BaseModelApiClient {
        }
    }

+    /**
+     * Set a preview from a remote URL (e.g., CivitAI)
+     * @param {string} filePath - Path to the model file
+     * @param {string} imageUrl - Remote image URL
+     * @param {number} nsfwLevel - NSFW level for the preview
+     */
+    async setPreviewFromUrl(filePath, imageUrl, nsfwLevel = 0) {
+        try {
+            state.loadingManager.showSimpleLoading('Setting preview from URL...');
+
+            const response = await fetch(this.apiConfig.endpoints.setPreviewFromUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model_path: filePath,
+                    image_url: imageUrl,
+                    nsfw_level: nsfwLevel
+                })
+            });
+
+            if (!response.ok) {
+                throw new Error('Failed to set preview from URL');
+            }
+
+            const data = await response.json();
+            const pageState = this.getPageState();
+
+            const timestamp = Date.now();
+            if (pageState.previewVersions) {
+                pageState.previewVersions.set(filePath, timestamp);
+
+                const storageKey = `${this.modelType}_preview_versions`;
+                saveMapToStorage(storageKey, pageState.previewVersions);
+            }
+
+            const updateData = {
+                preview_url: data.preview_url,
+                preview_nsfw_level: data.preview_nsfw_level
+            };
+
+            state.virtualScroller.updateSingleItem(filePath, updateData);
+            showToast('toast.api.previewUpdated', {}, 'success');
+        } catch (error) {
+            console.error('Error setting preview from URL:', error);
+            showToast('toast.api.previewUploadFailed', {}, 'error');
+        } finally {
+            state.loadingManager.hide();
+        }
+    }
+
    async saveModelMetadata(filePath, data) {
        try {
            state.loadingManager.showSimpleLoading('Saving metadata...');
--- a/static/js/api/recipeApi.js
+++ b/static/js/api/recipeApi.js
@@ -259,6 +259,26 @@ export async function resetAndReload(updateFolders = false) {
    });
 }

+/**
+ * Sync changes - quick refresh without rebuilding cache (similar to models page)
+ */
+export async function syncChanges() {
+    try {
+        state.loadingManager.showSimpleLoading('Syncing changes...');
+
+        // Simply reload the recipes without rebuilding cache
+        await resetAndReload();
+
+        showToast('toast.recipes.syncComplete', {}, 'success');
+    } catch (error) {
+        console.error('Error syncing recipes:', error);
+        showToast('toast.recipes.syncFailed', { message: error.message }, 'error');
+    } finally {
+        state.loadingManager.hide();
+        state.loadingManager.restoreProgressBar();
+    }
+}
+
 /**
 * Refreshes the recipe list by first rebuilding the cache and then loading recipes
 */
--- a/static/js/components/Header.js
+++ b/static/js/components/Header.js
@@ -5,6 +5,7 @@ import { FilterManager } from '../managers/FilterManager.js';
 import { initPageState } from '../state/index.js';
 import { getStorageItem } from '../utils/storageHelpers.js';
 import { updateElementAttribute } from '../utils/i18nHelpers.js';
+import { renderSupporters } from '../services/supportersService.js';

 /**
 * Header.js - Manages the application header behavior across different pages
@@ -85,9 +86,15 @@ export class HeaderManager {
      // Handle support toggle
      const supportToggle = document.getElementById('supportToggleBtn');
      if (supportToggle) {
-        supportToggle.addEventListener('click', () => {
+        supportToggle.addEventListener('click', async () => {
          if (window.modalManager) {
            window.modalManager.toggleModal('supportModal');
+            // Load supporters data when modal opens
+            try {
+              await renderSupporters();
+            } catch (error) {
+              console.error('Error loading supporters:', error);
+            }
          }
        });
      }
--- a/static/js/components/RecipeCard.js
+++ b/static/js/components/RecipeCard.js
@@ -21,6 +21,7 @@ class RecipeCard {
    createCardElement() {
        const card = document.createElement('div');
        card.className = 'model-card';
+        card.draggable = true;
        card.dataset.filepath = this.recipe.file_path;
        card.dataset.title = this.recipe.title;
        card.dataset.nsfwLevel = this.recipe.preview_nsfw_level || 0;
--- a/static/js/components/SidebarManager.js
+++ b/static/js/components/SidebarManager.js
@@ -7,6 +7,7 @@ import { translate } from '../utils/i18nHelpers.js';
 import { state } from '../state/index.js';
 import { bulkManager } from '../managers/BulkManager.js';
 import { showToast } from '../utils/uiHelpers.js';
+import { escapeHtml, escapeAttribute } from './shared/utils.js';

 export class SidebarManager {
    constructor() {
@@ -29,11 +30,14 @@ export class SidebarManager {
        this.draggedRootPath = null;
        this.draggedFromBulk = false;
        this.dragHandlersInitialized = false;
+        this.sidebarDragHandlersInitialized = false;
        this.folderTreeElement = null;
        this.currentDropTarget = null;
        this.lastPageControls = null;
        this.isDisabledBySetting = false;
        this.initializationPromise = null;
+        this.isCreatingFolder = false;
+        this._pendingDragState = null; // 用于保存拖拽创建文件夹时的状态

        // Bind methods
        this.handleTreeClick = this.handleTreeClick.bind(this);
@@ -56,6 +60,12 @@ export class SidebarManager {
        this.handleFolderDragOver = this.handleFolderDragOver.bind(this);
        this.handleFolderDragLeave = this.handleFolderDragLeave.bind(this);
        this.handleFolderDrop = this.handleFolderDrop.bind(this);
+        this.handleSidebarDragEnter = this.handleSidebarDragEnter.bind(this);
+        this.handleSidebarDragOver = this.handleSidebarDragOver.bind(this);
+        this.handleSidebarDragLeave = this.handleSidebarDragLeave.bind(this);
+        this.handleSidebarDrop = this.handleSidebarDrop.bind(this);
+        this.handleCreateFolderSubmit = this.handleCreateFolderSubmit.bind(this);
+        this.handleCreateFolderCancel = this.handleCreateFolderCancel.bind(this);
    }

    setHostPageControls(pageControls) {
@@ -118,19 +128,18 @@ export class SidebarManager {
        this.removeEventHandlers();

        this.clearAllDropHighlights();
-        if (this.dragHandlersInitialized) {
-            document.removeEventListener('dragstart', this.handleCardDragStart);
-            document.removeEventListener('dragend', this.handleCardDragEnd);
-            this.dragHandlersInitialized = false;
-        }
-        if (this.folderTreeElement) {
-            this.folderTreeElement.removeEventListener('dragenter', this.handleFolderDragEnter);
-            this.folderTreeElement.removeEventListener('dragover', this.handleFolderDragOver);
-            this.folderTreeElement.removeEventListener('dragleave', this.handleFolderDragLeave);
-            this.folderTreeElement.removeEventListener('drop', this.handleFolderDrop);
-            this.folderTreeElement = null;
-        }
        this.resetDragState();
+        this.hideCreateFolderInput();
+
+        // Cleanup sidebar drag handlers
+        const sidebar = document.getElementById('folderSidebar');
+        if (sidebar && this.sidebarDragHandlersInitialized) {
+            sidebar.removeEventListener('dragenter', this.handleSidebarDragEnter);
+            sidebar.removeEventListener('dragover', this.handleSidebarDragOver);
+            sidebar.removeEventListener('dragleave', this.handleSidebarDragLeave);
+            sidebar.removeEventListener('drop', this.handleSidebarDrop);
+            this.sidebarDragHandlersInitialized = false;
+        }

        // Reset state
        this.pageControls = null;
@@ -233,6 +242,16 @@ export class SidebarManager {

            this.folderTreeElement = folderTree;
        }
+
+        // Add sidebar-level drag handlers for creating new folders
+        const sidebar = document.getElementById('folderSidebar');
+        if (sidebar && !this.sidebarDragHandlersInitialized) {
+            sidebar.addEventListener('dragenter', this.handleSidebarDragEnter);
+            sidebar.addEventListener('dragover', this.handleSidebarDragOver);
+            sidebar.addEventListener('dragleave', this.handleSidebarDragLeave);
+            sidebar.addEventListener('drop', this.handleSidebarDrop);
+            this.sidebarDragHandlersInitialized = true;
+        }
    }

    handleCardDragStart(event) {
@@ -271,6 +290,12 @@ export class SidebarManager {
        }

        card.classList.add('dragging');
+
+        // Add dragging state to sidebar for visual feedback
+        const sidebar = document.getElementById('folderSidebar');
+        if (sidebar) {
+            sidebar.classList.add('dragging-active');
+        }
    }

    handleCardDragEnd(event) {
@@ -278,6 +303,13 @@ export class SidebarManager {
        if (card) {
            card.classList.remove('dragging');
        }
+        
+        // Remove dragging state from sidebar
+        const sidebar = document.getElementById('folderSidebar');
+        if (sidebar) {
+            sidebar.classList.remove('dragging-active');
+        }
+        
        this.clearAllDropHighlights();
        this.resetDragState();
    }
@@ -417,7 +449,12 @@ export class SidebarManager {
    }

    async performDragMove(targetRelativePath) {
+        console.log('[SidebarManager] performDragMove called with targetRelativePath:', targetRelativePath);
+        console.log('[SidebarManager] draggedFilePaths:', this.draggedFilePaths);
+        console.log('[SidebarManager] draggedRootPath:', this.draggedRootPath);
+        
        if (!this.draggedFilePaths || this.draggedFilePaths.length === 0) {
+            console.log('[SidebarManager] performDragMove returning false - no draggedFilePaths');
            return false;
        }

@@ -428,12 +465,15 @@ export class SidebarManager {
        }

        if (this.apiClient?.apiConfig?.config?.supportsMove === false) {
+            console.log('[SidebarManager] performDragMove returning false - supportsMove is false');
            showToast('toast.models.moveFailed', { message: translate('sidebar.dragDrop.moveUnsupported', {}, 'Move not supported for this page') }, 'error');
            return false;
        }

        const rootPath = this.draggedRootPath ? this.draggedRootPath.replace(/\\/g, '/') : '';
+        console.log('[SidebarManager] rootPath:', rootPath);
        if (!rootPath) {
+            console.log('[SidebarManager] performDragMove returning false - no rootPath');
            showToast(
                'toast.models.moveFailed',
                { message: translate('sidebar.dragDrop.unableToResolveRoot', {}, 'Unable to determine destination path for move.') },
@@ -446,15 +486,19 @@ export class SidebarManager {
        const useBulkMove = this.draggedFromBulk || this.draggedFilePaths.length > 1;

        try {
+            console.log('[SidebarManager] calling apiClient.move, useBulkMove:', useBulkMove);
            if (useBulkMove) {
                await this.apiClient.moveBulkModels(this.draggedFilePaths, destination);
            } else {
                await this.apiClient.moveSingleModel(this.draggedFilePaths[0], destination);
            }
+            console.log('[SidebarManager] apiClient.move successful');

            if (this.pageControls && typeof this.pageControls.resetAndReload === 'function') {
+                console.log('[SidebarManager] calling resetAndReload');
                await this.pageControls.resetAndReload(true);
            } else {
+                console.log('[SidebarManager] calling refresh');
                await this.refresh();
            }

@@ -462,10 +506,12 @@ export class SidebarManager {
                bulkManager.toggleBulkMode();
            }

+            console.log('[SidebarManager] performDragMove returning true');
            return true;
        } catch (error) {
-            console.error('Error moving model(s) via drag-and-drop:', error);
+            console.error('[SidebarManager] Error moving model(s) via drag-and-drop:', error);
            showToast('toast.models.moveFailed', { message: error.message || 'Unknown error' }, 'error');
+            console.log('[SidebarManager] performDragMove returning false due to error');
            return false;
        }
    }
@@ -476,6 +522,365 @@ export class SidebarManager {
        this.draggedFromBulk = false;
    }

+    // Version of performDragMove that accepts state as parameters (for create folder submit)
+    async performDragMoveWithState(targetRelativePath, draggedFilePaths, draggedRootPath, draggedFromBulk) {
+        console.log('[SidebarManager] performDragMoveWithState called with:', { targetRelativePath, draggedFilePaths, draggedRootPath, draggedFromBulk });
+
+        if (!draggedFilePaths || draggedFilePaths.length === 0) {
+            console.log('[SidebarManager] performDragMoveWithState returning false - no draggedFilePaths');
+            return false;
+        }
+
+        if (!this.apiClient) {
+            this.apiClient = this.pageControls?.getSidebarApiClient?.()
+                || this.pageControls?.sidebarApiClient
+                || getModelApiClient();
+        }
+
+        if (this.apiClient?.apiConfig?.config?.supportsMove === false) {
+            console.log('[SidebarManager] performDragMoveWithState returning false - supportsMove is false');
+            showToast('toast.models.moveFailed', { message: translate('sidebar.dragDrop.moveUnsupported', {}, 'Move not supported for this page') }, 'error');
+            return false;
+        }
+
+        const rootPath = draggedRootPath ? draggedRootPath.replace(/\\/g, '/') : '';
+        console.log('[SidebarManager] rootPath:', rootPath);
+        if (!rootPath) {
+            console.log('[SidebarManager] performDragMoveWithState returning false - no rootPath');
+            showToast(
+                'toast.models.moveFailed',
+                { message: translate('sidebar.dragDrop.unableToResolveRoot', {}, 'Unable to determine destination path for move.') },
+                'error'
+            );
+            return false;
+        }
+
+        const destination = this.combineRootAndRelativePath(rootPath, targetRelativePath);
+        const useBulkMove = draggedFromBulk || draggedFilePaths.length > 1;
+
+        try {
+            console.log('[SidebarManager] calling apiClient.move, useBulkMove:', useBulkMove);
+            if (useBulkMove) {
+                await this.apiClient.moveBulkModels(draggedFilePaths, destination);
+            } else {
+                await this.apiClient.moveSingleModel(draggedFilePaths[0], destination);
+            }
+            console.log('[SidebarManager] apiClient.move successful');
+
+            if (this.pageControls && typeof this.pageControls.resetAndReload === 'function') {
+                console.log('[SidebarManager] calling resetAndReload');
+                await this.pageControls.resetAndReload(true);
+            } else {
+                console.log('[SidebarManager] calling refresh');
+                await this.refresh();
+            }
+
+            if (draggedFromBulk && state.bulkMode && typeof bulkManager?.toggleBulkMode === 'function') {
+                bulkManager.toggleBulkMode();
+            }
+
+            console.log('[SidebarManager] performDragMoveWithState returning true');
+            return true;
+        } catch (error) {
+            console.error('[SidebarManager] Error moving model(s) via drag-and-drop:', error);
+            showToast('toast.models.moveFailed', { message: error.message || 'Unknown error' }, 'error');
+            console.log('[SidebarManager] performDragMoveWithState returning false due to error');
+            return false;
+        }
+    }
+
+    // ===== Sidebar-level drag handlers for creating new folders =====
+
+    handleSidebarDragEnter(event) {
+        if (!this.draggedFilePaths || this.draggedFilePaths.length === 0) return;
+
+        const sidebar = document.getElementById('folderSidebar');
+        if (!sidebar) return;
+
+        // Only show create folder zone if not hovering over an existing folder
+        const folderElement = this.getFolderElementFromEvent(event);
+        if (folderElement) {
+            this.hideCreateFolderZone();
+            return;
+        }
+
+        // Check if drag is within the sidebar tree container area
+        const treeContainer = document.querySelector('.sidebar-tree-container');
+        if (treeContainer && treeContainer.contains(event.target)) {
+            event.preventDefault();
+            this.showCreateFolderZone();
+        }
+    }
+
+    handleSidebarDragOver(event) {
+        if (!this.draggedFilePaths || this.draggedFilePaths.length === 0) return;
+
+        const folderElement = this.getFolderElementFromEvent(event);
+        if (folderElement) {
+            this.hideCreateFolderZone();
+            return;
+        }
+
+        const treeContainer = document.querySelector('.sidebar-tree-container');
+        if (treeContainer && treeContainer.contains(event.target)) {
+            event.preventDefault();
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = 'move';
+            }
+        }
+    }
+
+    handleSidebarDragLeave(event) {
+        if (!this.draggedFilePaths || this.draggedFilePaths.length === 0) return;
+
+        const sidebar = document.getElementById('folderSidebar');
+        if (!sidebar) return;
+
+        const relatedTarget = event.relatedTarget instanceof Element ? event.relatedTarget : null;
+
+        // Only hide if leaving the sidebar entirely
+        if (!relatedTarget || !sidebar.contains(relatedTarget)) {
+            this.hideCreateFolderZone();
+        }
+    }
+
+    async handleSidebarDrop(event) {
+        if (!this.draggedFilePaths || this.draggedFilePaths.length === 0) return;
+
+        const folderElement = this.getFolderElementFromEvent(event);
+        if (folderElement) {
+            // Let the folder drop handler take over
+            return;
+        }
+
+        const treeContainer = document.querySelector('.sidebar-tree-container');
+        if (!treeContainer || !treeContainer.contains(event.target)) {
+            return;
+        }
+
+        event.preventDefault();
+        event.stopPropagation();
+
+        // Show create folder input
+        this.showCreateFolderInput();
+    }
+
+    showCreateFolderZone() {
+        if (this.isCreatingFolder) return;
+
+        const treeContainer = document.querySelector('.sidebar-tree-container');
+        if (!treeContainer) return;
+
+        let zone = document.getElementById('sidebarCreateFolderZone');
+        if (!zone) {
+            zone = document.createElement('div');
+            zone.id = 'sidebarCreateFolderZone';
+            zone.className = 'sidebar-create-folder-zone';
+            zone.innerHTML = `
+                <div class="sidebar-create-folder-content">
+                    <i class="fas fa-plus-circle"></i>
+                    <span>${translate('sidebar.dragDrop.createFolderHint', {}, 'Release to create new folder')}</span>
+                </div>
+            `;
+            treeContainer.appendChild(zone);
+        }
+
+        zone.classList.add('active');
+    }
+
+    hideCreateFolderZone() {
+        const zone = document.getElementById('sidebarCreateFolderZone');
+        if (zone) {
+            zone.classList.remove('active');
+        }
+    }
+
+    showCreateFolderInput() {
+        console.log('[SidebarManager] showCreateFolderInput called');
+        this.isCreatingFolder = true;
+        
+        // 立即保存拖拽状态，防止后续事件（如blur）清空状态
+        this._pendingDragState = {
+            filePaths: this.draggedFilePaths ? [...this.draggedFilePaths] : null,
+            rootPath: this.draggedRootPath,
+            fromBulk: this.draggedFromBulk
+        };
+        console.log('[SidebarManager] saved pending drag state:', this._pendingDragState);
+        
+        this.hideCreateFolderZone();
+
+        const treeContainer = document.querySelector('.sidebar-tree-container');
+        if (!treeContainer) return;
+
+        // Remove existing input if any
+        this.hideCreateFolderInput();
+
+        const inputContainer = document.createElement('div');
+        inputContainer.id = 'sidebarCreateFolderInput';
+        inputContainer.className = 'sidebar-create-folder-input-container';
+        inputContainer.innerHTML = `
+            <div class="sidebar-create-folder-input-wrapper">
+                <i class="fas fa-folder-plus"></i>
+                <input type="text" 
+                       class="sidebar-create-folder-input" 
+                       placeholder="${translate('sidebar.dragDrop.newFolderName', {}, 'New folder name')}" 
+                       autofocus />
+                <button class="sidebar-create-folder-btn sidebar-create-folder-confirm" title="${translate('common.confirm', {}, 'Confirm')}">
+                    <i class="fas fa-check"></i>
+                </button>
+                <button class="sidebar-create-folder-btn sidebar-create-folder-cancel" title="${translate('common.cancel', {}, 'Cancel')}">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+            <div class="sidebar-create-folder-hint">
+                ${translate('sidebar.dragDrop.folderNameHint', {}, 'Press Enter to confirm, Escape to cancel')}
+            </div>
+        `;
+
+        treeContainer.appendChild(inputContainer);
+
+        // Focus input
+        const input = inputContainer.querySelector('.sidebar-create-folder-input');
+        if (input) {
+            input.focus();
+        }
+
+        // Bind events
+        const confirmBtn = inputContainer.querySelector('.sidebar-create-folder-confirm');
+        const cancelBtn = inputContainer.querySelector('.sidebar-create-folder-cancel');
+
+        // Flag to prevent blur from canceling when clicking buttons
+        let isButtonClick = false;
+
+        confirmBtn?.addEventListener('mousedown', () => { 
+            isButtonClick = true; 
+            console.log('[SidebarManager] confirmBtn mousedown - isButtonClick set to true');
+        });
+        cancelBtn?.addEventListener('mousedown', () => { 
+            isButtonClick = true; 
+            console.log('[SidebarManager] cancelBtn mousedown - isButtonClick set to true');
+        });
+
+        confirmBtn?.addEventListener('click', (e) => {
+            console.log('[SidebarManager] confirmBtn click event triggered');
+            this.handleCreateFolderSubmit();
+        });
+        cancelBtn?.addEventListener('click', () => {
+            console.log('[SidebarManager] cancelBtn click event triggered');
+            this.handleCreateFolderCancel();
+        });
+        input?.addEventListener('keydown', (e) => {
+            console.log('[SidebarManager] input keydown:', e.key);
+            if (e.key === 'Enter') {
+                console.log('[SidebarManager] Enter pressed, calling handleCreateFolderSubmit');
+                this.handleCreateFolderSubmit();
+            } else if (e.key === 'Escape') {
+                console.log('[SidebarManager] Escape pressed, calling handleCreateFolderCancel');
+                this.handleCreateFolderCancel();
+            }
+        });
+        input?.addEventListener('blur', () => {
+            console.log('[SidebarManager] input blur event - isButtonClick:', isButtonClick);
+            // Delay to allow button clicks to process first
+            setTimeout(() => {
+                console.log('[SidebarManager] blur timeout - isButtonClick:', isButtonClick, 'activeElement:', document.activeElement?.className);
+                if (!isButtonClick && document.activeElement !== confirmBtn && document.activeElement !== cancelBtn) {
+                    console.log('[SidebarManager] blur timeout - calling handleCreateFolderCancel');
+                    this.handleCreateFolderCancel();
+                } else {
+                    console.log('[SidebarManager] blur timeout - NOT canceling (button click detected)');
+                }
+                isButtonClick = false;
+            }, 200);
+        });
+    }
+
+    hideCreateFolderInput() {
+        console.log('[SidebarManager] hideCreateFolderInput called');
+        const inputContainer = document.getElementById('sidebarCreateFolderInput');
+        console.log('[SidebarManager] inputContainer:', inputContainer);
+        if (inputContainer) {
+            inputContainer.remove();
+            console.log('[SidebarManager] inputContainer removed');
+        }
+        this.isCreatingFolder = false;
+        console.log('[SidebarManager] isCreatingFolder set to false');
+    }
+
+    async handleCreateFolderSubmit() {
+        console.log('[SidebarManager] handleCreateFolderSubmit called');
+        const input = document.querySelector('#sidebarCreateFolderInput .sidebar-create-folder-input');
+        console.log('[SidebarManager] input element:', input);
+        if (!input) {
+            console.log('[SidebarManager] input not found, returning');
+            return;
+        }
+
+        const folderName = input.value.trim();
+        console.log('[SidebarManager] folderName:', folderName);
+        if (!folderName) {
+            showToast('sidebar.dragDrop.emptyFolderName', {}, 'warning');
+            return;
+        }
+
+        // Validate folder name (no slashes, no special chars)
+        if (/[\\/:*?"<>|]/.test(folderName)) {
+            showToast('sidebar.dragDrop.invalidFolderName', {}, 'error');
+            return;
+        }
+
+        // Build target path - use selected path as parent, or root if none selected
+        const parentPath = this.selectedPath || '';
+        const targetRelativePath = parentPath ? `${parentPath}/${folderName}` : folderName;
+        console.log('[SidebarManager] targetRelativePath:', targetRelativePath);
+
+        // 使用 showCreateFolderInput 时保存的拖拽状态
+        const pendingState = this._pendingDragState;
+        console.log('[SidebarManager] using pending drag state:', pendingState);
+        
+        if (!pendingState || !pendingState.filePaths || pendingState.filePaths.length === 0) {
+            console.log('[SidebarManager] no pending drag state found, cannot proceed');
+            showToast('sidebar.dragDrop.noDragState', {}, 'error');
+            this.hideCreateFolderInput();
+            return;
+        }
+
+        this.hideCreateFolderInput();
+
+        // Perform the move with saved state
+        console.log('[SidebarManager] calling performDragMove with pending state');
+        const success = await this.performDragMoveWithState(targetRelativePath, pendingState.filePaths, pendingState.rootPath, pendingState.fromBulk);
+        console.log('[SidebarManager] performDragMove result:', success);
+
+        if (success) {
+            // Expand the parent folder to show the new folder
+            if (parentPath) {
+                this.expandedNodes.add(parentPath);
+                this.saveExpandedState();
+            }
+            // Refresh the tree to show the newly created folder
+            // restoreSelectedFolder() inside refresh() will maintain the current active folder
+            await this.refresh();
+        }
+
+        // 清理待处理的拖拽状态
+        this._pendingDragState = null;
+        this.resetDragState();
+        this.clearAllDropHighlights();
+    }
+
+    handleCreateFolderCancel() {
+        this.hideCreateFolderInput();
+        // 清理待处理的拖拽状态
+        this._pendingDragState = null;
+        this.resetDragState();
+        this.clearAllDropHighlights();
+    }
+
+    saveSelectedFolder() {
+        setStorageItem(`${this.pageType}_activeFolder`, this.selectedPath);
+    }
+
    clearAllDropHighlights() {
        const highlighted = document.querySelectorAll('.sidebar-tree-node-content.drop-target, .sidebar-node-content.drop-target');
        highlighted.forEach((element) => element.classList.remove('drop-target'));
@@ -890,15 +1295,19 @@ export class SidebarManager {
            const isExpanded = this.expandedNodes.has(currentPath);
            const isSelected = this.selectedPath === currentPath;

+            const escapedPath = escapeAttribute(currentPath);
+            const escapedFolderName = escapeHtml(folderName);
+            const escapedTitle = escapeAttribute(folderName);
+
            return `
-                <div class="sidebar-tree-node" data-path="${currentPath}">
-                    <div class="sidebar-tree-node-content ${isSelected ? 'selected' : ''}" data-path="${currentPath}">
+                <div class="sidebar-tree-node" data-path="${escapedPath}">
+                    <div class="sidebar-tree-node-content ${isSelected ? 'selected' : ''}" data-path="${escapedPath}">
                        <div class="sidebar-tree-expand-icon ${isExpanded ? 'expanded' : ''}" 
                             style="${hasChildren ? '' : 'opacity: 0; pointer-events: none;'}">
                            <i class="fas fa-chevron-right"></i>
                        </div>
                        <i class="fas fa-folder sidebar-tree-folder-icon"></i>
-                        <div class="sidebar-tree-folder-name" title="${folderName}">${folderName}</div>
+                        <div class="sidebar-tree-folder-name" title="${escapedTitle}">${escapedFolderName}</div>
                    </div>
                    ${hasChildren ? `
                        <div class="sidebar-tree-children ${isExpanded ? 'expanded' : ''}">
@@ -917,7 +1326,11 @@ export class SidebarManager {
        folderTree.innerHTML = `
            <div class="sidebar-tree-placeholder">
                <i class="fas fa-folder-open"></i>
-                <div>No folders found</div>
+                <div>${translate('sidebar.empty.noFolders', {}, 'No folders found')}</div>
+                <div class="sidebar-empty-hint">
+                    <i class="fas fa-hand-pointer"></i>
+                    ${translate('sidebar.empty.dragHint', {}, 'Drag items here to create folders')}
+                </div>
            </div>
        `;
    }
@@ -934,12 +1347,15 @@ export class SidebarManager {
        const foldersHtml = this.foldersList.map(folder => {
            const displayName = folder === '' ? '/' : folder;
            const isSelected = this.selectedPath === folder;
+            const escapedPath = escapeAttribute(folder);
+            const escapedDisplayName = escapeHtml(displayName);
+            const escapedTitle = escapeAttribute(displayName);

            return `
-                <div class="sidebar-folder-item ${isSelected ? 'selected' : ''}" data-path="${folder}">
-                    <div class="sidebar-node-content" data-path="${folder}">
+                <div class="sidebar-folder-item ${isSelected ? 'selected' : ''}" data-path="${escapedPath}">
+                    <div class="sidebar-node-content" data-path="${escapedPath}">
                        <i class="fas fa-folder sidebar-folder-icon"></i>
-                        <div class="sidebar-folder-name" title="${displayName}">${displayName}</div>
+                        <div class="sidebar-folder-name" title="${escapedTitle}">${escapedDisplayName}</div>
                    </div>
                </div>
            `;
@@ -1162,7 +1578,8 @@ export class SidebarManager {

            // Add selection to current path
            if (this.selectedPath !== null && this.selectedPath !== undefined) {
-                const selectedItem = folderTree.querySelector(`[data-path="${this.selectedPath}"]`);
+                const escapedPathSelector = CSS.escape(this.selectedPath);
+                const selectedItem = folderTree.querySelector(`[data-path="${escapedPathSelector}"]`);
                if (selectedItem) {
                    selectedItem.classList.add('selected');
                }
@@ -1173,7 +1590,8 @@ export class SidebarManager {
            });

            if (this.selectedPath !== null && this.selectedPath !== undefined) {
-                const selectedNode = folderTree.querySelector(`[data-path="${this.selectedPath}"] .sidebar-tree-node-content`);
+                const escapedPathSelector = CSS.escape(this.selectedPath);
+                const selectedNode = folderTree.querySelector(`[data-path="${escapedPathSelector}"] .sidebar-tree-node-content`);
                if (selectedNode) {
                    selectedNode.classList.add('selected');
                    this.expandPathParents(this.selectedPath);
@@ -1247,7 +1665,7 @@ export class SidebarManager {
        const breadcrumbs = [`
            <div class="breadcrumb-dropdown">
                <span class="sidebar-breadcrumb-item ${isRootSelected ? 'active' : ''}" data-path="">
-                    <i class="fas fa-home"></i> ${this.apiClient.apiConfig.config.displayName} root
+                    <i class="fas fa-home"></i> ${escapeHtml(this.apiClient.apiConfig.config.displayName)} root
                </span>
            </div>
        `];
@@ -1267,8 +1685,8 @@ export class SidebarManager {
                        </span>
                        <div class="breadcrumb-dropdown-menu">
                            ${nextLevelFolders.map(folder => `
-                                <div class="breadcrumb-dropdown-item" data-path="${folder}">
-                                    ${folder}
+                                <div class="breadcrumb-dropdown-item" data-path="${escapeAttribute(folder)}">
+                                    ${escapeHtml(folder)}
                                </div>`).join('')
                    }
                        </div>
@@ -1284,12 +1702,14 @@ export class SidebarManager {

            // Get siblings for this level
            const siblings = this.getSiblingFolders(parts, index);
+            const escapedCurrentPath = escapeAttribute(currentPath);
+            const escapedPart = escapeHtml(part);

            breadcrumbs.push(`<span class="sidebar-breadcrumb-separator">/</span>`);
            breadcrumbs.push(`
                <div class="breadcrumb-dropdown">
-                    <span class="sidebar-breadcrumb-item ${isLast ? 'active' : ''}" data-path="${currentPath}">
-                        ${part}
+                    <span class="sidebar-breadcrumb-item ${isLast ? 'active' : ''}" data-path="${escapedCurrentPath}">
+                        ${escapedPart}
                        ${siblings.length > 1 ? `
                            <span class="breadcrumb-dropdown-indicator">
                                <i class="fas fa-caret-down"></i>
@@ -1298,11 +1718,14 @@ export class SidebarManager {
                    </span>
                    ${siblings.length > 1 ? `
                        <div class="breadcrumb-dropdown-menu">
-                            ${siblings.map(folder => `
-                                <div class="breadcrumb-dropdown-item ${folder === part ? 'active' : ''}" 
-                                     data-path="${currentPath.replace(part, folder)}">
-                                    ${folder}
-                                </div>`).join('')
+                            ${siblings.map(folder => {
+                                const siblingPath = parts.slice(0, index).concat(folder).join('/');
+                                return `
+                                    <div class="breadcrumb-dropdown-item ${folder === part ? 'active' : ''}" 
+                                         data-path="${escapeAttribute(siblingPath)}">
+                                        ${escapeHtml(folder)}
+                                    </div>`;
+                            }).join('')
                    }
                        </div>
                    ` : ''}
@@ -1324,8 +1747,8 @@ export class SidebarManager {
                            </span>
                            <div class="breadcrumb-dropdown-menu">
                                ${childFolders.map(folder => `
-                                    <div class="breadcrumb-dropdown-item" data-path="${currentPath}/${folder}">
-                                        ${folder}
+                                    <div class="breadcrumb-dropdown-item" data-path="${escapeAttribute(currentPath + '/' + folder)}">
+                                        ${escapeHtml(folder)}
                                    </div>`).join('')
                        }
                            </div>
--- a/static/js/components/shared/ModelCard.js
+++ b/static/js/components/shared/ModelCard.js
@@ -633,7 +633,7 @@ export function createModelCard(model, modelType) {
            ` : ''}
            <div class="card-footer">
                <div class="model-info">
-                    <span class="model-name">${getDisplayName(model)}</span>
+                    <span class="model-name" title="${getDisplayName(model).replace(/"/g, '&quot;')}">${getDisplayName(model)}</span>
                    <div>
                        ${model.civitai?.name ? `<span class="version-name">${model.civitai.name}</span>` : ''}
                        ${hasUsageCount ? `<span class="version-name" title="${translate('modelCard.usage.timesUsed', {}, 'Times used')}">${model.usage_count}×</span>` : ''}
--- a/static/js/components/shared/TriggerWords.js
+++ b/static/js/components/shared/TriggerWords.js
@@ -530,7 +530,7 @@ function addNewTriggerWord(word) {

    // Validation: Check total number
    const currentTags = tagsContainer.querySelectorAll('.trigger-word-tag');
-    if (currentTags.length >= 30) {
+    if (currentTags.length >= 100) {
        showToast('toast.triggerWords.tooMany', {}, 'error');
        return;
    }
--- a/static/js/components/shared/showcase/MediaRenderers.js
+++ b/static/js/components/shared/showcase/MediaRenderers.js
@@ -26,8 +26,7 @@ export function generateVideoWrapper(media, heightPercent, shouldBlur, nsfwText,
                </button>
            ` : ''}
            ${mediaControlsHtml}
-            <video controls autoplay muted loop crossorigin="anonymous" 
-                referrerpolicy="no-referrer" 
+            <video controls autoplay muted loop
                data-local-src="${localUrl || ''}"
                data-remote-src="${remoteUrl}"
                data-nsfw-level="${nsfwLevel}"
--- a/static/js/components/shared/showcase/MediaUtils.js
+++ b/static/js/components/shared/showcase/MediaUtils.js
@@ -527,17 +527,18 @@ function initSetPreviewHandlers(container) {
                    const response = await fetch(mediaElement.dataset.localSrc);
                    const blob = await response.blob();
                    const file = new File([blob], 'preview.jpg', { type: blob.type });
-                    
+
                    // Use the existing baseModelApi uploadPreview method with nsfw level
-                    await apiClient.uploadPreview(modelFilePath, file, modelType, nsfwLevel);
+                    await apiClient.uploadPreview(modelFilePath, file, nsfwLevel);
                } else {
-                    // We need to download the remote file first
-                    const response = await fetch(mediaElement.src);
-                    const blob = await response.blob();
-                    const file = new File([blob], 'preview.jpg', { type: blob.type });
-                    
-                    // Use the existing baseModelApi uploadPreview method with nsfw level
-                    await apiClient.uploadPreview(modelFilePath, file, modelType, nsfwLevel);
+                    // Remote file - send URL to backend to download (avoids CORS issues)
+                    const imageUrl = mediaElement.src || mediaElement.dataset.remoteSrc;
+                    if (!imageUrl) {
+                        throw new Error('No image URL available');
+                    }
+
+                    // Use the new setPreviewFromUrl method
+                    await apiClient.setPreviewFromUrl(modelFilePath, imageUrl, nsfwLevel);
                }
            } catch (error) {
                console.error('Error setting preview:', error);
--- a/static/js/components/shared/showcase/ShowcaseView.js
+++ b/static/js/components/shared/showcase/ShowcaseView.js
@@ -16,6 +16,7 @@ import {
 } from './MediaUtils.js';
 import { generateMetadataPanel } from './MetadataPanel.js';
 import { generateImageWrapper, generateVideoWrapper } from './MediaRenderers.js';
+import { getShowcaseUrl } from '../../../utils/civitaiUtils.js';

 export const showcaseListenerMetrics = {
    wheelListeners: 0,
@@ -61,8 +62,14 @@ export async function loadExampleImages(images, modelHash) {
        
        // Re-initialize the showcase event listeners
        const carousel = showcaseTab.querySelector('.carousel');
-        if (carousel && !carousel.classList.contains('collapsed')) {
-            initShowcaseContent(carousel);
+        if (carousel) {
+            // Always bind scroll-indicator click events (even when collapsed)
+            bindScrollIndicatorEvents(carousel);
+            
+            // Only initialize full showcase content when expanded
+            if (!carousel.classList.contains('collapsed')) {
+                initShowcaseContent(carousel);
+            }
        }
        
        // Initialize the example import functionality
@@ -151,11 +158,19 @@ export function renderShowcaseContent(images, exampleFiles = [], startExpanded =
 function renderMediaItem(img, index, exampleFiles) {
    // Find matching file in our list of actual files
    let localFile = findLocalFile(img, index, exampleFiles);
-    
-    const remoteUrl = img.url || '';
+
+    // Get original remote URL
+    const originalRemoteUrl = img.url || '';
+
+    // Determine media type for optimization
+    const isVideo = localFile ? localFile.is_video :
+                  originalRemoteUrl.endsWith('.mp4') || originalRemoteUrl.endsWith('.webm');
+    const mediaType = isVideo ? 'video' : 'image';
+
+    // Optimize CivitAI URLs for showcase display (full quality)
+    const remoteUrl = getShowcaseUrl(originalRemoteUrl, mediaType);
+
    const localUrl = localFile ? localFile.path : '';
-    const isVideo = localFile ? localFile.is_video : 
-                  remoteUrl.endsWith('.mp4') || remoteUrl.endsWith('.webm');
    
    // Calculate appropriate aspect ratio
    const aspectRatio = (img.height / img.width) * 100;
@@ -576,6 +591,41 @@ export function toggleShowcase(element) {
    }
 }

+/**
+ * Bind scroll-indicator click events (works even when carousel is collapsed)
+ * @param {HTMLElement} carousel - The carousel element
+ */
+function bindScrollIndicatorEvents(carousel) {
+    if (!carousel) return;
+
+    const scrollIndicator = carousel.previousElementSibling;
+    if (scrollIndicator && scrollIndicator.classList.contains('scroll-indicator')) {
+        // Remove previous listeners to avoid duplicates
+        scrollIndicator.onclick = null;
+        scrollIndicator.removeEventListener('click', scrollIndicator._leftClickHandler);
+        scrollIndicator.removeEventListener('mousedown', scrollIndicator._middleClickHandler);
+
+        // Handler for left-click (button 0) - uses 'click' event
+        scrollIndicator._leftClickHandler = (event) => {
+            if (event.button === 0) {
+                event.preventDefault();
+                toggleShowcase(scrollIndicator);
+            }
+        };
+
+        // Handler for middle-click (button 1) - uses 'mousedown' event
+        scrollIndicator._middleClickHandler = (event) => {
+            if (event.button === 1) {
+                event.preventDefault();
+                toggleShowcase(scrollIndicator);
+            }
+        };
+
+        scrollIndicator.addEventListener('click', scrollIndicator._leftClickHandler);
+        scrollIndicator.addEventListener('mousedown', scrollIndicator._middleClickHandler);
+    }
+}
+
 /**
 * Initialize all showcase content interactions
 * @param {HTMLElement} carousel - The carousel element
@@ -589,15 +639,8 @@ export function initShowcaseContent(carousel) {
    initMediaControlHandlers(carousel);
    positionAllMediaControls(carousel);

-    // Bind scroll-indicator click to toggleShowcase
-    const scrollIndicator = carousel.previousElementSibling;
-    if (scrollIndicator && scrollIndicator.classList.contains('scroll-indicator')) {
-        // Remove previous click listeners to avoid duplicates
-        scrollIndicator.onclick = null;
-        scrollIndicator.removeEventListener('click', scrollIndicator._toggleShowcaseHandler);
-        scrollIndicator._toggleShowcaseHandler = () => toggleShowcase(scrollIndicator);
-        scrollIndicator.addEventListener('click', scrollIndicator._toggleShowcaseHandler);
-    }
+    // Bind scroll-indicator click events
+    bindScrollIndicatorEvents(carousel);
    
    // Add window resize handler
    const resizeHandler = () => positionAllMediaControls(carousel);
--- a/static/js/managers/LoadingManager.js
+++ b/static/js/managers/LoadingManager.js
@@ -8,6 +8,22 @@ export class LoadingManager {
            return LoadingManager.instance;
        }

+        // Delay DOM creation until first use to ensure i18n is ready
+        this._initialized = false;
+        this.overlay = null;
+        this.loadingContent = null;
+        this.progressBar = null;
+        this.statusText = null;
+        this.cancelButton = null;
+        this.onCancelCallback = null;
+        this.detailsContainer = null;
+
+        LoadingManager.instance = this;
+    }
+
+    _ensureInitialized() {
+        if (this._initialized) return;
+
        this.overlay = document.getElementById('loading-overlay');

        if (!this.overlay) {
@@ -53,7 +69,6 @@ export class LoadingManager {
            this.loadingContent.appendChild(this.cancelButton);
        }

-        this.onCancelCallback = null;
        this.cancelButton.onclick = () => {
            if (this.onCancelCallback) {
                this.onCancelCallback();
@@ -62,12 +77,11 @@ export class LoadingManager {
            }
        };

-        this.detailsContainer = null; // Will be created when needed
-
-        LoadingManager.instance = this;
+        this._initialized = true;
    }

    show(message = 'Loading...', progress = 0) {
+        this._ensureInitialized();
        this.overlay.style.display = 'flex';
        this.setProgress(progress);
        this.setStatus(message);
@@ -77,21 +91,25 @@ export class LoadingManager {
    }

    hide() {
+        if (!this._initialized) return;
        this.overlay.style.display = 'none';
        this.reset();
        this.removeDetailsContainer();
    }

    setProgress(percent) {
+        if (!this._initialized) return;
        this.progressBar.style.width = `${percent}%`;
        this.progressBar.setAttribute('aria-valuenow', percent);
    }

    setStatus(message) {
+        if (!this._initialized) return;
        this.statusText.textContent = message;
    }

    reset() {
+        if (!this._initialized) return;
        this.setProgress(0);
        this.setStatus('');
        this.removeDetailsContainer();
@@ -100,6 +118,7 @@ export class LoadingManager {
    }

    showCancelButton(onCancel) {
+        this._ensureInitialized();
        if (this.cancelButton) {
            this.onCancelCallback = onCancel;
            this.cancelButton.style.display = 'flex';
@@ -109,6 +128,7 @@ export class LoadingManager {
    }

    hideCancelButton() {
+        if (!this._initialized) return;
        if (this.cancelButton) {
            this.cancelButton.style.display = 'none';
            this.onCancelCallback = null;
@@ -117,6 +137,7 @@ export class LoadingManager {

    // Create a details container for enhanced progress display
    createDetailsContainer() {
+        this._ensureInitialized();
        // Remove existing container if any
        this.removeDetailsContainer();

@@ -332,12 +353,14 @@ export class LoadingManager {
    }

    showSimpleLoading(message = 'Loading...') {
+        this._ensureInitialized();
        this.overlay.style.display = 'flex';
        this.progressBar.style.display = 'none';
        this.setStatus(message);
    }

    restoreProgressBar() {
+        if (!this._initialized) return;
        this.progressBar.style.display = 'block';
    }
 }
--- a/static/js/managers/MoveManager.js
+++ b/static/js/managers/MoveManager.js
@@ -88,6 +88,11 @@ class MoveManager {
            folderPathInput.value = '';
        }

+        // Reset folder tree selection
+        if (this.folderTreeManager) {
+            this.folderTreeManager.clearSelection();
+        }
+
        try {
            // Fetch model roots
            const modelRootSelect = document.getElementById('moveModelRoot');
@@ -286,6 +291,9 @@ class MoveManager {

        if (recursive) {
            // Visible if it's in activeFolder or any subfolder
+            // Special case for root: if activeFolder is empty, everything is visible in recursive mode
+            if (normalizedActive === '') return true;
+            
            return normalizedRelative === normalizedActive ||
                normalizedRelative.startsWith(normalizedActive + '/');
        } else {
@@ -305,7 +313,7 @@ class MoveManager {
        }

        // Get selected folder path from folder tree manager
-        const targetFolder = this.folderTreeManager.getSelectedPath();
+        const targetFolder = this.useDefaultPath ? '' : this.folderTreeManager.getSelectedPath();

        let targetPath = selectedRoot;
        if (targetFolder) {
@@ -315,81 +323,31 @@ class MoveManager {
        try {
            if (this.bulkFilePaths) {
                // Bulk move mode
-                const results = await apiClient.moveBulkModels(this.bulkFilePaths, targetPath, this.useDefaultPath);
-
-                // Update virtual scroller visibility/metadata
-                const pageState = getCurrentPageState();
-                if (state.virtualScroller) {
-                    results.forEach(result => {
-                        if (result.success) {
-                            // Deselect moving item
-                            bulkManager.deselectItem(result.original_file_path);
-
-                            const newRelativeFolder = this._getRelativeFolder(result.new_file_path);
-                            const isVisible = this._isModelVisible(newRelativeFolder, pageState);
-
-                            if (!isVisible) {
-                                state.virtualScroller.removeItemByFilePath(result.original_file_path);
-                            } else {
-                                const newFileNameWithExt = result.new_file_path.substring(result.new_file_path.lastIndexOf('/') + 1);
-                                const baseFileName = newFileNameWithExt.substring(0, newFileNameWithExt.lastIndexOf('.'));
-
-                                const updateData = {
-                                    file_path: result.new_file_path,
-                                    file_name: baseFileName,
-                                    folder: newRelativeFolder
-                                };
-
-                                // Only update sub_type if it's present in the cache_entry
-                                if (result.cache_entry && result.cache_entry.sub_type) {
-                                    updateData.sub_type = result.cache_entry.sub_type;
-                                }
-
-                                state.virtualScroller.updateSingleItem(result.original_file_path, updateData);
-                            }
-                        }
-                    });
-                }
+                await apiClient.moveBulkModels(this.bulkFilePaths, targetPath, this.useDefaultPath);
+                
+                // Deselect moving items
+                this.bulkFilePaths.forEach(path => bulkManager.deselectItem(path));
            } else {
                // Single move mode
-                const result = await apiClient.moveSingleModel(this.currentFilePath, targetPath, this.useDefaultPath);
-
-                const pageState = getCurrentPageState();
-                if (result && result.new_file_path && state.virtualScroller) {
-                    // Deselect moving item
-                    bulkManager.deselectItem(this.currentFilePath);
-
-                    const newRelativeFolder = this._getRelativeFolder(result.new_file_path);
-                    const isVisible = this._isModelVisible(newRelativeFolder, pageState);
-
-                    if (!isVisible) {
-                        state.virtualScroller.removeItemByFilePath(this.currentFilePath);
-                    } else {
-                        const newFileNameWithExt = result.new_file_path.substring(result.new_file_path.lastIndexOf('/') + 1);
-                        const baseFileName = newFileNameWithExt.substring(0, newFileNameWithExt.lastIndexOf('.'));
-
-                        const updateData = {
-                            file_path: result.new_file_path,
-                            file_name: baseFileName,
-                            folder: newRelativeFolder
-                        };
-
-                        // Only update sub_type if it's present in the cache_entry
-                        if (result.cache_entry && result.cache_entry.sub_type) {
-                            updateData.sub_type = result.cache_entry.sub_type;
-                        }
-
-                        state.virtualScroller.updateSingleItem(this.currentFilePath, updateData);
-                    }
-                }
+                await apiClient.moveSingleModel(this.currentFilePath, targetPath, this.useDefaultPath);
+                
+                // Deselect moving item
+                bulkManager.deselectItem(this.currentFilePath);
            }

-            // Refresh folder tags after successful move
-            sidebarManager.refresh();
+            // Refresh UI by reloading the current page, same as drag-and-drop behavior
+            // This ensures all metadata (like preview URLs) are correctly formatted by the backend
+            if (sidebarManager.pageControls && typeof sidebarManager.pageControls.resetAndReload === 'function') {
+                await sidebarManager.pageControls.resetAndReload(true);
+            } else if (sidebarManager.lastPageControls && typeof sidebarManager.lastPageControls.resetAndReload === 'function') {
+                await sidebarManager.lastPageControls.resetAndReload(true);
+            }
+
+            // Refresh folder tree in sidebar
+            await sidebarManager.refresh();

            modalManager.closeModal('moveModal');

-
        } catch (error) {
            console.error('Error moving model(s):', error);
            showToast('toast.models.moveFailed', { message: error.message }, 'error');
--- a/static/js/managers/SettingsManager.js
+++ b/static/js/managers/SettingsManager.js
@@ -364,10 +364,283 @@ export class SettingsManager {
        }

        this.setupPriorityTagInputs();
+        this.initializeNavigation();
+        this.initializeSearch();

        this.initialized = true;
    }

+    initializeNavigation() {
+        const navItems = document.querySelectorAll('.settings-nav-item');
+        const sections = document.querySelectorAll('.settings-section');
+
+        if (navItems.length === 0 || sections.length === 0) return;
+
+        // Handle navigation item clicks - macOS Settings style: show section instead of scroll
+        navItems.forEach(item => {
+            item.addEventListener('click', (e) => {
+                const sectionId = item.dataset.section;
+                if (!sectionId) return;
+
+                // Hide all sections
+                sections.forEach(section => {
+                    section.classList.remove('active');
+                });
+
+                // Show target section
+                const targetSection = document.getElementById(`section-${sectionId}`);
+                if (targetSection) {
+                    targetSection.classList.add('active');
+                }
+
+                // Update active nav state
+                navItems.forEach(nav => nav.classList.remove('active'));
+                item.classList.add('active');
+            });
+        });
+
+        // Show first section by default
+        const firstSection = sections[0];
+        if (firstSection) {
+            firstSection.classList.add('active');
+        }
+    }
+
+    initializeSearch() {
+        const searchInput = document.getElementById('settingsSearchInput');
+        const searchClear = document.getElementById('settingsSearchClear');
+        
+        if (!searchInput) return;
+
+        // Debounced search handler
+        let searchTimeout;
+        const debouncedSearch = (query) => {
+            clearTimeout(searchTimeout);
+            searchTimeout = setTimeout(() => {
+                this.performSearch(query);
+            }, 150);
+        };
+
+        // Handle input changes
+        searchInput.addEventListener('input', (e) => {
+            const query = e.target.value.trim();
+            
+            // Show/hide clear button
+            if (searchClear) {
+                searchClear.style.display = query ? 'flex' : 'none';
+            }
+            
+            debouncedSearch(query);
+        });
+
+        // Handle clear button click
+        if (searchClear) {
+            searchClear.addEventListener('click', () => {
+                searchInput.value = '';
+                searchClear.style.display = 'none';
+                searchInput.focus();
+                this.performSearch('');
+            });
+        }
+
+        // Handle Escape key to clear search
+        searchInput.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') {
+                if (searchInput.value) {
+                    searchInput.value = '';
+                    if (searchClear) searchClear.style.display = 'none';
+                    this.performSearch('');
+                }
+            }
+        });
+    }
+
+    performSearch(query) {
+        const sections = document.querySelectorAll('.settings-section');
+        const navItems = document.querySelectorAll('.settings-nav-item');
+        const settingsForm = document.querySelector('.settings-form');
+        
+        // Remove existing empty state
+        const existingEmptyState = settingsForm?.querySelector('.settings-search-empty');
+        if (existingEmptyState) {
+            existingEmptyState.remove();
+        }
+
+        if (!query) {
+            // Reset: remove highlights only, keep current section visible
+            sections.forEach(section => {
+                this.removeSearchHighlights(section);
+            });
+            return;
+        }
+
+        const lowerQuery = query.toLowerCase();
+        let firstMatchSection = null;
+        let firstMatchElement = null;
+        let matchCount = 0;
+
+        sections.forEach(section => {
+            const sectionText = this.getSectionSearchableText(section);
+            const hasMatch = sectionText.includes(lowerQuery);
+
+            if (hasMatch) {
+                const firstHighlight = this.highlightSearchMatches(section, lowerQuery);
+                matchCount++;
+                
+                // Track first match to auto-switch
+                if (!firstMatchSection) {
+                    firstMatchSection = section;
+                    firstMatchElement = firstHighlight;
+                }
+            } else {
+                this.removeSearchHighlights(section);
+            }
+        });
+
+        // Auto-switch to first matching section
+        if (firstMatchSection) {
+            const sectionId = firstMatchSection.id.replace('section-', '');
+            
+            // Hide all sections
+            sections.forEach(section => section.classList.remove('active'));
+            
+            // Show matching section
+            firstMatchSection.classList.add('active');
+            
+            // Update nav active state
+            navItems.forEach(item => {
+                item.classList.remove('active');
+                if (item.dataset.section === sectionId) {
+                    item.classList.add('active');
+                }
+            });
+
+            // Scroll to first match after a short delay to allow section to become visible
+            if (firstMatchElement) {
+                requestAnimationFrame(() => {
+                    firstMatchElement.scrollIntoView({
+                        behavior: 'smooth',
+                        block: 'center'
+                    });
+                });
+            }
+        }
+
+        // Show empty state if no matches found
+        if (matchCount === 0 && settingsForm) {
+            const emptyState = document.createElement('div');
+            emptyState.className = 'settings-search-empty';
+            emptyState.innerHTML = `
+                <i class="fas fa-search"></i>
+                <p>${translate('settings.search.noResults', { query }, `No settings found matching "${query}"`)}</p>
+            `;
+            settingsForm.appendChild(emptyState);
+        }
+    }
+
+    getSectionSearchableText(section) {
+        // Get all text content from labels, help text, and headers
+        const labels = section.querySelectorAll('label');
+        const helpTexts = section.querySelectorAll('.input-help');
+        const headers = section.querySelectorAll('h3');
+        
+        let text = '';
+        
+        labels.forEach(el => text += ' ' + el.textContent);
+        helpTexts.forEach(el => text += ' ' + el.textContent);
+        headers.forEach(el => text += ' ' + el.textContent);
+        
+        return text.toLowerCase();
+    }
+
+    highlightSearchMatches(section, query) {
+        // Remove existing highlights first
+        this.removeSearchHighlights(section);
+        
+        if (!query) return null;
+
+        // Highlight in labels and help text
+        const textElements = section.querySelectorAll('label, .input-help, h3');
+        let firstHighlight = null;
+        
+        textElements.forEach(element => {
+            const walker = document.createTreeWalker(
+                element,
+                NodeFilter.SHOW_TEXT,
+                null,
+                false
+            );
+            
+            const textNodes = [];
+            let node;
+            while (node = walker.nextNode()) {
+                if (node.textContent.toLowerCase().includes(query)) {
+                    textNodes.push(node);
+                }
+            }
+            
+            textNodes.forEach(textNode => {
+                const parent = textNode.parentElement;
+                const text = textNode.textContent;
+                const lowerText = text.toLowerCase();
+                
+                // Split text by query and wrap matches in highlight spans
+                const parts = [];
+                let lastIndex = 0;
+                let index;
+                
+                while ((index = lowerText.indexOf(query, lastIndex)) !== -1) {
+                    // Add text before match
+                    if (index > lastIndex) {
+                        parts.push(document.createTextNode(text.substring(lastIndex, index)));
+                    }
+                    
+                    // Add highlighted match
+                    const highlight = document.createElement('span');
+                    highlight.className = 'settings-search-highlight';
+                    highlight.textContent = text.substring(index, index + query.length);
+                    parts.push(highlight);
+                    
+                    // Track first highlight for scrolling
+                    if (!firstHighlight) {
+                        firstHighlight = highlight;
+                    }
+                    
+                    lastIndex = index + query.length;
+                }
+                
+                // Add remaining text
+                if (lastIndex < text.length) {
+                    parts.push(document.createTextNode(text.substring(lastIndex)));
+                }
+                
+                // Replace original text node with highlighted version
+                if (parts.length > 1) {
+                    parts.forEach(part => parent.insertBefore(part, textNode));
+                    parent.removeChild(textNode);
+                }
+            });
+        });
+        
+        return firstHighlight;
+    }
+
+    removeSearchHighlights(section) {
+        const highlights = section.querySelectorAll('.settings-search-highlight');
+        
+        highlights.forEach(highlight => {
+            const parent = highlight.parentElement;
+            if (parent) {
+                // Replace highlight with its text content
+                parent.insertBefore(document.createTextNode(highlight.textContent), highlight);
+                parent.removeChild(highlight);
+                
+                // Normalize to merge adjacent text nodes
+                parent.normalize();
+            }
+        });
+    }
+
    async openSettingsFileLocation() {
        try {
            const response = await fetch('/api/lm/settings/open-location', {
@@ -526,6 +799,9 @@ export class SettingsManager {
        // Load default unet root
        await this.loadUnetRoots();

+        // Load extra folder paths
+        this.loadExtraFolderPaths();
+
        // Load language setting
        const languageSelect = document.getElementById('languageSelect');
        if (languageSelect) {
@@ -1028,6 +1304,119 @@ export class SettingsManager {
        }
    }

+    loadExtraFolderPaths() {
+        const extraFolderPaths = state.global.settings.extra_folder_paths || {};
+
+        // Load paths for each model type
+        ['loras', 'checkpoints', 'unet', 'embeddings'].forEach((modelType) => {
+            const container = document.getElementById(`extraFolderPaths-${modelType}`);
+            if (!container) return;
+
+            // Clear existing paths
+            container.innerHTML = '';
+
+            // Add existing paths
+            const paths = extraFolderPaths[modelType] || [];
+            paths.forEach((path) => {
+                this.addExtraFolderPathRow(modelType, path);
+            });
+
+            // Add empty row for new path if no paths exist
+            if (paths.length === 0) {
+                this.addExtraFolderPathRow(modelType, '');
+            }
+        });
+    }
+
+    addExtraFolderPathRow(modelType, path = '') {
+        const container = document.getElementById(`extraFolderPaths-${modelType}`);
+        if (!container) return;
+
+        const row = document.createElement('div');
+        row.className = 'extra-folder-path-row mapping-row';
+
+        row.innerHTML = `
+            <div class="path-controls">
+                <input type="text" class="extra-folder-path-input"
+                       placeholder="${translate('settings.extraFolderPaths.pathPlaceholder', {}, '/path/to/models')}" value="${path}"
+                       onblur="settingsManager.updateExtraFolderPaths('${modelType}')"
+                       onkeydown="if(event.key === 'Enter') { this.blur(); }" />
+                <button type="button" class="remove-path-btn"
+                        onclick="this.parentElement.parentElement.remove(); settingsManager.updateExtraFolderPaths('${modelType}')"
+                        title="${translate('common.actions.delete', {}, 'Delete')}">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+        `;
+
+        container.appendChild(row);
+
+        // Focus the input if it's empty (new row)
+        if (!path) {
+            const input = row.querySelector('.extra-folder-path-input');
+            if (input) {
+                setTimeout(() => input.focus(), 0);
+            }
+        }
+    }
+
+    async updateExtraFolderPaths(changedModelType) {
+        const extraFolderPaths = {};
+
+        // Collect paths for all model types
+        ['loras', 'checkpoints', 'unet', 'embeddings'].forEach((modelType) => {
+            const container = document.getElementById(`extraFolderPaths-${modelType}`);
+            if (!container) return;
+
+            const inputs = container.querySelectorAll('.extra-folder-path-input');
+            const paths = [];
+
+            inputs.forEach((input) => {
+                const value = input.value.trim();
+                if (value) {
+                    paths.push(value);
+                }
+            });
+
+            extraFolderPaths[modelType] = paths;
+        });
+
+        // Check if paths have actually changed
+        const currentPaths = state.global.settings.extra_folder_paths || {};
+        const pathsChanged = JSON.stringify(currentPaths) !== JSON.stringify(extraFolderPaths);
+
+        if (!pathsChanged) {
+            return;
+        }
+
+        // Update state
+        state.global.settings.extra_folder_paths = extraFolderPaths;
+
+        try {
+            // Save to backend - this triggers path validation
+            await this.saveSetting('extra_folder_paths', extraFolderPaths);
+            showToast('toast.settings.settingsUpdated', { setting: 'Extra Folder Paths' }, 'success');
+
+            // Add empty row if no valid paths exist for the changed type
+            const container = document.getElementById(`extraFolderPaths-${changedModelType}`);
+            if (container) {
+                const inputs = container.querySelectorAll('.extra-folder-path-input');
+                const hasEmptyRow = Array.from(inputs).some((input) => !input.value.trim());
+
+                if (!hasEmptyRow) {
+                    this.addExtraFolderPathRow(changedModelType, '');
+                }
+            }
+        } catch (error) {
+            console.error('Failed to save extra folder paths:', error);
+            showToast('toast.settings.settingSaveFailed', { message: error.message }, 'error');
+
+            // Restore previous state on error
+            state.global.settings.extra_folder_paths = currentPaths;
+            this.loadExtraFolderPaths();
+        }
+    }
+
    loadBaseModelMappings() {
        const mappingsContainer = document.getElementById('baseModelMappingsContainer');
        if (!mappingsContainer) return;
--- a/static/js/recipes.js
+++ b/static/js/recipes.js
@@ -7,7 +7,7 @@ import { getSessionItem, removeSessionItem } from './utils/storageHelpers.js';
 import { RecipeContextMenu } from './components/ContextMenu/index.js';
 import { DuplicatesManager } from './components/DuplicatesManager.js';
 import { refreshVirtualScroll } from './utils/infiniteScroll.js';
-import { refreshRecipes, RecipeSidebarApiClient } from './api/recipeApi.js';
+import { refreshRecipes, syncChanges, RecipeSidebarApiClient } from './api/recipeApi.js';
 import { sidebarManager } from './components/SidebarManager.js';

 class RecipePageControls {
@@ -27,7 +27,7 @@ class RecipePageControls {
            return;
        }

-        refreshVirtualScroll();
+        await syncChanges();
    }

    getSidebarApiClient() {
@@ -236,6 +236,70 @@ class RecipeManager {
                refreshVirtualScroll();
            });
        }
+
+        // Initialize dropdown functionality for refresh button
+        this.initDropdowns();
+    }
+
+    initDropdowns() {
+        // Handle dropdown toggles
+        const dropdownToggles = document.querySelectorAll('.dropdown-toggle');
+        dropdownToggles.forEach(toggle => {
+            toggle.addEventListener('click', (e) => {
+                e.stopPropagation();
+                const dropdownGroup = toggle.closest('.dropdown-group');
+                
+                // Close all other open dropdowns first
+                document.querySelectorAll('.dropdown-group.active').forEach(group => {
+                    if (group !== dropdownGroup) {
+                        group.classList.remove('active');
+                    }
+                });
+                
+                dropdownGroup.classList.toggle('active');
+            });
+        });
+
+        // Handle quick refresh option (Sync Changes)
+        const quickRefreshOption = document.querySelector('[data-action="quick-refresh"]');
+        if (quickRefreshOption) {
+            quickRefreshOption.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.pageControls.refreshModels(false);
+                this.closeDropdowns();
+            });
+        }
+
+        // Handle full rebuild option (Rebuild Cache)
+        const fullRebuildOption = document.querySelector('[data-action="full-rebuild"]');
+        if (fullRebuildOption) {
+            fullRebuildOption.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.pageControls.refreshModels(true);
+                this.closeDropdowns();
+            });
+        }
+
+        // Handle main refresh button (default: sync changes)
+        const refreshBtn = document.querySelector('[data-action="refresh"]');
+        if (refreshBtn) {
+            refreshBtn.addEventListener('click', () => {
+                this.pageControls.refreshModels(false);
+            });
+        }
+
+        // Close dropdowns when clicking outside
+        document.addEventListener('click', (e) => {
+            if (!e.target.closest('.dropdown-group')) {
+                this.closeDropdowns();
+            }
+        });
+    }
+
+    closeDropdowns() {
+        document.querySelectorAll('.dropdown-group.active').forEach(group => {
+            group.classList.remove('active');
+        });
    }

    // This method is kept for compatibility but now uses virtual scrolling
--- a/static/js/services/supportersService.js
+++ b/static/js/services/supportersService.js
@@ -0,0 +1,209 @@
+/**
+ * Supporters service - Fetches and manages supporters data
+ */
+
+let supportersData = null;
+let isLoading = false;
+let loadPromise = null;
+
+/**
+ * Fetch supporters data from the API
+ * @returns {Promise<Object>} Supporters data
+ */
+export async function fetchSupporters() {
+    // Return cached data if available
+    if (supportersData) {
+        return supportersData;
+    }
+
+    // Return existing promise if already loading
+    if (isLoading && loadPromise) {
+        return loadPromise;
+    }
+
+    isLoading = true;
+    loadPromise = fetch('/api/lm/supporters')
+        .then(response => {
+            if (!response.ok) {
+                throw new Error(`Failed to fetch supporters: ${response.statusText}`);
+            }
+            return response.json();
+        })
+        .then(data => {
+            if (data.success && data.supporters) {
+                supportersData = data.supporters;
+                return supportersData;
+            }
+            throw new Error(data.error || 'Failed to load supporters data');
+        })
+        .catch(error => {
+            console.error('Error loading supporters:', error);
+            // Return empty data on error
+            return {
+                specialThanks: [],
+                allSupporters: [],
+                totalCount: 0
+            };
+        })
+        .finally(() => {
+            isLoading = false;
+            loadPromise = null;
+        });
+
+    return loadPromise;
+}
+
+/**
+ * Clear cached supporters data
+ */
+export function clearSupportersCache() {
+    supportersData = null;
+}
+
+let autoScrollRequest = null;
+let autoScrollTimeout = null;
+let isUserInteracting = false;
+let isHovering = false;
+let currentScrollPos = 0;
+
+/**
+ * Handle user interaction to stop auto-scroll
+ */
+function handleInteraction() {
+    isUserInteracting = true;
+}
+
+/**
+ * Handle mouse enter to pause auto-scroll
+ */
+function handleMouseEnter() {
+    isHovering = true;
+}
+
+/**
+ * Handle mouse leave to resume auto-scroll
+ */
+function handleMouseLeave() {
+    isHovering = false;
+}
+
+/**
+ * Initialize auto-scrolling for the supporters list like movie credits
+ * @param {HTMLElement} container The scrollable container
+ */
+function initAutoScroll(container) {
+    if (!container) return;
+    
+    // Stop any existing animation and clear any pending timeout
+    if (autoScrollRequest) {
+        cancelAnimationFrame(autoScrollRequest);
+        autoScrollRequest = null;
+    }
+    if (autoScrollTimeout) {
+        clearTimeout(autoScrollTimeout);
+        autoScrollTimeout = null;
+    }
+    
+    // Reset state for new scroll
+    isUserInteracting = false;
+    isHovering = false;
+    container.scrollTop = 0;
+    currentScrollPos = 0;
+
+    const scrollSpeed = 0.4; // Pixels per frame (~24px/sec at 60fps)
+    
+    const step = () => {
+        // Stop animation if container is hidden or no longer in DOM
+        if (!container.offsetParent) {
+            autoScrollRequest = null;
+            return;
+        }
+
+        if (!isHovering && !isUserInteracting) {
+            const prevScrollTop = container.scrollTop;
+            currentScrollPos += scrollSpeed;
+            container.scrollTop = currentScrollPos;
+            
+            // Check if we reached the bottom
+            if (container.scrollTop === prevScrollTop && currentScrollPos > 1) {
+                const isAtBottom = container.scrollTop + container.clientHeight >= container.scrollHeight - 1;
+                if (isAtBottom) {
+                    autoScrollRequest = null;
+                    return;
+                }
+            }
+        } else {
+            // Keep currentScrollPos in sync if user scrolls manually or pauses
+            currentScrollPos = container.scrollTop;
+        }
+        
+        autoScrollRequest = requestAnimationFrame(step);
+    };
+
+    // Remove existing listeners before adding to avoid duplicates
+    container.removeEventListener('mouseenter', handleMouseEnter);
+    container.removeEventListener('mouseleave', handleMouseLeave);
+    container.removeEventListener('wheel', handleInteraction);
+    container.removeEventListener('touchstart', handleInteraction);
+    container.removeEventListener('mousedown', handleInteraction);
+
+    // Event listeners to handle user control
+    container.addEventListener('mouseenter', handleMouseEnter);
+    container.addEventListener('mouseleave', handleMouseLeave);
+    
+    // Use { passive: true } for better scroll performance
+    container.addEventListener('wheel', handleInteraction, { passive: true });
+    container.addEventListener('touchstart', handleInteraction, { passive: true });
+    container.addEventListener('mousedown', handleInteraction);
+
+    // Initial delay before starting the credits-style scroll
+    autoScrollTimeout = setTimeout(() => {
+        if (container.scrollHeight > container.clientHeight) {
+            autoScrollRequest = requestAnimationFrame(step);
+        }
+    }, 1800);
+}
+
+/**
+ * Render supporters in the support modal
+ */
+export async function renderSupporters() {
+    const supporters = await fetchSupporters();
+
+    // Update subtitle with total count
+    const subtitleEl = document.getElementById('supportersSubtitle');
+    if (subtitleEl) {
+        const originalText = subtitleEl.textContent;
+        subtitleEl.textContent = originalText.replace(/\d+/, supporters.totalCount);
+    }
+
+    // Render special thanks
+    const specialThanksGrid = document.getElementById('specialThanksGrid');
+    if (specialThanksGrid && supporters.specialThanks) {
+        specialThanksGrid.innerHTML = supporters.specialThanks
+            .map(supporter => `
+                <div class="supporter-special-card" title="${supporter}">
+                    <span class="supporter-special-name">${supporter}</span>
+                </div>
+            `)
+            .join('');
+    }
+
+    // Render all supporters
+    const supportersGrid = document.getElementById('supportersGrid');
+    if (supportersGrid && supporters.allSupporters) {
+        supportersGrid.innerHTML = supporters.allSupporters
+            .map((supporter, index, array) => {
+                const separator = index < array.length - 1
+                    ? '<span class="supporter-separator">·</span>'
+                    : '';
+                return `
+                    <span class="supporter-name-item" title="${supporter}">${supporter}</span>${separator}
+                `;
+            })
+            .join('');
+            
+        // Initialize the auto-scroll effect
+        initAutoScroll(supportersGrid);
+    }
+}
--- a/static/js/statistics.js
+++ b/static/js/statistics.js
@@ -10,6 +10,11 @@ export class StatisticsManager {
        this.charts = {};
        this.data = {};
        this.initialized = false;
+        this.listStates = {
+            lora: { offset: 0, limit: 50, sort: 'desc', isLoading: false, hasMore: true },
+            checkpoint: { offset: 0, limit: 50, sort: 'desc', isLoading: false, hasMore: true },
+            embedding: { offset: 0, limit: 50, sort: 'desc', isLoading: false, hasMore: true }
+        };
    }

    async initialize() {
@@ -24,7 +29,7 @@ export class StatisticsManager {
        await this.loadAllData();
        
        // Initialize charts and visualizations
-        this.initializeVisualizations();
+        await this.initializeVisualizations();
        
        this.initialized = true;
    }
@@ -97,7 +102,7 @@ export class StatisticsManager {
        return response.json();
    }

-    initializeVisualizations() {
+    async initializeVisualizations() {
        // Initialize metrics cards
        this.renderMetricsCards();
        
@@ -105,7 +110,8 @@ export class StatisticsManager {
        this.initializeCharts();
        
        // Initialize lists and other components
-        this.renderTopModelsLists();
+        await this.initializeLists();
+        this.renderLargestModelsList();
        this.renderTagCloud();
        this.renderInsights();
    }
@@ -548,86 +554,87 @@ export class StatisticsManager {
        });
    }

-    renderTopModelsLists() {
-        this.renderTopLorasList();
-        this.renderTopCheckpointsList();
-        this.renderTopEmbeddingsList();
-        this.renderLargestModelsList();
+    async initializeLists() {
+        const listTypes = [
+            { type: 'lora', containerId: 'topLorasList' },
+            { type: 'checkpoint', containerId: 'topCheckpointsList' },
+            { type: 'embedding', containerId: 'topEmbeddingsList' }
+        ];
+
+        const promises = listTypes.map(({ type, containerId }) => {
+            const container = document.getElementById(containerId);
+            
+            if (container) {
+                // Handle infinite scrolling
+                container.addEventListener('scroll', () => {
+                    if (container.scrollTop + container.clientHeight >= container.scrollHeight - 50) {
+                        this.fetchAndRenderList(type, container);
+                    }
+                });
+
+                // Initial fetch
+                return this.fetchAndRenderList(type, container);
+            }
+            return Promise.resolve();
+        });
+
+        await Promise.all(promises);
    }

-    renderTopLorasList() {
-        const container = document.getElementById('topLorasList');
-        if (!container || !this.data.usage?.top_loras) return;
+    async fetchAndRenderList(type, container) {
+        const state = this.listStates[type];
+        if (state.isLoading || !state.hasMore) return;

-        const topLoras = this.data.usage.top_loras;
+        state.isLoading = true;
        
-        if (topLoras.length === 0) {
-            container.innerHTML = '<div class="loading-placeholder">No usage data available</div>';
-            return;
+        // Show loading indicator on initial load
+        if (state.offset === 0) {
+            container.innerHTML = '<div class="loading-placeholder"><i class="fas fa-spinner fa-spin"></i> Loading...</div>';
        }

-        container.innerHTML = topLoras.map(lora => `
-            <div class="model-item">
-                <img src="${lora.preview_url || '/loras_static/images/no-preview.png'}" 
-                     alt="${lora.name}" class="model-preview" 
-                     onerror="this.src='/loras_static/images/no-preview.png'">
-                <div class="model-info">
-                    <div class="model-name" title="${lora.name}">${lora.name}</div>
-                    <div class="model-meta">${lora.base_model} • ${lora.folder}</div>
-                </div>
-                <div class="model-usage">${lora.usage_count}</div>
-            </div>
-        `).join('');
-    }
+        try {
+            const url = `/api/lm/stats/model-usage-list?type=${type}&sort=${state.sort}&offset=${state.offset}&limit=${state.limit}`;
+            const result = await this.fetchData(url);
+            
+            if (result.success) {
+                const items = result.data.items;
+                
+                // Remove loading indicator if it's the first page
+                if (state.offset === 0) {
+                    container.innerHTML = '';
+                }

-    renderTopCheckpointsList() {
-        const container = document.getElementById('topCheckpointsList');
-        if (!container || !this.data.usage?.top_checkpoints) return;
+                if (items.length === 0 && state.offset === 0) {
+                    container.innerHTML = '<div class="loading-placeholder">No models found</div>';
+                    state.hasMore = false;
+                } else if (items.length < state.limit) {
+                    state.hasMore = false;
+                }

-        const topCheckpoints = this.data.usage.top_checkpoints;
-        
-        if (topCheckpoints.length === 0) {
-            container.innerHTML = '<div class="loading-placeholder">No usage data available</div>';
-            return;
+                const html = items.map(model => `
+                    <div class="model-item">
+                        <img src="${model.preview_url || '/loras_static/images/no-preview.png'}" 
+                             alt="${model.name}" class="model-preview" 
+                             onerror="this.src='/loras_static/images/no-preview.png'">
+                        <div class="model-info">
+                            <div class="model-name" title="${model.name}">${model.name}</div>
+                            <div class="model-meta">${model.base_model} • ${model.folder || 'Root'}</div>
+                        </div>
+                        <div class="model-usage">${model.usage_count}</div>
+                    </div>
+                `).join('');
+
+                container.insertAdjacentHTML('beforeend', html);
+                state.offset += state.limit;
+            }
+        } catch (error) {
+            console.error(`Error loading ${type} list:`, error);
+            if (state.offset === 0) {
+                container.innerHTML = '<div class="loading-placeholder">Error loading data</div>';
+            }
+        } finally {
+            state.isLoading = false;
        }
-
-        container.innerHTML = topCheckpoints.map(checkpoint => `
-            <div class="model-item">
-                <img src="${checkpoint.preview_url || '/loras_static/images/no-preview.png'}" 
-                     alt="${checkpoint.name}" class="model-preview"
-                     onerror="this.src='/loras_static/images/no-preview.png'">
-                <div class="model-info">
-                    <div class="model-name" title="${checkpoint.name}">${checkpoint.name}</div>
-                    <div class="model-meta">${checkpoint.base_model} • ${checkpoint.folder}</div>
-                </div>
-                <div class="model-usage">${checkpoint.usage_count}</div>
-            </div>
-        `).join('');
-    }
-
-    renderTopEmbeddingsList() {
-        const container = document.getElementById('topEmbeddingsList');
-        if (!container || !this.data.usage?.top_embeddings) return;
-
-        const topEmbeddings = this.data.usage.top_embeddings;
-        
-        if (topEmbeddings.length === 0) {
-            container.innerHTML = '<div class="loading-placeholder">No usage data available</div>';
-            return;
-        }
-
-        container.innerHTML = topEmbeddings.map(embedding => `
-            <div class="model-item">
-                <img src="${embedding.preview_url || '/loras_static/images/no-preview.png'}" 
-                     alt="${embedding.name}" class="model-preview"
-                     onerror="this.src='/loras_static/images/no-preview.png'">
-                <div class="model-info">
-                    <div class="model-name" title="${embedding.name}">${embedding.name}</div>
-                    <div class="model-meta">${embedding.base_model} • ${embedding.folder}</div>
-                </div>
-                <div class="model-usage">${embedding.usage_count}</div>
-            </div>
-        `).join('');
    }

    renderLargestModelsList() {
--- a/static/js/utils/civitaiUtils.js
+++ b/static/js/utils/civitaiUtils.js
@@ -0,0 +1,119 @@
+/**
+ * CivitAI URL utilities
+ * Functions for working with CivitAI media URLs
+ */
+
+/**
+ * Optimization strategies for CivitAI URLs
+ */
+export const OptimizationMode = {
+    /** Full quality for showcase/display - uses /optimized=true only */
+    SHOWCASE: 'showcase',
+    /** Thumbnail size for cards - uses /width=450,optimized=true */
+    THUMBNAIL: 'thumbnail',
+};
+
+/**
+ * Rewrite Civitai preview URLs to use optimized renditions.
+ * Mirrors the backend's rewrite_preview_url() function from py/utils/civitai_utils.py
+ *
+ * @param {string|null} sourceUrl - Original preview URL from the Civitai API
+ * @param {string|null} mediaType - Optional media type hint ("image" or "video")
+ * @param {string} mode - Optimization mode ('showcase' or 'thumbnail')
+ * @returns {[string|null, boolean]} - Tuple of [rewritten URL or original, wasRewritten flag]
+ */
+export function rewriteCivitaiUrl(sourceUrl, mediaType = null, mode = OptimizationMode.THUMBNAIL) {
+    if (!sourceUrl) {
+        return [sourceUrl, false];
+    }
+
+    try {
+        const url = new URL(sourceUrl);
+        
+        // Check if it's a CivitAI image domain
+        if (url.hostname.toLowerCase() !== 'image.civitai.com') {
+            return [sourceUrl, false];
+        }
+
+        // Determine replacement based on mode and media type
+        let replacement;
+        if (mode === OptimizationMode.SHOWCASE) {
+            // Full quality for showcase - no width restriction
+            replacement = '/optimized=true';
+        } else {
+            // Thumbnail mode with width restriction
+            replacement = '/width=450,optimized=true';
+            if (mediaType && mediaType.toLowerCase() === 'video') {
+                replacement = '/transcode=true,width=450,optimized=true';
+            }
+        }
+
+        // Replace /original=true with optimized version
+        if (!url.pathname.includes('/original=true')) {
+            return [sourceUrl, false];
+        }
+
+        const updatedPath = url.pathname.replace('/original=true', replacement, 1);
+        
+        if (updatedPath === url.pathname) {
+            return [sourceUrl, false];
+        }
+
+        url.pathname = updatedPath;
+        return [url.toString(), true];
+    } catch (e) {
+        // Invalid URL
+        return [sourceUrl, false];
+    }
+}
+
+/**
+ * Get the optimized URL for a media item, falling back to original if not a CivitAI URL
+ *
+ * @param {string} url - Original URL
+ * @param {string} type - Media type ("image" or "video")
+ * @param {string} mode - Optimization mode ('showcase' or 'thumbnail')
+ * @returns {string} - Optimized URL or original URL
+ */
+export function getOptimizedUrl(url, type = 'image', mode = OptimizationMode.THUMBNAIL) {
+    const [optimizedUrl] = rewriteCivitaiUrl(url, type, mode);
+    return optimizedUrl || url;
+}
+
+/**
+ * Get showcase-optimized URL (full quality)
+ * 
+ * @param {string} url - Original URL
+ * @param {string} type - Media type ("image" or "video")
+ * @returns {string} - Optimized URL for showcase display
+ */
+export function getShowcaseUrl(url, type = 'image') {
+    return getOptimizedUrl(url, type, OptimizationMode.SHOWCASE);
+}
+
+/**
+ * Get thumbnail-optimized URL (width=450)
+ * 
+ * @param {string} url - Original URL
+ * @param {string} type - Media type ("image" or "video")
+ * @returns {string} - Optimized URL for thumbnail display
+ */
+export function getThumbnailUrl(url, type = 'image') {
+    return getOptimizedUrl(url, type, OptimizationMode.THUMBNAIL);
+}
+
+/**
+ * Check if a URL is from CivitAI
+ *
+ * @param {string} url - URL to check
+ * @returns {boolean} - True if it's a CivitAI URL
+ */
+export function isCivitaiUrl(url) {
+    if (!url) return false;
+    try {
+        const parsed = new URL(url);
+        return parsed.hostname.toLowerCase() === 'image.civitai.com';
+    } catch (e) {
+        return false;
+    }
+}
--- a/static/js/utils/uiHelpers.js
+++ b/static/js/utils/uiHelpers.js
@@ -457,6 +457,14 @@ function getWidgetNames(node) {
  return [];
 }

+function isNodeEnabled(node) {
+  if (!node) {
+    return false;
+  }
+  // ComfyUI node mode: 0 = Normal/Enabled, others = Always/Never/OnEvent
+  return node.mode === undefined || node.mode === 0;
+}
+
 function isAbsolutePath(path) {
  if (typeof path !== 'string') {
    return false;
@@ -475,8 +483,12 @@ async function ensureRelativeModelPath(modelPath, collectionType) {
    return modelPath;
  }

+  // Remove model file extension (.safetensors, .ckpt, .pt, .bin) for cleaner matching
+  // Backend removes extensions from paths before matching, so search term should not include extension
+  const searchTerm = fileName.replace(/\.(safetensors|ckpt|pt|bin)$/i, '');
+
  try {
-    const response = await fetch(`/api/lm/${collectionType}/relative-paths?search=${encodeURIComponent(fileName)}&limit=10`);
+    const response = await fetch(`/api/lm/${collectionType}/relative-paths?search=${encodeURIComponent(searchTerm)}&limit=10`);
    if (!response.ok) {
      return modelPath;
    }
@@ -507,7 +519,7 @@ export async function sendLoraToWorkflow(loraSyntax, replaceMode = false, syntax
  }

  const loraNodes = filterRegistryNodes(registry.nodes, (node) => {
-    if (!node) {
+    if (!isNodeEnabled(node)) {
      return false;
    }
    if (node.capabilities && typeof node.capabilities === 'object') {
@@ -569,6 +581,9 @@ export async function sendModelPathToWorkflow(modelPath, options) {
  }

  const targetNodes = filterRegistryNodes(registry.nodes, (node) => {
+    if (!isNodeEnabled(node)) {
+      return false;
+    }
    const widgetNames = getWidgetNames(node);
    return widgetNames.includes(widgetName);
  });
--- a/templates/components/modals/settings_modal.html
+++ b/templates/components/modals/settings_modal.html
--- a/templates/components/modals/support_modal.html
+++ b/templates/components/modals/support_modal.html
@@ -2,90 +2,133 @@
 <div id="supportModal" class="modal">
    <div class="modal-content support-modal">
        <button class="close" onclick="modalManager.closeModal('supportModal')">&times;</button>
-        <div class="support-header">
-            <i class="fas fa-heart support-icon"></i>
-            <h2>{{ t('support.title') }}</h2>
-        </div>
-        <div class="support-content">
-            <p>{{ t('support.message') }}</p>
-            
-            <div class="support-section">
-                <h3><i class="fas fa-comment"></i> {{ t('support.feedback.title') }}</h3>
-                <p>{{ t('support.feedback.description') }}</p>
-                <div class="support-links">
-                    <a href="https://github.com/willmiao/ComfyUI-Lora-Manager/issues/new" class="social-link" target="_blank">
-                        <i class="fab fa-github"></i>
-                        <span>{{ t('support.links.submitGithubIssue') }}</span>
-                    </a>
-                    <a href="https://discord.gg/vcqNrWVFvM" class="social-link" target="_blank">
-                        <i class="fab fa-discord"></i>
-                        <span>{{ t('support.links.joinDiscord') }}</span>
-                    </a>
+        
+        <div class="support-container">
+            <!-- Left Side: Support Options -->
+            <div class="support-left">
+                <div class="support-header">
+                    <i class="fas fa-heart support-icon"></i>
+                    <h2>{{ t('support.title') }}</h2>
                </div>
-            </div>
-            
-            <div class="support-section">
-                <h3><i class="fas fa-rss"></i> {{ t('support.sections.followUpdates') }}</h3>
-                <div class="support-links">
-                    <a href="https://www.youtube.com/@pixelpaws-ai" class="social-link" target="_blank">
-                        <i class="fab fa-youtube"></i>
-                        <span>{{ t('support.links.youtubeChannel') }}</span>
-                    </a>
-                    <a href="https://civitai.com/user/PixelPawsAI" class="social-link civitai-link" target="_blank">
-                        <svg class="civitai-icon" viewBox="0 0 225 225" width="20" height="20">
-                            <g transform="translate(0,225) scale(0.1,-0.1)" fill="currentColor">
-                                <path d="M950 1899 c-96 -55 -262 -150 -367 -210 -106 -61 -200 -117 -208
-                                -125 -13 -13 -15 -76 -15 -443 0 -395 1 -429 18 -443 9 -9 116 -73 237 -143
-                                121 -70 283 -163 359 -208 76 -45 146 -80 155 -80 9 1 183 98 386 215 l370
-                                215 2 444 3 444 -376 215 c-206 118 -378 216 -382 217 -4 1 -86 -43 -182 -98z
-                                m346 -481 l163 -93 1 -57 0 -58 -89 0 c-87 0 -91 1 -166 44 l-78 45 -51 -30
-                                c-28 -17 -61 -35 -73 -41 -21 -10 -23 -18 -23 -99 l0 -87 71 -41 c39 -23 73
-                                -41 76 -41 3 0 37 18 75 40 68 39 72 40 164 40 l94 0 0 -53 c0 -60 23 -41
-                                -198 -168 l-133 -77 -92 52 c-51 29 -126 73 -167 97 l-75 45 0 193 0 192 164
-                                95 c91 52 167 94 169 94 2 0 78 -42 168 -92z"/>
-                            </g>
-                        </svg>
-                        <span>{{ t('support.links.civitaiProfile') }}</span>
-                    </a>
+                <div class="support-content">
+                    <p>{{ t('support.message') }}</p>
+                    
+                    <div class="support-section">
+                        <h3><i class="fas fa-comment"></i> {{ t('support.feedback.title') }}</h3>
+                        <p>{{ t('support.feedback.description') }}</p>
+                        <div class="support-links">
+                            <a href="https://github.com/willmiao/ComfyUI-Lora-Manager/issues/new" class="social-link" target="_blank">
+                                <i class="fab fa-github"></i>
+                                <span>{{ t('support.links.submitGithubIssue') }}</span>
+                            </a>
+                            <a href="https://discord.gg/vcqNrWVFvM" class="social-link" target="_blank">
+                                <i class="fab fa-discord"></i>
+                                <span>{{ t('support.links.joinDiscord') }}</span>
+                            </a>
+                        </div>
+                    </div>
+                    
+                    <div class="support-section">
+                        <h3><i class="fas fa-rss"></i> {{ t('support.sections.followUpdates') }}</h3>
+                        <div class="support-links">
+                            <a href="https://www.youtube.com/@pixelpaws-ai" class="social-link" target="_blank">
+                                <i class="fab fa-youtube"></i>
+                                <span>{{ t('support.links.youtubeChannel') }}</span>
+                            </a>
+                            <a href="https://civitai.com/user/PixelPawsAI" class="social-link civitai-link" target="_blank">
+                                <svg class="civitai-icon" viewBox="0 0 225 225" width="20" height="20">
+                                    <g transform="translate(0,225) scale(0.1,-0.1)" fill="currentColor">
+                                        <path d="M950 1899 c-96 -55 -262 -150 -367 -210 -106 -61 -200 -117 -208
+                                        -125 -13 -13 -15 -76 -15 -443 0 -395 1 -429 18 -443 9 -9 116 -73 237 -143
+                                        121 -70 283 -163 359 -208 76 -45 146 -80 155 -80 9 1 183 98 386 215 l370
+                                        215 2 444 3 444 -376 215 c-206 118 -378 216 -382 217 -4 1 -86 -43 -182 -98z
+                                        m346 -481 l163 -93 1 -57 0 -58 -89 0 c-87 0 -91 1 -166 44 l-78 45 -51 -30
+                                        c-28 -17 -61 -35 -73 -41 -21 -10 -23 -18 -23 -99 l0 -87 71 -41 c39 -23 73
+                                        -41 76 -41 3 0 37 18 75 40 68 39 72 40 164 40 l94 0 0 -53 c0 -60 23 -41
+                                        -198 -168 l-133 -77 -92 52 c-51 29 -126 73 -167 97 l-75 45 0 193 0 192 164
+                                        95 c91 52 167 94 169 94 2 0 78 -42 168 -92z"/>
+                                    </g>
+                                </svg>
+                                <span>{{ t('support.links.civitaiProfile') }}</span>
+                            </a>
+                        </div>
+                    </div>
+                    
+                    <div class="support-section">
+                        <h3><i class="fas fa-coffee"></i> {{ t('support.sections.buyMeCoffee') }}</h3>
+                        <p>{{ t('support.sections.coffeeDescription') }}</p>
+                        <a href="https://ko-fi.com/pixelpawsai" class="kofi-button" target="_blank">
+                            <i class="fas fa-mug-hot"></i>
+                            <span>{{ t('support.links.supportKofi') }}</span>
+                        </a>
+                    </div>
+
+                    <!-- Patreon Support Section -->
+                    <div class="support-section">
+                        <h3><i class="fab fa-patreon"></i> {{ t('support.sections.becomePatron') }}</h3>
+                        <p>{{ t('support.sections.patronDescription') }}</p>
+                        <a href="https://patreon.com/PixelPawsAI" class="patreon-button" target="_blank">
+                            <i class="fab fa-patreon"></i>
+                            <span>{{ t('support.links.supportPatreon') }}</span>
+                        </a>
+                    </div>
+
+                    <!-- New section for Chinese payment methods -->
+                    <div class="support-section">
+                        <h3><i class="fas fa-qrcode"></i> {{ t('support.sections.wechatSupport') }}</h3>
+                        <p>{{ t('support.sections.wechatDescription') }}</p>
+                        <button class="secondary-btn qrcode-toggle" id="toggleQRCode">
+                            <i class="fas fa-qrcode"></i>
+                            <span class="toggle-text">{{ t('support.sections.showWechatQR') }}</span>
+                            <i class="fas fa-chevron-down toggle-icon"></i>
+                        </button>
+                        <div class="qrcode-container" id="qrCodeContainer">
+                            <img src="/loras_static/images/wechat-qr.webp" alt="WeChat Pay QR Code" class="qrcode-image">
+                        </div>
+                    </div>
+                    
+                    <div class="support-footer">
+                        <p>{{ t('support.footer') }}</p>
+                    </div>
                </div>
            </div>
-            
-            <div class="support-section">
-                <h3><i class="fas fa-coffee"></i> {{ t('support.sections.buyMeCoffee') }}</h3>
-                <p>{{ t('support.sections.coffeeDescription') }}</p>
-                <a href="https://ko-fi.com/pixelpawsai" class="kofi-button" target="_blank">
-                    <i class="fas fa-mug-hot"></i>
-                    <span>{{ t('support.links.supportKofi') }}</span>
-                </a>
-            </div>

-            <!-- Patreon Support Section -->
-            <div class="support-section">
-                <h3><i class="fab fa-patreon"></i> {{ t('support.sections.becomePatron') }}</h3>
-                <p>{{ t('support.sections.patronDescription') }}</p>
-                <a href="https://patreon.com/PixelPawsAI" class="patreon-button" target="_blank">
-                    <i class="fab fa-patreon"></i>
-                    <span>{{ t('support.links.supportPatreon') }}</span>
-                </a>
-            </div>
+            <!-- Right Side: Supporters -->
+            <div class="support-right">
+                <div class="supporters-section">
+                    <div class="supporters-header">
+                        <h2 class="supporters-title">
+                            <i class="fas fa-hands-helping"></i>
+                            {{ t('support.supporters.title') }}
+                        </h2>
+                        <p class="supporters-subtitle" id="supportersSubtitle">
+                            {{ t('support.supporters.subtitle', count=0) }}
+                        </p>
+                    </div>
+                    
+                    <!-- Special Thanks Section -->
+                    <div class="supporters-group special-thanks-group">
+                        <h3 class="supporters-group-title">
+                            <i class="fas fa-star"></i>
+                            {{ t('support.supporters.specialThanks') }}
+                        </h3>
+                        <div class="supporters-special-grid" id="specialThanksGrid">
+                            <!-- Supporters will be loaded dynamically -->
+                        </div>
+                    </div>

-            <!-- New section for Chinese payment methods -->
-            <div class="support-section">
-                <h3><i class="fas fa-qrcode"></i> {{ t('support.sections.wechatSupport') }}</h3>
-                <p>{{ t('support.sections.wechatDescription') }}</p>
-                <button class="secondary-btn qrcode-toggle" id="toggleQRCode">
-                    <i class="fas fa-qrcode"></i>
-                    <span class="toggle-text">{{ t('support.sections.showWechatQR') }}</span>
-                    <i class="fas fa-chevron-down toggle-icon"></i>
-                </button>
-                <div class="qrcode-container" id="qrCodeContainer">
-                    <img src="/loras_static/images/wechat-qr.webp" alt="WeChat Pay QR Code" class="qrcode-image">
+                    <!-- All Supporters Section -->
+                    <div class="supporters-group all-supporters-group">
+                        <h3 class="supporters-group-title">
+                            <i class="fas fa-heart"></i>
+                            {{ t('support.supporters.allSupporters') }}
+                        </h3>
+                        <div class="supporters-all-list" id="supportersGrid">
+                            <!-- Supporters will be loaded dynamically -->
+                        </div>
+                    </div>
                </div>
            </div>
-            
-            <div class="support-footer">
-                <p>{{ t('support.footer') }}</p>
-            </div>
        </div>
    </div>
 </div>
--- a/templates/recipes.html
+++ b/templates/recipes.html
@@ -66,10 +66,20 @@
                    </optgroup>
                </select>
            </div>
-            <div title="{{ t('recipes.controls.refresh.title') }}" class="control-group">
-                <button onclick="recipeManager.refreshRecipes()"><i class="fas fa-sync"></i> {{
-                    t('common.actions.refresh')
-                    }}</button>
+            <div title="{{ t('recipes.controls.refresh.title') }}" class="control-group dropdown-group">
+                <button data-action="refresh" class="dropdown-main"><i class="fas fa-sync"></i> <span>{{
+                    t('common.actions.refresh') }}</span></button>
+                <button class="dropdown-toggle" aria-label="Show refresh options">
+                    <i class="fas fa-caret-down"></i>
+                </button>
+                <div class="dropdown-menu">
+                    <div class="dropdown-item" data-action="quick-refresh" title="{{ t('recipes.controls.refresh.quickTooltip', default='Sync changes - quick refresh without rebuilding cache') }}">
+                        <i class="fas fa-bolt"></i> <span>{{ t('loras.controls.refresh.quick', default='Sync Changes') }}</span>
+                    </div>
+                    <div class="dropdown-item" data-action="full-rebuild" title="{{ t('recipes.controls.refresh.fullTooltip', default='Rebuild cache - full rescan of all recipe files') }}">
+                        <i class="fas fa-tools"></i> <span>{{ t('loras.controls.refresh.full', default='Rebuild Cache') }}</span>
+                    </div>
+                </div>
            </div>
            <div title="{{ t('recipes.controls.import.title') }}" class="control-group">
                <button onclick="importManager.showImportModal()"><i class="fas fa-file-import"></i> {{
--- a/tests/config/test_config_save_paths.py
+++ b/tests/config/test_config_save_paths.py
@@ -215,3 +215,110 @@ def test_save_paths_removes_template_default_library(monkeypatch, tmp_path):
    )
    assert payload["metadata"] == {"display_name": "ComfyUI", "source": "comfyui"}
    assert payload["activate"] is True
+
+
+def test_apply_library_settings_merges_extra_paths(monkeypatch, tmp_path):
+    """Test that apply_library_settings correctly merges folder_paths with extra_folder_paths."""
+    loras_dir = tmp_path / "loras"
+    extra_loras_dir = tmp_path / "extra_loras"
+    checkpoints_dir = tmp_path / "checkpoints"
+    extra_checkpoints_dir = tmp_path / "extra_checkpoints"
+    embeddings_dir = tmp_path / "embeddings"
+    extra_embeddings_dir = tmp_path / "extra_embeddings"
+
+    for directory in (loras_dir, extra_loras_dir, checkpoints_dir, extra_checkpoints_dir, embeddings_dir, extra_embeddings_dir):
+        directory.mkdir()
+
+    config_instance = config_module.Config()
+
+    folder_paths = {
+        "loras": [str(loras_dir)],
+        "checkpoints": [str(checkpoints_dir)],
+        "unet": [],
+        "embeddings": [str(embeddings_dir)],
+    }
+    extra_folder_paths = {
+        "loras": [str(extra_loras_dir)],
+        "checkpoints": [str(extra_checkpoints_dir)],
+        "unet": [],
+        "embeddings": [str(extra_embeddings_dir)],
+    }
+
+    library_config = {
+        "folder_paths": folder_paths,
+        "extra_folder_paths": extra_folder_paths,
+    }
+
+    config_instance.apply_library_settings(library_config)
+
+    assert str(loras_dir) in config_instance.loras_roots
+    assert str(extra_loras_dir) in config_instance.extra_loras_roots
+    assert str(checkpoints_dir) in config_instance.base_models_roots
+    assert str(extra_checkpoints_dir) in config_instance.extra_checkpoints_roots
+    assert str(embeddings_dir) in config_instance.embeddings_roots
+    assert str(extra_embeddings_dir) in config_instance.extra_embeddings_roots
+
+
+def test_apply_library_settings_without_extra_paths(monkeypatch, tmp_path):
+    """Test that apply_library_settings works when extra_folder_paths is not provided."""
+    loras_dir = tmp_path / "loras"
+    checkpoints_dir = tmp_path / "checkpoints"
+    embeddings_dir = tmp_path / "embeddings"
+
+    for directory in (loras_dir, checkpoints_dir, embeddings_dir):
+        directory.mkdir()
+
+    config_instance = config_module.Config()
+
+    folder_paths = {
+        "loras": [str(loras_dir)],
+        "checkpoints": [str(checkpoints_dir)],
+        "unet": [],
+        "embeddings": [str(embeddings_dir)],
+    }
+
+    library_config = {
+        "folder_paths": folder_paths,
+    }
+
+    config_instance.apply_library_settings(library_config)
+
+    assert str(loras_dir) in config_instance.loras_roots
+    assert config_instance.extra_loras_roots == []
+    assert str(checkpoints_dir) in config_instance.base_models_roots
+    assert config_instance.extra_checkpoints_roots == []
+    assert str(embeddings_dir) in config_instance.embeddings_roots
+    assert config_instance.extra_embeddings_roots == []
+
+
+def test_extra_paths_deduplication(monkeypatch, tmp_path):
+    """Test that extra paths are stored separately from main paths in Config."""
+    loras_dir = tmp_path / "loras"
+    extra_loras_dir = tmp_path / "extra_loras"
+    loras_dir.mkdir()
+    extra_loras_dir.mkdir()
+
+    config_instance = config_module.Config()
+
+    folder_paths = {
+        "loras": [str(loras_dir)],
+        "checkpoints": [],
+        "unet": [],
+        "embeddings": [],
+    }
+    extra_folder_paths = {
+        "loras": [str(extra_loras_dir)],
+        "checkpoints": [],
+        "unet": [],
+        "embeddings": [],
+    }
+
+    library_config = {
+        "folder_paths": folder_paths,
+        "extra_folder_paths": extra_folder_paths,
+    }
+
+    config_instance.apply_library_settings(library_config)
+
+    assert config_instance.loras_roots == [str(loras_dir)]
+    assert config_instance.extra_loras_roots == [str(extra_loras_dir)]
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -74,11 +74,15 @@ sys.modules['folder_paths'] = folder_paths_mock
 # Mock other ComfyUI modules that might be imported
 comfy_mock = MockModule("comfy")
 comfy_mock.utils = MockModule("comfy.utils")
+comfy_mock.utils.load_torch_file = mock.MagicMock(return_value={})
+comfy_mock.sd = MockModule("comfy.sd")
+comfy_mock.sd.load_lora_for_models = mock.MagicMock(return_value=(None, None))
 comfy_mock.model_management = MockModule("comfy.model_management")
 comfy_mock.comfy_types = MockModule("comfy.comfy_types")
 comfy_mock.comfy_types.IO = mock.MagicMock()
 sys.modules['comfy'] = comfy_mock
 sys.modules['comfy.utils'] = comfy_mock.utils
+sys.modules['comfy.sd'] = comfy_mock.sd
 sys.modules['comfy.model_management'] = comfy_mock.model_management
 sys.modules['comfy.comfy_types'] = comfy_mock.comfy_types

--- a/tests/frontend/components/autocomplete.behavior.test.js
+++ b/tests/frontend/components/autocomplete.behavior.test.js
@@ -90,7 +90,7 @@ describe('AutoComplete widget interactions', () => {
    await vi.runAllTimersAsync();
    await Promise.resolve();

-    expect(fetchApiMock).toHaveBeenCalledWith('/lm/loras/relative-paths?search=example&limit=20');
+    expect(fetchApiMock).toHaveBeenCalledWith('/lm/loras/relative-paths?search=example&limit=100');
    const items = autoComplete.dropdown.querySelectorAll('.comfy-autocomplete-item');
    expect(items).toHaveLength(1);
    expect(autoComplete.dropdown.style.display).toBe('block');
--- a/tests/frontend/managers/MoveManager.test.js
+++ b/tests/frontend/managers/MoveManager.test.js
@@ -0,0 +1,159 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { moveManager } from '../../../static/js/managers/MoveManager.js';
+import { state } from '../../../static/js/state/index.js';
+import { modalManager } from '../../../static/js/managers/ModalManager.js';
+import { getModelApiClient } from '../../../static/js/api/modelApiFactory.js';
+import * as storageHelpers from '../../../static/js/utils/storageHelpers.js';
+
+// Mock dependencies
+vi.mock('../../../static/js/state/index.js', () => ({
+    state: {
+        currentPageType: 'loras',
+        selectedModels: new Set(),
+        global: {
+            settings: {
+                download_path_templates: {
+                    lora: '{base_model}/unstaged'
+                }
+            }
+        }
+    }
+}));
+
+vi.mock('../../../static/js/managers/ModalManager.js', () => ({
+    modalManager: {
+        showModal: vi.fn(),
+        closeModal: vi.fn()
+    }
+}));
+
+vi.mock('../../../static/js/api/modelApiFactory.js', () => ({
+    getModelApiClient: vi.fn()
+}));
+
+vi.mock('../../../static/js/utils/storageHelpers.js', () => ({
+    getStorageItem: vi.fn(),
+    setStorageItem: vi.fn()
+}));
+
+vi.mock('../../../static/js/utils/uiHelpers.js', () => ({
+    showToast: vi.fn()
+}));
+
+vi.mock('../../../static/js/utils/i18nHelpers.js', () => ({
+    translate: vi.fn(key => key)
+}));
+
+describe('MoveManager', () => {
+    let mockApiClient;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        
+        // Setup DOM
+        document.body.innerHTML = `
+            <div id="moveModal">
+                <h2 id="moveModalTitle"></h2>
+                <label id="moveRootLabel"></label>
+                <select id="moveModelRoot"></select>
+                <input type="checkbox" id="moveUseDefaultPath" />
+                <div id="moveManualPathSelection">
+                    <input id="moveFolderPath" />
+                    <div id="moveFolderTree"></div>
+                </div>
+                <div id="moveTargetPathDisplay"><span class="path-text"></span></div>
+            </div>
+        `;
+
+        mockApiClient = {
+            apiConfig: {
+                config: {
+                    displayName: 'LoRA',
+                    supportsMove: true
+                },
+                endpoints: {
+                    moveModel: '/api/move'
+                }
+            },
+            modelType: 'loras',
+            fetchModelRoots: vi.fn().mockResolvedValue({ roots: ['/models/loras'] }),
+            fetchUnifiedFolderTree: vi.fn().mockResolvedValue({ success: true, tree: {} }),
+            moveSingleModel: vi.fn().mockResolvedValue({ success: true })
+        };
+        getModelApiClient.mockReturnValue(mockApiClient);
+    });
+
+    it('should reset folder selection when showing move modal', async () => {
+        // Manually set a selected path in folderTreeManager
+        moveManager.folderTreeManager.selectedPath = 'previous/path';
+        
+        await moveManager.showMoveModal('some/file.safetensors');
+        
+        expect(moveManager.folderTreeManager.getSelectedPath()).toBe('');
+    });
+
+    it('should ignore manual folder selection when useDefaultPath is true', async () => {
+        // Setup state
+        moveManager.useDefaultPath = true;
+        moveManager.currentFilePath = '/models/loras/flux/my-lora.safetensors';
+        document.getElementById('moveModelRoot').innerHTML = '<option value="/models/loras">/models/loras</option>';
+        document.getElementById('moveModelRoot').value = '/models/loras';
+        
+        // Manually set a selected path despite useDefaultPath being true
+        moveManager.folderTreeManager.selectedPath = 'wrong/folder';
+        
+        await moveManager.moveModel();
+        
+        // Should call moveSingleModel with the root path, NOT including the 'wrong/folder'
+        expect(mockApiClient.moveSingleModel).toHaveBeenCalledWith(
+            '/models/loras/flux/my-lora.safetensors',
+            '/models/loras',
+            true
+        );
+    });
+
+    it('should include manual folder selection when useDefaultPath is false', async () => {
+        // Setup state
+        moveManager.useDefaultPath = false;
+        moveManager.currentFilePath = '/models/loras/flux/my-lora.safetensors';
+        document.getElementById('moveModelRoot').innerHTML = '<option value="/models/loras">/models/loras</option>';
+        document.getElementById('moveModelRoot').value = '/models/loras';
+        
+        // Set a selected path
+        moveManager.folderTreeManager.selectedPath = 'my/organized/folder';
+        
+        await moveManager.moveModel();
+        
+        // Should call moveSingleModel with root + selected folder
+        expect(mockApiClient.moveSingleModel).toHaveBeenCalledWith(
+            '/models/loras/flux/my-lora.safetensors',
+            '/models/loras/my/organized/folder',
+            false
+        );
+    });
+
+    it('should handle bulk move and ignore manual folder selection when useDefaultPath is true', async () => {
+        // Setup state
+        moveManager.useDefaultPath = true;
+        moveManager.bulkFilePaths = [
+            '/models/loras/flux/lora1.safetensors',
+            '/models/loras/flux/lora2.safetensors'
+        ];
+        document.getElementById('moveModelRoot').innerHTML = '<option value="/models/loras">/models/loras</option>';
+        document.getElementById('moveModelRoot').value = '/models/loras';
+        
+        // Manually set a selected path
+        moveManager.folderTreeManager.selectedPath = 'wrong/folder';
+        
+        mockApiClient.moveBulkModels = vi.fn().mockResolvedValue({ success: true });
+        
+        await moveManager.moveModel();
+        
+        // Should call moveBulkModels with the root path, NOT including the 'wrong/folder'
+        expect(mockApiClient.moveBulkModels).toHaveBeenCalledWith(
+            moveManager.bulkFilePaths,
+            '/models/loras',
+            true
+        );
+    });
+});
--- a/tests/frontend/pages/statistics.dashboard.test.js
+++ b/tests/frontend/pages/statistics.dashboard.test.js
@@ -107,6 +107,33 @@ describe('Statistics dashboard rendering', () => {
          ],
        },
      },
+      '/api/lm/stats/model-usage-list?type=lora&sort=desc&offset=0&limit=50': {
+        success: true,
+        data: {
+          items: [
+            { name: 'Lora A', base_model: 'SDXL', folder: 'loras', usage_count: 10, preview_url: '' },
+          ],
+          total: 1,
+        },
+      },
+      '/api/lm/stats/model-usage-list?type=checkpoint&sort=desc&offset=0&limit=50': {
+        success: true,
+        data: {
+          items: [
+            { name: 'Checkpoint A', base_model: 'SDXL', folder: 'checkpoints', usage_count: 5, preview_url: '' },
+          ],
+          total: 1,
+        },
+      },
+      '/api/lm/stats/model-usage-list?type=embedding&sort=desc&offset=0&limit=50': {
+        success: true,
+        data: {
+          items: [
+            { name: 'Embedding A', base_model: 'SDXL', folder: 'embeddings', usage_count: 7, preview_url: '' },
+          ],
+          total: 1,
+        },
+      },
    };

    const { StatisticsManager } = await import(STATISTICS_MODULE);
--- a/tests/frontend/utils/civitaiUtils.test.js
+++ b/tests/frontend/utils/civitaiUtils.test.js
@@ -0,0 +1,172 @@
+import { describe, it, expect } from 'vitest';
+import {
+    rewriteCivitaiUrl,
+    getOptimizedUrl,
+    getShowcaseUrl,
+    getThumbnailUrl,
+    isCivitaiUrl,
+    OptimizationMode
+} from '../../../static/js/utils/civitaiUtils.js';
+
+describe('civitaiUtils', () => {
+    describe('OptimizationMode', () => {
+        it('should have correct mode values', () => {
+            expect(OptimizationMode.SHOWCASE).toBe('showcase');
+            expect(OptimizationMode.THUMBNAIL).toBe('thumbnail');
+        });
+    });
+
+    describe('rewriteCivitaiUrl', () => {
+        it('should rewrite image URLs with /original=true for thumbnail mode', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.THUMBNAIL);
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/width=450,optimized=true/12345.jpeg');
+        });
+
+        it('should rewrite image URLs with /original=true for showcase mode (no width)', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.SHOWCASE);
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/optimized=true/12345.jpeg');
+        });
+
+        it('should rewrite video URLs with /original=true for thumbnail mode', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.mp4';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'video', OptimizationMode.THUMBNAIL);
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/transcode=true,width=450,optimized=true/12345.mp4');
+        });
+
+        it('should rewrite video URLs with /original=true for showcase mode (no width/transcode)', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.mp4';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'video', OptimizationMode.SHOWCASE);
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/optimized=true/12345.mp4');
+        });
+
+        it('should default to thumbnail mode when mode is not specified', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image');
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/width=450,optimized=true/12345.jpeg');
+        });
+
+        it('should not rewrite URLs without /original=true', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/width=450/12345.jpeg';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.THUMBNAIL);
+
+            expect(wasRewritten).toBe(false);
+            expect(rewritten).toBe(originalUrl);
+        });
+
+        it('should not rewrite non-CivitAI URLs', () => {
+            const originalUrl = 'https://example.com/image.jpg';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.SHOWCASE);
+
+            expect(wasRewritten).toBe(false);
+            expect(rewritten).toBe(originalUrl);
+        });
+
+        it('should handle null/undefined URLs', () => {
+            const [rewritten1, wasRewritten1] = rewriteCivitaiUrl(null, 'image');
+            expect(wasRewritten1).toBe(false);
+            expect(rewritten1).toBe(null);
+
+            const [rewritten2, wasRewritten2] = rewriteCivitaiUrl(undefined, 'image');
+            expect(wasRewritten2).toBe(false);
+            expect(rewritten2).toBe(undefined);
+        });
+
+        it('should handle empty strings', () => {
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl('', 'image');
+            expect(wasRewritten).toBe(false);
+            expect(rewritten).toBe('');
+        });
+
+        it('should handle invalid URLs gracefully', () => {
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl('not-a-valid-url', 'image');
+            expect(wasRewritten).toBe(false);
+            expect(rewritten).toBe('not-a-valid-url');
+        });
+    });
+
+    describe('getOptimizedUrl', () => {
+        it('should return optimized URL for CivitAI images in thumbnail mode', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const optimized = getOptimizedUrl(originalUrl, 'image', OptimizationMode.THUMBNAIL);
+
+            expect(optimized).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/width=450,optimized=true/12345.jpeg');
+        });
+
+        it('should return optimized URL for CivitAI images in showcase mode', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const optimized = getOptimizedUrl(originalUrl, 'image', OptimizationMode.SHOWCASE);
+
+            expect(optimized).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/optimized=true/12345.jpeg');
+        });
+
+        it('should return original URL for non-CivitAI URLs', () => {
+            const originalUrl = 'https://example.com/image.jpg';
+            const optimized = getOptimizedUrl(originalUrl, 'image');
+
+            expect(optimized).toBe(originalUrl);
+        });
+    });
+
+    describe('getShowcaseUrl', () => {
+        it('should return showcase-optimized URL (full quality)', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const showcaseUrl = getShowcaseUrl(originalUrl, 'image');
+
+            expect(showcaseUrl).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/optimized=true/12345.jpeg');
+        });
+
+        it('should handle videos for showcase', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.mp4';
+            const showcaseUrl = getShowcaseUrl(originalUrl, 'video');
+
+            expect(showcaseUrl).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/optimized=true/12345.mp4');
+        });
+    });
+
+    describe('getThumbnailUrl', () => {
+        it('should return thumbnail-optimized URL (width=450)', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.jpeg';
+            const thumbnailUrl = getThumbnailUrl(originalUrl, 'image');
+
+            expect(thumbnailUrl).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/width=450,optimized=true/12345.jpeg');
+        });
+
+        it('should handle videos for thumbnails', () => {
+            const originalUrl = 'https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.mp4';
+            const thumbnailUrl = getThumbnailUrl(originalUrl, 'video');
+
+            expect(thumbnailUrl).toBe('https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/transcode=true,width=450,optimized=true/12345.mp4');
+        });
+    });
+
+    describe('isCivitaiUrl', () => {
+        it('should return true for CivitAI URLs', () => {
+            expect(isCivitaiUrl('https://image.civitai.com/something')).toBe(true);
+            expect(isCivitaiUrl('https://image.civitai.com/')).toBe(true);
+        });
+
+        it('should return false for non-CivitAI URLs', () => {
+            expect(isCivitaiUrl('https://example.com/image.jpg')).toBe(false);
+            expect(isCivitaiUrl('https://civitai.com/image.jpg')).toBe(false);
+            expect(isCivitaiUrl('')).toBe(false);
+            expect(isCivitaiUrl(null)).toBe(false);
+            expect(isCivitaiUrl(undefined)).toBe(false);
+        });
+
+        it('should handle invalid URLs gracefully', () => {
+            expect(isCivitaiUrl('not-a-url')).toBe(false);
+        });
+    });
+});
--- a/tests/performance/test_cache_performance.py
+++ b/tests/performance/test_cache_performance.py
@@ -14,12 +14,17 @@ from py.services.model_hash_index import ModelHashIndex
 from py.utils.utils import fuzzy_match, calculate_recipe_fingerprint


+pytestmark = pytest.mark.performance
+
+
 class TestHashIndexPerformance:
    """Performance benchmarks for hash index operations."""

    def test_hash_index_lookup_small(self, benchmark):
        """Benchmark hash index lookup with 100 models."""
-        index, target_hash = self._create_hash_index_with_n_models(100, return_target=True)
+        index, target_hash = self._create_hash_index_with_n_models(
+            100, return_target=True
+        )

        def lookup():
            return index.get_path(target_hash)
@@ -29,7 +34,9 @@ class TestHashIndexPerformance:

    def test_hash_index_lookup_medium(self, benchmark):
        """Benchmark hash index lookup with 1,000 models."""
-        index, target_hash = self._create_hash_index_with_n_models(1000, return_target=True)
+        index, target_hash = self._create_hash_index_with_n_models(
+            1000, return_target=True
+        )

        def lookup():
            return index.get_path(target_hash)
@@ -39,7 +46,9 @@ class TestHashIndexPerformance:

    def test_hash_index_lookup_large(self, benchmark):
        """Benchmark hash index lookup with 10,000 models."""
-        index, target_hash = self._create_hash_index_with_n_models(10000, return_target=True)
+        index, target_hash = self._create_hash_index_with_n_models(
+            10000, return_target=True
+        )

        def lookup():
            return index.get_path(target_hash)
@@ -71,11 +80,11 @@ class TestHashIndexPerformance:

    def _create_hash_index_with_n_models(self, n: int, return_target: bool = False):
        """Create a hash index with n mock models.
-        
+
        Args:
            n: Number of models to create
            return_target: If True, returns the hash of the middle model for lookup testing
-            
+
        Returns:
            ModelHashIndex or tuple of (ModelHashIndex, target_hash)
        """
@@ -94,7 +103,7 @@ class TestHashIndexPerformance:

    def _random_string(self, length: int) -> str:
        """Generate a random string of fixed length."""
-        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
+        return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))


 class TestFuzzyMatchPerformance:
--- a/tests/routes/test_base_model_routes_smoke.py
+++ b/tests/routes/test_base_model_routes_smoke.py
@@ -31,7 +31,9 @@ from py.utils.metadata_manager import MetadataManager
 class DummyRoutes(BaseModelRoutes):
    template_name = "dummy.html"

-    def setup_specific_routes(self, registrar, prefix: str) -> None:  # pragma: no cover - no extra routes in smoke tests
+    def setup_specific_routes(
+        self, registrar, prefix: str
+    ) -> None:  # pragma: no cover - no extra routes in smoke tests
        return None

    def __init__(self, service=None):
@@ -59,7 +61,9 @@ class NullUpdateRecord:

    @property
    def in_library_version_ids(self) -> list[int]:
-        return [version.version_id for version in self.versions if version.is_in_library]
+        return [
+            version.version_id for version in self.versions if version.is_in_library
+        ]

    def has_update(self) -> bool:
        return False
@@ -86,7 +90,9 @@ class NullModelUpdateService:
            )
            for version_id in version_ids
        ]
-        return NullUpdateRecord(model_type=model_type, model_id=model_id, versions=versions)
+        return NullUpdateRecord(
+            model_type=model_type, model_id=model_id, versions=versions
+        )

    async def set_should_ignore(self, model_type, model_id, should_ignore):
        return NullUpdateRecord(
@@ -95,7 +101,9 @@ class NullModelUpdateService:
            should_ignore_model=should_ignore,
        )

-    async def set_version_should_ignore(self, model_type, model_id, version_id, should_ignore):
+    async def set_version_should_ignore(
+        self, model_type, model_id, version_id, should_ignore
+    ):
        return await self.set_should_ignore(model_type, model_id, should_ignore)

    async def get_record(self, *args, **kwargs):
@@ -167,7 +175,9 @@ def download_manager_stub():


 def test_list_models_returns_formatted_items(mock_service, mock_scanner):
-    mock_service.paginated_items = [{"file_path": "/tmp/demo.safetensors", "name": "Demo"}]
+    mock_service.paginated_items = [
+        {"file_path": "/tmp/demo.safetensors", "name": "Demo"}
+    ]

    async def scenario():
        client = await create_test_client(mock_service)
@@ -176,7 +186,13 @@ def test_list_models_returns_formatted_items(mock_service, mock_scanner):
            payload = await response.json()

            assert response.status == 200
-            assert payload["items"] == [{"file_path": "/tmp/demo.safetensors", "name": "Demo", "formatted": True}]
+            assert payload["items"] == [
+                {
+                    "file_path": "/tmp/demo.safetensors",
+                    "name": "Demo",
+                    "formatted": True,
+                }
+            ]
            assert payload["total"] == 1
            assert mock_service.formatted == payload["items"]
        finally:
@@ -220,7 +236,9 @@ def test_routes_return_service_not_ready_when_unattached():
    asyncio.run(scenario())


-def test_delete_model_updates_cache_and_hash_index(mock_service, mock_scanner, tmp_path: Path):
+def test_delete_model_updates_cache_and_hash_index(
+    mock_service, mock_scanner, tmp_path: Path
+):
    model_path = tmp_path / "sample.safetensors"
    model_path.write_bytes(b"model")
    mock_scanner._cache.raw_data = [{"file_path": str(model_path)}]
@@ -271,17 +289,23 @@ def test_replace_preview_writes_file_and_updates_cache(
    )

    form = FormData()
-    form.add_field("preview_file", b"binary-data", filename="preview.png", content_type="image/png")
+    form.add_field(
+        "preview_file", b"binary-data", filename="preview.png", content_type="image/png"
+    )
    form.add_field("model_path", str(model_path))
    form.add_field("nsfw_level", "2")

    async def scenario():
        client = await create_test_client(mock_service)
        try:
-            response = await client.post("/api/lm/test-models/replace-preview", data=form)
+            response = await client.post(
+                "/api/lm/test-models/replace-preview", data=form
+            )
            payload = await response.json()

-            expected_preview = str((tmp_path / "preview-model.webp")).replace(os.sep, "/")
+            expected_preview = str((tmp_path / "preview-model.webp")).replace(
+                os.sep, "/"
+            )
            assert response.status == 200
            assert payload["success"] is True
            assert payload["preview_url"] == "/static/preview-model.webp"
@@ -299,6 +323,66 @@ def test_replace_preview_writes_file_and_updates_cache(
    asyncio.run(scenario())


+def test_set_preview_from_url_downloads_and_updates_cache(
+    mock_service,
+    mock_scanner,
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+):
+    """Test that set_preview_from_url endpoint downloads remote images and sets them as preview."""
+    model_path = tmp_path / "url-preview-model.safetensors"
+    model_path.write_bytes(b"model")
+    metadata_path = tmp_path / "url-preview-model.metadata.json"
+    metadata_path.write_text(json.dumps({"file_path": str(model_path)}))
+
+    mock_scanner._cache.raw_data = [{"file_path": str(model_path)}]
+
+    monkeypatch.setattr(
+        config,
+        "get_preview_static_url",
+        lambda preview_path: f"/static/{Path(preview_path).name}",
+    )
+
+    async def scenario():
+        client = await create_test_client(mock_service)
+        try:
+            # Mock the Downloader to return a test image
+            from py.services import downloader
+
+            class FakeDownloader:
+                async def download_to_memory(
+                    self, url, use_auth=False, return_headers=True
+                ):
+                    return True, b"fake-image-data", {"Content-Type": "image/jpeg"}
+
+            async def fake_get_downloader():
+                return FakeDownloader()
+
+            monkeypatch.setattr(downloader, "get_downloader", fake_get_downloader)
+
+            response = await client.post(
+                "/api/lm/test-models/set-preview-from-url",
+                json={
+                    "model_path": str(model_path),
+                    "image_url": "https://example.com/image.jpg",
+                    "nsfw_level": 3,
+                },
+            )
+            payload = await response.json()
+
+            expected_preview = str((tmp_path / "url-preview-model.webp")).replace(
+                os.sep, "/"
+            )
+            assert response.status == 200
+            assert payload["success"] is True
+            assert payload["preview_url"] == "/static/url-preview-model.webp"
+            assert Path(expected_preview).exists()
+        finally:
+            await client.close()
+
+    asyncio.run(scenario())
+
+
 def test_fetch_civitai_hydrates_metadata_before_sync(
    mock_service,
    mock_scanner,
@@ -370,9 +454,15 @@ def test_fetch_civitai_hydrates_metadata_before_sync(
    save_calls: list[tuple[str, dict]] = []
    captured: dict[str, dict] = {}

-    monkeypatch.setattr(MetadataManager, "load_metadata", staticmethod(fake_load_metadata))
-    monkeypatch.setattr(MetadataManager, "save_metadata", staticmethod(fake_save_metadata))
-    monkeypatch.setattr(MetadataSyncService, "fetch_and_update_model", fake_fetch_and_update_model)
+    monkeypatch.setattr(
+        MetadataManager, "load_metadata", staticmethod(fake_load_metadata)
+    )
+    monkeypatch.setattr(
+        MetadataManager, "save_metadata", staticmethod(fake_save_metadata)
+    )
+    monkeypatch.setattr(
+        MetadataSyncService, "fetch_and_update_model", fake_fetch_and_update_model
+    )

    async def scenario():
        client = await create_test_client(mock_service)
@@ -386,7 +476,10 @@ def test_fetch_civitai_hydrates_metadata_before_sync(
            assert response.status == 200
            assert payload["success"] is True
            assert captured["model_data"]["custom_field"] == "preserve"
-            assert captured["model_data"]["civitai"]["images"][0]["url"] == "https://example.com/existing.png"
+            assert (
+                captured["model_data"]["civitai"]["images"][0]["url"]
+                == "https://example.com/existing.png"
+            )
            assert captured["model_data"]["civitai"]["trainedWords"] == ["keep"]
            assert captured["model_data"]["civitai"]["id"] == 99
        finally:
@@ -398,7 +491,10 @@ def test_fetch_civitai_hydrates_metadata_before_sync(
    saved_path, saved_payload = save_calls[0]
    assert saved_path == str(metadata_path)
    assert saved_payload["custom_field"] == "preserve"
-    assert saved_payload["civitai"]["images"][0]["url"] == "https://example.com/existing.png"
+    assert (
+        saved_payload["civitai"]["images"][0]["url"]
+        == "https://example.com/existing.png"
+    )
    assert saved_payload["civitai"]["trainedWords"] == ["keep"]
    assert saved_payload["civitai"]["id"] == 99
    assert saved_payload["legacy_field"] == "legacy"
@@ -432,11 +528,22 @@ def test_download_model_invokes_download_manager(
            assert call_args["download_id"] == payload["download_id"]
            progress = ws_manager.get_download_progress(payload["download_id"])
            assert progress is not None
-            expected_progress = round(download_manager_stub.last_progress_snapshot.percent_complete)
+            expected_progress = round(
+                download_manager_stub.last_progress_snapshot.percent_complete
+            )
            assert progress["progress"] == expected_progress
-            assert progress["bytes_downloaded"] == download_manager_stub.last_progress_snapshot.bytes_downloaded
-            assert progress["total_bytes"] == download_manager_stub.last_progress_snapshot.total_bytes
-            assert progress["bytes_per_second"] == download_manager_stub.last_progress_snapshot.bytes_per_second
+            assert (
+                progress["bytes_downloaded"]
+                == download_manager_stub.last_progress_snapshot.bytes_downloaded
+            )
+            assert (
+                progress["total_bytes"]
+                == download_manager_stub.last_progress_snapshot.total_bytes
+            )
+            assert (
+                progress["bytes_per_second"]
+                == download_manager_stub.last_progress_snapshot.bytes_per_second
+            )
            assert "timestamp" in progress

            progress_response = await client.get(
@@ -526,21 +633,30 @@ def test_auto_organize_progress_returns_latest_snapshot(mock_service):
    async def scenario():
        client = await create_test_client(mock_service)
        try:
-            await ws_manager.broadcast_auto_organize_progress({"status": "processing", "percent": 50})
+            await ws_manager.broadcast_auto_organize_progress(
+                {"status": "processing", "percent": 50}
+            )

            response = await client.get("/api/lm/test-models/auto-organize-progress")
            payload = await response.json()

            assert response.status == 200
-            assert payload == {"success": True, "progress": {"status": "processing", "percent": 50}}
+            assert payload == {
+                "success": True,
+                "progress": {"status": "processing", "percent": 50},
+            }
        finally:
            await client.close()
-    
+
    asyncio.run(scenario())


-def test_auto_organize_route_emits_progress(mock_service, monkeypatch: pytest.MonkeyPatch):
-    async def fake_auto_organize(self, file_paths=None, progress_callback=None, exclusion_patterns=None):
+def test_auto_organize_route_emits_progress(
+    mock_service, monkeypatch: pytest.MonkeyPatch
+):
+    async def fake_auto_organize(
+        self, file_paths=None, progress_callback=None, exclusion_patterns=None
+    ):
        result = AutoOrganizeResult()
        result.total = 1
        result.processed = 1
@@ -549,8 +665,12 @@ def test_auto_organize_route_emits_progress(mock_service, monkeypatch: pytest.Mo
        result.failure_count = 0
        result.operation_type = "bulk"
        if progress_callback is not None:
-            await progress_callback.on_progress({"type": "auto_organize_progress", "status": "started"})
-            await progress_callback.on_progress({"type": "auto_organize_progress", "status": "completed"})
+            await progress_callback.on_progress(
+                {"type": "auto_organize_progress", "status": "started"}
+            )
+            await progress_callback.on_progress(
+                {"type": "auto_organize_progress", "status": "completed"}
+            )
        return result

    monkeypatch.setattr(
@@ -562,7 +682,9 @@ def test_auto_organize_route_emits_progress(mock_service, monkeypatch: pytest.Mo
    async def scenario():
        client = await create_test_client(mock_service)
        try:
-            response = await client.post("/api/lm/test-models/auto-organize", json={"file_paths": []})
+            response = await client.post(
+                "/api/lm/test-models/auto-organize", json={"file_paths": []}
+            )
            payload = await response.json()

            assert response.status == 200
--- a/tests/services/test_cache_entry_validator.py
+++ b/tests/services/test_cache_entry_validator.py
@@ -73,6 +73,46 @@ class TestCacheEntryValidator:
        assert result.repaired is False
        assert any('sha256' in error for error in result.errors)

+    def test_validate_empty_sha256_allowed_when_hash_status_pending(self):
+        """Test validation passes when sha256 is empty but hash_status is pending (lazy hash)"""
+        entry = {
+            'file_path': '/models/test.safetensors',
+            'sha256': '',  # Empty string
+            'hash_status': 'pending',  # Lazy hash calculation
+        }
+
+        result = CacheEntryValidator.validate(entry, auto_repair=False)
+
+        assert result.is_valid is True
+        assert result.entry['sha256'] == ''
+        assert result.entry['hash_status'] == 'pending'
+
+    def test_validate_empty_sha256_fails_when_hash_status_not_pending(self):
+        """Test validation fails when sha256 is empty and hash_status is not pending"""
+        entry = {
+            'file_path': '/models/test.safetensors',
+            'sha256': '',  # Empty string
+            'hash_status': 'completed',  # Not pending
+        }
+
+        result = CacheEntryValidator.validate(entry, auto_repair=False)
+
+        assert result.is_valid is False
+        assert any('sha256' in error for error in result.errors)
+
+    def test_validate_empty_sha256_fails_when_hash_status_missing(self):
+        """Test validation fails when sha256 is empty and hash_status is missing"""
+        entry = {
+            'file_path': '/models/test.safetensors',
+            'sha256': '',  # Empty string
+            # hash_status missing (defaults to 'completed')
+        }
+
+        result = CacheEntryValidator.validate(entry, auto_repair=False)
+
+        assert result.is_valid is False
+        assert any('sha256' in error for error in result.errors)
+
    def test_validate_empty_required_field_file_path(self):
        """Test validation fails when file_path is empty string"""
        entry = {
--- a/tests/services/test_checkpoint_lazy_hash.py
+++ b/tests/services/test_checkpoint_lazy_hash.py
@@ -0,0 +1,271 @@
+"""Tests for checkpoint lazy hash calculation feature."""
+
+import json
+import os
+from pathlib import Path
+from typing import List
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from py.services import model_scanner
+from py.services.checkpoint_scanner import CheckpointScanner
+from py.services.model_scanner import ModelScanner
+from py.utils.models import CheckpointMetadata
+
+
+class RecordingWebSocketManager:
+    def __init__(self) -> None:
+        self.payloads: List[dict] = []
+
+    async def broadcast_init_progress(self, payload: dict) -> None:
+        self.payloads.append(payload)
+
+
+def _normalize(path: Path) -> str:
+    return str(path).replace(os.sep, "/")
+
+
+@pytest.fixture(autouse=True)
+def reset_model_scanner_singletons():
+    ModelScanner._instances.clear()
+    ModelScanner._locks.clear()
+    yield
+    ModelScanner._instances.clear()
+    ModelScanner._locks.clear()
+
+
+@pytest.mark.asyncio
+async def test_checkpoint_default_metadata_has_pending_hash(tmp_path: Path, monkeypatch):
+    """Test that checkpoint metadata is created with hash_status='pending' and empty sha256."""
+    checkpoints_root = tmp_path / "checkpoints"
+    checkpoints_root.mkdir()
+
+    # Create a fake checkpoint file (small for testing)
+    checkpoint_file = checkpoints_root / "test_model.safetensors"
+    checkpoint_file.write_text("fake checkpoint content", encoding="utf-8")
+
+    normalized_root = _normalize(checkpoints_root)
+    normalized_file = _normalize(checkpoint_file)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_root],
+        raising=False,
+    )
+    monkeypatch.setattr(
+        model_scanner.config,
+        "checkpoints_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    
+    # Create default metadata
+    metadata = await scanner._create_default_metadata(normalized_file)
+    
+    assert metadata is not None
+    assert metadata.sha256 == "", "sha256 should be empty for lazy hash"
+    assert metadata.hash_status == "pending", "hash_status should be 'pending'"
+    assert metadata.from_civitai is False, "from_civitai should be False for local models"
+    assert metadata.file_name == "test_model"
+
+
+@pytest.mark.asyncio
+async def test_checkpoint_metadata_saved_to_disk_with_pending_status(tmp_path: Path, monkeypatch):
+    """Test that pending metadata is saved to .metadata.json file."""
+    checkpoints_root = tmp_path / "checkpoints"
+    checkpoints_root.mkdir()
+
+    checkpoint_file = checkpoints_root / "test_model.safetensors"
+    checkpoint_file.write_text("fake content", encoding="utf-8")
+
+    normalized_root = _normalize(checkpoints_root)
+    normalized_file = _normalize(checkpoint_file)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    
+    # Create metadata
+    metadata = await scanner._create_default_metadata(normalized_file)
+    assert metadata is not None
+    
+    # Verify the metadata file was created
+    metadata_file = checkpoints_root / "test_model.metadata.json"
+    assert metadata_file.exists(), "Metadata file should be created"
+    
+    # Load and verify content
+    with open(metadata_file, "r", encoding="utf-8") as f:
+        saved_data = json.load(f)
+    
+    assert saved_data.get("sha256") == "", "Saved sha256 should be empty"
+    assert saved_data.get("hash_status") == "pending", "Saved hash_status should be 'pending'"
+
+
+@pytest.mark.asyncio
+async def test_calculate_hash_for_model_completes_pending(tmp_path: Path, monkeypatch):
+    """Test that calculate_hash_for_model updates status to 'completed'."""
+    checkpoints_root = tmp_path / "checkpoints"
+    checkpoints_root.mkdir()
+
+    checkpoint_file = checkpoints_root / "test_model.safetensors"
+    checkpoint_file.write_text("fake content for hashing", encoding="utf-8")
+
+    normalized_root = _normalize(checkpoints_root)
+    normalized_file = _normalize(checkpoint_file)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    
+    # Create pending metadata
+    metadata = await scanner._create_default_metadata(normalized_file)
+    assert metadata is not None
+    assert metadata.hash_status == "pending"
+    
+    # Calculate hash
+    hash_result = await scanner.calculate_hash_for_model(normalized_file)
+    
+    assert hash_result is not None, "Hash calculation should succeed"
+    assert len(hash_result) == 64, "SHA256 should be 64 hex characters"
+    
+    # Verify metadata was updated
+    metadata_file = checkpoints_root / "test_model.metadata.json"
+    with open(metadata_file, "r", encoding="utf-8") as f:
+        saved_data = json.load(f)
+    
+    assert saved_data.get("sha256") == hash_result, "sha256 should be updated"
+    assert saved_data.get("hash_status") == "completed", "hash_status should be 'completed'"
+
+
+@pytest.mark.asyncio
+async def test_calculate_hash_skips_if_already_completed(tmp_path: Path, monkeypatch):
+    """Test that calculate_hash_for_model skips calculation if already completed."""
+    checkpoints_root = tmp_path / "checkpoints"
+    checkpoints_root.mkdir()
+
+    checkpoint_file = checkpoints_root / "test_model.safetensors"
+    checkpoint_file.write_text("fake content", encoding="utf-8")
+
+    normalized_root = _normalize(checkpoints_root)
+    normalized_file = _normalize(checkpoint_file)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    
+    # Create metadata with completed hash
+    metadata = CheckpointMetadata(
+        file_name="test_model",
+        model_name="test_model",
+        file_path=normalized_file,
+        size=100,
+        modified=1234567890.0,
+        sha256="existing_hash_value",
+        base_model="Unknown",
+        preview_url="",
+        hash_status="completed",
+        from_civitai=False,
+    )
+    
+    # Save metadata first
+    from py.utils.metadata_manager import MetadataManager
+    await MetadataManager.save_metadata(normalized_file, metadata)
+    
+    # Calculate hash should return existing value
+    with patch("py.utils.file_utils.calculate_sha256") as mock_calc:
+        mock_calc.return_value = "new_calculated_hash"
+        hash_result = await scanner.calculate_hash_for_model(normalized_file)
+    
+    assert hash_result == "existing_hash_value", "Should return existing hash"
+    mock_calc.assert_not_called(), "Should not recalculate if already completed"
+
+
+@pytest.mark.asyncio
+async def test_calculate_all_pending_hashes(tmp_path: Path, monkeypatch):
+    """Test bulk hash calculation for all pending checkpoints."""
+    checkpoints_root = tmp_path / "checkpoints"
+    checkpoints_root.mkdir()
+
+    # Create multiple checkpoint files
+    for i in range(3):
+        checkpoint_file = checkpoints_root / f"model_{i}.safetensors"
+        checkpoint_file.write_text(f"content {i}", encoding="utf-8")
+
+    normalized_root = _normalize(checkpoints_root)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    
+    # Create pending metadata for all models
+    for i in range(3):
+        checkpoint_file = checkpoints_root / f"model_{i}.safetensors"
+        await scanner._create_default_metadata(_normalize(checkpoint_file))
+    
+    # Mock progress callback
+    progress_calls = []
+    async def progress_callback(current, total, file_path):
+        progress_calls.append((current, total, file_path))
+    
+    # Calculate all pending hashes
+    result = await scanner.calculate_all_pending_hashes(progress_callback)
+    
+    assert result["total"] == 3, "Should find 3 pending models"
+    assert result["completed"] == 3, "Should complete all 3"
+    assert result["failed"] == 0, "Should not fail any"
+    assert len(progress_calls) == 3, "Progress callback should be called 3 times"
+
+
+@pytest.mark.asyncio
+async def test_lora_scanner_not_affected(tmp_path: Path, monkeypatch):
+    """Test that LoraScanner still calculates hash during initial scan."""
+    from py.services.lora_scanner import LoraScanner
+    
+    loras_root = tmp_path / "loras"
+    loras_root.mkdir()
+
+    lora_file = loras_root / "test_lora.safetensors"
+    lora_file.write_text("fake lora content", encoding="utf-8")
+
+    normalized_root = _normalize(loras_root)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "loras_roots",
+        [normalized_root],
+        raising=False,
+    )
+
+    # Reset singleton for LoraScanner
+    if LoraScanner in ModelScanner._instances:
+        del ModelScanner._instances[LoraScanner]
+
+    scanner = LoraScanner()
+    
+    # LoraScanner should use parent's _create_default_metadata which calculates hash
+    # We verify this by checking that it doesn't override the method
+    assert scanner._create_default_metadata.__qualname__ == "ModelScanner._create_default_metadata"
--- a/tests/services/test_checkpoint_scanner.py
+++ b/tests/services/test_checkpoint_scanner.py
@@ -132,4 +132,59 @@ async def test_persisted_cache_restores_model_type(tmp_path: Path, monkeypatch):
    assert types_by_path[normalized_unet_file] == "diffusion_model"

    assert ws_stub.payloads
-    assert ws_stub.payloads[-1]["stage"] == "loading_cache"
+
+
+@pytest.mark.asyncio
+async def test_checkpoint_scanner_get_model_roots_includes_extra_paths(monkeypatch, tmp_path):
+    """Test that get_model_roots includes both main and extra paths."""
+    checkpoints_root = tmp_path / "checkpoints"
+    extra_checkpoints_root = tmp_path / "extra_checkpoints"
+    unet_root = tmp_path / "unet"
+    extra_unet_root = tmp_path / "extra_unet"
+
+    for directory in (checkpoints_root, extra_checkpoints_root, unet_root, extra_unet_root):
+        directory.mkdir()
+
+    normalized_checkpoints = _normalize(checkpoints_root)
+    normalized_extra_checkpoints = _normalize(extra_checkpoints_root)
+    normalized_unet = _normalize(unet_root)
+    normalized_extra_unet = _normalize(extra_unet_root)
+
+    monkeypatch.setattr(
+        model_scanner.config,
+        "base_models_roots",
+        [normalized_checkpoints, normalized_unet],
+        raising=False,
+    )
+    monkeypatch.setattr(
+        model_scanner.config,
+        "checkpoints_roots",
+        [normalized_checkpoints],
+        raising=False,
+    )
+    monkeypatch.setattr(
+        model_scanner.config,
+        "unet_roots",
+        [normalized_unet],
+        raising=False,
+    )
+    monkeypatch.setattr(
+        model_scanner.config,
+        "extra_checkpoints_roots",
+        [normalized_extra_checkpoints],
+        raising=False,
+    )
+    monkeypatch.setattr(
+        model_scanner.config,
+        "extra_unet_roots",
+        [normalized_extra_unet],
+        raising=False,
+    )
+
+    scanner = CheckpointScanner()
+    roots = scanner.get_model_roots()
+
+    assert normalized_checkpoints in roots
+    assert normalized_unet in roots
+    assert normalized_extra_checkpoints in roots
+    assert normalized_extra_unet in roots
--- a/tests/services/test_recipe_scanner.py
+++ b/tests/services/test_recipe_scanner.py
@@ -60,11 +60,13 @@ class StubLoraScanner:
                "preview_url": info.get("preview_url", ""),
                "civitai": info.get("civitai", {}),
            }
-        self._cache.raw_data.append({
-            "sha256": info.get("sha256", ""),
-            "path": info.get("file_path", ""),
-            "civitai": info.get("civitai", {}),
-        })
+        self._cache.raw_data.append(
+            {
+                "sha256": info.get("sha256", ""),
+                "path": info.get("file_path", ""),
+                "civitai": info.get("civitai", {}),
+            }
+        )


@pytest.fixture
@@ -107,7 +109,8 @@ async def test_add_recipe_during_concurrent_reads(recipe_scanner):
            await asyncio.sleep(0)

    await asyncio.gather(reader_task(), reader_task(), scanner.add_recipe(new_recipe))
-    await asyncio.sleep(0)
+    # Wait a bit longer for the thread-pool resort to complete
+    await asyncio.sleep(0.1)
    cache = await scanner.get_cached_data()

    assert {item["id"] for item in cache.raw_data} == {"one", "two"}
@@ -119,14 +122,16 @@ async def test_remove_recipe_during_reads(recipe_scanner):

    recipe_ids = ["alpha", "beta", "gamma"]
    for index, recipe_id in enumerate(recipe_ids):
-        await scanner.add_recipe({
-            "id": recipe_id,
-            "file_path": f"path/{recipe_id}.png",
-            "title": recipe_id,
-            "modified": float(index),
-            "created_date": float(index),
-            "loras": [],
-        })
+        await scanner.add_recipe(
+            {
+                "id": recipe_id,
+                "file_path": f"path/{recipe_id}.png",
+                "title": recipe_id,
+                "modified": float(index),
+                "created_date": float(index),
+                "loras": [],
+            }
+        )

    async def reader_task():
        for _ in range(5):
@@ -155,7 +160,13 @@ async def test_update_lora_entry_updates_cache_and_file(tmp_path: Path, recipe_s
        "modified": 0.0,
        "created_date": 0.0,
        "loras": [
-            {"file_name": "old", "strength": 1.0, "hash": "", "isDeleted": True, "exclude": True},
+            {
+                "file_name": "old",
+                "strength": 1.0,
+                "hash": "",
+                "isDeleted": True,
+                "exclude": True,
+            },
        ],
    }
    recipe_path.write_text(json.dumps(recipe_data))
@@ -380,7 +391,9 @@ async def test_initialize_waits_for_lora_scanner(monkeypatch):


@pytest.mark.asyncio
-async def test_invalid_model_version_marked_deleted_and_not_retried(monkeypatch, recipe_scanner):
+async def test_invalid_model_version_marked_deleted_and_not_retried(
+    monkeypatch, recipe_scanner
+):
    scanner, _ = recipe_scanner
    recipes_dir = Path(config.loras_roots[0]) / "recipes"
    recipes_dir.mkdir(parents=True, exist_ok=True)
@@ -417,7 +430,9 @@ async def test_invalid_model_version_marked_deleted_and_not_retried(monkeypatch,


@pytest.mark.asyncio
-async def test_load_recipe_persists_deleted_flag_on_invalid_version(monkeypatch, recipe_scanner, tmp_path):
+async def test_load_recipe_persists_deleted_flag_on_invalid_version(
+    monkeypatch, recipe_scanner, tmp_path
+):
    scanner, _ = recipe_scanner
    recipes_dir = Path(config.loras_roots[0]) / "recipes"
    recipes_dir.mkdir(parents=True, exist_ok=True)
@@ -448,7 +463,9 @@ async def test_load_recipe_persists_deleted_flag_on_invalid_version(monkeypatch,


@pytest.mark.asyncio
-async def test_update_lora_filename_by_hash_updates_affected_recipes(tmp_path: Path, recipe_scanner):
+async def test_update_lora_filename_by_hash_updates_affected_recipes(
+    tmp_path: Path, recipe_scanner
+):
    scanner, _ = recipe_scanner
    recipes_dir = Path(config.loras_roots[0]) / "recipes"
    recipes_dir.mkdir(parents=True, exist_ok=True)
@@ -464,7 +481,7 @@ async def test_update_lora_filename_by_hash_updates_affected_recipes(tmp_path: P
        "created_date": 0.0,
        "loras": [
            {"file_name": "old_name", "hash": "hash1"},
-            {"file_name": "other_lora", "hash": "hash2"}
+            {"file_name": "other_lora", "hash": "hash2"},
        ],
    }
    recipe1_path.write_text(json.dumps(recipe1_data))
@@ -479,16 +496,16 @@ async def test_update_lora_filename_by_hash_updates_affected_recipes(tmp_path: P
        "title": "Recipe 2",
        "modified": 0.0,
        "created_date": 0.0,
-        "loras": [
-            {"file_name": "other_lora", "hash": "hash2"}
-        ],
+        "loras": [{"file_name": "other_lora", "hash": "hash2"}],
    }
    recipe2_path.write_text(json.dumps(recipe2_data))
    await scanner.add_recipe(dict(recipe2_data))

    # Update LoRA name for "hash1" (using different case to test normalization)
    new_name = "new_name"
-    file_count, cache_count = await scanner.update_lora_filename_by_hash("HASH1", new_name)
+    file_count, cache_count = await scanner.update_lora_filename_by_hash(
+        "HASH1", new_name
+    )

    assert file_count == 1
    assert cache_count == 1
@@ -510,92 +527,100 @@ async def test_update_lora_filename_by_hash_updates_affected_recipes(tmp_path: P
@pytest.mark.asyncio
 async def test_get_paginated_data_filters_by_favorite(recipe_scanner):
    scanner, _ = recipe_scanner
-    
+
    # Add a normal recipe
-    await scanner.add_recipe({
-        "id": "regular",
-        "file_path": "path/regular.png",
-        "title": "Regular Recipe",
-        "modified": 1.0,
-        "created_date": 1.0,
-        "loras": [],
-    })
-    
+    await scanner.add_recipe(
+        {
+            "id": "regular",
+            "file_path": "path/regular.png",
+            "title": "Regular Recipe",
+            "modified": 1.0,
+            "created_date": 1.0,
+            "loras": [],
+        }
+    )
+
    # Add a favorite recipe
-    await scanner.add_recipe({
-        "id": "favorite",
-        "file_path": "path/favorite.png",
-        "title": "Favorite Recipe",
-        "modified": 2.0,
-        "created_date": 2.0,
-        "loras": [],
-        "favorite": True
-    })
-    
+    await scanner.add_recipe(
+        {
+            "id": "favorite",
+            "file_path": "path/favorite.png",
+            "title": "Favorite Recipe",
+            "modified": 2.0,
+            "created_date": 2.0,
+            "loras": [],
+            "favorite": True,
+        }
+    )
+
    # Wait for cache update (it's async in some places, add_recipe is usually enough but let's be safe)
    await asyncio.sleep(0)
-    
+
    # Test without filter (should return both)
    result_all = await scanner.get_paginated_data(page=1, page_size=10)
    assert len(result_all["items"]) == 2
-    
+
    # Test with favorite filter
-    result_fav = await scanner.get_paginated_data(page=1, page_size=10, filters={"favorite": True})
+    result_fav = await scanner.get_paginated_data(
+        page=1, page_size=10, filters={"favorite": True}
+    )
    assert len(result_fav["items"]) == 1
    assert result_fav["items"][0]["id"] == "favorite"
-    
+
    # Test with favorite filter set to False (should return both or at least not filter if it's the default)
    # Actually our implementation checks if 'favorite' in filters and filters['favorite']
-    result_fav_false = await scanner.get_paginated_data(page=1, page_size=10, filters={"favorite": False})
+    result_fav_false = await scanner.get_paginated_data(
+        page=1, page_size=10, filters={"favorite": False}
+    )
    assert len(result_fav_false["items"]) == 2


@pytest.mark.asyncio
 async def test_get_paginated_data_filters_by_prompt(recipe_scanner):
    scanner, _ = recipe_scanner
-    
+
    # Add a recipe with a specific prompt
-    await scanner.add_recipe({
-        "id": "prompt-recipe",
-        "file_path": "path/prompt.png",
-        "title": "Prompt Recipe",
-        "modified": 1.0,
-        "created_date": 1.0,
-        "loras": [],
-        "gen_params": {
-            "prompt": "a beautiful forest landscape"
+    await scanner.add_recipe(
+        {
+            "id": "prompt-recipe",
+            "file_path": "path/prompt.png",
+            "title": "Prompt Recipe",
+            "modified": 1.0,
+            "created_date": 1.0,
+            "loras": [],
+            "gen_params": {"prompt": "a beautiful forest landscape"},
        }
-    })
-    
+    )
+
    # Add a recipe with a specific negative prompt
-    await scanner.add_recipe({
-        "id": "neg-prompt-recipe",
-        "file_path": "path/neg.png",
-        "title": "Negative Prompt Recipe",
-        "modified": 2.0,
-        "created_date": 2.0,
-        "loras": [],
-        "gen_params": {
-            "negative_prompt": "ugly, blurry mountains"
+    await scanner.add_recipe(
+        {
+            "id": "neg-prompt-recipe",
+            "file_path": "path/neg.png",
+            "title": "Negative Prompt Recipe",
+            "modified": 2.0,
+            "created_date": 2.0,
+            "loras": [],
+            "gen_params": {"negative_prompt": "ugly, blurry mountains"},
        }
-    })
-    
+    )
+
    await asyncio.sleep(0)
-    
+
    # Test search in prompt
    result_prompt = await scanner.get_paginated_data(
        page=1, page_size=10, search="forest", search_options={"prompt": True}
    )
    assert len(result_prompt["items"]) == 1
    assert result_prompt["items"][0]["id"] == "prompt-recipe"
-    
+
    # Test search in negative prompt
    result_neg = await scanner.get_paginated_data(
        page=1, page_size=10, search="mountains", search_options={"prompt": True}
    )
    assert len(result_neg["items"]) == 1
    assert result_neg["items"][0]["id"] == "neg-prompt-recipe"
-    
+
    # Test search disabled (should not find by prompt)
    result_disabled = await scanner.get_paginated_data(
        page=1, page_size=10, search="forest", search_options={"prompt": False}
@@ -606,38 +631,57 @@ async def test_get_paginated_data_filters_by_prompt(recipe_scanner):
@pytest.mark.asyncio
 async def test_get_paginated_data_sorting(recipe_scanner):
    scanner, _ = recipe_scanner
-    
+
    # Add test recipes
    # Recipe A: Name "Alpha", Date 10, LoRAs 2
-    await scanner.add_recipe({
-        "id": "A", "title": "Alpha", "created_date": 10.0,
-        "loras": [{}, {}], "file_path": "a.png"
-    })
+    await scanner.add_recipe(
+        {
+            "id": "A",
+            "title": "Alpha",
+            "created_date": 10.0,
+            "loras": [{}, {}],
+            "file_path": "a.png",
+        }
+    )
    # Recipe B: Name "Beta", Date 20, LoRAs 1
-    await scanner.add_recipe({
-        "id": "B", "title": "Beta", "created_date": 20.0,
-        "loras": [{}], "file_path": "b.png"
-    })
+    await scanner.add_recipe(
+        {
+            "id": "B",
+            "title": "Beta",
+            "created_date": 20.0,
+            "loras": [{}],
+            "file_path": "b.png",
+        }
+    )
    # Recipe C: Name "Gamma", Date 5, LoRAs 3
-    await scanner.add_recipe({
-        "id": "C", "title": "Gamma", "created_date": 5.0,
-        "loras": [{}, {}, {}], "file_path": "c.png"
-    })
-    
+    await scanner.add_recipe(
+        {
+            "id": "C",
+            "title": "Gamma",
+            "created_date": 5.0,
+            "loras": [{}, {}, {}],
+            "file_path": "c.png",
+        }
+    )
+
    await asyncio.sleep(0)
-    
+
    # Test Name DESC: Gamma, Beta, Alpha
    res = await scanner.get_paginated_data(page=1, page_size=10, sort_by="name:desc")
    assert [i["id"] for i in res["items"]] == ["C", "B", "A"]
-    
+
    # Test LoRA Count DESC: Gamma (3), Alpha (2), Beta (1)
-    res = await scanner.get_paginated_data(page=1, page_size=10, sort_by="loras_count:desc")
+    res = await scanner.get_paginated_data(
+        page=1, page_size=10, sort_by="loras_count:desc"
+    )
    assert [i["id"] for i in res["items"]] == ["C", "A", "B"]
-    
+
    # Test LoRA Count ASC: Beta (1), Alpha (2), Gamma (3)
-    res = await scanner.get_paginated_data(page=1, page_size=10, sort_by="loras_count:asc")
+    res = await scanner.get_paginated_data(
+        page=1, page_size=10, sort_by="loras_count:asc"
+    )
    assert [i["id"] for i in res["items"]] == ["B", "A", "C"]
-    
+
    # Test Date ASC: Gamma (5), Alpha (10), Beta (20)
    res = await scanner.get_paginated_data(page=1, page_size=10, sort_by="date:asc")
    assert [i["id"] for i in res["items"]] == ["C", "A", "B"]
--- a/tests/services/test_relative_path_search.py
+++ b/tests/services/test_relative_path_search.py
@@ -62,3 +62,42 @@ async def test_search_relative_paths_excludes_tokens():
    matching = await service.search_relative_paths("flux -detail")

    assert matching == [f"flux{os.sep}keep-me.safetensors"]
+
+
+@pytest.mark.asyncio
+async def test_search_does_not_match_extension():
+    """Searching for 's' or 'safe' should not match .safetensors extension."""
+    scanner = FakeScanner(
+        [
+            {"file_path": "/models/lora1.safetensors"},
+            {"file_path": "/models/lora2.safetensors"},
+            {"file_path": "/models/special-model.safetensors"},  # 's' in filename
+        ],
+        ["/models"],
+    )
+    service = DummyService("stub", scanner, BaseModelMetadata)
+
+    # Searching for 's' should only match 'special-model', not all .safetensors
+    matching = await service.search_relative_paths("s")
+
+    # Should only match 'special-model' because 's' is in the filename
+    assert len(matching) == 1
+    assert "special-model" in matching[0]
+
+
+@pytest.mark.asyncio
+async def test_search_safe_does_not_match_all_files():
+    """Searching for 'safe' should not match .safetensors extension."""
+    scanner = FakeScanner(
+        [
+            {"file_path": "/models/flux.safetensors"},
+            {"file_path": "/models/detail.safetensors"},
+        ],
+        ["/models"],
+    )
+    service = DummyService("stub", scanner, BaseModelMetadata)
+
+    # Searching for 'safe' should return nothing (no file has 'safe' in its name)
+    matching = await service.search_relative_paths("safe")
+
+    assert len(matching) == 0
--- a/tests/services/test_settings_manager.py
+++ b/tests/services/test_settings_manager.py
@@ -470,6 +470,100 @@ def test_upsert_library_creates_entry_and_activates(manager, tmp_path):
    assert str(lora_dir).replace(os.sep, "/") in normalized_stored_paths


+def test_extra_folder_paths_stored_separately(manager, tmp_path):
+    lora_dir = tmp_path / "loras"
+    extra_dir = tmp_path / "extra_loras"
+    lora_dir.mkdir()
+    extra_dir.mkdir()
+
+    manager.upsert_library(
+        "test_library",
+        folder_paths={"loras": [str(lora_dir)]},
+        extra_folder_paths={"loras": [str(extra_dir)]},
+        activate=True,
+    )
+
+    libraries = manager.get_libraries()
+    lib = libraries["test_library"]
+
+    # Verify folder_paths contains main path
+    assert str(lora_dir) in lib["folder_paths"]["loras"]
+    # Verify extra_folder_paths contains extra path
+    assert str(extra_dir) in lib["extra_folder_paths"]["loras"]
+    # Verify they are separate
+    assert str(extra_dir) not in lib["folder_paths"]["loras"]
+
+
+def test_get_extra_folder_paths(manager, tmp_path):
+    extra_dir = tmp_path / "extra_loras"
+    extra_dir.mkdir()
+
+    manager.update_extra_folder_paths({"loras": [str(extra_dir)]})
+
+    extra_paths = manager.get_extra_folder_paths()
+    assert str(extra_dir) in extra_paths.get("loras", [])
+
+
+def test_library_switch_preserves_extra_paths(manager, tmp_path):
+    """Test that switching libraries preserves each library's extra paths."""
+    lora_dir1 = tmp_path / "lib1_loras"
+    extra_dir1 = tmp_path / "lib1_extra"
+    lora_dir2 = tmp_path / "lib2_loras"
+    extra_dir2 = tmp_path / "lib2_extra"
+
+    for directory in (lora_dir1, extra_dir1, lora_dir2, extra_dir2):
+        directory.mkdir()
+
+    manager.create_library(
+        "library1",
+        folder_paths={"loras": [str(lora_dir1)]},
+        extra_folder_paths={"loras": [str(extra_dir1)]},
+        activate=True,
+    )
+
+    manager.create_library(
+        "library2",
+        folder_paths={"loras": [str(lora_dir2)]},
+        extra_folder_paths={"loras": [str(extra_dir2)]},
+    )
+
+    assert manager.get_active_library_name() == "library1"
+    lib1 = manager.get_active_library()
+    assert str(lora_dir1) in lib1["folder_paths"]["loras"]
+    assert str(extra_dir1) in lib1["extra_folder_paths"]["loras"]
+
+    manager.activate_library("library2")
+
+    assert manager.get_active_library_name() == "library2"
+    lib2 = manager.get_active_library()
+    assert str(lora_dir2) in lib2["folder_paths"]["loras"]
+    assert str(extra_dir2) in lib2["extra_folder_paths"]["loras"]
+
+
+def test_extra_paths_validation_no_overlap_with_other_libraries(manager, tmp_path):
+    """Test that extra paths cannot overlap with other libraries' paths."""
+    lora_dir1 = tmp_path / "lib1_loras"
+    lora_dir1.mkdir()
+
+    manager.create_library(
+        "library1",
+        folder_paths={"loras": [str(lora_dir1)]},
+        activate=True,
+    )
+
+    extra_dir = tmp_path / "extra_loras"
+    extra_dir.mkdir()
+
+    manager.create_library(
+        "library2",
+        folder_paths={"loras": [str(extra_dir)]},
+        activate=True,
+    )
+
+    with pytest.raises(ValueError, match="already assigned to library"):
+        manager.update_extra_folder_paths({"loras": [str(lora_dir1)]})
+
+
 def test_delete_library_switches_active(manager, tmp_path):
    other_dir = tmp_path / "other"
    other_dir.mkdir()
--- a/tests/services/use_cases/test_bulk_metadata_refresh_use_case.py
+++ b/tests/services/use_cases/test_bulk_metadata_refresh_use_case.py
@@ -0,0 +1,404 @@
+"""Tests for BulkMetadataRefreshUseCase."""
+
+from __future__ import annotations
+
+import pytest
+from types import SimpleNamespace
+from typing import Any, Dict
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from py.services.use_cases.bulk_metadata_refresh_use_case import (
+    BulkMetadataRefreshUseCase,
+    MetadataRefreshProgressReporter,
+)
+from py.utils import metadata_manager
+
+
+class MockProgressReporter:
+    """Mock progress reporter for testing."""
+
+    def __init__(self):
+        self.progress_calls = []
+
+    async def on_progress(self, payload: Dict[str, Any]) -> None:
+        self.progress_calls.append(payload)
+
+
+@pytest.fixture
+def mock_service():
+    """Create a mock service with scanner."""
+    scanner = MagicMock()
+    scanner.get_cached_data = AsyncMock()
+    scanner.reset_cancellation = MagicMock()
+    scanner.is_cancelled = MagicMock(return_value=False)
+    scanner.update_single_model_cache = AsyncMock(return_value=True)
+    scanner.calculate_hash_for_model = AsyncMock(return_value="calculated_hash_123")
+
+    service = MagicMock()
+    service.scanner = scanner
+    service.model_type = "checkpoint"
+
+    return service
+
+
+@pytest.fixture
+def mock_metadata_sync():
+    """Create a mock metadata sync service."""
+    sync = MagicMock()
+    sync.fetch_and_update_model = AsyncMock(return_value=(True, None))
+    return sync
+
+
+@pytest.fixture
+def mock_settings():
+    """Create mock settings service."""
+    settings = MagicMock()
+    settings.get = MagicMock(return_value=False)
+    return settings
+
+
+@pytest.fixture
+def use_case(mock_service, mock_metadata_sync, mock_settings):
+    """Create a BulkMetadataRefreshUseCase instance."""
+    return BulkMetadataRefreshUseCase(
+        service=mock_service,
+        metadata_sync=mock_metadata_sync,
+        settings_service=mock_settings,
+    )
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_pending_hash_calculated_on_demand(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test that models with pending hash status get their hash calculated on demand."""
+    mock_hydrate.return_value = None
+    
+    # Setup cache with a model that has pending hash
+    pending_model = {
+        "file_path": "/extra_ckpt/model.safetensors",
+        "sha256": "",  # Empty hash
+        "hash_status": "pending",
+        "model_name": "Test Model",
+        "folder": "extra_ckpt",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[pending_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify hash was calculated
+    mock_service.scanner.calculate_hash_for_model.assert_called_once_with(
+        "/extra_ckpt/model.safetensors"
+    )
+
+    # Verify model hash was updated
+    assert pending_model["sha256"] == "calculated_hash_123"
+    assert pending_model["hash_status"] == "completed"
+
+    # Verify metadata sync was called with the calculated hash
+    mock_metadata_sync.fetch_and_update_model.assert_called_once()
+    call_args = mock_metadata_sync.fetch_and_update_model.call_args[1]
+    assert call_args["sha256"] == "calculated_hash_123"
+
+    assert result["success"] is True
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_skip_model_when_hash_calculation_fails(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test that models are skipped when hash calculation fails."""
+    mock_hydrate.return_value = None
+    
+    # Setup model with pending hash
+    pending_model = {
+        "file_path": "/extra_ckpt/model.safetensors",
+        "sha256": "",
+        "hash_status": "pending",
+        "model_name": "Test Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    # Make hash calculation fail
+    mock_service.scanner.calculate_hash_for_model.return_value = None
+
+    cache = SimpleNamespace(raw_data=[pending_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify hash was attempted
+    mock_service.scanner.calculate_hash_for_model.assert_called_once()
+
+    # Verify metadata sync was NOT called (model skipped)
+    mock_metadata_sync.fetch_and_update_model.assert_not_called()
+
+    # Verify result shows processed but no success
+    assert result["success"] is True
+    assert result["processed"] == 1
+    assert result["updated"] == 0
+
+
+@pytest.mark.asyncio
+async def test_skip_model_when_scanner_does_not_support_lazy_hash(
+    use_case, mock_service, mock_metadata_sync
+):
+    """Test that models are skipped when scanner doesn't support lazy hash calculation."""
+    # Setup model with pending hash
+    pending_model = {
+        "file_path": "/models/model.safetensors",
+        "sha256": "",
+        "hash_status": "pending",
+        "model_name": "Test Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    # Remove calculate_hash_for_model method (simulating LoRA scanner)
+    del mock_service.scanner.calculate_hash_for_model
+
+    cache = SimpleNamespace(raw_data=[pending_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify metadata sync was NOT called
+    mock_metadata_sync.fetch_and_update_model.assert_not_called()
+
+    assert result["success"] is True
+    assert result["processed"] == 1
+    assert result["updated"] == 0
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_normal_model_with_existing_hash_not_affected(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test that models with existing hash work normally."""
+    mock_hydrate.return_value = None
+    
+    # Setup model with existing hash
+    existing_model = {
+        "file_path": "/models/model.safetensors",
+        "sha256": "existing_hash_abc",
+        "hash_status": "completed",
+        "model_name": "Test Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[existing_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify hash calculation was NOT called
+    assert not mock_service.scanner.calculate_hash_for_model.called
+
+    # Verify metadata sync was called with existing hash
+    mock_metadata_sync.fetch_and_update_model.assert_called_once()
+    call_args = mock_metadata_sync.fetch_and_update_model.call_args[1]
+    assert call_args["sha256"] == "existing_hash_abc"
+
+    assert result["success"] is True
+    assert result["updated"] == 1
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_mixed_models_some_pending_some_existing(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test handling of mixed models: some with pending hash, some with existing hash."""
+    mock_hydrate.return_value = None
+    
+    pending_model = {
+        "file_path": "/extra_ckpt/pending_model.safetensors",
+        "sha256": "",
+        "hash_status": "pending",
+        "model_name": "Pending Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    existing_model = {
+        "file_path": "/models/existing_model.safetensors",
+        "sha256": "existing_hash_xyz",
+        "hash_status": "completed",
+        "model_name": "Existing Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[pending_model, existing_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify hash was calculated only for pending model
+    mock_service.scanner.calculate_hash_for_model.assert_called_once_with(
+        "/extra_ckpt/pending_model.safetensors"
+    )
+
+    # Verify metadata sync was called for both
+    assert mock_metadata_sync.fetch_and_update_model.call_count == 2
+
+    assert result["success"] is True
+    assert result["processed"] == 2
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_progress_callback_receives_updates(mock_hydrate, use_case, mock_service):
+    """Test that progress callback receives correct updates."""
+    mock_hydrate.return_value = None
+    
+    model = {
+        "file_path": "/models/model.safetensors",
+        "sha256": "hash123",
+        "model_name": "Test Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    reporter = MockProgressReporter()
+
+    # Execute
+    await use_case.execute(progress_callback=reporter)
+
+    # Verify progress was reported
+    assert len(reporter.progress_calls) >= 2
+
+    # Check started status
+    started_calls = [c for c in reporter.progress_calls if c["status"] == "started"]
+    assert len(started_calls) == 1
+
+    # Check completed status
+    completed_calls = [c for c in reporter.progress_calls if c["status"] == "completed"]
+    assert len(completed_calls) == 1
+    assert completed_calls[0]["processed"] == 1
+    assert completed_calls[0]["success"] == 1
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_respects_skip_metadata_refresh_flag(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test that models with skip_metadata_refresh=True are skipped."""
+    mock_hydrate.return_value = None
+    
+    skip_model = {
+        "file_path": "/models/skip_model.safetensors",
+        "sha256": "hash123",
+        "model_name": "Skip Model",
+        "skip_metadata_refresh": True,
+        "civitai": {},
+    }
+
+    normal_model = {
+        "file_path": "/models/normal_model.safetensors",
+        "sha256": "hash456",
+        "model_name": "Normal Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[skip_model, normal_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify only normal model was processed
+    assert mock_metadata_sync.fetch_and_update_model.call_count == 1
+    call_args = mock_metadata_sync.fetch_and_update_model.call_args[1]
+    assert call_args["file_path"] == "/models/normal_model.safetensors"
+
+    assert result["processed"] == 1
+
+
+@pytest.mark.asyncio
+@patch.object(metadata_manager.MetadataManager, "hydrate_model_data")
+async def test_respects_skip_paths(mock_hydrate, use_case, mock_service, mock_metadata_sync):
+    """Test that models in skip paths are excluded."""
+    mock_hydrate.return_value = None
+    
+    # Setup settings to skip certain paths
+    use_case._settings.get = MagicMock(side_effect=lambda key, default=None: {
+        "enable_metadata_archive_db": False,
+        "metadata_refresh_skip_paths": ["skip_folder"],
+    }.get(key, default))
+
+    skip_path_model = {
+        "file_path": "/models/skip_folder/model.safetensors",
+        "sha256": "hash123",
+        "model_name": "Skip Path Model",
+        "folder": "skip_folder",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    normal_model = {
+        "file_path": "/models/normal/model.safetensors",
+        "sha256": "hash456",
+        "model_name": "Normal Model",
+        "folder": "normal",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[skip_path_model, normal_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify only normal model was processed
+    assert mock_metadata_sync.fetch_and_update_model.call_count == 1
+    call_args = mock_metadata_sync.fetch_and_update_model.call_args[1]
+    assert "normal" in call_args["file_path"]
+
+    assert result["processed"] == 1
+
+
+@pytest.mark.asyncio
+async def test_model_without_hash_skipped(use_case, mock_service, mock_metadata_sync):
+    """Test that models without hash (and not pending) are skipped."""
+    no_hash_model = {
+        "file_path": "/models/no_hash_model.safetensors",
+        "sha256": "",  # Empty but NOT pending
+        "hash_status": "completed",  # Not pending
+        "model_name": "No Hash Model",
+        "civitai": {},
+        "from_civitai": False,
+        "civitai_deleted": False,
+    }
+
+    cache = SimpleNamespace(raw_data=[no_hash_model], resort=AsyncMock())
+    mock_service.scanner.get_cached_data.return_value = cache
+
+    # Execute
+    result = await use_case.execute()
+
+    # Verify metadata sync was NOT called
+    mock_metadata_sync.fetch_and_update_model.assert_not_called()
+
+    assert result["processed"] == 1
+    assert result["updated"] == 0
--- a/tests/test_custom_words_service.py
+++ b/tests/test_custom_words_service.py
@@ -2,7 +2,10 @@

 import pytest

-from py.services.custom_words_service import CustomWordsService, get_custom_words_service
+from py.services.custom_words_service import (
+    CustomWordsService,
+    get_custom_words_service,
+)


 class TestCustomWordsService:
@@ -99,13 +102,19 @@ class MockTagFTSIndex:
        self.called = False
        self._results = [
            {"tag_name": "hatsune_miku", "category": 4, "post_count": 500000},
-            {"tag_name": "hatsune_miku_(vocaloid)", "category": 4, "post_count": 250000},
+            {
+                "tag_name": "hatsune_miku_(vocaloid)",
+                "category": 4,
+                "post_count": 250000,
+            },
        ]

-    def search(self, query, categories=None, limit=20):
+    def search(self, query, categories=None, limit=20, offset=0):
        self.called = True
        if not query:
            return []
        if categories:
-            return [r for r in self._results if r["category"] in categories][:limit]
-        return self._results[:limit]
+            results = [r for r in self._results if r["category"] in categories]
+        else:
+            results = self._results
+        return results[offset : offset + limit]
--- a/Show More
+++ b/Show More