feat(model-modal): improve transition animations and fix navigation logic

- Add `!important` to overlay background and closing opacity for consistent styling
- Remove navigation spam prevention to allow consecutive transitions
- Implement in-place content updates during model transitions instead of reopening modal
- Add opacity transitions for showcase and metadata components
- Fetch complete Civitai metadata during transitions for updated model data

.agents/skills/lora-manager-e2e/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: lora-manager-e2e
+description: End-to-end testing and validation for LoRa Manager features. Use when performing automated E2E validation of LoRa Manager standalone mode, including starting/restarting the server, using Chrome DevTools MCP to interact with the web UI at http://127.0.0.1:8188/loras, and verifying frontend-to-backend functionality. Covers workflow validation, UI interaction testing, and integration testing between the standalone Python backend and the browser frontend.
+---
+
+# LoRa Manager E2E Testing
+
+This skill provides workflows and utilities for end-to-end testing of LoRa Manager using Chrome DevTools MCP.
+
+## Prerequisites
+
+- LoRa Manager project cloned and dependencies installed (`pip install -r requirements.txt`)
+- Chrome browser available for debugging
+- Chrome DevTools MCP connected
+
+## Quick Start Workflow
+
+### 1. Start LoRa Manager Standalone
+
+```python
+# Use the provided script to start the server
+python .agents/skills/lora-manager-e2e/scripts/start_server.py --port 8188
+```
+
+Or manually:
+```bash
+cd /home/miao/workspace/ComfyUI/custom_nodes/ComfyUI-Lora-Manager
+python standalone.py --port 8188
+```
+
+Wait for server ready message before proceeding.
+
+### 2. Open Chrome Debug Mode
+
+```bash
+# Chrome with remote debugging on port 9222
+google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:8188/loras
+```
+
+### 3. Connect Chrome DevTools MCP
+
+Ensure the MCP server is connected to Chrome at `http://localhost:9222`.
+
+### 4. Navigate and Interact
+
+Use Chrome DevTools MCP tools to:
+- Take snapshots: `take_snapshot`
+- Click elements: `click`
+- Fill forms: `fill` or `fill_form`
+- Evaluate scripts: `evaluate_script`
+- Wait for elements: `wait_for`
+
+## Common E2E Test Patterns
+
+### Pattern: Full Page Load Verification
+
+```python
+# Navigate to LoRA list page
+navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+
+# Wait for page to load
+wait_for(text="LoRAs", timeout=10000)
+
+# Take snapshot to verify UI state
+snapshot = take_snapshot()
+```
+
+### Pattern: Restart Server for Configuration Changes
+
+```python
+# Stop current server (if running)
+# Start with new configuration
+python .agents/skills/lora-manager-e2e/scripts/start_server.py --port 8188 --restart
+
+# Wait and refresh browser
+navigate_page(type="reload", ignoreCache=True)
+wait_for(text="LoRAs", timeout=15000)
+```
+
+### Pattern: Verify Backend API via Frontend
+
+```python
+# Execute script in browser to call backend API
+result = evaluate_script(function="""
+async () => {
+  const response = await fetch('/loras/api/list');
+  const data = await response.json();
+  return { count: data.length, firstItem: data[0]?.name };
+}
+""")
+```
+
+### Pattern: Form Submission Flow
+
+```python
+# Fill a form (e.g., search or filter)
+fill_form(elements=[
+    {"uid": "search-input", "value": "character"},
+])
+
+# Click submit button
+click(uid="search-button")
+
+# Wait for results
+wait_for(text="Results", timeout=5000)
+
+# Verify results via snapshot
+snapshot = take_snapshot()
+```
+
+### Pattern: Modal Dialog Interaction
+
+```python
+# Open modal (e.g., add LoRA)
+click(uid="add-lora-button")
+
+# Wait for modal to appear
+wait_for(text="Add LoRA", timeout=3000)
+
+# Fill modal form
+fill_form(elements=[
+    {"uid": "lora-name", "value": "Test LoRA"},
+    {"uid": "lora-path", "value": "/path/to/lora.safetensors"},
+])
+
+# Submit
+click(uid="modal-submit-button")
+
+# Wait for success message or close
+wait_for(text="Success", timeout=5000)
+```
+
+## Available Scripts
+
+### scripts/start_server.py
+
+Starts or restarts the LoRa Manager standalone server.
+
+```bash
+python scripts/start_server.py [--port PORT] [--restart] [--wait]
+```
+
+Options:
+- `--port`: Server port (default: 8188)
+- `--restart`: Kill existing server before starting
+- `--wait`: Wait for server to be ready before exiting
+
+### scripts/wait_for_server.py
+
+Polls server until ready or timeout.
+
+```bash
+python scripts/wait_for_server.py [--port PORT] [--timeout SECONDS]
+```
+
+## Test Scenarios Reference
+
+See [references/test-scenarios.md](references/test-scenarios.md) for detailed test scenarios including:
+- LoRA list display and filtering
+- Model metadata editing
+- Recipe creation and management
+- Settings configuration
+- Import/export functionality
+
+## Network Request Verification
+
+Use `list_network_requests` and `get_network_request` to verify API calls:
+
+```python
+# List recent XHR/fetch requests
+requests = list_network_requests(resourceTypes=["xhr", "fetch"])
+
+# Get details of specific request
+details = get_network_request(reqid=123)
+```
+
+## Console Message Monitoring
+
+```python
+# Check for errors or warnings
+messages = list_console_messages(types=["error", "warn"])
+```
+
+## Performance Testing
+
+```python
+# Start performance trace
+performance_start_trace(reload=True, autoStop=False)
+
+# Perform actions...
+
+# Stop and analyze
+results = performance_stop_trace()
+```
+
+## Cleanup
+
+Always ensure proper cleanup after tests:
+1. Stop the standalone server
+2. Close browser pages (keep at least one open)
+3. Clear temporary data if needed

.agents/skills/lora-manager-e2e/references/mcp-cheatsheet.md

@@ -0,0 +1,324 @@
+# Chrome DevTools MCP Cheatsheet for LoRa Manager
+
+Quick reference for common MCP commands used in LoRa Manager E2E testing.
+
+## Navigation
+
+```python
+# Navigate to LoRA list page
+navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+
+# Reload page with cache clear
+navigate_page(type="reload", ignoreCache=True)
+
+# Go back/forward
+navigate_page(type="back")
+navigate_page(type="forward")
+```
+
+## Waiting
+
+```python
+# Wait for text to appear
+wait_for(text="LoRAs", timeout=10000)
+
+# Wait for specific element (via evaluate_script)
+evaluate_script(function="""
+() => {
+    return new Promise((resolve) => {
+        const check = () => {
+            if (document.querySelector('.lora-card')) {
+                resolve(true);
+            } else {
+                setTimeout(check, 100);
+            }
+        };
+        check();
+    });
+}
+""")
+```
+
+## Taking Snapshots
+
+```python
+# Full page snapshot
+snapshot = take_snapshot()
+
+# Verbose snapshot (more details)
+snapshot = take_snapshot(verbose=True)
+
+# Save to file
+take_snapshot(filePath="test-snapshots/page-load.json")
+```
+
+## Element Interaction
+
+```python
+# Click element
+click(uid="element-uid-from-snapshot")
+
+# Double click
+click(uid="element-uid", dblClick=True)
+
+# Fill input
+fill(uid="search-input", value="test query")
+
+# Fill multiple inputs
+fill_form(elements=[
+    {"uid": "input-1", "value": "value 1"},
+    {"uid": "input-2", "value": "value 2"},
+])
+
+# Hover
+hover(uid="lora-card-1")
+
+# Upload file
+upload_file(uid="file-input", filePath="/path/to/file.safetensors")
+```
+
+## Keyboard Input
+
+```python
+# Press key
+press_key(key="Enter")
+press_key(key="Escape")
+press_key(key="Tab")
+
+# Keyboard shortcuts
+press_key(key="Control+A")  # Select all
+press_key(key="Control+F")  # Find
+```
+
+## JavaScript Evaluation
+
+```python
+# Simple evaluation
+result = evaluate_script(function="() => document.title")
+
+# Async evaluation
+result = evaluate_script(function="""
+async () => {
+    const response = await fetch('/loras/api/list');
+    return await response.json();
+}
+""")
+
+# Check element existence
+exists = evaluate_script(function="""
+() => document.querySelector('.lora-card') !== null
+""")
+
+# Get element count
+count = evaluate_script(function="""
+() => document.querySelectorAll('.lora-card').length
+""")
+```
+
+## Network Monitoring
+
+```python
+# List all network requests
+requests = list_network_requests()
+
+# Filter by resource type
+xhr_requests = list_network_requests(resourceTypes=["xhr", "fetch"])
+
+# Get specific request details
+details = get_network_request(reqid=123)
+
+# Include preserved requests from previous navigations
+all_requests = list_network_requests(includePreservedRequests=True)
+```
+
+## Console Monitoring
+
+```python
+# List all console messages
+messages = list_console_messages()
+
+# Filter by type
+errors = list_console_messages(types=["error", "warn"])
+
+# Include preserved messages
+all_messages = list_console_messages(includePreservedMessages=True)
+
+# Get specific message
+details = get_console_message(msgid=1)
+```
+
+## Performance Testing
+
+```python
+# Start trace with page reload
+performance_start_trace(reload=True, autoStop=False)
+
+# Start trace without reload
+performance_start_trace(reload=False, autoStop=True, filePath="trace.json.gz")
+
+# Stop trace
+results = performance_stop_trace()
+
+# Stop and save
+performance_stop_trace(filePath="trace-results.json.gz")
+
+# Analyze specific insight
+insight = performance_analyze_insight(
+    insightSetId="results.insightSets[0].id",
+    insightName="LCPBreakdown"
+)
+```
+
+## Page Management
+
+```python
+# List open pages
+pages = list_pages()
+
+# Select a page
+select_page(pageId=0, bringToFront=True)
+
+# Create new page
+new_page(url="http://127.0.0.1:8188/loras")
+
+# Close page (keep at least one open!)
+close_page(pageId=1)
+
+# Resize page
+resize_page(width=1920, height=1080)
+```
+
+## Screenshots
+
+```python
+# Full page screenshot
+take_screenshot(fullPage=True)
+
+# Viewport screenshot
+take_screenshot()
+
+# Element screenshot
+take_screenshot(uid="lora-card-1")
+
+# Save to file
+take_screenshot(filePath="screenshots/page.png", format="png")
+
+# JPEG with quality
+take_screenshot(filePath="screenshots/page.jpg", format="jpeg", quality=90)
+```
+
+## Dialog Handling
+
+```python
+# Accept dialog
+handle_dialog(action="accept")
+
+# Accept with text input
+handle_dialog(action="accept", promptText="user input")
+
+# Dismiss dialog
+handle_dialog(action="dismiss")
+```
+
+## Device Emulation
+
+```python
+# Mobile viewport
+emulate(viewport={"width": 375, "height": 667, "isMobile": True, "hasTouch": True})
+
+# Tablet viewport
+emulate(viewport={"width": 768, "height": 1024, "isMobile": True, "hasTouch": True})
+
+# Desktop viewport
+emulate(viewport={"width": 1920, "height": 1080})
+
+# Network throttling
+emulate(networkConditions="Slow 3G")
+emulate(networkConditions="Fast 4G")
+
+# CPU throttling
+emulate(cpuThrottlingRate=4)  # 4x slowdown
+
+# Geolocation
+emulate(geolocation={"latitude": 37.7749, "longitude": -122.4194})
+
+# User agent
+emulate(userAgent="Mozilla/5.0 (Custom)")
+
+# Reset emulation
+emulate(viewport=None, networkConditions="No emulation", userAgent=None)
+```
+
+## Drag and Drop
+
+```python
+# Drag element to another
+drag(from_uid="draggable-item", to_uid="drop-zone")
+```
+
+## Common LoRa Manager Test Patterns
+
+### Verify LoRA Cards Loaded
+
+```python
+navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+wait_for(text="LoRAs", timeout=10000)
+
+# Check if cards loaded
+result = evaluate_script(function="""
+() => {
+    const cards = document.querySelectorAll('.lora-card');
+    return {
+        count: cards.length,
+        hasData: cards.length > 0
+    };
+}
+""")
+```
+
+### Search and Verify Results
+
+```python
+fill(uid="search-input", value="character")
+press_key(key="Enter")
+wait_for(timeout=2000)  # Wait for debounce
+
+# Check results
+result = evaluate_script(function="""
+() => {
+    const cards = document.querySelectorAll('.lora-card');
+    const names = Array.from(cards).map(c => c.dataset.name || c.textContent);
+    return { count: cards.length, names };
+}
+""")
+```
+
+### Check API Response
+
+```python
+# Trigger API call
+evaluate_script(function="""
+() => window.loraApiCallPromise = fetch('/loras/api/list').then(r => r.json())
+""")
+
+# Wait and get result
+import time
+time.sleep(1)
+
+result = evaluate_script(function="""
+async () => await window.loraApiCallPromise
+""")
+```
+
+### Monitor Console for Errors
+
+```python
+# Before test: clear console (navigate reloads)
+navigate_page(type="reload")
+
+# ... perform actions ...
+
+# Check for errors
+errors = list_console_messages(types=["error"])
+assert len(errors) == 0, f"Console errors: {errors}"
+```

.agents/skills/lora-manager-e2e/references/test-scenarios.md

@@ -0,0 +1,272 @@
+# LoRa Manager E2E Test Scenarios
+
+This document provides detailed test scenarios for end-to-end validation of LoRa Manager features.
+
+## Table of Contents
+
+1. [LoRA List Page](#lora-list-page)
+2. [Model Details](#model-details)
+3. [Recipes](#recipes)
+4. [Settings](#settings)
+5. [Import/Export](#importexport)
+
+---
+
+## LoRA List Page
+
+### Scenario: Page Load and Display
+
+**Objective**: Verify the LoRA list page loads correctly and displays models.
+
+**Steps**:
+1. Navigate to `http://127.0.0.1:8188/loras`
+2. Wait for page title "LoRAs" to appear
+3. Take snapshot to verify:
+   - Header with "LoRAs" title is visible
+   - Search/filter controls are present
+   - Grid/list view toggle exists
+   - LoRA cards are displayed (if models exist)
+   - Pagination controls (if applicable)
+
+**Expected Result**: Page loads without errors, UI elements are present.
+
+### Scenario: Search Functionality
+
+**Objective**: Verify search filters LoRA models correctly.
+
+**Steps**:
+1. Ensure at least one LoRA exists with known name (e.g., "test-character")
+2. Navigate to LoRA list page
+3. Enter search term in search box: "test"
+4. Press Enter or click search button
+5. Wait for results to update
+
+**Expected Result**: Only LoRAs matching search term are displayed.
+
+**Verification Script**:
+```python
+# After search, verify filtered results
+evaluate_script(function="""
+() => {
+  const cards = document.querySelectorAll('.lora-card');
+  const names = Array.from(cards).map(c => c.dataset.name);
+  return { count: cards.length, names };
+}
+""")
+```
+
+### Scenario: Filter by Tags
+
+**Objective**: Verify tag filtering works correctly.
+
+**Steps**:
+1. Navigate to LoRA list page
+2. Click on a tag (e.g., "character", "style")
+3. Wait for filtered results
+
+**Expected Result**: Only LoRAs with selected tag are displayed.
+
+### Scenario: View Mode Toggle
+
+**Objective**: Verify grid/list view toggle works.
+
+**Steps**:
+1. Navigate to LoRA list page
+2. Click list view button
+3. Verify list layout
+4. Click grid view button
+5. Verify grid layout
+
+**Expected Result**: View mode changes correctly, layout updates.
+
+---
+
+## Model Details
+
+### Scenario: Open Model Details
+
+**Objective**: Verify clicking a LoRA opens its details.
+
+**Steps**:
+1. Navigate to LoRA list page
+2. Click on a LoRA card
+3. Wait for details panel/modal to open
+
+**Expected Result**: Details panel shows:
+- Model name
+- Preview image
+- Metadata (trigger words, tags, etc.)
+- Action buttons (edit, delete, etc.)
+
+### Scenario: Edit Model Metadata
+
+**Objective**: Verify metadata editing works end-to-end.
+
+**Steps**:
+1. Open a LoRA's details
+2. Click "Edit" button
+3. Modify trigger words field
+4. Add/remove tags
+5. Save changes
+6. Refresh page
+7. Reopen the same LoRA
+
+**Expected Result**: Changes persist after refresh.
+
+### Scenario: Delete Model
+
+**Objective**: Verify model deletion works.
+
+**Steps**:
+1. Open a LoRA's details
+2. Click "Delete" button
+3. Confirm deletion in dialog
+4. Wait for removal
+
+**Expected Result**: Model removed from list, success message shown.
+
+---
+
+## Recipes
+
+### Scenario: Recipe List Display
+
+**Objective**: Verify recipes page loads and displays recipes.
+
+**Steps**:
+1. Navigate to `http://127.0.0.1:8188/recipes`
+2. Wait for "Recipes" title
+3. Take snapshot
+
+**Expected Result**: Recipe list displayed with cards/items.
+
+### Scenario: Create New Recipe
+
+**Objective**: Verify recipe creation workflow.
+
+**Steps**:
+1. Navigate to recipes page
+2. Click "New Recipe" button
+3. Fill recipe form:
+   - Name: "Test Recipe"
+   - Description: "E2E test recipe"
+   - Add LoRA models
+4. Save recipe
+5. Verify recipe appears in list
+
+**Expected Result**: New recipe created and displayed.
+
+### Scenario: Apply Recipe
+
+**Objective**: Verify applying a recipe to ComfyUI.
+
+**Steps**:
+1. Open a recipe
+2. Click "Apply" or "Load in ComfyUI"
+3. Verify action completes
+
+**Expected Result**: Recipe applied successfully.
+
+---
+
+## Settings
+
+### Scenario: Settings Page Load
+
+**Objective**: Verify settings page displays correctly.
+
+**Steps**:
+1. Navigate to `http://127.0.0.1:8188/settings`
+2. Wait for "Settings" title
+3. Take snapshot
+
+**Expected Result**: Settings form with various options displayed.
+
+### Scenario: Change Setting and Restart
+
+**Objective**: Verify settings persist after restart.
+
+**Steps**:
+1. Navigate to settings page
+2. Change a setting (e.g., default view mode)
+3. Save settings
+4. Restart server: `python scripts/start_server.py --restart --wait`
+5. Refresh browser page
+6. Navigate to settings
+
+**Expected Result**: Changed setting value persists.
+
+---
+
+## Import/Export
+
+### Scenario: Export Models List
+
+**Objective**: Verify export functionality.
+
+**Steps**:
+1. Navigate to LoRA list
+2. Click "Export" button
+3. Select format (JSON/CSV)
+4. Download file
+
+**Expected Result**: File downloaded with correct data.
+
+### Scenario: Import Models
+
+**Objective**: Verify import functionality.
+
+**Steps**:
+1. Prepare import file
+2. Navigate to import page
+3. Upload file
+4. Verify import results
+
+**Expected Result**: Models imported successfully, confirmation shown.
+
+---
+
+## API Integration Tests
+
+### Scenario: Verify API Endpoints
+
+**Objective**: Verify backend API responds correctly.
+
+**Test via browser console**:
+```javascript
+// List LoRAs
+fetch('/loras/api/list').then(r => r.json()).then(console.log)
+
+// Get LoRA details
+fetch('/loras/api/detail/<id>').then(r => r.json()).then(console.log)
+
+// Search LoRAs
+fetch('/loras/api/search?q=test').then(r => r.json()).then(console.log)
+```
+
+**Expected Result**: APIs return valid JSON with expected structure.
+
+---
+
+## Console Error Monitoring
+
+During all tests, monitor browser console for errors:
+
+```python
+# Check for JavaScript errors
+messages = list_console_messages(types=["error"])
+assert len(messages) == 0, f"Console errors found: {messages}"
+```
+
+## Network Request Verification
+
+Verify key API calls are made:
+
+```python
+# List XHR requests
+requests = list_network_requests(resourceTypes=["xhr", "fetch"])
+
+# Look for specific endpoints
+lora_list_requests = [r for r in requests if "/api/list" in r.get("url", "")]
+assert len(lora_list_requests) > 0, "LoRA list API not called"
+```

.agents/skills/lora-manager-e2e/scripts/example_e2e_test.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Example E2E test demonstrating LoRa Manager testing workflow.
+
+This script shows how to:
+1. Start the standalone server
+2. Use Chrome DevTools MCP to interact with the UI
+3. Verify functionality end-to-end
+
+Note: This is a template. Actual execution requires Chrome DevTools MCP.
+"""
+
+import subprocess
+import sys
+import time
+
+
+def run_test():
+    """Run example E2E test flow."""
+    
+    print("=" * 60)
+    print("LoRa Manager E2E Test Example")
+    print("=" * 60)
+    
+    # Step 1: Start server
+    print("\n[1/5] Starting LoRa Manager standalone server...")
+    result = subprocess.run(
+        [sys.executable, "start_server.py", "--port", "8188", "--wait", "--timeout", "30"],
+        capture_output=True,
+        text=True
+    )
+    if result.returncode != 0:
+        print(f"Failed to start server: {result.stderr}")
+        return 1
+    print("Server ready!")
+    
+    # Step 2: Open Chrome (manual step - show command)
+    print("\n[2/5] Open Chrome with debug mode:")
+    print("google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:8188/loras")
+    print("(In actual test, this would be automated via MCP)")
+    
+    # Step 3: Navigate and verify page load
+    print("\n[3/5] Page Load Verification:")
+    print("""
+    MCP Commands to execute:
+    1. navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+    2. wait_for(text="LoRAs", timeout=10000)
+    3. snapshot = take_snapshot()
+    """)
+    
+    # Step 4: Test search functionality
+    print("\n[4/5] Search Functionality Test:")
+    print("""
+    MCP Commands to execute:
+    1. fill(uid="search-input", value="test")
+    2. press_key(key="Enter")
+    3. wait_for(text="Results", timeout=5000)
+    4. result = evaluate_script(function="""
+        () => {
+            const cards = document.querySelectorAll('.lora-card');
+            return { count: cards.length };
+        }
+        """)
+    """)
+    
+    # Step 5: Verify API
+    print("\n[5/5] API Verification:")
+    print("""
+    MCP Commands to execute:
+    1. api_result = evaluate_script(function="""
+        async () => {
+            const response = await fetch('/loras/api/list');
+            const data = await response.json();
+            return { count: data.length, status: response.status };
+        }
+        """)
+    2. Verify api_result['status'] == 200
+    """)
+    
+    print("\n" + "=" * 60)
+    print("Test flow completed!")
+    print("=" * 60)
+    
+    return 0
+
+
+def example_restart_flow():
+    """Example: Testing configuration change that requires restart."""
+    
+    print("\n" + "=" * 60)
+    print("Example: Server Restart Flow")
+    print("=" * 60)
+    
+    print("""
+    Scenario: Change setting and verify after restart
+    
+    Steps:
+    1. Navigate to settings page
+       - navigate_page(type="url", url="http://127.0.0.1:8188/settings")
+    
+    2. Change a setting (e.g., theme)
+       - fill(uid="theme-select", value="dark")
+       - click(uid="save-settings-button")
+    
+    3. Restart server
+       - subprocess.run([python, "start_server.py", "--restart", "--wait"])
+    
+    4. Refresh browser
+       - navigate_page(type="reload", ignoreCache=True)
+       - wait_for(text="LoRAs", timeout=15000)
+    
+    5. Verify setting persisted
+       - navigate_page(type="url", url="http://127.0.0.1:8188/settings")
+       - theme = evaluate_script(function="() => document.querySelector('#theme-select').value")
+       - assert theme == "dark"
+    """)
+
+
+def example_modal_interaction():
+    """Example: Testing modal dialog interaction."""
+    
+    print("\n" + "=" * 60)
+    print("Example: Modal Dialog Interaction")
+    print("=" * 60)
+    
+    print("""
+    Scenario: Add new LoRA via modal
+    
+    Steps:
+    1. Open modal
+       - click(uid="add-lora-button")
+       - wait_for(text="Add LoRA", timeout=3000)
+    
+    2. Fill form
+       - fill_form(elements=[
+           {"uid": "lora-name", "value": "Test Character"},
+           {"uid": "lora-path", "value": "/models/test.safetensors"},
+       ])
+    
+    3. Submit
+       - click(uid="modal-submit-button")
+    
+    4. Verify success
+       - wait_for(text="Successfully added", timeout=5000)
+       - snapshot = take_snapshot()
+    """)
+
+
+def example_network_monitoring():
+    """Example: Network request monitoring."""
+    
+    print("\n" + "=" * 60)
+    print("Example: Network Request Monitoring")
+    print("=" * 60)
+    
+    print("""
+    Scenario: Verify API calls during user interaction
+    
+    Steps:
+    1. Clear network log (implicit on navigation)
+       - navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+    
+    2. Perform action that triggers API call
+       - fill(uid="search-input", value="character")
+       - press_key(key="Enter")
+    
+    3. List network requests
+       - requests = list_network_requests(resourceTypes=["xhr", "fetch"])
+    
+    4. Find search API call
+       - search_requests = [r for r in requests if "/api/search" in r.get("url", "")]
+       - assert len(search_requests) > 0, "Search API was not called"
+    
+    5. Get request details
+       - if search_requests:
+           details = get_network_request(reqid=search_requests[0]["reqid"])
+           - Verify request method, response status, etc.
+    """)
+
+
+if __name__ == "__main__":
+    print("LoRa Manager E2E Test Examples\n")
+    print("This script demonstrates E2E testing patterns.\n")
+    print("Note: Actual execution requires Chrome DevTools MCP connection.\n")
+    
+    run_test()
+    example_restart_flow()
+    example_modal_interaction()
+    example_network_monitoring()
+    
+    print("\n" + "=" * 60)
+    print("All examples shown!")
+    print("=" * 60)

.agents/skills/lora-manager-e2e/scripts/start_server.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+Start or restart LoRa Manager standalone server for E2E testing.
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+import socket
+import signal
+import os
+
+
+def find_server_process(port: int) -> list[int]:
+    """Find PIDs of processes listening on the given port."""
+    try:
+        result = subprocess.run(
+            ["lsof", "-ti", f":{port}"],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return [int(pid) for pid in result.stdout.strip().split("\n") if pid]
+    except FileNotFoundError:
+        # lsof not available, try netstat
+        try:
+            result = subprocess.run(
+                ["netstat", "-tlnp"],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            pids = []
+            for line in result.stdout.split("\n"):
+                if f":{port}" in line:
+                    parts = line.split()
+                    for part in parts:
+                        if "/" in part:
+                            try:
+                                pid = int(part.split("/")[0])
+                                pids.append(pid)
+                            except ValueError:
+                                pass
+            return pids
+        except FileNotFoundError:
+            pass
+    return []
+
+
+def kill_server(port: int) -> None:
+    """Kill processes using the specified port."""
+    pids = find_server_process(port)
+    for pid in pids:
+        try:
+            os.kill(pid, signal.SIGTERM)
+            print(f"Sent SIGTERM to process {pid}")
+        except ProcessLookupError:
+            pass
+    
+    # Wait for processes to terminate
+    time.sleep(1)
+    
+    # Force kill if still running
+    pids = find_server_process(port)
+    for pid in pids:
+        try:
+            os.kill(pid, signal.SIGKILL)
+            print(f"Sent SIGKILL to process {pid}")
+        except ProcessLookupError:
+            pass
+
+
+def is_server_ready(port: int, timeout: float = 0.5) -> bool:
+    """Check if server is accepting connections."""
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=timeout):
+            return True
+    except (socket.timeout, ConnectionRefusedError, OSError):
+        return False
+
+
+def wait_for_server(port: int, timeout: int = 30) -> bool:
+    """Wait for server to become ready."""
+    start = time.time()
+    while time.time() - start < timeout:
+        if is_server_ready(port):
+            return True
+        time.sleep(0.5)
+    return False
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Start LoRa Manager standalone server for E2E testing"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8188,
+        help="Server port (default: 8188)"
+    )
+    parser.add_argument(
+        "--restart",
+        action="store_true",
+        help="Kill existing server before starting"
+    )
+    parser.add_argument(
+        "--wait",
+        action="store_true",
+        help="Wait for server to be ready before exiting"
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=30,
+        help="Timeout for waiting (default: 30)"
+    )
+    
+    args = parser.parse_args()
+    
+    # Get project root (parent of .agents directory)
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    skill_dir = os.path.dirname(script_dir)
+    project_root = os.path.dirname(os.path.dirname(os.path.dirname(skill_dir)))
+    
+    # Restart if requested
+    if args.restart:
+        print(f"Killing existing server on port {args.port}...")
+        kill_server(args.port)
+        time.sleep(1)
+    
+    # Check if already running
+    if is_server_ready(args.port):
+        print(f"Server already running on port {args.port}")
+        return 0
+    
+    # Start server
+    print(f"Starting LoRa Manager standalone server on port {args.port}...")
+    cmd = [sys.executable, "standalone.py", "--port", str(args.port)]
+    
+    # Start in background
+    process = subprocess.Popen(
+        cmd,
+        cwd=project_root,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        start_new_session=True
+    )
+    
+    print(f"Server process started with PID {process.pid}")
+    
+    # Wait for ready if requested
+    if args.wait:
+        print(f"Waiting for server to be ready (timeout: {args.timeout}s)...")
+        if wait_for_server(args.port, args.timeout):
+            print(f"Server ready at http://127.0.0.1:{args.port}/loras")
+            return 0
+        else:
+            print(f"Timeout waiting for server")
+            return 1
+    
+    print(f"Server starting at http://127.0.0.1:{args.port}/loras")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.agents/skills/lora-manager-e2e/scripts/wait_for_server.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Wait for LoRa Manager server to become ready.
+"""
+
+import argparse
+import socket
+import sys
+import time
+
+
+def is_server_ready(port: int, timeout: float = 0.5) -> bool:
+    """Check if server is accepting connections."""
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=timeout):
+            return True
+    except (socket.timeout, ConnectionRefusedError, OSError):
+        return False
+
+
+def wait_for_server(port: int, timeout: int = 30) -> bool:
+    """Wait for server to become ready."""
+    start = time.time()
+    while time.time() - start < timeout:
+        if is_server_ready(port):
+            return True
+        time.sleep(0.5)
+    return False
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Wait for LoRa Manager server to become ready"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8188,
+        help="Server port (default: 8188)"
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=30,
+        help="Timeout in seconds (default: 30)"
+    )
+    
+    args = parser.parse_args()
+    
+    print(f"Waiting for server on port {args.port} (timeout: {args.timeout}s)...")
+    
+    if wait_for_server(args.port, args.timeout):
+        print(f"Server ready at http://127.0.0.1:{args.port}/loras")
+        return 0
+    else:
+        print(f"Timeout: Server not ready after {args.timeout}s")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/backend-tests.yml

@@ -47,6 +47,30 @@ jobs:
           python -m pip install --upgrade pip
           pip install -r requirements-dev.txt
 
+      - name: Verify symlink support
+        run: |
+          python - <<'PY'
+          import os
+          import pathlib
+          import tempfile
+
+          root = pathlib.Path(tempfile.mkdtemp(prefix="lm-symlink-check-"))
+          target = root / "target"
+          target.mkdir()
+          link = root / "link"
+          try:
+              link.symlink_to(target, target_is_directory=True)
+          except OSError as exc:
+              raise SystemExit(f"Failed to create directory symlink in CI: {exc}")
+
+          is_link = os.path.islink(link)
+          is_dir = os.path.isdir(link)
+          realpath = os.path.realpath(link)
+          print(f"islink={is_link} isdir={is_dir} realpath={realpath}")
+          if not (is_link and is_dir and realpath == str(target)):
+              raise SystemExit("Directory symlink is not functioning correctly in CI; aborting.")
+          PY
+
       - name: Run pytest with coverage
         env:
           COVERAGE_FILE: coverage/backend/.coverage

.gitignore

@@ -1,4 +1,5 @@
 __pycache__/
+.pytest_cache/
 settings.json
 path_mappings.yaml
 output/*
@@ -10,3 +11,11 @@ node_modules/
 coverage/
 .coverage
 model_cache/
+
+# agent
+.opencode/
+
+# Vue widgets development cache (but keep build output)
+vue-widgets/node_modules/
+vue-widgets/.vite/
+vue-widgets/dist/

AGENTS.md

@@ -1,22 +1,192 @@
-# Repository Guidelines
+# AGENTS.md
 
-## Project Structure & Module Organization
-ComfyUI LoRA Manager pairs a Python backend with browser-side widgets. Backend modules live in <code>py/</code> with HTTP entry points in <code>py/routes/</code>, feature logic in <code>py/services/</code>, shared helpers in <code>py/utils/</code>, and custom nodes in <code>py/nodes/</code>. UI scripts extend ComfyUI from <code>web/comfyui/</code>, while deploy-ready assets remain in <code>static/</code> and <code>templates/</code>. Localization files live in <code>locales/</code>, example workflows in <code>example_workflows/</code>, and interim tests such as <code>test_i18n.py</code> sit beside their source until a dedicated <code>tests/</code> tree lands.
+This file provides guidance for agentic coding assistants working in this repository.
 
-## Build, Test, and Development Commands
-- <code>pip install -r requirements.txt</code> installs backend dependencies.
-- <code>python standalone.py --port 8188</code> launches the standalone server for iterative development.
-- <code>python -m pytest test_i18n.py</code> runs the current regression suite; target new files explicitly, e.g. <code>python -m pytest tests/test_recipes.py</code>.
-- <code>python scripts/sync_translation_keys.py</code> synchronizes locale keys after UI string updates.
+## Development Commands
 
-## Coding Style & Naming Conventions
-Follow PEP 8 with four-space indentation and descriptive snake_case file and function names such as <code>settings_manager.py</code>. Classes stay PascalCase, constants in UPPER_SNAKE_CASE, and loggers retrieved via <code>logging.getLogger(__name__)</code>. Prefer explicit type hints and docstrings on public APIs. JavaScript under <code>web/comfyui/</code> uses ES modules with camelCase helpers and the <code>_widget.js</code> suffix for UI components.
+### Backend Development
 
-## Testing Guidelines
-Pytest powers backend tests. Name modules <code>test_<feature>.py</code> and keep them near the code or in a future <code>tests/</code> package. Mock ComfyUI dependencies through helpers in <code>standalone.py</code>, keep filesystem fixtures deterministic, and ensure translations are covered. Run <code>python -m pytest</code> before submitting changes.
+```bash
+# Install dependencies
+pip install -r requirements.txt
+pip install -r requirements-dev.txt
 
-## Commit & Pull Request Guidelines
-Commits follow the conventional format, e.g. <code>feat(settings): add default model path</code>, and should stay focused on a single concern. Pull requests must outline the problem, summarize the solution, list manual verification steps (server run, targeted pytest), and link related issues. Include screenshots or GIFs for UI or locale updates and call out migration steps such as <code>settings.json</code> adjustments.
+# Run standalone server (port 8188 by default)
+python standalone.py --port 8188
+
+# Run all backend tests
+pytest
+
+# Run specific test file
+pytest tests/test_recipes.py
+
+# Run specific test function
+pytest tests/test_recipes.py::test_function_name
+
+# Run backend tests with coverage
+COVERAGE_FILE=coverage/backend/.coverage pytest \
+  --cov=py \
+  --cov=standalone \
+  --cov-report=term-missing \
+  --cov-report=html:coverage/backend/html \
+  --cov-report=xml:coverage/backend/coverage.xml \
+  --cov-report=json:coverage/backend/coverage.json
+```
+
+### Frontend Development
+
+```bash
+# Install frontend dependencies
+npm install
+
+# Run frontend tests
+npm test
+
+# Run frontend tests in watch mode
+npm run test:watch
+
+# Run frontend tests with coverage
+npm run test:coverage
+```
+
+## Python Code Style
+
+### Imports
+
+- Use `from __future__ import annotations` for forward references in type hints
+- Group imports: standard library, third-party, local (separated by blank lines)
+- Use absolute imports within `py/` package: `from ..services import X`
+- Mock ComfyUI dependencies in tests using `tests/conftest.py` patterns
+
+### Formatting & Types
+
+- PEP 8 with 4-space indentation
+- Type hints required for function signatures and class attributes
+- Use `TYPE_CHECKING` guard for type-checking-only imports
+- Prefer dataclasses for simple data containers
+- Use `Optional[T]` for nullable types, `Union[T, None]` only when necessary
+
+### Naming Conventions
+
+- Files: `snake_case.py` (e.g., `model_scanner.py`, `lora_service.py`)
+- Classes: `PascalCase` (e.g., `ModelScanner`, `LoraService`)
+- Functions/variables: `snake_case` (e.g., `get_instance`, `model_type`)
+- Constants: `UPPER_SNAKE_CASE` (e.g., `VALID_LORA_TYPES`)
+- Private members: `_single_underscore` (protected), `__double_underscore` (name-mangled)
+
+### Error Handling
+
+- Use `logging.getLogger(__name__)` for module-level loggers
+- Define custom exceptions in `py/services/errors.py`
+- Use `asyncio.Lock` for thread-safe singleton patterns
+- Raise specific exceptions with descriptive messages
+- Log errors at appropriate levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+
+### Async Patterns
+
+- Use `async def` for I/O-bound operations
+- Mark async tests with `@pytest.mark.asyncio`
+- Use `async with` for context managers
+- Singleton pattern with class-level locks: see `ModelScanner.get_instance()`
+- Use `aiohttp.web.Response` for HTTP responses
+
+### Testing Patterns
+
+- Use `pytest` with `--import-mode=importlib`
+- Fixtures in `tests/conftest.py` handle ComfyUI mocking
+- Use `@pytest.mark.no_settings_dir_isolation` for tests needing real paths
+- Test files: `tests/test_*.py`
+- Use `tmp_path_factory` for temporary directory isolation
+
+## JavaScript Code Style
+
+### Imports & Modules
+
+- ES modules with `import`/`export`
+- Use `import { app } from "../../scripts/app.js"` for ComfyUI integration
+- Export named functions/classes: `export function foo() {}`
+- Widget files use `*_widget.js` suffix
+
+### Naming & Formatting
+
+- camelCase for functions, variables, object properties
+- PascalCase for classes/constructors
+- Constants: `UPPER_SNAKE_CASE` (e.g., `CONVERTED_TYPE`)
+- Files: `snake_case.js` or `kebab-case.js`
+- 2-space indentation preferred (follow existing file conventions)
+
+### Widget Development
+
+- Use `app.registerExtension()` to register ComfyUI extensions
+- Use `node.addDOMWidget(name, type, element, options)` for custom widgets
+- Event handlers attached via `addEventListener` or widget callbacks
+- See `web/comfyui/utils.js` for shared utilities
+
+## Architecture Patterns
+
+### Service Layer
+
+- Use `ServiceRegistry` singleton for dependency injection
+- Services follow singleton pattern via `get_instance()` class method
+- Separate scanners (discovery) from services (business logic)
+- Handlers in `py/routes/handlers/` implement route logic
+
+### Model Types
+
+- BaseModelService is abstract base for LoRA, Checkpoint, Embedding services
+- ModelScanner provides file discovery and hash-based deduplication
+- Persistent cache in SQLite via `PersistentModelCache`
+- Metadata sync from CivitAI/CivArchive via `MetadataSyncService`
+
+### Routes & Handlers
+
+- Route registrars organize endpoints by domain: `ModelRouteRegistrar`, etc.
+- Handlers are pure functions taking dependencies as parameters
+- Use `WebSocketManager` for real-time progress updates
+- Return `aiohttp.web.json_response` or `web.Response`
+
+### Recipe System
+
+- Base metadata in `py/recipes/base.py`
+- Enrichment adds model metadata: `RecipeEnrichmentService`
+- Parsers for different formats in `py/recipes/parsers/`
+
+## Important Notes
+
+- Always use English for comments (per copilot-instructions.md)
+- Dual mode: ComfyUI plugin (uses folder_paths) vs standalone (reads settings.json)
+- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+- Settings auto-saved in user directory or portable mode
+- WebSocket broadcasts for real-time updates (downloads, scans)
+- Symlink handling requires normalized paths
+- API endpoints follow `/loras/*`, `/checkpoints/*`, `/embeddings/*` patterns
+- Run `python scripts/sync_translation_keys.py` after UI string updates
+
+## Frontend UI Architecture
+
+This project has two distinct UI systems:
+
+### 1. Standalone Lora Manager Web UI
+- Location: `./static/` and `./templates/`
+- Purpose: Full-featured web application for managing LoRA models
+- Tech stack: Vanilla JS + CSS, served by the standalone server
+- Development: Uses npm for frontend testing (`npm test`, `npm run test:watch`, etc.)
+
+### 2. ComfyUI Custom Node Widgets
+- Location: `./web/comfyui/`
+- Purpose: Widgets and UI logic that ComfyUI loads as custom node extensions
+- Tech stack: Vanilla JS + Vue.js widgets (in `./vue-widgets/` and built to `./web/comfyui/vue-widgets/`)
+- Widget styling: Primary styles in `./web/comfyui/lm_styles.css` (NOT `./static/css/`)
+- Development: No npm build step for these widgets (Vue widgets use build system)
+
+### Widget Development Guidelines
+- Use `app.registerExtension()` to register ComfyUI extensions (ComfyUI integration layer)
+- Use `node.addDOMWidget()` for custom DOM widgets
+- Widget styles should follow the patterns in `./web/comfyui/lm_styles.css`
+  - Selected state: `rgba(66, 153, 225, 0.3)` background, `rgba(66, 153, 225, 0.6)` border
+  - Hover state: `rgba(66, 153, 225, 0.2)` background
+  - Color palette matches the Lora Manager accent color (blue #4299e1)
+  - Use oklch() for color values when possible (defined in `./static/css/base.css`)
+- Vue widget components are in `./vue-widgets/src/components/` and built to `./web/comfyui/vue-widgets/`
+- When modifying widget styles, check `./web/comfyui/lm_styles.css` for consistency with other ComfyUI widgets
 
-## Configuration & Localization Tips
-Copy <code>settings.json.example</code> to <code>settings.json</code> and adapt model directories before running the standalone server. Store reference assets in <code>civitai/</code> or <code>docs/</code> to keep runtime directories deploy-ready. Whenever UI text changes, update every <code>locales/&lt;lang&gt;.json</code> file and rerun the translation sync script so ComfyUI surfaces localized strings.

CLAUDE.md

@@ -0,0 +1,211 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+ComfyUI LoRA Manager is a comprehensive LoRA management system for ComfyUI that combines a Python backend with browser-based widgets. It provides model organization, downloading from CivitAI/CivArchive, recipe management, and one-click workflow integration.
+
+## Development Commands
+
+### Backend Development
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Install development dependencies (for testing)
+pip install -r requirements-dev.txt
+
+# Run standalone server (port 8188 by default)
+python standalone.py --port 8188
+
+# Run backend tests with coverage
+COVERAGE_FILE=coverage/backend/.coverage pytest \
+  --cov=py \
+  --cov=standalone \
+  --cov-report=term-missing \
+  --cov-report=html:coverage/backend/html \
+  --cov-report=xml:coverage/backend/coverage.xml \
+  --cov-report=json:coverage/backend/coverage.json
+
+# Run specific test file
+pytest tests/test_recipes.py
+```
+
+### Frontend Development
+```bash
+# Install frontend dependencies
+npm install
+
+# Run frontend tests
+npm test
+
+# Run frontend tests in watch mode
+npm run test:watch
+
+# Run frontend tests with coverage
+npm run test:coverage
+```
+
+### Localization
+```bash
+# Sync translation keys after UI string updates
+python scripts/sync_translation_keys.py
+```
+
+## Architecture
+
+### Backend Structure (Python)
+
+**Core Entry Points:**
+- `__init__.py` - ComfyUI plugin entry point, registers nodes and routes
+- `standalone.py` - Standalone server that mocks ComfyUI dependencies
+- `py/lora_manager.py` - Main LoraManager class that registers HTTP routes
+
+**Service Layer** (`py/services/`):
+- `ServiceRegistry` - Singleton service registry for dependency management
+- `ModelServiceFactory` - Factory for creating model services (LoRA, Checkpoint, Embedding)
+- Scanner services (`lora_scanner.py`, `checkpoint_scanner.py`, `embedding_scanner.py`) - Model file discovery and indexing
+- `model_scanner.py` - Base scanner with hash-based deduplication and metadata extraction
+- `persistent_model_cache.py` - SQLite-based cache for model metadata
+- `metadata_sync_service.py` - Syncs metadata from CivitAI/CivArchive APIs
+- `civitai_client.py` / `civarchive_client.py` - API clients for external services
+- `downloader.py` / `download_manager.py` - Model download orchestration
+- `recipe_scanner.py` - Recipe file management and image association
+- `settings_manager.py` - Application settings with migration support
+- `websocket_manager.py` - WebSocket broadcasting for real-time updates
+- `use_cases/` - Business logic orchestration (auto-organize, bulk refresh, downloads)
+
+**Routes Layer** (`py/routes/`):
+- Route registrars organize endpoints by domain (models, recipes, previews, example images, updates)
+- `handlers/` - Request handlers implementing business logic
+- Routes use aiohttp and integrate with ComfyUI's PromptServer
+
+**Recipe System** (`py/recipes/`):
+- `base.py` - Base recipe metadata structure
+- `enrichment.py` - Enriches recipes with model metadata
+- `merger.py` - Merges recipe data from multiple sources
+- `parsers/` - Parsers for different recipe formats (PNG, JSON, workflow)
+
+**Custom Nodes** (`py/nodes/`):
+- `lora_loader.py` - LoRA loader nodes with preset support
+- `save_image.py` - Enhanced save image with pattern-based filenames
+- `trigger_word_toggle.py` - Toggle trigger words in prompts
+- `lora_stacker.py` - Stack multiple LoRAs
+- `prompt.py` - Prompt node with autocomplete
+- `wanvideo_lora_select.py` - WanVideo-specific LoRA selection
+
+**Configuration** (`py/config.py`):
+- Manages folder paths for models, checkpoints, embeddings
+- Handles symlink mappings for complex directory structures
+- Auto-saves paths to settings.json in ComfyUI mode
+
+### Frontend Structure (JavaScript)
+
+**ComfyUI Widgets** (`web/comfyui/`):
+- Vanilla JavaScript ES modules extending ComfyUI's LiteGraph-based UI
+- `loras_widget.js` - Main LoRA selection widget with preview
+- `loras_widget_events.js` - Event handling for widget interactions
+- `autocomplete.js` - Autocomplete for trigger words and embeddings
+- `preview_tooltip.js` - Preview tooltip for model cards
+- `top_menu_extension.js` - Adds "Launch LoRA Manager" menu item
+- `trigger_word_highlight.js` - Syntax highlighting for trigger words
+- `utils.js` - Shared utilities and API helpers
+
+**Widget Development:**
+- Widgets use `app.registerExtension` and `getCustomWidgets` hooks
+- `node.addDOMWidget(name, type, element, options)` embeds HTML in nodes
+- See `docs/dom_widget_dev_guide.md` for complete DOMWidget development guide
+
+**Web Source** (`web-src/`):
+- Modern frontend components (if migrating from static)
+- `components/` - Reusable UI components
+- `styles/` - CSS styling
+
+### Key Patterns
+
+**Dual Mode Operation:**
+- ComfyUI plugin mode: Integrates with ComfyUI's PromptServer, uses folder_paths
+- Standalone mode: Mocks ComfyUI dependencies via `standalone.py`, reads paths from settings.json
+- Detection: `os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1"`
+
+**Settings Management:**
+- Settings stored in user directory (via `platformdirs`) or portable mode (in repo)
+- Migration system tracks settings schema version
+- Template in `settings.json.example` defines defaults
+
+**Model Scanning Flow:**
+1. Scanner walks folder paths, computes file hashes
+2. Hash-based deduplication prevents duplicate processing
+3. Metadata extracted from safetensors headers
+4. Persistent cache stores results in SQLite
+5. Background sync fetches CivitAI/CivArchive metadata
+6. WebSocket broadcasts updates to connected clients
+
+**Recipe System:**
+- Recipes store LoRA combinations with parameters
+- Supports import from workflow JSON, PNG metadata
+- Images associated with recipes via sibling file detection
+- Enrichment adds model metadata for display
+
+**Frontend-Backend Communication:**
+- REST API for CRUD operations
+- WebSocket for real-time progress updates (downloads, scans)
+- API endpoints follow `/loras/*` pattern
+
+## Code Style
+
+**Python:**
+- PEP 8 with 4-space indentation
+- snake_case for files, functions, variables
+- PascalCase for classes
+- Type hints preferred
+- English comments only (per copilot-instructions.md)
+- Loggers via `logging.getLogger(__name__)`
+
+**JavaScript:**
+- ES modules with camelCase
+- Files use `*_widget.js` suffix for ComfyUI widgets
+- Prefer vanilla JS, avoid framework dependencies
+
+## Testing
+
+**Backend Tests:**
+- pytest with `--import-mode=importlib`
+- Test files: `tests/test_*.py`
+- Fixtures in `tests/conftest.py`
+- Mock ComfyUI dependencies using standalone.py patterns
+- Markers: `@pytest.mark.asyncio` for async tests, `@pytest.mark.no_settings_dir_isolation` for real paths
+
+**Frontend Tests:**
+- Vitest with jsdom environment
+- Test files: `tests/frontend/**/*.test.js`
+- Setup in `tests/frontend/setup.js`
+- Coverage via `npm run test:coverage`
+
+## Important Notes
+
+**Settings Location:**
+- ComfyUI mode: Auto-saves folder paths to user settings directory
+- Standalone mode: Use `settings.json` (copy from `settings.json.example`)
+- Portable mode: Set `"use_portable_settings": true` in settings.json
+
+**API Integration:**
+- CivitAI API key required for downloads (add to settings)
+- CivArchive API used as fallback for deleted models
+- Metadata archive database available for offline metadata
+
+**Symlink Handling:**
+- Config scans symlinks to map virtual paths to physical locations
+- Preview validation uses normalized preview root paths
+- Fingerprinting prevents redundant symlink rescans
+
+**ComfyUI Node Development:**
+- Nodes defined in `py/nodes/`, registered in `__init__.py`
+- Frontend widgets in `web/comfyui/`, matched by node type
+- Use `WEB_DIRECTORY = "./web/comfyui"` convention
+
+**Recipe Image Association:**
+- Recipes scan for sibling images in same directory
+- Supports repair/migration of recipe image paths
+- See `py/services/recipe_scanner.py` for implementation details

IFLOW.md

@@ -1,103 +0,0 @@
-# ComfyUI LoRA Manager - iFlow 上下文
-
-## 项目概述
-
-ComfyUI LoRA Manager 是一个全面的工具集，用于简化 ComfyUI 中 LoRA 模型的组织、下载和应用。它提供了强大的功能，如配方管理、检查点组织和一键工作流集成，使模型操作更快、更流畅、更简单。
-
-该项目是一个 Python 后端与 JavaScript 前端结合的 Web 应用程序，既可以作为 ComfyUI 的自定义节点运行，也可以作为独立应用程序运行。
-
-## 项目结构
-
-```
-D:\Workspace\ComfyUI\custom_nodes\ComfyUI-Lora-Manager\
-├── py/                 # Python 后端代码
-│   ├── config.py       # 全局配置
-│   ├── lora_manager.py # 主入口点
-│   ├── controllers/    # 控制器
-│   ├── metadata_collector/ # 元数据收集器
-│   ├── middleware/     # 中间件
-│   ├── nodes/          # ComfyUI 节点
-│   ├── recipes/        # 配方相关
-│   ├── routes/         # API 路由
-│   ├── services/       # 业务逻辑服务
-│   ├── utils/          # 工具函数
-│   └── validators/     # 验证器
-├── static/             # 静态资源 (CSS, JS, 图片)
-├── templates/          # HTML 模板
-├── locales/            # 国际化文件
-├── tests/              # 测试代码
-├── standalone.py       # 独立模式入口
-├── requirements.txt    # Python 依赖
-├── package.json        # Node.js 依赖和脚本
-└── README.md           # 项目说明
-```
-
-## 核心组件
-
-### 后端 (Python)
-
-- **主入口**: `py/lora_manager.py` 和 `standalone.py`
-- **配置**: `py/config.py` 管理全局配置和路径
-- **路由**: `py/routes/` 目录下包含各种 API 路由
-- **服务**: `py/services/` 目录下包含业务逻辑，如模型扫描、下载管理等
-- **模型管理**: 使用 `ModelServiceFactory` 来管理不同类型的模型 (LoRA, Checkpoint, Embedding)
-
-### 前端 (JavaScript)
-
-- **构建工具**: 使用 Node.js 和 npm 进行依赖管理和测试
-- **测试**: 使用 Vitest 进行前端测试
-
-## 构建和运行
-
-### 安装依赖
-
-```bash
-# Python 依赖
-pip install -r requirements.txt
-
-# Node.js 依赖 (用于测试)
-npm install
-```
-
-### 运行 (ComfyUI 模式)
-
-作为 ComfyUI 的自定义节点安装后，在 ComfyUI 中启动即可。
-
-### 运行 (独立模式)
-
-```bash
-# 使用默认配置运行
-python standalone.py
-
-# 指定主机和端口
-python standalone.py --host 127.0.0.1 --port 9000
-```
-
-### 测试
-
-#### 后端测试
-
-```bash
-# 安装开发依赖
-pip install -r requirements-dev.txt
-
-# 运行测试
-pytest
-```
-
-#### 前端测试
-
-```bash
-# 运行测试
-npm run test
-
-# 运行测试并生成覆盖率报告
-npm run test:coverage
-```
-
-## 开发约定
-
-- **代码风格**: Python 代码应遵循 PEP 8 规范
-- **测试**: 新功能应包含相应的单元测试
-- **配置**: 使用 `settings.json` 文件进行用户配置
-- **日志**: 使用 Python 标准库 `logging` 模块进行日志记录

README.md

@@ -34,6 +34,26 @@ Enhance your Civitai browsing experience with our companion browser extension! S
 
 ## Release Notes
 
+### v0.9.15
+* **Filter Presets** - Save filter combinations as presets for quick switching and reapplication.
+* **Bug Fixes** - Fixed various bugs for improved stability.
+
+### v0.9.14
+* **LoRA Cycler Node** - Introduced a new LoRA Cycler node that enables iteration through specified LoRAs with support for repeat count and pause iteration functionality. Refer to the new "Lora Cycler" template workflow for concrete example.
+* **Enhanced Prompt Node with Tag Autocomplete** - Enhanced the Prompt node with comprehensive tag autocomplete based on merged Danbooru + e621 tags. Supports tag search and autocomplete functionality. Implemented a command system with shortcuts like `/char` or `/artist` for category-specific tag searching. Added `/ac` or `/noac` commands to quickly enable or disable autocomplete. Refer to the "Lora Manager Basic" template workflow in ComfyUI -> Templates -> ComfyUI-Lora-Manager for detailed tips.
+* **Bug Fixes & Stability** - Addressed multiple bugs and improved overall stability.
+
+### v0.9.12
+* **LoRA Randomizer System** - Introduced a comprehensive LoRA randomization system featuring LoRA Pool and LoRA Randomizer nodes for flexible and dynamic generation workflows.
+* **LoRA Randomizer Template** - Refer to the new "LoRA Randomizer" template workflow for detailed examples of flexible randomization modes, lock & reuse options, and other features.
+* **Recipe Folders** - Introduced a folder system for the Recipes page, allowing users to freely organize recipes just like they do with models.
+* **Recipe Bulk Operations** - Added bulk mode support for batch moving, deleting, and setting base models for selected recipes with intuitive controls like click-and-drag selection, drag-to-folder, and Ctrl+A (Select All).
+* **Prompt Search & Sorting** - Search recipes by prompt content and sort by Recipe Name, Imported Date, or LoRA Count for better browsing.
+* **Recipe Favorites** - Mark specific recipes as favorites for quick access.
+* **Video Recipe Support** - Enabled support for video recipes (import via LM extension or URL; video file import not supported).
+* **Performance Improvements** - Fixed performance issues for dramatically improved startup and loading speed. After first scan, subsequent loads are instant regardless of collection size.
+* **ComfyUI Nodes 2.0 Support** - Basic support for ComfyUI Nodes 2.0.
+
 ### v0.9.10
 * **Smarter Update Matching** - Users can now choose to check and group updates by matching base model only or with no base-model constraint; version lists also support toggling between same-base versions or all versions.
 * **Flexible Tag Filtering** - The filter panel now supports tag exclusion: click a tag to include, click again to exclude, and click a third time to clear, enabling stronger and more flexible tag filters.

__init__.py

@@ -1,15 +1,21 @@
 try:  # pragma: no cover - import fallback for pytest collection
     from .py.lora_manager import LoraManager
-    from .py.nodes.lora_loader import LoraManagerLoader, LoraManagerTextLoader
-    from .py.nodes.trigger_word_toggle import TriggerWordToggle
-    from .py.nodes.prompt import PromptLoraManager
-    from .py.nodes.lora_stacker import LoraStacker
-    from .py.nodes.save_image import SaveImage
-    from .py.nodes.debug_metadata import DebugMetadata
-    from .py.nodes.wanvideo_lora_select import WanVideoLoraSelect
-    from .py.nodes.wanvideo_lora_select_from_text import WanVideoLoraSelectFromText
+    from .py.nodes.lora_loader import LoraLoaderLM, LoraTextLoaderLM
+    from .py.nodes.trigger_word_toggle import TriggerWordToggleLM
+    from .py.nodes.prompt import PromptLM
+    from .py.nodes.text import TextLM
+    from .py.nodes.lora_stacker import LoraStackerLM
+    from .py.nodes.save_image import SaveImageLM
+    from .py.nodes.debug_metadata import DebugMetadataLM
+    from .py.nodes.wanvideo_lora_select import WanVideoLoraSelectLM
+    from .py.nodes.wanvideo_lora_select_from_text import WanVideoLoraTextSelectLM
+    from .py.nodes.lora_pool import LoraPoolLM
+    from .py.nodes.lora_randomizer import LoraRandomizerLM
+    from .py.nodes.lora_cycler import LoraCyclerLM
     from .py.metadata_collector import init as init_metadata_collector
-except ImportError:  # pragma: no cover - allows running under pytest without package install
+except (
+    ImportError
+):  # pragma: no cover - allows running under pytest without package install
     import importlib
     import pathlib
     import sys
@@ -18,35 +24,76 @@ except ImportError:  # pragma: no cover - allows running under pytest without pa
     if str(package_root) not in sys.path:
         sys.path.append(str(package_root))
 
-    PromptLoraManager = importlib.import_module("py.nodes.prompt").PromptLoraManager
+    PromptLM = importlib.import_module("py.nodes.prompt").PromptLM
+    TextLM = importlib.import_module("py.nodes.text").TextLM
     LoraManager = importlib.import_module("py.lora_manager").LoraManager
-    LoraManagerLoader = importlib.import_module("py.nodes.lora_loader").LoraManagerLoader
-    LoraManagerTextLoader = importlib.import_module("py.nodes.lora_loader").LoraManagerTextLoader
-    TriggerWordToggle = importlib.import_module("py.nodes.trigger_word_toggle").TriggerWordToggle
-    LoraStacker = importlib.import_module("py.nodes.lora_stacker").LoraStacker
-    SaveImage = importlib.import_module("py.nodes.save_image").SaveImage
-    DebugMetadata = importlib.import_module("py.nodes.debug_metadata").DebugMetadata
-    WanVideoLoraSelect = importlib.import_module("py.nodes.wanvideo_lora_select").WanVideoLoraSelect
-    WanVideoLoraSelectFromText = importlib.import_module("py.nodes.wanvideo_lora_select_from_text").WanVideoLoraSelectFromText
+    LoraLoaderLM = importlib.import_module(
+        "py.nodes.lora_loader"
+    ).LoraLoaderLM
+    LoraTextLoaderLM = importlib.import_module(
+        "py.nodes.lora_loader"
+    ).LoraTextLoaderLM
+    TriggerWordToggleLM = importlib.import_module(
+        "py.nodes.trigger_word_toggle"
+    ).TriggerWordToggleLM
+    LoraStackerLM = importlib.import_module("py.nodes.lora_stacker").LoraStackerLM
+    SaveImageLM = importlib.import_module("py.nodes.save_image").SaveImageLM
+    DebugMetadataLM = importlib.import_module("py.nodes.debug_metadata").DebugMetadataLM
+    WanVideoLoraSelectLM = importlib.import_module(
+        "py.nodes.wanvideo_lora_select"
+    ).WanVideoLoraSelectLM
+    WanVideoLoraTextSelectLM = importlib.import_module(
+        "py.nodes.wanvideo_lora_select_from_text"
+    ).WanVideoLoraTextSelectLM
+    LoraPoolLM = importlib.import_module("py.nodes.lora_pool").LoraPoolLM
+    LoraRandomizerLM = importlib.import_module(
+        "py.nodes.lora_randomizer"
+    ).LoraRandomizerLM
+    LoraCyclerLM = importlib.import_module(
+        "py.nodes.lora_cycler"
+    ).LoraCyclerLM
     init_metadata_collector = importlib.import_module("py.metadata_collector").init
 
 NODE_CLASS_MAPPINGS = {
-    PromptLoraManager.NAME: PromptLoraManager,
-    LoraManagerLoader.NAME: LoraManagerLoader,
-    LoraManagerTextLoader.NAME: LoraManagerTextLoader,
-    TriggerWordToggle.NAME: TriggerWordToggle,
-    LoraStacker.NAME: LoraStacker,
-    SaveImage.NAME: SaveImage,
-    DebugMetadata.NAME: DebugMetadata,
-    WanVideoLoraSelect.NAME: WanVideoLoraSelect,
-    WanVideoLoraSelectFromText.NAME: WanVideoLoraSelectFromText
+    PromptLM.NAME: PromptLM,
+    TextLM.NAME: TextLM,
+    LoraLoaderLM.NAME: LoraLoaderLM,
+    LoraTextLoaderLM.NAME: LoraTextLoaderLM,
+    TriggerWordToggleLM.NAME: TriggerWordToggleLM,
+    LoraStackerLM.NAME: LoraStackerLM,
+    SaveImageLM.NAME: SaveImageLM,
+    DebugMetadataLM.NAME: DebugMetadataLM,
+    WanVideoLoraSelectLM.NAME: WanVideoLoraSelectLM,
+    WanVideoLoraTextSelectLM.NAME: WanVideoLoraTextSelectLM,
+    LoraPoolLM.NAME: LoraPoolLM,
+    LoraRandomizerLM.NAME: LoraRandomizerLM,
+    LoraCyclerLM.NAME: LoraCyclerLM,
 }
 
 WEB_DIRECTORY = "./web/comfyui"
 
+# Check and build Vue widgets if needed (development mode)
+try:
+    from .py.vue_widget_builder import check_and_build_vue_widgets
+
+    # Auto-build in development, warn only if fails
+    check_and_build_vue_widgets(auto_build=True, warn_only=True)
+except ImportError:
+    # Fallback for pytest
+    import importlib
+
+    check_and_build_vue_widgets = importlib.import_module(
+        "py.vue_widget_builder"
+    ).check_and_build_vue_widgets
+    check_and_build_vue_widgets(auto_build=True, warn_only=True)
+except Exception as e:
+    import logging
+
+    logging.warning(f"[LoRA Manager] Vue widget build check skipped: {e}")
+
 # Initialize metadata collector
 init_metadata_collector()
 
 # Register routes on import
 LoraManager.add_routes()
-__all__ = ['NODE_CLASS_MAPPINGS', 'WEB_DIRECTORY']
+__all__ = ["NODE_CLASS_MAPPINGS", "WEB_DIRECTORY"]

docs/dom-widgets/README.md

@@ -0,0 +1,28 @@
+# DOM Widgets Documentation
+
+Documentation for custom DOM widget development in ComfyUI LoRA Manager.
+
+## Files
+
+- **[Value Persistence Best Practices](value-persistence-best-practices.md)** - Essential guide for implementing text input DOM widgets that persist values correctly
+
+## Key Lessons
+
+### Common Anti-Patterns
+
+❌ **Don't**: Create internal state variables  
+❌ **Don't**: Use v-model for text inputs  
+❌ **Don't**: Add serializeValue, onSetValue callbacks  
+❌ **Don't**: Watch props.widget.value  
+
+### Best Practices
+
+✅ **Do**: Use DOM element as single source of truth  
+✅ **Do**: Store DOM reference on widget.inputEl  
+✅ **Do**: Direct getValue/setValue to DOM  
+✅ **Do**: Clean up reference on unmount
+
+## Related Documentation
+
+- [DOM Widget Development Guide](../dom_widget_dev_guide.md) - Comprehensive guide for building DOM widgets
+- [ComfyUI Built-in Example](../../../../code/ComfyUI_frontend/src/renderer/extensions/vueNodes/widgets/composables/useStringWidget.ts) - Reference implementation

docs/dom-widgets/value-persistence-best-practices.md

@@ -0,0 +1,225 @@
+# DOM Widget Value Persistence - Best Practices
+
+## Overview
+
+DOM widgets require different persistence patterns depending on their complexity. This document covers two patterns:
+
+1. **Simple Text Widgets**: DOM element as source of truth (e.g., textarea, input)
+2. **Complex Widgets**: Internal value with `widget.callback` (e.g., LoraPoolWidget, RandomizerWidget)
+
+## Understanding ComfyUI's Built-in Callback Mechanism
+
+When `widget.value` is set (e.g., during workflow load), ComfyUI's `domWidget.ts` triggers this flow:
+
+```typescript
+// From ComfyUI_frontend/src/scripts/domWidget.ts:146-149
+set value(v: V) {
+  this.options.setValue?.(v)      // 1. Update internal state
+  this.callback?.(this.value)     // 2. Notify listeners for UI updates
+}
+```
+
+This means:
+- `setValue()` handles storing the value
+- `widget.callback()` is automatically called to notify the UI
+- You don't need custom callback mechanisms like `onSetValue`
+
+---
+
+## Pattern 1: Simple Text Input Widgets
+
+For widgets where the value IS the DOM element's text content (textarea, input fields).
+
+### When to Use
+
+- Single text input/textarea widgets
+- Value is a simple string
+- No complex state management needed
+
+### Implementation
+
+**main.ts:**
+```typescript
+const widget = node.addDOMWidget(name, type, container, {
+  getValue() {
+    return widget.inputEl?.value ?? ''
+  },
+  setValue(v: string) {
+    if (widget.inputEl) {
+      widget.inputEl.value = v ?? ''
+    }
+  }
+})
+```
+
+**Vue Component:**
+```typescript
+onMounted(() => {
+  if (textareaRef.value) {
+    props.widget.inputEl = textareaRef.value
+  }
+})
+
+onUnmounted(() => {
+  if (props.widget.inputEl === textareaRef.value) {
+    props.widget.inputEl = undefined
+  }
+})
+```
+
+### Why This Works
+
+- Single source of truth: the DOM element
+- `getValue()` reads directly from DOM
+- `setValue()` writes directly to DOM
+- No sync issues between multiple state variables
+
+---
+
+## Pattern 2: Complex Widgets
+
+For widgets with structured data (JSON configs, arrays, objects) where the value cannot be stored in a DOM element.
+
+### When to Use
+
+- Value is a complex object/array (e.g., `{ loras: [...], settings: {...} }`)
+- Multiple UI elements contribute to the value
+- Vue reactive state manages the UI
+
+### Implementation
+
+**main.ts:**
+```typescript
+let internalValue: MyConfig | undefined
+
+const widget = node.addDOMWidget(name, type, container, {
+  getValue() {
+    return internalValue
+  },
+  setValue(v: MyConfig) {
+    internalValue = v
+    // NO custom onSetValue needed - widget.callback is called automatically
+  },
+  serialize: true  // Ensure value is saved with workflow
+})
+```
+
+**Vue Component:**
+```typescript
+const config = ref<MyConfig>(getDefaultConfig())
+
+onMounted(() => {
+  // Set up callback for UI updates when widget.value changes externally
+  // (e.g., workflow load, undo/redo)
+  props.widget.callback = (newValue: MyConfig) => {
+    if (newValue) {
+      config.value = newValue
+    }
+  }
+
+  // Restore initial value if workflow was already loaded
+  if (props.widget.value) {
+    config.value = props.widget.value
+  }
+})
+
+// When UI changes, update widget value
+function onConfigChange(newConfig: MyConfig) {
+  config.value = newConfig
+  props.widget.value = newConfig  // This also triggers callback
+}
+```
+
+### Why This Works
+
+1. **Clear separation**: `internalValue` stores the data, Vue ref manages the UI
+2. **Built-in callback**: ComfyUI calls `widget.callback()` automatically after `setValue()`
+3. **Bidirectional sync**:
+   - External → UI: `setValue()` updates `internalValue`, `callback()` updates Vue ref
+   - UI → External: User interaction updates Vue ref, which updates `widget.value`
+
+---
+
+## Common Mistakes
+
+### ❌ Creating custom callback mechanisms
+
+```typescript
+// Wrong - unnecessary complexity
+setValue(v: MyConfig) {
+  internalValue = v
+  widget.onSetValue?.(v)  // Don't add this - use widget.callback instead
+}
+```
+
+Use the built-in `widget.callback` instead.
+
+### ❌ Using v-model for simple text inputs in DOM widgets
+
+```html
+<!-- Wrong - creates sync issues -->
+<textarea v-model="textValue" />
+
+<!-- Right for simple text widgets -->
+<textarea ref="textareaRef" @input="onInput" />
+```
+
+### ❌ Watching props.widget.value
+
+```typescript
+// Wrong - creates race conditions
+watch(() => props.widget.value, (newValue) => {
+  config.value = newValue
+})
+```
+
+Use `widget.callback` instead - it's called at the right time in the lifecycle.
+
+### ❌ Multiple sources of truth
+
+```typescript
+// Wrong - who is the source of truth?
+let internalValue = ''        // State 1
+const textValue = ref('')     // State 2
+const domElement = textarea   // State 3
+props.widget.value            // State 4
+```
+
+Choose ONE source of truth:
+- **Simple widgets**: DOM element
+- **Complex widgets**: `internalValue` (with Vue ref as derived UI state)
+
+### ❌ Adding serializeValue for simple widgets
+
+```typescript
+// Wrong - getValue/setValue handle serialization
+props.widget.serializeValue = async () => textValue.value
+```
+
+---
+
+## Decision Guide
+
+| Widget Type | Source of Truth | Use `widget.callback` | Example |
+|-------------|-----------------|----------------------|---------|
+| Simple text input | DOM element (`inputEl`) | Optional | AutocompleteTextWidget |
+| Complex config | `internalValue` | Yes, for UI sync | LoraPoolWidget |
+| Vue component widget | Vue ref + `internalValue` | Yes | RandomizerWidget |
+
+---
+
+## Testing Checklist
+
+- [ ] Load workflow - value restores correctly
+- [ ] Switch workflow - value persists
+- [ ] Reload page - value persists
+- [ ] UI interaction - value updates
+- [ ] Undo/redo - value syncs with UI
+- [ ] No console errors
+
+---
+
+## References
+
+- ComfyUI DOMWidget implementation: `ComfyUI_frontend/src/scripts/domWidget.ts`
+- Simple text widget example: `ComfyUI_frontend/src/renderer/extensions/vueNodes/widgets/composables/useStringWidget.ts`

docs/dom_widget_dev_guide.md

@@ -0,0 +1,546 @@
+# DOMWidget Development Guide
+
+This document provides a comprehensive guide for developing custom DOMWidgets in ComfyUI using Vanilla JavaScript. DOMWidgets allow you to embed standard HTML elements (div, video, canvas, input, etc.) into ComfyUI nodes while benefitting from the frontend's automatic layout and zoom management.
+
+## 1. Core Concepts
+
+In ComfyUI, a `DOMWidget` extends the default LiteGraph Canvas rendering logic. It maintains an HTML layer on top of the Canvas, making complex interactions and media displays significantly easier to implement than pure Canvas drawing.
+
+### Key APIs
+*   **`app.registerExtension`**: The entry point for registering extensions.
+*   **`getCustomWidgets`**: A hook for defining new widget types associated with specific input types.
+*   **`node.addDOMWidget`**: The core method to add HTML elements to a node.
+
+---
+
+## 2. Basic Structure
+
+A standard custom DOMWidget extension typically follows this structure:
+
+```javascript
+import { app } from "../../scripts/app.js";
+
+app.registerExtension({
+    name: "My.Custom.Extension",
+    async getCustomWidgets() {
+        return {
+            // Define a new widget type named "MY_WIDGET_TYPE"
+            MY_WIDGET_TYPE(node, inputName, inputData, app) {
+                // 1. Create the HTML element
+                const container = document.createElement("div");
+                container.innerHTML = "Hello <b>DOMWidget</b>!";
+                
+                // 2. Setup styles (Optional but recommended)
+                container.style.color = "white";
+                container.style.backgroundColor = "#222";
+                container.style.padding = "5px";
+
+                // 3. Add the DOMWidget and return the result
+                const widget = node.addDOMWidget(inputName, "MY_WIDGET_TYPE", container, {
+                    // Configuration options
+                    getValue() {
+                        return container.innerText;
+                    },
+                    setValue(v) {
+                        container.innerText = v;
+                    }
+                });
+
+                // 4. Return in the standard format
+                return { widget };
+            }
+        };
+    }
+});
+```
+
+---
+
+## ComfyUI Dual Rendering Modes
+
+ComfyUI frontend supports two rendering modes:
+
+| Mode | Description | DOM Structure |
+| :--- | :--- | :--- |
+| **Canvas Mode** | Traditional rendering where widgets are rendered on top of canvas using absolute positioning | Uses `.dom-widget` class on containers |
+| **Vue DOM Mode** | New rendering mode where nodes and widgets are rendered as Vue components | Uses `.lg-node-widget` class on containers with dynamic IDs (e.g., `v-1-0`) |
+
+### Mode Switching
+
+The frontend switches between modes via `LiteGraph.vueNodesMode` boolean:
+- `LiteGraph.vueNodesMode = true` → Vue DOM Mode
+- `LiteGraph.vueNodesMode = false` → Canvas Mode
+
+**Key Behavior**: Mode switching triggers DOM re-rendering WITHOUT page reload. Widget elements are destroyed and recreated, so any event listeners or references to old DOM elements become invalid.
+
+### Testing Mode Switches via Chrome DevTools MCP
+
+```javascript
+// Trigger render mode change
+LiteGraph.vueNodesMode = !LiteGraph.vueNodesMode;
+
+// Force canvas redraw (optional but helps trigger re-render)
+if (app.canvas) {
+    app.canvas.draw(true, true);
+}
+```
+
+### Development Notes
+
+When implementing widgets that attach event listeners or maintain external references:
+1. **Use `node.onRemoved`** to clean up when node is deleted
+2. **Detect DOM changes** by checking if widget input element is still in document: `document.body.contains(inputElement)`
+3. **Poll for mode changes** by watching `LiteGraph.vueNodesMode` and re-initializing when it changes
+4. **Use `loadedGraphNode` hook** for initial setup (guarantees DOM is fully rendered)
+
+
+---
+
+## 3. The `addDOMWidget` API
+
+```javascript
+node.addDOMWidget(name, type, element, options)
+```
+
+### Parameters
+1.  **`name`**: The internal name of the widget (usually matches the input name).
+2.  **`type`**: The type identifier for the widget.
+3.  **`element`**: The actual HTMLElement to embed.
+4.  **`options`**: (Object) Configuration for lifecycle, sizing, and persistence.
+
+### Common `options` Fields
+| Field | Type | Description |
+| :--- | :--- | :--- |
+| `getValue` | `Function` | Defines how to retrieve the widget's value for serialization. |
+| `setValue` | `Function` | Defines how to restore the widget's state from workflow data. |
+| `getMinHeight` | `Function` | Returns the minimum height in pixels. |
+| `getHeight` | `Function` | Returns the preferred height (supports numbers or percentage strings like `"50%"`). |
+| `onResize` | `Function` | Callback triggered when the widget is resized. |
+| `hideOnZoom`| `Boolean` | Whether to hide the DOM element when zoomed out to improve performance (default: `true`). |
+| `selectOn` | `string[]` | Events on the element that should trigger node selection (default: `['focus', 'click']`). |
+
+---
+
+## 4. Size Control
+
+Custom DOMWidgets must actively inform the parent Node of their size requirements to ensure the Node layout is calculated correctly and connection wires remain aligned.
+
+### 4.1 Core Mechanism
+
+Whether in Canvas Mode or Vue Mode, the underlying logic model (`LGraphNode`) calls the widget's `computeLayoutSize` method to determine dimensions. This logic is used to calculate the Node's total size and the position of input/output slots.
+
+### 4.2 Controlling Height
+
+It is recommended to use the `options` parameter to define height behavior.
+
+**Performance Note:** providing `getMinHeight` and `getHeight` via `options` allows the system to skip expensive DOM measurements (`getComputedStyle`) during rendering loop. This significantly improves performance and prevents FPS drops during node resizing.
+
+**Method 1: Using `options` (Recommended)**
+
+```javascript
+const widget = node.addDOMWidget("MyWidget", "custom", element, {
+    // Specify minimum height in pixels
+    getMinHeight: () => 150,
+    
+    // Or specify preferred height (pixels or percentage string)
+    // getHeight: () => "50%", 
+});
+```
+
+**Method 2: Using CSS Variables**
+
+You can also set specific CSS variables on the root element:
+
+```javascript
+element.style.setProperty("--comfy-widget-min-height", "150px");
+// or --comfy-widget-height
+```
+
+### 4.3 Controlling Width
+
+By default, a DOMWidget's width automatically stretches to fit the Node's width (which is determined by the Title or other Input Slots).
+
+If you must **force the Node to be wider** to accommodate your widget, you need to override the widget instance's `computeLayoutSize` method:
+
+```javascript
+const widget = node.addDOMWidget("WideWidget", "custom", element);
+
+// Override the default layout calculation
+widget.computeLayoutSize = (targetNode) => {
+    return {
+        minHeight: 150, // Must return height
+        minWidth: 300   // Force the Node to be at least 300px wide
+    };
+};
+```
+
+### 4.4 Dynamic Resizing
+
+If your widget's content changes dynamically (e.g., expanding sections, loading images, or CSS changes), the DOM element will resize, but the Canvas-rendered Node background and Slots will not automatically follow. You must manually trigger a synchronization.
+
+**The Update Sequence:**
+Whenever the **actual rendering height** of your DOM element changes, execute the following "three-step combo":
+
+```javascript
+// 1. Calculate the new optimal size for the node based on current widget requirements
+const newSize = node.computeSize();
+
+// 2. Apply the new size to the node model (updates bounding box and slot positions)
+node.setSize(newSize);
+
+// 3. Mark the canvas as dirty to trigger a redraw in the next animation frame
+node.setDirtyCanvas(true, true);
+```
+
+**Common Scenarios:**
+
+| Scenario | Actual Height Change? | Update Required? |
+| :--- | :--- | :--- |
+| **Expand/Collapse content** | **Yes** | ✅ **Yes**. Prevents widget from overflowing node boundaries. |
+| **Image/Video finished loading** | **Yes** | ✅ **Yes**. Initial height might be 0 until the media loads. |
+| **Changing `minHeight`** | **Maybe** | ❓ **Only if** the change causes the element's actual height to shift. |
+| **Changing font size/styles** | **Yes** | ✅ **Yes**. Text reflow often changes the total height. |
+| **User dragging node corner** | **Yes** | ❌ **No**. LiteGraph handles this internally. |
+
+---
+
+## 5. State Persistence (Serialization)
+
+### 5.1 Default Behavior
+
+DOMWidgets have **serialization enabled** by default (`serialize` property is `true`).
+*   **Saving**: ComfyUI attempts to read the widget's value to save into the Workflow file.
+*   **Loading**: ComfyUI reads the value from the Workflow file and assigns it to the widget.
+
+### 5.2 Custom Serialization
+
+To make persistence work effectively (saving internal DOM state and restoring it), you must implement `getValue` and `setValue` in the `options`:
+
+*   **`getValue`**: Returns the state to be saved (Number, String, or Object).
+*   **`setValue`**: Receives the restored value and updates the DOM element.
+
+**Example:**
+
+```javascript
+const inputEl = document.createElement("input");
+const widget = node.addDOMWidget("MyInput", "custom", inputEl, {
+    // 1. Called during Save
+    getValue: () => {
+        return inputEl.value;
+    },
+    // 2. Called during Load or Copy/Paste
+    setValue: (value) => {
+        inputEl.value = value || "";
+    }
+});
+
+// Optional: Listen for changes to update widget.value immediately
+inputEl.addEventListener("change", () => {
+    widget.value = inputEl.value; // Triggers callbacks
+});
+```
+
+> **⚠️ Important**: For Vue-based DOM widgets with text inputs, follow the [Value Persistence Best Practices](dom-widgets/value-persistence-best-practices.md) to avoid sync issues. Key takeaway: use DOM element as single source of truth, avoid internal state variables and v-model.
+
+### 5.3 The Restoration Mechanism (`configure`)
+
+*   **`configure(data)`**: When a Workflow is loaded, `LGraphNode` calls its `configure(data)` method.
+*   **`setValue` Chain**: During `configure`, the Node iterates over the saved `widgets_values` array and assigns each value (`widget.value = savedValue`). For DOMWidgets, this assignment triggers the `setValue` callback defined in your options.
+
+Therefore, `options.setValue` is the critical hook for restoring widget state.
+
+### 5.4 Disabling Serialization
+
+If your widget is purely for display (e.g., a real-time monitor or generated chart) and doesn't need to save state, disable serialization to reduce workflow file size.
+
+**Note**: You cannot set this via `options`. You must modify the widget instance directly.
+
+```javascript
+const widget = node.addDOMWidget("DisplayOnly", "custom", element);
+widget.serialize = false; // Explicitly disable
+```
+
+---
+
+## 6. Lifecycle & Events
+
+### 6.1 `onResize`
+
+When the Node size changes (e.g., user drags the corner), the widget can receive a notification via `options`:
+
+```javascript
+const widget = node.addDOMWidget("ResizingWidget", "custom", element, {
+    onResize: (w) => {
+        // 'w' is the widget instance
+        // Adjust internal DOM layout here if necessary
+        console.log("Widget resized");
+    }
+});
+```
+
+### 6.2 Construction & Mounting
+
+*   **Construction**: Occurs immediately when `addDOMWidget` is called.
+*   **Mounting**:
+    *   **Canvas Mode**: Appended to `.dom-widget-container` via `DomWidget.vue`.
+    *   **Vue Mode**: Appended inside the Node component via `WidgetDOM.vue`.
+    *   **Caution**: When `addDOMWidget` returns, the element may not be in the `document.body` yet. If you need to access layout properties like `getBoundingClientRect`, use `setTimeout` or wait for the first `onResize`.
+
+### 6.3 Cleanup
+
+If you create external references (like `setInterval` or global event listeners), ensure you clean them up using `node.onRemoved`:
+
+```javascript
+node.onRemoved = function() {
+    clearInterval(myInterval);
+    // Call original onRemoved if it existed
+};
+```
+
+---
+
+## 7. Styling & Best Practices
+
+### 7.1 Styling
+Since DOMWidgets are placed in absolute positioned containers or managed by Vue, ensure your container handles sizing gracefully:
+
+```javascript
+container.style.width = "100%";
+container.style.boxSizing = "border-box";
+```
+
+### 7.2 Path References
+When importing `app`, adjust the path based on your extension's folder depth. Typically:
+`import { app } from "../../scripts/app.js";`
+
+### 7.3 Security
+If setting `innerHTML` dynamically, ensure the content is sanitized or trusted to prevent XSS attacks.
+
+### 7.4 UI Constraints for ComfyUI Custom Node Widgets
+
+When developing DOMWidgets as internal UI widgets for ComfyUI custom nodes, keep the following constraints in mind:
+
+#### 7.4.1 Minimize Vertical Space
+
+ComfyUI nodes are often displayed in a compact graph view with many nodes visible simultaneously. Avoid excessive vertical spacing that could clutter the workspace.
+
+- Keep layouts compact and efficient
+- Use appropriate padding and margins (4-8px typically)
+- Stack related controls vertically but avoid unnecessary spacing
+
+#### 7.4.2 Avoid Dynamic Height Changes
+
+Dynamic height changes (expand/collapse sections, showing/hiding content) can cause node layout recalculations and affect connection wire positioning.
+
+- Prefer static layouts over expandable/collapsible sections
+- Use tooltips or overlays for additional information instead
+- If dynamic height is unavoidable, manually trigger layout updates (see Section 4.4)
+
+#### 7.4.3 Keep UI Simple and Intuitive
+
+As internal widgets for ComfyUI custom nodes, the UI should be accessible to users without technical implementation details.
+
+- Use clear, user-friendly terminology (avoid "frontend/backend roll" in favor of "fixed/always randomize")
+- Focus on user intent rather than implementation details
+- Avoid complex interactions that may confuse users
+
+#### 7.4.4 Forward Middle Mouse Events to Canvas
+
+By default, when a DOM widget receives pointer events (e.g., mouse clicks, drags), these events are captured by the widget and not forwarded to the ComfyUI canvas. This prevents users from panning the workflow using the middle mouse button when the cursor is over a DOM widget.
+
+To enable workflow panning over your widget, you should forward middle mouse events (button 1) to the canvas using the `forwardMiddleMouseToCanvas` utility function:
+
+```javascript
+import { forwardMiddleMouseToCanvas } from "./utils.js";
+
+// In your widget creation function
+const container = document.createElement("div");
+container.style.width = "100%";
+container.style.height = "100%";
+// ... other styles ...
+
+// Forward middle mouse events to canvas for panning
+forwardMiddleMouseToCanvas(container);
+
+const widget = node.addDOMWidget(name, type, container, { ... });
+```
+
+The `forwardMiddleMouseToCanvas` function:
+- Forwards `pointerdown` events with button 1 (middle mouse button) to `app.canvas.processMouseDown`
+- Forwards `pointermove` events while middle mouse button is pressed to `app.canvas.processMouseMove`
+- Forwards `pointerup` events with button 1 to `app.canvas.processMouseUp`
+
+This allows users to pan the workflow canvas even when their mouse cursor is hovering over your DOM widget.
+
+---
+
+## 8. Event Handling in Vue DOM Render Mode
+
+ComfyUI frontend supports two rendering modes for nodes:
+- **Legacy Canvas Mode**: Traditional rendering where widgets are rendered on top of the canvas using absolute positioning
+- **Vue DOM Render Mode**: New rendering mode where nodes and widgets are rendered as Vue components
+
+In Vue DOM render mode, event handling works differently. The frontend uses `useCanvasInteractions` composable to manage event forwarding to the canvas. This can cause custom event handlers in your widgets (e.g., mouse wheel for sliders, custom drag operations) to be intercepted by the canvas.
+
+### 8.1 Wheel Event Handling
+
+By default in Vue DOM render mode, wheel events on widgets may be forwarded to the canvas for workflow zoom, overriding your custom wheel handlers (e.g., adjusting slider values with mouse wheel).
+
+To fix this, use the `data-capture-wheel="true"` attribute on elements that should capture wheel events:
+
+```vue
+<!-- Vue component template -->
+<div class="my-slider" data-capture-wheel="true" @wheel="onWheel">
+  <!-- Slider content -->
+</div>
+
+<script setup lang="ts">
+const onWheel = (event: WheelEvent) => {
+  event.preventDefault()
+  // Custom wheel handling logic here
+}
+</script>
+```
+
+**How it works:**
+- ComfyUI's `useCanvasInteractions.ts` checks `target?.closest('[data-capture-wheel="true"]')` before forwarding wheel events
+- If an element (or its ancestor) has this attribute, wheel events are not forwarded to canvas
+- Your custom `@wheel` handler will work as expected
+
+**Granular control:**
+- Apply `data-capture-wheel="true"` to specific interactive elements (e.g., sliders, scrollable areas)
+- Widget container without this attribute will allow workflow zoom when wheel is used elsewhere
+- This allows users to both: adjust widget values with wheel, and zoom workflow with wheel in widget's non-interactive areas
+
+**Example from DualRangeSlider.vue:**
+```vue
+<template>
+  <div
+    class="dual-range-slider"
+    :class="{ disabled, 'is-dragging': dragging !== null }"
+    data-capture-wheel="true"
+    @wheel="onWheel"
+  >
+    <!-- Slider tracks and handles -->
+  </div>
+</template>
+```
+
+### 8.2 Pointer Event Handling
+
+In Vue DOM render mode, pointer events (click, drag, etc.) may also be captured by the canvas system. For custom drag operations:
+
+1. **Use event modifiers to stop propagation:**
+   ```vue
+   <div
+     @pointerdown.stop="startDrag"
+     @pointermove.stop="onDrag"
+     @pointerup.stop="stopDrag"
+   >
+   ```
+
+2. **Use pointer capture for reliable drag tracking:**
+   ```javascript
+   const startDrag = (event: PointerEvent) => {
+     const target = event.currentTarget as HTMLElement
+     target.setPointerCapture(event.pointerId)
+     // ... drag initialization
+   }
+
+   const stopDrag = (event: PointerEvent) => {
+     const target = event.currentTarget as HTMLElement
+     target.releasePointerCapture(event.pointerId)
+     // ... drag cleanup
+   }
+   ```
+
+3. **Use `touch-action: none` CSS for touch devices:**
+   ```css
+   .my-draggable {
+     touch-action: none;
+   }
+   ```
+
+### 8.3 Compatibility Checklist
+
+Ensure your widget works in both rendering modes:
+
+| Feature | Canvas Mode | Vue DOM Mode | Solution |
+|---------|-------------|--------------|----------|
+| Mouse wheel on sliders | Works by default | Needs `data-capture-wheel` | Add `data-capture-wheel="true"` to slider elements |
+| Custom drag operations | Works with `stopPropagation()` | Needs `stopPropagation()` | Use `.stop` modifier and pointer capture |
+| Middle mouse panning | Manual forwarding required | Manual forwarding required | Use `forwardMiddleMouseToCanvas()` |
+| Workflow zoom on widget edges | Works by default | Works by default | No action needed (works by default) |
+
+### 8.4 Testing Recommendations
+
+Test your widget in both rendering modes:
+1. Toggle between Canvas Mode and Vue DOM Mode in ComfyUI settings
+2. Verify custom interactions (wheel, drag, etc.) work in both modes
+3. Verify canvas interactions (zoom, pan) still work when cursor is over non-interactive widget areas
+4. Test with touch devices if applicable
+
+---
+
+## 9. Complete Example: Text Counter
+
+This example implements a simple widget that displays the character count of another text widget in the same node.
+
+```javascript
+import { app } from "../../scripts/app.js";
+
+app.registerExtension({
+    name: "Comfy.TextCounter",
+    getCustomWidgets() {
+        return {
+            TEXT_COUNTER(node, inputName) {
+                const el = document.createElement("div");
+                Object.assign(el.style, {
+                    background: "#222",
+                    border: "1px solid #444",
+                    padding: "8px",
+                    borderRadius: "4px",
+                    fontSize: "12px",
+                    color: "#eee"
+                });
+                
+                const label = document.createElement("span");
+                label.innerText = "Characters: 0";
+                el.appendChild(label);
+
+                const widget = node.addDOMWidget(inputName, "TEXT_COUNTER", el, {
+                    getValue() { return ""; }, // Nothing to save
+                    setValue(v) { },           // Nothing to restore
+                    getMinHeight() { return 40; }
+                });
+                
+                // Disable serialization for this display-only widget
+                widget.serialize = false;
+
+                // Custom method to update UI
+                widget.updateCount = (text) => {
+                    label.innerText = `Characters: ${text.length}`;
+                };
+
+                return { widget };
+            }
+        };
+    },
+    nodeCreated(node) {
+        // Logic to link widgets after the node is initialized
+        if (node.comfyClass === "MyTextNode") {
+            const counterWidget = node.widgets.find(w => w.type === "TEXT_COUNTER");
+            const textWidget = node.widgets.find(w => w.name === "text");
+            
+            if (counterWidget && textWidget) {
+                // Hook into the text widget's callback
+                const oldCallback = textWidget.callback;
+                textWidget.callback = function(v) {
+                    if (oldCallback) oldCallback.apply(this, arguments);
+                    counterWidget.updateCount(v);
+                };
+            }
+        }
+    }
+});
+```

docs/plan/model-modal-redesign.md

@@ -0,0 +1,449 @@
+# Model Modal UI/UX 重构计划
+
+> **Status**: Phase 1 Complete ✓  
+> **Created**: 2026-02-06  
+> **Target**: v2.x Release
+
+---
+
+## 1. 项目概述
+
+### 1.1 背景与问题
+
+当前 Model Modal 存在以下 UX 问题：
+
+1. **空间利用率低** - 固定 800px 宽度，大屏环境下大量留白
+2. **Tab 切换繁琐** - 4 个 Tab（Examples/Description/Versions/Recipes）隐藏了重要信息
+3. **Examples 浏览不便** - 需持续向下滚动，无快速导航
+4. **添加自定义示例困难** - 需滚动到底部，操作路径长
+
+### 1.2 设计目标
+
+- **空间效率**: 利用 header 以下、sidebar 右侧的全部可用空间
+- **浏览体验**: 类似 Midjourney 的沉浸式图片浏览
+- **信息架构**: 关键元数据固定可见，次要信息可折叠
+- **操作效率**: 直觉化的键盘导航，减少点击次数
+
+---
+
+## 2. 设计方案
+
+### 2.1 布局架构: Split-View Overlay
+
+```
+┌──────────────────────────────────────────────────────────────────────┐
+│  HEADER (保持现有)                                                    │
+├──────────┬───────────────────────────────────────────────────────────┤
+│          │  ┌───────────────────────────┬────────────────────────┐   │
+│ FOLDER   │  │                           │  MODEL HEADER          │   │
+│ SIDEBAR  │  │      EXAMPLES SHOWCASE    │  ├─ Name               │   │
+│ (可折叠)  │  │                           │  ├─ Creator + Actions  │   │
+│          │  │   ┌─────────────────┐     │  ├─ Tags               │   │
+│          │  │   │                 │     ├────────────────────────┤   │
+│          │  │   │   MAIN IMAGE    │     │  COMPACT METADATA      │   │
+│          │  │   │   (自适应高度)   │     │  ├─ Ver | Base | Size  │   │
+│          │  │   │                 │     │  ├─ Location           │   │
+│          │  │   └─────────────────┘     │  ├─ Usage Tips         │   │
+│          │  │                           │  ├─ Trigger Words      │   │
+│          │  │   [PARAMS PREVIEW]        │  ├─ Notes              │   │
+│          │  │   (Prompt + Copy)         ├────────────────────────┤   │
+│          │  │                           │  CONTENT TABS          │   │
+│          │  │   ┌─────────────────┐     │  [Desc][Versions][Rec] │   │
+│          │  │   │  THUMBNAIL RAIL │     │                        │   │
+│          │  │   │  [1][2][3][4][+]│     │  TAB CONTENT AREA      │   │
+│          │  │   └─────────────────┘     │  (Accordion / List)    │   │
+│          │  └───────────────────────────┴────────────────────────┘   │
+└──────────┴───────────────────────────────────────────────────────────┘
+```
+
+**尺寸规格**:
+- Sidebar 展开: Left 60% | Right 40%
+- Sidebar 折叠: Left 65% | Right 35%
+- 最小宽度: 1200px (低于此值触发移动端适配)
+
+### 2.2 左侧: Examples Showcase
+
+#### 2.2.1 组件结构
+
+| 组件 | 描述 | 优先级 |
+|------|------|--------|
+| Main Image | 自适应容器，保持原始比例，最大高度 70vh | P0 |
+| Params Panel | 底部滑出面板，显示 Prompt/Negative/Params | P0 |
+| Thumbnail Rail | 底部横向滚动条，支持点击跳转 | P0 |
+| Add Button | Rail 最右侧 "+" 按钮，打开上传区 | P0 |
+| Nav Arrows | 图片左右两侧悬停显示 | P1 |
+
+#### 2.2.2 图片悬停操作
+
+```
+┌─────────────────┐
+│ [👁] [📌] [🗑] │  ← 查看参数 | 设为预览 | 删除
+│                 │
+│     IMAGE       │
+│                 │
+└─────────────────┘
+```
+
+#### 2.2.3 键盘导航
+
+| 按键 | 功能 | 说明 |
+|------|------|------|
+| ← | 上一个 Example | 循环（首张时到最后一张） |
+| → | 下一个 Example | 循环（末张时到第一张） |
+| I | Toggle Params Panel | 显示/隐藏图片参数 |
+| C | Copy Prompt | 复制当前 Prompt 到剪贴板 |
+
+### 2.3 右侧: Metadata + Content
+
+#### 2.3.1 固定头部 (不可折叠)
+
+```
+┌────────────────────────┐
+│ MODEL NAME        [×]  │
+│ [👤 Creator] [🌐 Civ]  │
+│ [tag1] [tag2] [tag3]   │
+├────────────────────────┤
+│ Ver: v1.0  Size: 96MB  │
+│ Base: SDXL             │
+│ 📁 /path/to/file       │
+├────────────────────────┤
+│ USAGE TIPS        [✏️] │
+│ [strength: 0.8] [+]    │
+├────────────────────────┤
+│ TRIGGER WORDS     [✏️] │
+│ [word1] [word2]  [📋]  │
+├────────────────────────┤
+│ NOTES             [✏️] │
+│ "Add your notes..."    │
+└────────────────────────┘
+```
+
+#### 2.3.2 Tabs 设计
+
+保留横向 Tab 切换，但优化内容展示：
+
+| Tab | 内容 | 交互方式 |
+|-----|------|----------|
+| Description | About this version + Model Description | Accordion 折叠 |
+| Versions | 版本列表卡片 | 完整列表视图 |
+| Recipes | Recipe 卡片网格 | 网格布局 |
+
+**Accordion 行为**:
+- 手风琴模式：同时只能展开一个 section
+- 默认：About this version 展开，Description 折叠
+- 动画：300ms ease-out
+
+### 2.4 全局导航
+
+#### 2.4.1 Model 切换
+
+| 按键 | 功能 |
+|------|------|
+| ↑ | 上一个 Model |
+| ↓ | 下一个 Model |
+
+**切换动画**:
+1. 当前 Modal 淡出 (150ms)
+2. 加载新 Model 数据
+3. 新 Modal 淡入 (150ms)
+4. 保持当前 Tab 状态（不重置到默认）
+
+#### 2.4.2 首次使用提示
+
+Modal 首次打开时，顶部显示提示条：
+```
+┌─────────────────────────────────────────────────────────────┐
+│  💡 Tip: ↑↓ 切换模型 | ←→ 浏览示例 | I 查看参数 | ESC 关闭   │
+└─────────────────────────────────────────────────────────────┘
+```
+- 3 秒后自动淡出
+- 提供 "不再显示" 选项
+
+---
+
+## 3. 技术实现
+
+### 3.1 文件结构变更
+
+```
+static/
+├── js/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── index.js           # 主入口
+│           ├── ModelModal.js      # Modal 容器
+│           ├── ExampleShowcase.js # 左侧展示
+│           ├── ThumbnailRail.js   # 缩略图导航
+│           ├── MetadataPanel.js   # 右侧元数据
+│           ├── ContentTabs.js     # Tabs 容器
+│           └── accordions/        # Accordion 组件
+│               ├── DescriptionAccordion.js
+│               └── VersionsList.js
+├── css/
+│   └── components/
+│       └── model-modal/           # 新目录
+│           ├── modal-overlay.css
+│           ├── showcase.css
+│           ├── thumbnail-rail.css
+│           ├── metadata.css
+│           └── tabs.css
+```
+
+### 3.2 核心 CSS 架构
+
+```css
+/* modal-overlay.css */
+.model-overlay {
+  position: fixed;
+  top: var(--header-height);
+  left: var(--sidebar-width, 250px);
+  right: 0;
+  bottom: 0;
+  z-index: var(--z-modal);
+  
+  display: grid;
+  grid-template-columns: 1.2fr 0.8fr;
+  gap: 0;
+  
+  background: var(--bg-color);
+  animation: modalSlideIn 0.2s ease-out;
+}
+
+.model-overlay.sidebar-collapsed {
+  left: var(--sidebar-collapsed-width, 60px);
+  grid-template-columns: 1.3fr 0.7fr;
+}
+
+/* 移动端适配 */
+@media (max-width: 768px) {
+  .model-overlay {
+    left: 0;
+    grid-template-columns: 1fr;
+    grid-template-rows: auto 1fr;
+  }
+}
+```
+
+### 3.3 响应式断点
+
+| 断点 | 布局 | 说明 |
+|------|------|------|
+| > 1400px | Split 60/40 | 大屏优化 |
+| 1200-1400px | Split 50/50 | 标准桌面 |
+| 768-1200px | Split 50/50 | 小屏桌面/平板 |
+| < 768px | Stack | 移动端：Examples 在上，Metadata 在下 |
+
+---
+
+## 4. 实施阶段
+
+### Phase 1: 核心重构 (预计 2-3 周)
+
+**目标**: MVP 可用，基础功能完整
+
+**任务清单**:
+
+- [ ] 创建新的文件结构和基础组件
+- [ ] 实现 Split-View Overlay 布局
+  - [ ] CSS Grid 布局系统
+  - [ ] Sidebar 状态联动
+  - [ ] 响应式断点处理
+- [ ] 迁移左侧 Examples 区域
+  - [ ] Main Image 自适应容器
+  - [ ] Thumbnail Rail 组件
+  - [ ] Params Panel 滑出动画
+- [ ] 实现新的快捷键系统
+  - [ ] ↑↓ 切换 Model
+  - [ ] ←→ 切换 Example
+  - [ ] I/C/ESC 功能键
+- [ ] 移除旧 Modal 的 max-width 限制
+- [ ] 基础动画过渡
+
+**验收标准**:
+- [ ] 新布局在各种屏幕尺寸下正常显示
+- [ ] 键盘导航正常工作
+- [ ] 无阻塞性 Bug
+
+---
+
+### Phase 2: 体验优化 (预计 1-2 周)
+
+**目标**: 信息架构优化，交互细节完善
+
+**任务清单**:
+
+- [ ] Accordion 组件实现
+  - [ ] Description Tab 的折叠面板
+  - [ ] 手风琴交互逻辑
+  - [ ] 动画优化
+- [ ] 右侧 Metadata 区域固定化
+  - [ ] 滚动行为优化
+  - [ ] 编辑功能迁移
+- [ ] Example 添加流程优化
+  - [ ] Rail 上的 "+" 按钮
+  - [ ] Inline Upload Area
+  - [ ] 拖拽上传支持
+- [ ] Model 切换动画优化
+  - [ ] 淡入淡出效果
+  - [ ] 加载状态指示
+- [ ] 首次使用提示
+
+**验收标准**:
+- [ ] Accordion 交互流畅
+- [ ] 添加 Example 操作路径 < 2 步
+- [ ] Model 切换视觉反馈清晰
+
+---
+
+### Phase 3: 功能完整化 (预计 1-2 周)
+
+**目标**: 所有现有功能迁移完成
+
+**任务清单**:
+
+- [ ] Versions Tab 完整实现
+  - [ ] 版本列表卡片
+  - [ ] 下载/忽略/删除操作
+  - [ ] 更新状态 Badge
+- [ ] Recipes Tab 完整实现
+  - [ ] Recipe 卡片网格
+  - [ ] 复制/应用操作
+- [ ] Tab 状态保持
+  - [ ] 切换 Model 时保持当前 Tab
+  - [ ] Tab 内容滚动位置记忆
+- [ ] 所有编辑功能迁移
+  - [ ] Model Name 编辑
+  - [ ] Base Model 编辑
+  - [ ] File Name 编辑
+  - [ ] Tags 编辑
+  - [ ] Usage Tips 编辑
+  - [ ] Notes 编辑
+
+**验收标准**:
+- [ ] 所有现有功能可用
+- [ ] 单元测试覆盖率 > 80%
+
+---
+
+### Phase 4: 打磨与优化 (预计 1 周)
+
+**目标**: 性能优化，边缘 case 处理
+
+**任务清单**:
+
+- [ ] 移动端适配完善
+  - [ ] Stack 布局优化
+  - [ ] 触摸手势支持（滑动切换）
+- [ ] 性能优化
+  - [ ] 图片懒加载优化
+  - [ ] 虚拟滚动（大量 Examples 时）
+  - [ ] 减少重渲染
+- [ ] 无障碍支持
+  - [ ] ARIA 标签
+  - [ ] 键盘导航焦点管理
+  - [ ] 屏幕阅读器测试
+- [ ] 动画性能优化
+  - [ ] will-change 优化
+  - [ ] 减少 layout thrashing
+
+**验收标准**:
+- [ ] Lighthouse Performance > 90
+- [ ] 无障碍检查无严重问题
+
+---
+
+### Phase 5: 发布准备 (预计 3-5 天)
+
+**目标**: 稳定版本，文档完整
+
+**任务清单**:
+
+- [ ] Bug 修复
+- [ ] 用户测试
+- [ ] 更新文档
+  - [ ] README 更新
+  - [ ] 快捷键说明
+  - [ ] 截图/GIF 演示
+- [ ] 发布说明
+
+---
+
+## 5. 风险与应对
+
+| 风险 | 影响 | 应对策略 |
+|------|------|----------|
+| 用户不适应新布局 | 中 | 提供设置选项，允许切换回旧版（临时） |
+| 性能问题（大量 Examples） | 高 | Phase 4 重点优化，必要时虚拟滚动 |
+| 移动端体验不佳 | 中 | 单独设计移动端布局，非简单缩放 |
+| 与现有扩展冲突 | 低 | 充分的回归测试 |
+
+---
+
+## 6. 关联文件
+
+### 6.1 需修改的现有文件
+
+```
+static/js/components/shared/ModelModal.js      # 完全重构
+static/js/components/shared/showcase/          # 迁移至新目录
+static/css/components/lora-modal/              # 样式重写
+static/css/components/modal/_base.css          # Overlay 样式调整
+```
+
+### 6.2 参考资源
+
+- [Midjourney Explore](https://www.midjourney.com/explore) - 交互参考
+- [Pinterest Pin View](https://www.pinterest.com) - 布局参考
+- [AGENTS.md](/AGENTS.md) - 项目代码规范
+
+---
+
+## 7. Checklist
+
+### 7.1 启动前
+
+- [ ] 创建 feature branch: `feature/model-modal-redesign`
+- [ ] 设置开发环境
+- [ ] 准备测试数据集（多种 Model 类型）
+
+### 7.2 每个 Phase 完成时
+
+- [ ] 代码审查
+- [ ] 功能测试
+- [ ] 更新本文档状态
+
+### 7.3 发布前
+
+- [ ] 完整回归测试
+- [ ] 更新 CHANGELOG
+- [ ] 更新版本号
+
+---
+
+## 8. 附录
+
+### 8.1 命名规范
+
+| 类型 | 规范 | 示例 |
+|------|------|------|
+| 文件 | kebab-case | `thumbnail-rail.js` |
+| 组件 | PascalCase | `ThumbnailRail` |
+| CSS 类 | BEM | `.thumbnail-rail__item--active` |
+| 变量 | camelCase | `currentExampleIndex` |
+
+### 8.2 颜色规范
+
+使用现有 CSS 变量，不引入新颜色：
+
+```css
+--lora-accent: #4299e1;
+--lora-accent-l: 60%;
+--lora-accent-c: 0.2;
+--lora-accent-h: 250;
+--lora-surface: var(--card-bg);
+--lora-border: var(--border-color);
+```
+
+---
+
+*Last Updated: 2026-02-06*

docs/reference/danbooru_e621_categories.md

@@ -0,0 +1,69 @@
+# Danbooru/E621 Tag Categories Reference
+
+Reference for category values used in `danbooru_e621_merged.csv` tag files.
+
+## Category Value Mapping
+
+### Danbooru Categories
+
+| Value | Description |
+|-------|-------------|
+| 0 | General |
+| 1 | Artist |
+| 2 | *(unused)* |
+| 3 | Copyright |
+| 4 | Character |
+| 5 | Meta |
+
+### e621 Categories
+
+| Value | Description |
+|-------|-------------|
+| 6 | *(unused)* |
+| 7 | General |
+| 8 | Artist |
+| 9 | Contributor |
+| 10 | Copyright |
+| 11 | Character |
+| 12 | Species |
+| 13 | *(unused)* |
+| 14 | Meta |
+| 15 | Lore |
+
+## Danbooru Category Colors
+
+| Description | Normal Color | Hover Color |
+|-------------|--------------|-------------|
+| General | #009be6 | #4bb4ff |
+| Artist | #ff8a8b | #ffc3c3 |
+| Copyright | #c797ff | #ddc9fb |
+| Character | #35c64a | #93e49a |
+| Meta | #ead084 | #f7e7c3 |
+
+## CSV Column Structure
+
+Each row in the merged CSV file contains 4 columns:
+
+| Column | Description | Example |
+|--------|-------------|---------|
+| 1 | Tag name | `1girl`, `highres`, `solo` |
+| 2 | Category value (0-15) | `0`, `5`, `7` |
+| 3 | Post count | `6008644`, `5256195` |
+| 4 | Aliases (comma-separated, quoted) | `"1girls,sole_female"`, empty string |
+
+### Sample Data
+
+```
+1girl,0,6008644,"1girls,sole_female"
+highres,5,5256195,"high_res,high_resolution,hires"
+solo,0,5000954,"alone,female_solo,single,solo_female"
+long_hair,0,4350743,"/lh,longhair"
+mammal,12,3437444,"cetancodont,cetancodontamorph,feralmammal"
+anthro,7,3381927,"adult_anthro,anhtro,antho,anthro_horse"
+skirt,0,1557883,
+```
+
+## Source
+
+- [PR #312: Add danbooru_e621_merged.csv](https://github.com/DominikDoom/a1111-sd-webui-tagcomplete/pull/312)
+- [DraconicDragon/dbr-e621-lists-archive](https://github.com/DraconicDragon/dbr-e621-lists-archive)

docs/technical/model_type_refactoring_todo.md

@@ -0,0 +1,191 @@
+# Model Type 字段重构 - 遗留工作清单
+
+> **状态**: Phase 1-4 已完成 | **创建日期**: 2026-01-30  
+> **相关文件**: `py/utils/models.py`, `py/services/model_query.py`, `py/services/checkpoint_scanner.py`, etc.
+
+---
+
+## 概述
+
+本次重构旨在解决 `model_type` 字段语义不统一的问题。系统中有两个层面的"类型"概念：
+
+1. **Scanner Type** (`scanner_type`): 架构层面的大类 - `lora`, `checkpoint`, `embedding`
+2. **Sub Type** (`sub_type`): 业务层面的细分类型 - `lora`/`locon`/`dora`, `checkpoint`/`diffusion_model`, `embedding`
+
+重构目标是统一使用 `sub_type` 表示细分类型，保留 `model_type` 作为向后兼容的别名。
+
+---
+
+## 已完成工作 ✅
+
+### Phase 1: 后端字段重命名
+- [x] `CheckpointMetadata.model_type` → `sub_type`
+- [x] `EmbeddingMetadata.model_type` → `sub_type`
+- [x] `model_scanner.py` `_build_cache_entry()` 同时处理 `sub_type` 和 `model_type`
+
+### Phase 2: 查询逻辑更新
+- [x] `model_query.py` 新增 `resolve_sub_type()` 和 `normalize_sub_type()`
+- [x] ~~保持向后兼容的别名 `resolve_civitai_model_type`, `normalize_civitai_model_type`~~ (已在 Phase 5 移除)
+- [x] `ModelFilterSet.apply()` 更新为使用新的解析函数
+
+### Phase 3: API 响应更新
+- [x] `LoraService.format_response()` 返回 `sub_type` ~~+ `model_type`~~ (已移除 `model_type`)
+- [x] `CheckpointService.format_response()` 返回 `sub_type` ~~+ `model_type`~~ (已移除 `model_type`)
+- [x] `EmbeddingService.format_response()` 返回 `sub_type` ~~+ `model_type`~~ (已移除 `model_type`)
+
+### Phase 4: 前端更新
+- [x] `constants.js` 新增 `MODEL_SUBTYPE_DISPLAY_NAMES`
+- [x] `MODEL_TYPE_DISPLAY_NAMES` 作为别名保留
+
+### Phase 5: 清理废弃代码 ✅
+- [x] 从 `ModelScanner._build_cache_entry()` 中移除 `model_type` 向后兼容代码
+- [x] 从 `CheckpointScanner` 中移除 `model_type` 兼容处理
+- [x] 从 `model_query.py` 中移除 `resolve_civitai_model_type` 和 `normalize_civitai_model_type` 别名
+- [x] 更新前端 `FilterManager.js` 使用 `sub_type` (已在使用 `MODEL_SUBTYPE_DISPLAY_NAMES`)
+- [x] 更新所有相关测试
+
+---
+
+## 遗留工作 ⏳
+
+### Phase 5: 清理废弃代码 ✅ **已完成**
+
+所有 Phase 5 的清理工作已完成：
+
+#### 5.1 移除 `model_type` 字段的向后兼容代码 ✅
+- 从 `ModelScanner._build_cache_entry()` 中移除了 `model_type` 的设置
+- 现在只设置 `sub_type` 字段
+
+#### 5.2 移除 CheckpointScanner 的 model_type 兼容处理 ✅
+- `adjust_metadata()` 现在只处理 `sub_type`
+- `adjust_cached_entry()` 现在只设置 `sub_type`
+
+#### 5.3 移除 model_query 中的向后兼容别名 ✅
+- 移除了 `resolve_civitai_model_type = resolve_sub_type`
+- 移除了 `normalize_civitai_model_type = normalize_sub_type`
+
+#### 5.4 前端清理 ✅
+- `FilterManager.js` 已经在使用 `MODEL_SUBTYPE_DISPLAY_NAMES` (通过别名 `MODEL_TYPE_DISPLAY_NAMES`)
+- API list endpoint 现在只返回 `sub_type`，不再返回 `model_type`
+- `ModelCard.js` 现在设置 `card.dataset.sub_type` (所有模型类型通用)
+- `CheckpointContextMenu.js` 现在读取 `card.dataset.sub_type`
+- `MoveManager.js` 现在处理 `cache_entry.sub_type`
+- `RecipeModal.js` 现在读取 `checkpoint.sub_type`
+
+---
+
+## 数据库迁移评估
+
+### 当前状态
+- `persistent_model_cache.py` 使用 `civitai_model_type` 列存储 CivitAI 原始类型
+- 缓存 entry 中的 `sub_type` 在运行期动态计算
+- 数据库 schema **无需立即修改**
+
+### 未来可选优化
+```sql
+-- 可选：在 models 表中添加 sub_type 列（与 civitai_model_type 保持一致但语义更清晰）
+ALTER TABLE models ADD COLUMN sub_type TEXT;
+
+-- 数据迁移
+UPDATE models SET sub_type = civitai_model_type WHERE sub_type IS NULL;
+```
+
+**建议**: 如果决定添加 `sub_type` 列，应与 Phase 5 一起进行。
+
+---
+
+## 测试覆盖率
+
+### 新增/更新测试文件（已全部通过 ✅）
+
+| 测试文件 | 数量 | 覆盖内容 |
+|---------|------|---------|
+| `tests/utils/test_models_sub_type.py` | 7 | Metadata sub_type 字段 |
+| `tests/services/test_model_query_sub_type.py` | 19 | sub_type 解析和过滤 |
+| `tests/services/test_checkpoint_scanner_sub_type.py` | 6 | CheckpointScanner sub_type |
+| `tests/services/test_service_format_response_sub_type.py` | 6 | API 响应 sub_type 包含 |
+| `tests/services/test_checkpoint_scanner.py` | 1 | Checkpoint 缓存 sub_type |
+| `tests/services/test_model_scanner.py` | 1 | adjust_cached_entry hook |
+| `tests/services/test_download_manager.py` | 1 | Checkpoint 下载 sub_type |
+
+### 需要补充的测试（可选）
+
+- [ ] 集成测试：验证前端过滤使用 sub_type 字段
+- [ ] 数据库迁移测试（如果执行可选优化）
+- [ ] 性能测试：确认 resolve_sub_type 的优先级查找没有显著性能影响
+
+---
+
+## 兼容性检查清单
+
+### 已完成 ✅
+
+- [x] 前端代码已全部改用 `sub_type` 字段
+- [x] API list endpoint 已移除 `model_type`，只返回 `sub_type`
+- [x] 后端 cache entry 已移除 `model_type`，只保留 `sub_type`
+- [x] 所有测试已更新通过
+- [x] 文档已更新
+
+---
+
+## 相关文件清单
+
+### 核心文件
+```
+py/utils/models.py
+py/utils/constants.py
+py/services/model_scanner.py
+py/services/model_query.py
+py/services/checkpoint_scanner.py
+py/services/base_model_service.py
+py/services/lora_service.py
+py/services/checkpoint_service.py
+py/services/embedding_service.py
+```
+
+### 前端文件
+```
+static/js/utils/constants.js
+static/js/managers/FilterManager.js
+static/js/managers/MoveManager.js
+static/js/components/shared/ModelCard.js
+static/js/components/ContextMenu/CheckpointContextMenu.js
+static/js/components/RecipeModal.js
+```
+
+### 测试文件
+```
+tests/utils/test_models_sub_type.py
+tests/services/test_model_query_sub_type.py
+tests/services/test_checkpoint_scanner_sub_type.py
+tests/services/test_service_format_response_sub_type.py
+```
+
+---
+
+## 风险评估
+
+| 风险项 | 影响 | 缓解措施 |
+|-------|------|---------|
+| ~~第三方代码依赖 `model_type`~~ | ~~高~~ | ~~保持别名至少 1 个 major 版本~~ ✅ 已完成移除 |
+| ~~数据库 schema 变更~~ | ~~中~~ | ~~暂缓 schema 变更，仅运行时计算~~ ✅ 无需变更 |
+| ~~前端过滤失效~~ | ~~中~~ | ~~全面的集成测试覆盖~~ ✅ 测试通过 |
+| CivitAI API 变化 | 低 | 保持多源解析策略 |
+
+---
+
+## 时间线
+
+- **v1.x**: Phase 1-4 已完成，保持向后兼容
+- **v2.0 (当前)**: ✅ Phase 5 已完成 - `model_type` 兼容代码已移除
+  - API list endpoint 只返回 `sub_type`
+  - Cache entry 只保留 `sub_type`
+  - 移除了 `resolve_civitai_model_type` 和 `normalize_civitai_model_type` 别名
+
+---
+
+## 备注
+
+- 重构期间发现 `civitai_model_type` 数据库列命名尚可，但语义上应理解为存储 CivitAI API 返回的原始类型值
+- Checkpoint 的 `diffusion_model` sub_type 不能通过 CivitAI API 获取，必须通过文件路径（model root）判断
+- LoRA 的 sub_type（lora/locon/dora）直接来自 CivitAI API 的 `version_info.model.type`

locales/de.json

@@ -10,7 +10,8 @@
             "next": "Weiter",
             "backToTop": "Nach oben",
             "settings": "Einstellungen",
-            "help": "Hilfe"
+            "help": "Hilfe",
+            "add": "Hinzufügen"
         },
         "status": {
             "loading": "Wird geladen...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "Update",
             "updateAvailable": "Update verfügbar"
+        },
+        "usage": {
+            "timesUsed": "Verwendungsanzahl"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "Recipe-Daten reparieren",
+            "loading": "Recipe-Daten werden repariert...",
+            "success": "{count} Rezepte erfolgreich repariert.",
+            "cancelled": "Reparatur abgebrochen. {count} Rezepte wurden repariert.",
+            "error": "Recipe-Reparatur fehlgeschlagen: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "Ersteller",
                 "title": "Rezept-Titel",
                 "loraName": "LoRA-Dateiname",
-                "loraModel": "LoRA-Modellname"
+                "loraModel": "LoRA-Modellname",
+                "prompt": "Prompt"
             }
         },
         "filter": {
             "title": "Modelle filtern",
+            "presets": "Voreinstellungen",
+            "savePreset": "Aktive Filter als neue Voreinstellung speichern.",
+            "savePresetDisabledActive": "Speichern nicht möglich: Eine Voreinstellung ist bereits aktiv. Ändern Sie die Filter, um eine neue Voreinstellung zu speichern",
+            "savePresetDisabledNoFilters": "Wählen Sie zuerst Filter aus, um als Voreinstellung zu speichern",
+            "savePresetPrompt": "Voreinstellungsname eingeben:",
+            "presetClickTooltip": "Voreinstellung \"{name}\" anwenden",
+            "presetDeleteTooltip": "Voreinstellung löschen",
+            "presetDeleteConfirm": "Voreinstellung \"{name}\" löschen?",
+            "presetDeleteConfirmClick": "Zum Bestätigen erneut klicken",
+            "presetOverwriteConfirm": "Voreinstellung \"{name}\" existiert bereits. Überschreiben?",
+            "presetNamePlaceholder": "Voreinstellungsname...",
             "baseModel": "Basis-Modell",
             "modelTags": "Tags (Top 20)",
             "modelTypes": "Model Types",
             "license": "Lizenz",
             "noCreditRequired": "Kein Credit erforderlich",
             "allowSellingGeneratedContent": "Verkauf erlaubt",
-            "clearAll": "Alle Filter löschen"
+            "noTags": "Keine Tags",
+            "clearAll": "Alle Filter löschen",
+            "any": "Beliebig",
+            "all": "Alle",
+            "tagLogicAny": "Jedes Tag abgleichen (ODER)",
+            "tagLogicAll": "Alle Tags abgleichen (UND)"
         },
         "theme": {
             "toggle": "Theme wechseln",
@@ -221,7 +249,9 @@
             "label": "Einstellungsordner öffnen",
             "tooltip": "Den Ordner mit der settings.json öffnen",
             "success": "Einstellungsordner geöffnet",
-            "failed": "Einstellungsordner konnte nicht geöffnet werden"
+            "failed": "Einstellungsordner konnte nicht geöffnet werden",
+            "copied": "Einstellungspfad in die Zwischenablage kopiert: {{path}}",
+            "clipboardFallback": "Einstellungspfad: {{path}}"
         },
         "sections": {
             "contentFiltering": "Inhaltsfilterung",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "Legen Sie den Standard-LoRA-Stammordner für Downloads, Importe und Verschiebungen fest",
             "defaultCheckpointRoot": "Standard-Checkpoint-Stammordner",
             "defaultCheckpointRootHelp": "Legen Sie den Standard-Checkpoint-Stammordner für Downloads, Importe und Verschiebungen fest",
+            "defaultUnetRoot": "Standard-Diffusion-Modell-Stammordner",
+            "defaultUnetRootHelp": "Legen Sie den Standard-Diffusion-Modell-(UNET)-Stammordner für Downloads, Importe und Verschiebungen fest",
             "defaultEmbeddingRoot": "Standard-Embedding-Stammordner",
             "defaultEmbeddingRootHelp": "Legen Sie den Standard-Embedding-Stammordner für Downloads, Importe und Verschiebungen fest",
             "noDefault": "Kein Standard"
@@ -443,7 +475,10 @@
                 "dateAsc": "Älteste",
                 "size": "Dateigröße",
                 "sizeDesc": "Größte",
-                "sizeAsc": "Kleinste"
+                "sizeAsc": "Kleinste",
+                "usage": "Anzahl Nutzung",
+                "usageDesc": "Meiste",
+                "usageAsc": "Wenigste"
             },
             "refresh": {
                 "title": "Modelliste aktualisieren",
@@ -518,6 +553,7 @@
             "replacePreview": "Vorschau ersetzen",
             "setContentRating": "Inhaltsbewertung festlegen",
             "moveToFolder": "In Ordner verschieben",
+            "repairMetadata": "Metadaten reparieren",
             "excludeModel": "Modell ausschließen",
             "deleteModel": "Modell löschen",
             "shareRecipe": "Rezept teilen",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "Bitte wählen Sie ein LoRA-Stammverzeichnis aus"
                 }
             },
+            "sort": {
+                "title": "Rezepte sortieren nach...",
+                "name": "Name",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "Datum",
+                "dateDesc": "Neueste",
+                "dateAsc": "Älteste",
+                "lorasCount": "LoRA-Anzahl",
+                "lorasCountDesc": "Meiste",
+                "lorasCountAsc": "Wenigste"
+            },
             "refresh": {
                 "title": "Rezeptliste aktualisieren"
             },
-            "filteredByLora": "Gefiltert nach LoRA"
+            "filteredByLora": "Gefiltert nach LoRA",
+            "favorites": {
+                "title": "Nur Favoriten anzeigen",
+                "action": "Favoriten"
+            }
         },
         "duplicates": {
             "found": "{count} Duplikat-Gruppen gefunden",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "Keine fehlenden LoRAs zum Herunterladen",
                 "getInfoFailed": "Fehler beim Abrufen der Informationen für fehlende LoRAs",
                 "prepareError": "Fehler beim Vorbereiten der LoRAs für den Download: {message}"
+            },
+            "repair": {
+                "starting": "Rezept-Metadaten werden repariert...",
+                "success": "Rezept-Metadaten erfolgreich repariert",
+                "skipped": "Rezept bereits in der neuesten Version, keine Reparatur erforderlich",
+                "failed": "Rezept-Reparatur fehlgeschlagen: {message}",
+                "missingId": "Rezept kann nicht repariert werden: Fehlende Rezept-ID"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpoint-Modelle"
+        "title": "Checkpoint-Modelle",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "In {otherType}-Ordner verschieben"
+        }
     },
     "embeddings": {
         "title": "Embedding-Modelle"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "Rekursive Suche ist nur in der Baumansicht verfügbar",
         "collapseAllDisabled": "Im Listenmodus nicht verfügbar",
         "dragDrop": {
-            "unableToResolveRoot": "Zielpfad für das Verschieben konnte nicht ermittelt werden."
+            "unableToResolveRoot": "Zielpfad für das Verschieben konnte nicht ermittelt werden.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "Dateispeicherort erfolgreich geöffnet",
-                "failed": "Fehler beim Öffnen des Dateispeicherorts"
+                "failed": "Fehler beim Öffnen des Dateispeicherorts",
+                "copied": "Pfad in die Zwischenablage kopiert: {{path}}",
+                "clipboardFallback": "Pfad: {{path}}"
             },
             "metadata": {
                 "version": "Version",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "Voreingestellten Parameter hinzufügen...",
                 "strengthMin": "Stärke Min",
                 "strengthMax": "Stärke Max",
+                "strengthRange": "Stärkenbereich",
                 "strength": "Stärke",
                 "clipStrength": "Clip-Stärke",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Wert",
-                "add": "Hinzufügen"
+                "add": "Hinzufügen",
+                "invalidRange": "Ungültiges Bereichsformat. Verwenden Sie x.x-y.y"
             },
             "triggerWords": {
                 "label": "Trigger Words",
@@ -914,6 +985,13 @@
                 "recipes": "Rezepte",
                 "versions": "Versionen"
             },
+            "navigation": {
+                "label": "Modellnavigation",
+                "previousWithShortcut": "Vorheriges Modell (←)",
+                "nextWithShortcut": "Nächstes Modell (→)",
+                "noPrevious": "Kein vorheriges Modell verfügbar",
+                "noNext": "Kein weiteres Modell verfügbar"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "Beispielbilder-Ordner geöffnet",
             "openingFolder": "Beispielbilder-Ordner wird geöffnet",
-            "failedToOpen": "Fehler beim Öffnen des Beispielbilder-Ordners"
+            "failedToOpen": "Fehler beim Öffnen des Beispielbilder-Ordners",
+            "setupRequired": "Beispielbilder-Speicher",
+            "setupDescription": "Um benutzerdefinierte Beispielbilder hinzuzufügen, müssen Sie zuerst einen Download-Speicherort festlegen.",
+            "setupUsage": "Dieser Pfad wird sowohl für heruntergeladene als auch für benutzerdefinierte Beispielbilder verwendet.",
+            "openSettings": "Einstellungen öffnen"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "Nach Updates wird gesucht...",
         "checkingMessage": "Bitte warten Sie, während wir nach der neuesten Version suchen.",
         "showNotifications": "Update-Benachrichtigungen anzeigen",
+        "latestBadge": "Neueste",
         "updateProgress": {
             "preparing": "Update wird vorbereitet...",
             "installing": "Update wird installiert...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "Verifikation abgeschlossen. Alle Dateien sind bestätigte Duplikate.",
             "verificationFailed": "Fehler beim Verifizieren der Hashes: {message}",
             "noTagsToAdd": "Keine Tags zum Hinzufügen",
+            "bulkTagsUpdating": "Tags für {count} Modell(e) werden aktualisiert...",
             "tagsAddedSuccessfully": "Erfolgreich {tagCount} Tag(s) zu {count} {type}(s) hinzugefügt",
             "tagsReplacedSuccessfully": "Tags für {count} {type}(s) erfolgreich durch {tagCount} Tag(s) ersetzt",
             "tagsAddFailed": "Fehler beim Hinzufügen von Tags zu {count} Modell(en)",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "Fehler beim Laden der LoRA-Stammverzeichnisse: {message}",
             "checkpointRootsFailed": "Fehler beim Laden der Checkpoint-Stammverzeichnisse: {message}",
+            "unetRootsFailed": "Fehler beim Laden der Diffusion-Modell-Stammverzeichnisse: {message}",
             "embeddingRootsFailed": "Fehler beim Laden der Embedding-Stammverzeichnisse: {message}",
             "mappingsUpdated": "Basis-Modell-Pfad-Zuordnungen aktualisiert ({count} Zuordnung{plural})",
             "mappingsCleared": "Basis-Modell-Pfad-Zuordnungen gelöscht",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "Filter gelöscht",
-            "noCustomFilterToClear": "Kein benutzerdefinierter Filter zum Löschen"
+            "noCustomFilterToClear": "Kein benutzerdefinierter Filter zum Löschen",
+            "noActiveFilters": "Keine aktiven Filter zum Speichern"
+        },
+        "presets": {
+            "created": "Voreinstellung \"{name}\" erstellt",
+            "deleted": "Voreinstellung \"{name}\" gelöscht",
+            "applied": "Voreinstellung \"{name}\" angewendet",
+            "overwritten": "Voreinstellung \"{name}\" überschrieben",
+            "restored": "Standard-Voreinstellungen wiederhergestellt"
+        },
+        "error": {
+            "presetNameEmpty": "Voreinstellungsname darf nicht leer sein",
+            "presetNameTooLong": "Voreinstellungsname darf maximal {max} Zeichen haben",
+            "presetNameInvalidChars": "Voreinstellungsname enthält ungültige Zeichen",
+            "presetNameExists": "Eine Voreinstellung mit diesem Namen existiert bereits",
+            "maxPresetsReached": "Maximal {max} Voreinstellungen erlaubt. Löschen Sie eine, um weitere hinzuzufügen.",
+            "presetNotFound": "Voreinstellung nicht gefunden",
+            "invalidPreset": "Ungültige Voreinstellungsdaten",
+            "deletePresetFailed": "Fehler beim Löschen der Voreinstellung",
+            "applyPresetFailed": "Fehler beim Anwenden der Voreinstellung"
         },
         "downloads": {
             "imagesCompleted": "Beispielbilder {action} abgeschlossen",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "Metadaten erfolgreich aktualisiert",
             "metadataRefreshFailed": "Fehler beim Aktualisieren der Metadaten: {message}",
             "metadataUpdateComplete": "Metadaten-Update abgeschlossen",
+            "operationCancelled": "Vorgang vom Benutzer abgebrochen",
+            "operationCancelledPartial": "Vorgang abgebrochen. {success} Elemente verarbeitet.",
             "metadataFetchFailed": "Fehler beim Abrufen der Metadaten: {message}",
             "bulkMetadataCompleteAll": "Alle {count} {type}s erfolgreich aktualisiert",
             "bulkMetadataCompletePartial": "{success} von {total} {type}s aktualisiert",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "Fehlgeschlagene Verschiebungen:\n{failures}",
             "bulkMoveSuccess": "{successCount} {type}s erfolgreich verschoben",
             "exampleImagesDownloadSuccess": "Beispielbilder erfolgreich heruntergeladen!",
-            "exampleImagesDownloadFailed": "Fehler beim Herunterladen der Beispielbilder: {message}"
+            "exampleImagesDownloadFailed": "Fehler beim Herunterladen der Beispielbilder: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "Cache-Korruption erkannt"
+            },
+            "degraded": {
+                "title": "Cache-Probleme erkannt"
+            },
+            "content": "{invalid} von {total} Cache-Einträgen sind ungültig ({rate}). Dies kann zu fehlenden Modellen oder Fehlern führen. Ein Neuaufbau des Caches wird empfohlen.",
+            "rebuildCache": "Cache neu aufbauen",
+            "dismiss": "Verwerfen",
+            "rebuilding": "Cache wird neu aufgebaut...",
+            "rebuildFailed": "Fehler beim Neuaufbau des Caches: {error}",
+            "retry": "Wiederholen"
         }
     }
 }

locales/en.json

@@ -10,7 +10,8 @@
             "next": "Next",
             "backToTop": "Back to top",
             "settings": "Settings",
-            "help": "Help"
+            "help": "Help",
+            "add": "Add"
         },
         "status": {
             "loading": "Loading...",
@@ -32,7 +33,7 @@
             "korean": "한국어",
             "french": "Français",
             "spanish": "Español",
-			"Hebrew": "עברית"
+            "Hebrew": "עברית"
         },
         "fileSize": {
             "zero": "0 Bytes",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "Update",
             "updateAvailable": "Update available"
+        },
+        "usage": {
+            "timesUsed": "Times used"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "Repair recipes data",
+            "loading": "Repairing recipe data...",
+            "success": "Successfully repaired {count} recipes.",
+            "cancelled": "Repair cancelled. {count} recipes were repaired.",
+            "error": "Recipe repair failed: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "Creator",
                 "title": "Recipe Title",
                 "loraName": "LoRA Filename",
-                "loraModel": "LoRA Model Name"
+                "loraModel": "LoRA Model Name",
+                "prompt": "Prompt"
             }
         },
         "filter": {
             "title": "Filter Models",
+            "presets": "Presets",
+            "savePreset": "Save current active filters as a new preset.",
+            "savePresetDisabledActive": "Cannot save: A preset is already active. Modify filters to save new preset.",
+            "savePresetDisabledNoFilters": "Select filters first to save as preset",
+            "savePresetPrompt": "Enter preset name:",
+            "presetClickTooltip": "Click to apply preset \"{name}\"",
+            "presetDeleteTooltip": "Delete preset",
+            "presetDeleteConfirm": "Delete preset \"{name}\"?",
+            "presetDeleteConfirmClick": "Click again to confirm",
+            "presetOverwriteConfirm": "Preset \"{name}\" already exists. Overwrite?",
+            "presetNamePlaceholder": "Preset name...",
             "baseModel": "Base Model",
             "modelTags": "Tags (Top 20)",
             "modelTypes": "Model Types",
             "license": "License",
             "noCreditRequired": "No Credit Required",
             "allowSellingGeneratedContent": "Allow Selling",
-            "clearAll": "Clear All Filters"
+            "noTags": "No tags",
+            "clearAll": "Clear All Filters",
+            "any": "Any",
+            "all": "All",
+            "tagLogicAny": "Match any tag (OR)",
+            "tagLogicAll": "Match all tags (AND)"
         },
         "theme": {
             "toggle": "Toggle theme",
@@ -219,9 +247,11 @@
         "civitaiApiKeyHelp": "Used for authentication when downloading models from Civitai",
         "openSettingsFileLocation": {
             "label": "Open settings folder",
-            "tooltip": "Open the folder containing settings.json",
+            "tooltip": "Open folder containing settings.json",
             "success": "Opened settings.json folder",
-            "failed": "Failed to open settings.json folder"
+            "failed": "Failed to open settings.json folder",
+            "copied": "Settings path copied to clipboard: {{path}}",
+            "clipboardFallback": "Settings path: {{path}}"
         },
         "sections": {
             "contentFiltering": "Content Filtering",
@@ -302,11 +332,13 @@
             "loadingLibraries": "Loading libraries...",
             "noLibraries": "No libraries configured",
             "defaultLoraRoot": "Default LoRA Root",
-            "defaultLoraRootHelp": "Set the default LoRA root directory for downloads, imports and moves",
+            "defaultLoraRootHelp": "Set default LoRA root directory for downloads, imports and moves",
             "defaultCheckpointRoot": "Default Checkpoint Root",
-            "defaultCheckpointRootHelp": "Set the default checkpoint root directory for downloads, imports and moves",
+            "defaultCheckpointRootHelp": "Set default checkpoint root directory for downloads, imports and moves",
+            "defaultUnetRoot": "Default Diffusion Model Root",
+            "defaultUnetRootHelp": "Set default diffusion model (UNET) root directory for downloads, imports and moves",
             "defaultEmbeddingRoot": "Default Embedding Root",
-            "defaultEmbeddingRootHelp": "Set the default embedding root directory for downloads, imports and moves",
+            "defaultEmbeddingRootHelp": "Set default embedding root directory for downloads, imports and moves",
             "noDefault": "No Default"
         },
         "priorityTags": {
@@ -443,7 +475,10 @@
                 "dateAsc": "Oldest",
                 "size": "File Size",
                 "sizeDesc": "Largest",
-                "sizeAsc": "Smallest"
+                "sizeAsc": "Smallest",
+                "usage": "Use Count",
+                "usageDesc": "Most",
+                "usageAsc": "Least"
             },
             "refresh": {
                 "title": "Refresh model list",
@@ -518,6 +553,7 @@
             "replacePreview": "Replace Preview",
             "setContentRating": "Set Content Rating",
             "moveToFolder": "Move to Folder",
+            "repairMetadata": "Repair metadata",
             "excludeModel": "Exclude Model",
             "deleteModel": "Delete Model",
             "shareRecipe": "Share Recipe",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "Please select a LoRA root directory"
                 }
             },
+            "sort": {
+                "title": "Sort recipes by...",
+                "name": "Name",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "Date",
+                "dateDesc": "Newest",
+                "dateAsc": "Oldest",
+                "lorasCount": "LoRA Count",
+                "lorasCountDesc": "Most",
+                "lorasCountAsc": "Least"
+            },
             "refresh": {
                 "title": "Refresh recipe list"
             },
-            "filteredByLora": "Filtered by LoRA"
+            "filteredByLora": "Filtered by LoRA",
+            "favorites": {
+                "title": "Show Favorites Only",
+                "action": "Favorites"
+            }
         },
         "duplicates": {
             "found": "Found {count} duplicate groups",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "No missing LoRAs to download",
                 "getInfoFailed": "Failed to get information for missing LoRAs",
                 "prepareError": "Error preparing LoRAs for download: {message}"
+            },
+            "repair": {
+                "starting": "Repairing recipe metadata...",
+                "success": "Recipe metadata repaired successfully",
+                "skipped": "Recipe already at latest version, no repair needed",
+                "failed": "Failed to repair recipe: {message}",
+                "missingId": "Cannot repair recipe: Missing recipe ID"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpoint Models"
+        "title": "Checkpoint Models",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "Move to {otherType} Folder"
+        }
     },
     "embeddings": {
         "title": "Embedding Models"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "Recursive search is available in tree view only",
         "collapseAllDisabled": "Not available in list view",
         "dragDrop": {
-            "unableToResolveRoot": "Unable to determine destination path for move."
+            "unableToResolveRoot": "Unable to determine destination path for move.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -844,11 +911,18 @@
                 "viewOnCivitai": "View on Civitai",
                 "viewOnCivitaiText": "View on Civitai",
                 "viewCreatorProfile": "View Creator Profile",
-                "openFileLocation": "Open File Location"
+                "openFileLocation": "Open File Location",
+                "viewParams": "View parameters",
+                "setPreview": "Set as preview",
+                "previewSet": "Preview updated successfully",
+                "previewFailed": "Failed to update preview",
+                "delete": "Delete"
             },
             "openFileLocation": {
                 "success": "File location opened successfully",
-                "failed": "Failed to open file location"
+                "failed": "Failed to open file location",
+                "copied": "Path copied to clipboard: {{path}}",
+                "clipboardFallback": "Path: {{path}}"
             },
             "metadata": {
                 "version": "Version",
@@ -861,30 +935,41 @@
                 "additionalNotes": "Additional Notes",
                 "notesHint": "Press Enter to save, Shift+Enter for new line",
                 "addNotesPlaceholder": "Add your notes here...",
-                "aboutThisVersion": "About this version"
+                "aboutThisVersion": "About this version",
+                "triggerWords": "Trigger Words"
             },
             "notes": {
                 "saved": "Notes saved successfully",
                 "saveFailed": "Failed to save notes"
             },
             "usageTips": {
+                "add": "Add",
                 "addPresetParameter": "Add preset parameter...",
                 "strengthMin": "Strength Min",
                 "strengthMax": "Strength Max",
+                "strengthRange": "Strength Range",
                 "strength": "Strength",
                 "clipStrength": "Clip Strength",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Value",
-                "add": "Add"
+                "invalidRange": "Invalid range format. Use x.x-y.y"
+            },
+            "params": {
+                "title": "Generation Parameters",
+                "prompt": "Prompt",
+                "negativePrompt": "Negative Prompt",
+                "noData": "No generation data available",
+                "promptCopied": "Prompt copied to clipboard"
             },
             "triggerWords": {
                 "label": "Trigger Words",
-                "noTriggerWordsNeeded": "No trigger word needed",
+                "noTriggerWordsNeeded": "No trigger words needed",
                 "edit": "Edit trigger words",
                 "cancel": "Cancel editing",
                 "save": "Save changes",
-                "addPlaceholder": "Type to add or click suggestions below",
+                "addPlaceholder": "Type to add trigger word...",
                 "copyWord": "Copy trigger word",
+                "copyAll": "Copy all trigger words",
                 "deleteWord": "Delete trigger word",
                 "suggestions": {
                     "noSuggestions": "No suggestions available",
@@ -894,6 +979,9 @@
                     "wordSuggestions": "Word Suggestions",
                     "wordsFound": "{count} words found",
                     "loading": "Loading suggestions..."
+                },
+                "validation": {
+                    "duplicate": "This trigger word already exists"
                 }
             },
             "description": {
@@ -914,6 +1002,17 @@
                 "recipes": "Recipes",
                 "versions": "Versions"
             },
+            "navigation": {
+                "label": "Model navigation",
+                "previousWithShortcut": "Previous model (←)",
+                "nextWithShortcut": "Next model (→)",
+                "noPrevious": "No previous model available",
+                "noNext": "No next model available",
+                "previous": "Previous",
+                "next": "Next",
+                "switchModel": "Switch model",
+                "browseExamples": "Browse examples"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -924,6 +1023,23 @@
                 "noReLicense": "Same permissions required",
                 "restrictionsLabel": "License restrictions"
             },
+            "examples": {
+                "add": "Add",
+                "addFirst": "Add your first example",
+                "dropFiles": "Drop files here or click to browse",
+                "supportedFormats": "Supports: JPG, PNG, WEBP, MP4, WEBM",
+                "uploading": "Uploading...",
+                "uploadSuccess": "Example uploaded successfully",
+                "uploadFailed": "Failed to upload example",
+                "confirmDelete": "Delete this example image?",
+                "deleted": "Example deleted successfully",
+                "deleteFailed": "Failed to delete example",
+                "title": "Example",
+                "empty": "No example images available"
+            },
+            "accordion": {
+                "modelDescription": "Model Description"
+            },
             "loading": {
                 "exampleImages": "Loading example images...",
                 "description": "Loading model description...",
@@ -1103,7 +1219,11 @@
         "exampleImages": {
             "opened": "Example images folder opened",
             "openingFolder": "Opening example images folder",
-            "failedToOpen": "Failed to open example images folder"
+            "failedToOpen": "Failed to open example images folder",
+            "setupRequired": "Example Images Storage",
+            "setupDescription": "To add custom example images, you need to set a download location first.",
+            "setupUsage": "This path is used for both downloaded and custom example images.",
+            "openSettings": "Open Settings"
         }
     },
     "help": {
@@ -1152,6 +1272,7 @@
         "checkingUpdates": "Checking for updates...",
         "checkingMessage": "Please wait while we check for the latest version.",
         "showNotifications": "Show update notifications",
+        "latestBadge": "Latest",
         "updateProgress": {
             "preparing": "Preparing update...",
             "installing": "Installing update...",
@@ -1317,6 +1438,7 @@
             "verificationCompleteSuccess": "Verification complete. All files are confirmed duplicates.",
             "verificationFailed": "Failed to verify hashes: {message}",
             "noTagsToAdd": "No tags to add",
+            "bulkTagsUpdating": "Updating tags for {count} model(s)...",
             "tagsAddedSuccessfully": "Successfully added {tagCount} tag(s) to {count} {type}(s)",
             "tagsReplacedSuccessfully": "Successfully replaced tags for {count} {type}(s) with {tagCount} tag(s)",
             "tagsAddFailed": "Failed to add tags to {count} model(s)",
@@ -1330,6 +1452,7 @@
         "settings": {
             "loraRootsFailed": "Failed to load LoRA roots: {message}",
             "checkpointRootsFailed": "Failed to load checkpoint roots: {message}",
+            "unetRootsFailed": "Failed to load diffusion model roots: {message}",
             "embeddingRootsFailed": "Failed to load embedding roots: {message}",
             "mappingsUpdated": "Base model path mappings updated ({count} mapping{plural})",
             "mappingsCleared": "Base model path mappings cleared",
@@ -1350,7 +1473,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "Filters cleared",
-            "noCustomFilterToClear": "No custom filter to clear"
+            "noCustomFilterToClear": "No custom filter to clear",
+            "noActiveFilters": "No active filters to save"
+        },
+        "presets": {
+            "created": "Preset \"{name}\" created",
+            "deleted": "Preset \"{name}\" deleted",
+            "applied": "Preset \"{name}\" applied",
+            "overwritten": "Preset \"{name}\" overwritten",
+            "restored": "Default presets restored"
+        },
+        "error": {
+            "presetNameEmpty": "Preset name cannot be empty",
+            "presetNameTooLong": "Preset name must be {max} characters or less",
+            "presetNameInvalidChars": "Preset name contains invalid characters",
+            "presetNameExists": "A preset with this name already exists",
+            "maxPresetsReached": "Maximum {max} presets allowed. Delete one to add more.",
+            "presetNotFound": "Preset not found",
+            "invalidPreset": "Invalid preset data",
+            "deletePresetFailed": "Failed to delete preset",
+            "applyPresetFailed": "Failed to apply preset"
         },
         "downloads": {
             "imagesCompleted": "Example images {action} completed",
@@ -1437,6 +1579,8 @@
             "metadataRefreshed": "Metadata refreshed successfully",
             "metadataRefreshFailed": "Failed to refresh metadata: {message}",
             "metadataUpdateComplete": "Metadata update complete",
+            "operationCancelled": "Operation cancelled by user",
+            "operationCancelledPartial": "Operation cancelled. {success} items processed.",
             "metadataFetchFailed": "Failed to fetch metadata: {message}",
             "bulkMetadataCompleteAll": "Successfully refreshed all {count} {type}s",
             "bulkMetadataCompletePartial": "Refreshed {success} of {total} {type}s",
@@ -1453,7 +1597,8 @@
             "bulkMoveFailures": "Failed moves:\n{failures}",
             "bulkMoveSuccess": "Successfully moved {successCount} {type}s",
             "exampleImagesDownloadSuccess": "Successfully downloaded example images!",
-            "exampleImagesDownloadFailed": "Failed to download example images: {message}"
+            "exampleImagesDownloadFailed": "Failed to download example images: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1614,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "Cache Corruption Detected"
+            },
+            "degraded": {
+                "title": "Cache Issues Detected"
+            },
+            "content": "{invalid} of {total} cache entries are invalid ({rate}). This may cause missing models or errors. Rebuilding the cache is recommended.",
+            "rebuildCache": "Rebuild Cache",
+            "dismiss": "Dismiss",
+            "rebuilding": "Rebuilding cache...",
+            "rebuildFailed": "Failed to rebuild cache: {error}",
+            "retry": "Retry"
         }
     }
 }

locales/es.json

@@ -10,7 +10,8 @@
             "next": "Siguiente",
             "backToTop": "Volver arriba",
             "settings": "Configuración",
-            "help": "Ayuda"
+            "help": "Ayuda",
+            "add": "Añadir"
         },
         "status": {
             "loading": "Cargando...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "Actualización",
             "updateAvailable": "Actualización disponible"
+        },
+        "usage": {
+            "timesUsed": "Veces usado"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "Reparar datos de recetas",
+            "loading": "Reparando datos de recetas...",
+            "success": "Se repararon con éxito {count} recetas.",
+            "cancelled": "Reparación cancelada. {count} recetas fueron reparadas.",
+            "error": "Error al reparar recetas: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "Creador",
                 "title": "Título de la receta",
                 "loraName": "Nombre de archivo LoRA",
-                "loraModel": "Nombre del modelo LoRA"
+                "loraModel": "Nombre del modelo LoRA",
+                "prompt": "Prompt"
             }
         },
         "filter": {
             "title": "Filtrar modelos",
+            "presets": "Preajustes",
+            "savePreset": "Guardar filtros activos como nuevo preajuste.",
+            "savePresetDisabledActive": "No se puede guardar: Ya hay un preajuste activo. Modifique los filtros para guardar un nuevo preajuste",
+            "savePresetDisabledNoFilters": "Seleccione filtros primero para guardar como preajuste",
+            "savePresetPrompt": "Ingrese el nombre del preajuste:",
+            "presetClickTooltip": "Hacer clic para aplicar preajuste \"{name}\"",
+            "presetDeleteTooltip": "Eliminar preajuste",
+            "presetDeleteConfirm": "¿Eliminar preajuste \"{name}\"?",
+            "presetDeleteConfirmClick": "Haga clic de nuevo para confirmar",
+            "presetOverwriteConfirm": "El preset \"{name}\" ya existe. ¿Sobrescribir?",
+            "presetNamePlaceholder": "Nombre del preajuste...",
             "baseModel": "Modelo base",
             "modelTags": "Etiquetas (Top 20)",
             "modelTypes": "Model Types",
             "license": "Licencia",
             "noCreditRequired": "Sin crédito requerido",
             "allowSellingGeneratedContent": "Venta permitida",
-            "clearAll": "Limpiar todos los filtros"
+            "noTags": "Sin etiquetas",
+            "clearAll": "Limpiar todos los filtros",
+            "any": "Cualquiera",
+            "all": "Todos",
+            "tagLogicAny": "Coincidir con cualquier etiqueta (O)",
+            "tagLogicAll": "Coincidir con todas las etiquetas (Y)"
         },
         "theme": {
             "toggle": "Cambiar tema",
@@ -221,7 +249,9 @@
             "label": "Abrir carpeta de ajustes",
             "tooltip": "Abrir la carpeta que contiene settings.json",
             "success": "Carpeta de settings.json abierta",
-            "failed": "No se pudo abrir la carpeta de settings.json"
+            "failed": "No se pudo abrir la carpeta de settings.json",
+            "copied": "Ruta de configuración copiada al portapapeles: {{path}}",
+            "clipboardFallback": "Ruta de configuración: {{path}}"
         },
         "sections": {
             "contentFiltering": "Filtrado de contenido",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "Establecer el directorio raíz predeterminado de LoRA para descargas, importaciones y movimientos",
             "defaultCheckpointRoot": "Raíz predeterminada de checkpoint",
             "defaultCheckpointRootHelp": "Establecer el directorio raíz predeterminado de checkpoint para descargas, importaciones y movimientos",
+            "defaultUnetRoot": "Raíz predeterminada 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",
             "defaultEmbeddingRootHelp": "Establecer el directorio raíz predeterminado de embedding para descargas, importaciones y movimientos",
             "noDefault": "Sin predeterminado"
@@ -443,7 +475,10 @@
                 "dateAsc": "Más antiguo",
                 "size": "Tamaño de archivo",
                 "sizeDesc": "Mayor",
-                "sizeAsc": "Menor"
+                "sizeAsc": "Menor",
+                "usage": "Número de usos",
+                "usageDesc": "Más",
+                "usageAsc": "Menos"
             },
             "refresh": {
                 "title": "Actualizar lista de modelos",
@@ -518,6 +553,7 @@
             "replacePreview": "Reemplazar vista previa",
             "setContentRating": "Establecer clasificación de contenido",
             "moveToFolder": "Mover a carpeta",
+            "repairMetadata": "Reparar metadatos",
             "excludeModel": "Excluir modelo",
             "deleteModel": "Eliminar modelo",
             "shareRecipe": "Compartir receta",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "Por favor selecciona un directorio raíz de LoRA"
                 }
             },
+            "sort": {
+                "title": "Ordenar recetas por...",
+                "name": "Nombre",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "Fecha",
+                "dateDesc": "Más reciente",
+                "dateAsc": "Más antiguo",
+                "lorasCount": "Cant. de LoRAs",
+                "lorasCountDesc": "Más",
+                "lorasCountAsc": "Menos"
+            },
             "refresh": {
                 "title": "Actualizar lista de recetas"
             },
-            "filteredByLora": "Filtrado por LoRA"
+            "filteredByLora": "Filtrado por LoRA",
+            "favorites": {
+                "title": "Mostrar solo favoritos",
+                "action": "Favoritos"
+            }
         },
         "duplicates": {
             "found": "Se encontraron {count} grupos de duplicados",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "No hay LoRAs faltantes para descargar",
                 "getInfoFailed": "Error al obtener información de LoRAs faltantes",
                 "prepareError": "Error preparando LoRAs para descarga: {message}"
+            },
+            "repair": {
+                "starting": "Reparando metadatos de la receta...",
+                "success": "Metadatos de la receta reparados con éxito",
+                "skipped": "La receta ya está en la última versión, no se necesita reparación",
+                "failed": "Error al reparar la receta: {message}",
+                "missingId": "No se puede reparar la receta: falta el ID de la receta"
             }
         }
     },
     "checkpoints": {
-        "title": "Modelos checkpoint"
+        "title": "Modelos checkpoint",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "Mover a la carpeta {otherType}"
+        }
     },
     "embeddings": {
         "title": "Modelos embedding"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "La búsqueda recursiva solo está disponible en la vista en árbol",
         "collapseAllDisabled": "No disponible en vista de lista",
         "dragDrop": {
-            "unableToResolveRoot": "No se puede determinar la ruta de destino para el movimiento."
+            "unableToResolveRoot": "No se puede determinar la ruta de destino para el movimiento.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "Ubicación del archivo abierta exitosamente",
-                "failed": "Error al abrir la ubicación del archivo"
+                "failed": "Error al abrir la ubicación del archivo",
+                "copied": "Ruta copiada al portapapeles: {{path}}",
+                "clipboardFallback": "Ruta: {{path}}"
             },
             "metadata": {
                 "version": "Versión",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "Añadir parámetro preestablecido...",
                 "strengthMin": "Fuerza mínima",
                 "strengthMax": "Fuerza máxima",
+                "strengthRange": "Rango de fuerza",
                 "strength": "Fuerza",
                 "clipStrength": "Fuerza de Clip",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Valor",
-                "add": "Añadir"
+                "add": "Añadir",
+                "invalidRange": "Formato de rango inválido. Use x.x-y.y"
             },
             "triggerWords": {
                 "label": "Palabras clave",
@@ -914,6 +985,13 @@
                 "recipes": "Recetas",
                 "versions": "Versiones"
             },
+            "navigation": {
+                "label": "Navegación de modelos",
+                "previousWithShortcut": "Modelo anterior (←)",
+                "nextWithShortcut": "Siguiente modelo (→)",
+                "noPrevious": "No hay modelo anterior disponible",
+                "noNext": "No hay siguiente modelo disponible"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "Carpeta de imágenes de ejemplo abierta",
             "openingFolder": "Abriendo carpeta de imágenes de ejemplo",
-            "failedToOpen": "Error al abrir carpeta de imágenes de ejemplo"
+            "failedToOpen": "Error al abrir carpeta de imágenes de ejemplo",
+            "setupRequired": "Almacenamiento de imágenes de ejemplo",
+            "setupDescription": "Para agregar imágenes de ejemplo personalizadas, primero necesita establecer una ubicación de descarga.",
+            "setupUsage": "Esta ruta se utiliza tanto para imágenes de ejemplo descargadas como personalizadas.",
+            "openSettings": "Abrir configuración"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "Comprobando actualizaciones...",
         "checkingMessage": "Por favor espera mientras comprobamos la última versión.",
         "showNotifications": "Mostrar notificaciones de actualización",
+        "latestBadge": "Último",
         "updateProgress": {
             "preparing": "Preparando actualización...",
             "installing": "Instalando actualización...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "Verificación completa. Todos los archivos son confirmados duplicados.",
             "verificationFailed": "Error al verificar hashes: {message}",
             "noTagsToAdd": "No hay etiquetas para añadir",
+            "bulkTagsUpdating": "Actualizando etiquetas para {count} modelo(s)...",
             "tagsAddedSuccessfully": "Se añadieron exitosamente {tagCount} etiqueta(s) a {count} {type}(s)",
             "tagsReplacedSuccessfully": "Se reemplazaron exitosamente las etiquetas de {count} {type}(s) con {tagCount} etiqueta(s)",
             "tagsAddFailed": "Error al añadir etiquetas a {count} modelo(s)",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "Error al cargar raíces de LoRA: {message}",
             "checkpointRootsFailed": "Error al cargar raíces de checkpoint: {message}",
+            "unetRootsFailed": "Error al cargar raíces de Diffusion Model: {message}",
             "embeddingRootsFailed": "Error al cargar raíces de embedding: {message}",
             "mappingsUpdated": "Mapeos de rutas de modelo base actualizados ({count} mapeo{plural})",
             "mappingsCleared": "Mapeos de rutas de modelo base limpiados",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "Filtros limpiados",
-            "noCustomFilterToClear": "No hay filtro personalizado para limpiar"
+            "noCustomFilterToClear": "No hay filtro personalizado para limpiar",
+            "noActiveFilters": "No hay filtros activos para guardar"
+        },
+        "presets": {
+            "created": "Preajuste \"{name}\" creado",
+            "deleted": "Preajuste \"{name}\" eliminado",
+            "applied": "Preajuste \"{name}\" aplicado",
+            "overwritten": "Preset \"{name}\" sobrescrito",
+            "restored": "Presets predeterminados restaurados"
+        },
+        "error": {
+            "presetNameEmpty": "El nombre del preajuste no puede estar vacío",
+            "presetNameTooLong": "El nombre del preajuste debe tener {max} caracteres o menos",
+            "presetNameInvalidChars": "El nombre del preajuste contiene caracteres inválidos",
+            "presetNameExists": "Ya existe un preajuste con este nombre",
+            "maxPresetsReached": "Máximo {max} preajustes permitidos. Elimine uno para agregar más.",
+            "presetNotFound": "Preajuste no encontrado",
+            "invalidPreset": "Datos de preajuste inválidos",
+            "deletePresetFailed": "Error al eliminar el preajuste",
+            "applyPresetFailed": "Error al aplicar el preajuste"
         },
         "downloads": {
             "imagesCompleted": "Imágenes de ejemplo {action} completadas",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "Metadatos actualizados exitosamente",
             "metadataRefreshFailed": "Error al actualizar metadatos: {message}",
             "metadataUpdateComplete": "Actualización de metadatos completada",
+            "operationCancelled": "Operación cancelada por el usuario",
+            "operationCancelledPartial": "Operación cancelada. {success} elementos procesados.",
             "metadataFetchFailed": "Error al obtener metadatos: {message}",
             "bulkMetadataCompleteAll": "Actualizados exitosamente todos los {count} {type}s",
             "bulkMetadataCompletePartial": "Actualizados {success} de {total} {type}s",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "Movimientos fallidos:\n{failures}",
             "bulkMoveSuccess": "Movidos exitosamente {successCount} {type}s",
             "exampleImagesDownloadSuccess": "¡Imágenes de ejemplo descargadas exitosamente!",
-            "exampleImagesDownloadFailed": "Error al descargar imágenes de ejemplo: {message}"
+            "exampleImagesDownloadFailed": "Error al descargar imágenes de ejemplo: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "Corrupción de caché detectada"
+            },
+            "degraded": {
+                "title": "Problemas de caché detectados"
+            },
+            "content": "{invalid} de {total} entradas de caché son inválidas ({rate}). Esto puede causar modelos faltantes o errores. Se recomienda reconstruir la caché.",
+            "rebuildCache": "Reconstruir caché",
+            "dismiss": "Descartar",
+            "rebuilding": "Reconstruyendo caché...",
+            "rebuildFailed": "Error al reconstruir la caché: {error}",
+            "retry": "Reintentar"
         }
     }
 }

locales/fr.json

@@ -10,7 +10,8 @@
             "next": "Suivant",
             "backToTop": "Retour en haut",
             "settings": "Paramètres",
-            "help": "Aide"
+            "help": "Aide",
+            "add": "Ajouter"
         },
         "status": {
             "loading": "Chargement...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "Mise à jour",
             "updateAvailable": "Mise à jour disponible"
+        },
+        "usage": {
+            "timesUsed": "Nombre d'utilisations"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "Réparer les données de recettes",
+            "loading": "Réparation des données de recettes...",
+            "success": "{count} recettes réparées avec succès.",
+            "cancelled": "Réparation annulée. {count} recettes ont été réparées.",
+            "error": "Échec de la réparation des recettes : {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "Créateur",
                 "title": "Titre de la recipe",
                 "loraName": "Nom de fichier LoRA",
-                "loraModel": "Nom du modèle LoRA"
+                "loraModel": "Nom du modèle LoRA",
+                "prompt": "Prompt"
             }
         },
         "filter": {
             "title": "Filtrer les modèles",
+            "presets": "Préréglages",
+            "savePreset": "Enregistrer les filtres actifs comme nouveau préréglage.",
+            "savePresetDisabledActive": "Impossible d'enregistrer : Un préréglage est déjà actif. Modifiez les filtres pour enregistrer un nouveau préréglage",
+            "savePresetDisabledNoFilters": "Sélectionnez d'abord des filtres à enregistrer comme préréglage",
+            "savePresetPrompt": "Entrez le nom du préréglage :",
+            "presetClickTooltip": "Cliquer pour appliquer le préréglage \"{name}\"",
+            "presetDeleteTooltip": "Supprimer le préréglage",
+            "presetDeleteConfirm": "Supprimer le préréglage \"{name}\" ?",
+            "presetDeleteConfirmClick": "Cliquez à nouveau pour confirmer",
+            "presetOverwriteConfirm": "Le préréglage \"{name}\" existe déjà. Remplacer?",
+            "presetNamePlaceholder": "Nom du préréglage...",
             "baseModel": "Modèle de base",
             "modelTags": "Tags (Top 20)",
             "modelTypes": "Model Types",
             "license": "Licence",
             "noCreditRequired": "Crédit non requis",
             "allowSellingGeneratedContent": "Vente autorisée",
-            "clearAll": "Effacer tous les filtres"
+            "noTags": "Aucun tag",
+            "clearAll": "Effacer tous les filtres",
+            "any": "N'importe quel",
+            "all": "Tous",
+            "tagLogicAny": "Correspondre à n'importe quel tag (OU)",
+            "tagLogicAll": "Correspondre à tous les tags (ET)"
         },
         "theme": {
             "toggle": "Basculer le thème",
@@ -221,7 +249,9 @@
             "label": "Ouvrir le dossier des paramètres",
             "tooltip": "Ouvrir le dossier contenant settings.json",
             "success": "Dossier settings.json ouvert",
-            "failed": "Impossible d'ouvrir le dossier settings.json"
+            "failed": "Impossible d'ouvrir le dossier settings.json",
+            "copied": "Chemin des paramètres copié dans le presse-papiers: {{path}}",
+            "clipboardFallback": "Chemin des paramètres: {{path}}"
         },
         "sections": {
             "contentFiltering": "Filtrage du contenu",
@@ -305,6 +335,8 @@
             "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",
             "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",
+            "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",
             "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"
@@ -443,7 +475,10 @@
                 "dateAsc": "Plus ancien",
                 "size": "Taille du fichier",
                 "sizeDesc": "Plus grand",
-                "sizeAsc": "Plus petit"
+                "sizeAsc": "Plus petit",
+                "usage": "Nombre d'utilisations",
+                "usageDesc": "Plus",
+                "usageAsc": "Moins"
             },
             "refresh": {
                 "title": "Actualiser la liste des modèles",
@@ -518,6 +553,7 @@
             "replacePreview": "Remplacer l'aperçu",
             "setContentRating": "Définir la classification du contenu",
             "moveToFolder": "Déplacer vers un dossier",
+            "repairMetadata": "Réparer les métadonnées",
             "excludeModel": "Exclure le modèle",
             "deleteModel": "Supprimer le modèle",
             "shareRecipe": "Partager la recipe",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "Veuillez sélectionner un répertoire racine LoRA"
                 }
             },
+            "sort": {
+                "title": "Trier les recettes par...",
+                "name": "Nom",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "Date",
+                "dateDesc": "Plus récent",
+                "dateAsc": "Plus ancien",
+                "lorasCount": "Nombre de LoRAs",
+                "lorasCountDesc": "Plus",
+                "lorasCountAsc": "Moins"
+            },
             "refresh": {
                 "title": "Actualiser la liste des recipes"
             },
-            "filteredByLora": "Filtré par LoRA"
+            "filteredByLora": "Filtré par LoRA",
+            "favorites": {
+                "title": "Afficher uniquement les favoris",
+                "action": "Favoris"
+            }
         },
         "duplicates": {
             "found": "Trouvé {count} groupes de doublons",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "Aucun LoRA manquant à télécharger",
                 "getInfoFailed": "Échec de l'obtention des informations pour les LoRAs manquants",
                 "prepareError": "Erreur lors de la préparation des LoRAs pour le téléchargement : {message}"
+            },
+            "repair": {
+                "starting": "Réparation des métadonnées de la recette...",
+                "success": "Métadonnées de la recette réparées avec succès",
+                "skipped": "Recette déjà à la version la plus récente, aucune réparation nécessaire",
+                "failed": "Échec de la réparation de la recette : {message}",
+                "missingId": "Impossible de réparer la recette : ID de recette manquant"
             }
         }
     },
     "checkpoints": {
-        "title": "Modèles Checkpoint"
+        "title": "Modèles Checkpoint",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "Déplacer vers le dossier {otherType}"
+        }
     },
     "embeddings": {
         "title": "Modèles Embedding"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "La recherche récursive n'est disponible qu'en vue arborescente",
         "collapseAllDisabled": "Non disponible en vue liste",
         "dragDrop": {
-            "unableToResolveRoot": "Impossible de déterminer le chemin de destination pour le déplacement."
+            "unableToResolveRoot": "Impossible de déterminer le chemin de destination pour le déplacement.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "Emplacement du fichier ouvert avec succès",
-                "failed": "Échec de l'ouverture de l'emplacement du fichier"
+                "failed": "Échec de l'ouverture de l'emplacement du fichier",
+                "copied": "Chemin copié dans le presse-papiers: {{path}}",
+                "clipboardFallback": "Chemin: {{path}}"
             },
             "metadata": {
                 "version": "Version",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "Ajouter un paramètre prédéfini...",
                 "strengthMin": "Force Min",
                 "strengthMax": "Force Max",
+                "strengthRange": "Gamme de force",
                 "strength": "Force",
                 "clipStrength": "Force Clip",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Valeur",
-                "add": "Ajouter"
+                "add": "Ajouter",
+                "invalidRange": "Format de plage invalide. Utilisez x.x-y.y"
             },
             "triggerWords": {
                 "label": "Mots-clés",
@@ -914,6 +985,13 @@
                 "recipes": "Recipes",
                 "versions": "Versions"
             },
+            "navigation": {
+                "label": "Navigation des modèles",
+                "previousWithShortcut": "Modèle précédent (←)",
+                "nextWithShortcut": "Modèle suivant (→)",
+                "noPrevious": "Aucun modèle précédent",
+                "noNext": "Aucun modèle suivant"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "Dossier d'images d'exemple ouvert",
             "openingFolder": "Ouverture du dossier d'images d'exemple",
-            "failedToOpen": "Échec de l'ouverture du dossier d'images d'exemple"
+            "failedToOpen": "Échec de l'ouverture du dossier d'images d'exemple",
+            "setupRequired": "Stockage d'images d'exemple",
+            "setupDescription": "Pour ajouter des images d'exemple personnalisées, vous devez d'abord définir un emplacement de téléchargement.",
+            "setupUsage": "Ce chemin est utilisé pour les images d'exemple téléchargées et personnalisées.",
+            "openSettings": "Ouvrir les paramètres"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "Vérification des mises à jour...",
         "checkingMessage": "Veuillez patienter pendant la vérification de la dernière version.",
         "showNotifications": "Afficher les notifications de mise à jour",
+        "latestBadge": "Dernier",
         "updateProgress": {
             "preparing": "Préparation de la mise à jour...",
             "installing": "Installation de la mise à jour...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "Vérification terminée. Tous les fichiers sont confirmés comme doublons.",
             "verificationFailed": "Échec de la vérification des hash : {message}",
             "noTagsToAdd": "Aucun tag à ajouter",
+            "bulkTagsUpdating": "Mise à jour des tags pour {count} modèle(s)...",
             "tagsAddedSuccessfully": "{tagCount} tag(s) ajouté(s) avec succès à {count} {type}(s)",
             "tagsReplacedSuccessfully": "Tags remplacés avec succès pour {count} {type}(s) avec {tagCount} tag(s)",
             "tagsAddFailed": "Échec de l'ajout des tags à {count} modèle(s)",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "Échec du chargement des racines LoRA : {message}",
             "checkpointRootsFailed": "Échec du chargement des racines checkpoint : {message}",
+            "unetRootsFailed": "Échec du chargement des racines Diffusion Model : {message}",
             "embeddingRootsFailed": "Échec du chargement des racines embedding : {message}",
             "mappingsUpdated": "Mappages de chemin de modèle de base mis à jour ({count} mappage{plural})",
             "mappingsCleared": "Mappages de chemin de modèle de base effacés",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "Filtres effacés",
-            "noCustomFilterToClear": "Aucun filtre personnalisé à effacer"
+            "noCustomFilterToClear": "Aucun filtre personnalisé à effacer",
+            "noActiveFilters": "Aucun filtre actif à enregistrer"
+        },
+        "presets": {
+            "created": "Préréglage \"{name}\" créé",
+            "deleted": "Préréglage \"{name}\" supprimé",
+            "applied": "Préréglage \"{name}\" appliqué",
+            "overwritten": "Préréglage \"{name}\" remplacé",
+            "restored": "Paramètres par défaut restaurés"
+        },
+        "error": {
+            "presetNameEmpty": "Le nom du préréglage ne peut pas être vide",
+            "presetNameTooLong": "Le nom du préréglage doit contenir au maximum {max} caractères",
+            "presetNameInvalidChars": "Le nom du préréglage contient des caractères invalides",
+            "presetNameExists": "Un préréglage avec ce nom existe déjà",
+            "maxPresetsReached": "Maximum {max} préréglages autorisés. Supprimez-en un pour en ajouter plus.",
+            "presetNotFound": "Préréglage non trouvé",
+            "invalidPreset": "Données de préréglage invalides",
+            "deletePresetFailed": "Échec de la suppression du préréglage",
+            "applyPresetFailed": "Échec de l'application du préréglage"
         },
         "downloads": {
             "imagesCompleted": "Images d'exemple {action} terminées",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "Métadonnées actualisées avec succès",
             "metadataRefreshFailed": "Échec de l'actualisation des métadonnées : {message}",
             "metadataUpdateComplete": "Mise à jour des métadonnées terminée",
+            "operationCancelled": "Opération annulée par l'utilisateur",
+            "operationCancelledPartial": "Opération annulée. {success} éléments traités.",
             "metadataFetchFailed": "Échec de la récupération des métadonnées : {message}",
             "bulkMetadataCompleteAll": "Actualisation réussie de tous les {count} {type}s",
             "bulkMetadataCompletePartial": "{success} sur {total} {type}s actualisés",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "Échecs de déplacement :\n{failures}",
             "bulkMoveSuccess": "{successCount} {type}s déplacés avec succès",
             "exampleImagesDownloadSuccess": "Images d'exemple téléchargées avec succès !",
-            "exampleImagesDownloadFailed": "Échec du téléchargement des images d'exemple : {message}"
+            "exampleImagesDownloadFailed": "Échec du téléchargement des images d'exemple : {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "Corruption du cache détectée"
+            },
+            "degraded": {
+                "title": "Problèmes de cache détectés"
+            },
+            "content": "{invalid} des {total} entrées de cache sont invalides ({rate}). Cela peut provoquer des modèles manquants ou des erreurs. Il est recommandé de reconstruire le cache.",
+            "rebuildCache": "Reconstruire le cache",
+            "dismiss": "Ignorer",
+            "rebuilding": "Reconstruction du cache...",
+            "rebuildFailed": "Échec de la reconstruction du cache : {error}",
+            "retry": "Réessayer"
         }
     }
 }

locales/he.json

@@ -10,7 +10,8 @@
             "next": "הבא",
             "backToTop": "חזור למעלה",
             "settings": "הגדרות",
-            "help": "עזרה"
+            "help": "עזרה",
+            "add": "הוסף"
         },
         "status": {
             "loading": "טוען...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "עדכון",
             "updateAvailable": "עדכון זמין"
+        },
+        "usage": {
+            "timesUsed": "מספר שימושים"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "תיקון נתוני מתכונים",
+            "loading": "מתקן נתוני מתכונים...",
+            "success": "תוקנו בהצלחה {count} מתכונים.",
+            "cancelled": "תיקון בוטל. {count} מתכונים תוקנו.",
+            "error": "תיקון המתכונים נכשל: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "יוצר",
                 "title": "כותרת מתכון",
                 "loraName": "שם קובץ LoRA",
-                "loraModel": "שם מודל LoRA"
+                "loraModel": "שם מודל LoRA",
+                "prompt": "הנחיה"
             }
         },
         "filter": {
             "title": "סנן מודלים",
+            "presets": "קביעות מראש",
+            "savePreset": "שמור מסננים פעילים כקביעה מראש חדשה.",
+            "savePresetDisabledActive": "לא ניתן לשמור: קביעה מראש כבר פעילה. שנה מסננים כדי לשמור קביעה מראש חדשה",
+            "savePresetDisabledNoFilters": "בחר מסננים תחילה כדי לשמור כקביעה מראש",
+            "savePresetPrompt": "הזן שם קביעה מראש:",
+            "presetClickTooltip": "לחץ כדי להפעיל קביעה מראש \"{name}\"",
+            "presetDeleteTooltip": "מחק קביעה מראש",
+            "presetDeleteConfirm": "למחוק קביעה מראש \"{name}\"?",
+            "presetDeleteConfirmClick": "לחץ שוב לאישור",
+            "presetOverwriteConfirm": "הפריסט \"{name}\" כבר קיים. לדרוס?",
+            "presetNamePlaceholder": "שם קביעה מראש...",
             "baseModel": "מודל בסיס",
             "modelTags": "תגיות (20 המובילות)",
             "modelTypes": "Model Types",
             "license": "רישיון",
             "noCreditRequired": "ללא קרדיט נדרש",
             "allowSellingGeneratedContent": "אפשר מכירה",
-            "clearAll": "נקה את כל המסננים"
+            "noTags": "ללא תגיות",
+            "clearAll": "נקה את כל המסננים",
+            "any": "כלשהו",
+            "all": "כל התגים",
+            "tagLogicAny": "התאם כל תג (או)",
+            "tagLogicAll": "התאם את כל התגים (וגם)"
         },
         "theme": {
             "toggle": "החלף ערכת נושא",
@@ -221,13 +249,16 @@
             "label": "פתח תיקיית הגדרות",
             "tooltip": "פתח את התיקייה שמכילה את ‎settings.json",
             "success": "תיקיית settings.json נפתחה",
-            "failed": "לא ניתן לפתוח את תיקיית settings.json"
+            "failed": "לא ניתן לפתוח את תיקיית settings.json",
+            "copied": "נתיב ההגדרות הועתק ללוח העריכה: {{path}}",
+            "clipboardFallback": "נתיב ההגדרות: {{path}}"
         },
         "sections": {
             "contentFiltering": "סינון תוכן",
             "videoSettings": "הגדרות וידאו",
             "layoutSettings": "הגדרות פריסה",
             "folderSettings": "הגדרות תיקייה",
+            "priorityTags": "תגיות עדיפות",
             "downloadPathTemplates": "תבניות נתיב הורדה",
             "exampleImages": "תמונות דוגמה",
             "updateFlags": "תגי עדכון",
@@ -235,8 +266,7 @@
             "misc": "שונות",
             "metadataArchive": "מסד נתונים של ארכיון מטא-דאטה",
             "storageLocation": "מיקום ההגדרות",
-            "proxySettings": "הגדרות פרוקסי",
-            "priorityTags": "תגיות עדיפות"
+            "proxySettings": "הגדרות פרוקסי"
         },
         "storage": {
             "locationLabel": "מצב נייד",
@@ -298,17 +328,39 @@
         },
         "folderSettings": {
             "activeLibrary": "ספרייה פעילה",
-            "activeLibraryHelp": "החלפה בין הספריות המוגדרות תעדכן את תיקיות ברירת המחדל. שינוי הבחירה ירענן את הדף.",
+            "activeLibraryHelp": "החלפה בין הספריות המוגדרות לעדכן את תיקיות ברירת המחדל. שינוי הבחירה ירענן את הדף.",
             "loadingLibraries": "טוען ספריות...",
             "noLibraries": "לא הוגדרו ספריות",
             "defaultLoraRoot": "תיקיית שורש ברירת מחדל של LoRA",
             "defaultLoraRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של LoRA להורדות, ייבוא והעברות",
             "defaultCheckpointRoot": "תיקיית שורש ברירת מחדל של Checkpoint",
             "defaultCheckpointRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של checkpoint להורדות, ייבוא והעברות",
+            "defaultUnetRoot": "תיקיית שורש ברירת מחדל של Diffusion Model",
+            "defaultUnetRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של Diffusion Model (UNET) להורדות, ייבוא והעברות",
             "defaultEmbeddingRoot": "תיקיית שורש ברירת מחדל של Embedding",
             "defaultEmbeddingRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של embedding להורדות, ייבוא והעברות",
             "noDefault": "אין ברירת מחדל"
         },
+        "priorityTags": {
+            "title": "תגיות עדיפות",
+            "description": "התאם את סדר העדיפות של התגיות עבור כל סוג מודל (לדוגמה: character, concept, style(toon|toon_style))",
+            "placeholder": "character, concept, style(toon|toon_style)",
+            "helpLinkLabel": "פתח עזרה בנושא תגיות עדיפות",
+            "modelTypes": {
+                "lora": "LoRA",
+                "checkpoint": "Checkpoint",
+                "embedding": "Embedding"
+            },
+            "saveSuccess": "תגיות העדיפות עודכנו.",
+            "saveError": "עדכון תגיות העדיפות נכשל.",
+            "loadingSuggestions": "טוען הצעות...",
+            "validation": {
+                "missingClosingParen": "לרשומה {index} חסר סוגר סוגריים.",
+                "missingCanonical": "על הרשומה {index} לכלול שם תגית קנונית.",
+                "duplicateCanonical": "התגית הקנונית \"{tag}\" מופיעה יותר מפעם אחת.",
+                "unknown": "תצורת תגיות העדיפות שגויה."
+            }
+        },
         "downloadPathTemplates": {
             "title": "תבניות נתיב הורדה",
             "help": "הגדר מבני תיקיות לסוגי מודלים שונים בעת הורדה מ-Civitai.",
@@ -320,8 +372,8 @@
                 "byFirstTag": "לפי תגית ראשונה",
                 "baseModelFirstTag": "מודל בסיס + תגית ראשונה",
                 "baseModelAuthor": "מודל בסיס + יוצר",
-                "baseModelAuthorFirstTag": "מודל בסיס + יוצר + תגית ראשונה",
                 "authorFirstTag": "יוצר + תגית ראשונה",
+                "baseModelAuthorFirstTag": "מודל בסיס + יוצר + תגית ראשונה",
                 "customTemplate": "תבנית מותאמת אישית"
             },
             "customTemplatePlaceholder": "הזן תבנית מותאמת אישית (למשל, {base_model}/{author}/{first_tag})",
@@ -409,26 +461,6 @@
             "proxyPassword": "סיסמה (אופציונלי)",
             "proxyPasswordPlaceholder": "password",
             "proxyPasswordHelp": "סיסמה לאימות מול הפרוקסי (אם נדרש)"
-        },
-        "priorityTags": {
-            "title": "תגיות עדיפות",
-            "description": "התאם את סדר העדיפות של התגיות עבור כל סוג מודל (לדוגמה: character, concept, style(toon|toon_style))",
-            "placeholder": "character, concept, style(toon|toon_style)",
-            "helpLinkLabel": "פתח עזרה בנושא תגיות עדיפות",
-            "modelTypes": {
-                "lora": "LoRA",
-                "checkpoint": "Checkpoint",
-                "embedding": "Embedding"
-            },
-            "saveSuccess": "תגיות העדיפות עודכנו.",
-            "saveError": "עדכון תגיות העדיפות נכשל.",
-            "loadingSuggestions": "טוען הצעות...",
-            "validation": {
-                "missingClosingParen": "לרשומה {index} חסר סוגר סוגריים.",
-                "missingCanonical": "על הרשומה {index} לכלול שם תגית קנונית.",
-                "duplicateCanonical": "התגית הקנונית \"{tag}\" מופיעה יותר מפעם אחת.",
-                "unknown": "תצורת תגיות העדיפות שגויה."
-            }
         }
     },
     "loras": {
@@ -443,7 +475,10 @@
                 "dateAsc": "הישן ביותר",
                 "size": "גודל קובץ",
                 "sizeDesc": "הגדול ביותר",
-                "sizeAsc": "הקטן ביותר"
+                "sizeAsc": "הקטן ביותר",
+                "usage": "מספר שימושים",
+                "usageDesc": "הכי הרבה",
+                "usageAsc": "הכי פחות"
             },
             "refresh": {
                 "title": "רענן רשימת מודלים",
@@ -518,6 +553,7 @@
             "replacePreview": "החלף תצוגה מקדימה",
             "setContentRating": "הגדר דירוג תוכן",
             "moveToFolder": "העבר לתיקייה",
+            "repairMetadata": "תיקון מטא-דאטה",
             "excludeModel": "החרג מודל",
             "deleteModel": "מחק מודל",
             "shareRecipe": "שתף מתכון",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "אנא בחר ספריית שורש של LoRA"
                 }
             },
+            "sort": {
+                "title": "מיון מתכונים לפי...",
+                "name": "שם",
+                "nameAsc": "א - ת",
+                "nameDesc": "ת - א",
+                "date": "תאריך",
+                "dateDesc": "הכי חדש",
+                "dateAsc": "הכי ישן",
+                "lorasCount": "מספר LoRAs",
+                "lorasCountDesc": "הכי הרבה",
+                "lorasCountAsc": "הכי פחות"
+            },
             "refresh": {
                 "title": "רענן רשימת מתכונים"
             },
-            "filteredByLora": "מסונן לפי LoRA"
+            "filteredByLora": "מסונן לפי LoRA",
+            "favorites": {
+                "title": "הצג מועדפים בלבד",
+                "action": "מועדפים"
+            }
         },
         "duplicates": {
             "found": "נמצאו {count} קבוצות כפולות",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "אין LoRAs חסרים להורדה",
                 "getInfoFailed": "קבלת מידע עבור LoRAs חסרים נכשלה",
                 "prepareError": "שגיאה בהכנת LoRAs להורדה: {message}"
+            },
+            "repair": {
+                "starting": "מתקן מטא-דאטה של מתכון...",
+                "success": "מטא-דאטה של מתכון תוקן בהצלחה",
+                "skipped": "המתכון כבר בגרסה העדכנית ביותר, אין צורך בתיקון",
+                "failed": "תיקון המתכון נכשל: {message}",
+                "missingId": "לא ניתן לתקן את המתכון: חסר מזהה מתכון"
             }
         }
     },
     "checkpoints": {
-        "title": "מודלי Checkpoint"
+        "title": "מודלי Checkpoint",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "העבר לתיקיית {otherType}"
+        }
     },
     "embeddings": {
         "title": "מודלי Embedding"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "חיפוש רקורסיבי זמין רק בתצוגת עץ",
         "collapseAllDisabled": "לא זמין בתצוגת רשימה",
         "dragDrop": {
-            "unableToResolveRoot": "לא ניתן לקבוע את נתיב היעד להעברה."
+            "unableToResolveRoot": "לא ניתן לקבוע את נתיב היעד להעברה.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "מיקום הקובץ נפתח בהצלחה",
-                "failed": "פתיחת מיקום הקובץ נכשלה"
+                "failed": "פתיחת מיקום הקובץ נכשלה",
+                "copied": "הנתיב הועתק ללוח העריכה: {{path}}",
+                "clipboardFallback": "נתיב: {{path}}"
             },
             "metadata": {
                 "version": "גרסה",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "הוסף פרמטר קבוע מראש...",
                 "strengthMin": "חוזק מינימלי",
                 "strengthMax": "חוזק מקסימלי",
+                "strengthRange": "טווח עוצמה",
                 "strength": "חוזק",
                 "clipStrength": "עוצמת CLIP",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "ערך",
-                "add": "הוסף"
+                "add": "הוסף",
+                "invalidRange": "פורמט טווח לא תקין. השתמש ב-x.x-y.y"
             },
             "triggerWords": {
                 "label": "מילות טריגר",
@@ -914,6 +985,13 @@
                 "recipes": "מתכונים",
                 "versions": "גרסאות"
             },
+            "navigation": {
+                "label": "ניווט מודלים",
+                "previousWithShortcut": "המודל הקודם (←)",
+                "nextWithShortcut": "המודל הבא (→)",
+                "noPrevious": "אין מודל קודם זמין",
+                "noNext": "אין מודל נוסף זמין"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "תיקיית תמונות הדוגמה נפתחה",
             "openingFolder": "פותח תיקיית תמונות דוגמה",
-            "failedToOpen": "פתיחת תיקיית תמונות הדוגמה נכשלה"
+            "failedToOpen": "פתיחת תיקיית תמונות הדוגמה נכשלה",
+            "setupRequired": "אחסון תמונות דוגמה",
+            "setupDescription": "כדי להוסיף תמונות דוגמה מותאמות אישית, עליך קודם להגדיר מיקום הורדה.",
+            "setupUsage": "נתיב זה משמש הן עבור תמונות דוגמה שהורדו והן עבור תמונות מותאמות אישית.",
+            "openSettings": "פתח הגדרות"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "בודק עדכונים...",
         "checkingMessage": "אנא המתן בזמן שאנו בודקים את הגרסה האחרונה.",
         "showNotifications": "הצג התראות עדכון",
+        "latestBadge": "עדכן",
         "updateProgress": {
             "preparing": "מכין עדכון...",
             "installing": "מתקין עדכון...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "האימות הושלם. כל הקבצים אושרו ככפולים.",
             "verificationFailed": "אימות ה-hashes נכשל: {message}",
             "noTagsToAdd": "אין תגיות להוספה",
+            "bulkTagsUpdating": "מעדכן תגיות עבור {count} מודלים...",
             "tagsAddedSuccessfully": "נוספו בהצלחה {tagCount} תגית(ות) ל-{count} {type}(ים)",
             "tagsReplacedSuccessfully": "הוחלפו בהצלחה תגיות עבור {count} {type}(ים) ב-{tagCount} תגית(ות)",
             "tagsAddFailed": "הוספת תגיות ל-{count} מודל(ים) נכשלה",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "טעינת שורשי LoRA נכשלה: {message}",
             "checkpointRootsFailed": "טעינת שורשי checkpoint נכשלה: {message}",
+            "unetRootsFailed": "טעינת שורשי Diffusion Model נכשלה: {message}",
             "embeddingRootsFailed": "טעינת שורשי embedding נכשלה: {message}",
             "mappingsUpdated": "מיפויי נתיבי מודל בסיס עודכנו ({count} מיפוי{plural})",
             "mappingsCleared": "מיפויי נתיבי מודל בסיס נוקו",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "המסננים נוקו",
-            "noCustomFilterToClear": "אין מסנן מותאם אישית לניקוי"
+            "noCustomFilterToClear": "אין מסנן מותאם אישית לניקוי",
+            "noActiveFilters": "אין מסננים פעילים לשמירה"
+        },
+        "presets": {
+            "created": "קביעה מראש \"{name}\" נוצרה",
+            "deleted": "קביעה מראש \"{name}\" נמחקה",
+            "applied": "קביעה מראש \"{name}\" הופעלה",
+            "overwritten": "קביעה מראש \"{name}\" נדרסה",
+            "restored": "ברירות המחדל שוחזרו"
+        },
+        "error": {
+            "presetNameEmpty": "שם קביעה מראש לא יכול להיות ריק",
+            "presetNameTooLong": "שם קביעה מראש חייב להיות {max} תווים או פחות",
+            "presetNameInvalidChars": "שם קביעה מראש מכיל תווים לא חוקיים",
+            "presetNameExists": "קביעה מראש עם שם זה כבר קיימת",
+            "maxPresetsReached": "מותר מקסימום {max} קביעות מראש. מחק אחת כדי להוסיף עוד.",
+            "presetNotFound": "קביעה מראש לא נמצאה",
+            "invalidPreset": "נתוני קביעה מראש לא חוקיים",
+            "deletePresetFailed": "מחיקת קביעה מראש נכשלה",
+            "applyPresetFailed": "הפעלת קביעה מראש נכשלה"
         },
         "downloads": {
             "imagesCompleted": "{action} תמונות הדוגמה הושלם",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "המטא-דאטה רועננה בהצלחה",
             "metadataRefreshFailed": "רענון המטא-דאטה נכשל: {message}",
             "metadataUpdateComplete": "עדכון המטא-דאטה הושלם",
+            "operationCancelled": "הפעולה בוטלה על ידי המשתמש",
+            "operationCancelledPartial": "הפעולה בוטלה. {success} פריטים עובדו.",
             "metadataFetchFailed": "אחזור המטא-דאטה נכשל: {message}",
             "bulkMetadataCompleteAll": "רועננו בהצלחה כל {count} ה-{type}s",
             "bulkMetadataCompletePartial": "רועננו {success} מתוך {total} {type}s",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "העברות שנכשלו:\n{failures}",
             "bulkMoveSuccess": "הועברו בהצלחה {successCount} {type}s",
             "exampleImagesDownloadSuccess": "תמונות הדוגמה הורדו בהצלחה!",
-            "exampleImagesDownloadFailed": "הורדת תמונות הדוגמה נכשלה: {message}"
+            "exampleImagesDownloadFailed": "הורדת תמונות הדוגמה נכשלה: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "זוהתה שחיתות במטמון"
+            },
+            "degraded": {
+                "title": "זוהו בעיות במטמון"
+            },
+            "content": "{invalid} מתוך {total} רשומות מטמון אינן תקינות ({rate}). זה עלול לגרום לדגמים חסרים או לשגיאות. מומלץ לבנות מחדש את המטמון.",
+            "rebuildCache": "בניית מטמון מחדש",
+            "dismiss": "ביטול",
+            "rebuilding": "בונה מחדש את המטמון...",
+            "rebuildFailed": "נכשלה בניית המטמון מחדש: {error}",
+            "retry": "נסה שוב"
         }
     }
 }

locales/ja.json

@@ -10,7 +10,8 @@
             "next": "次へ",
             "backToTop": "トップに戻る",
             "settings": "設定",
-            "help": "ヘルプ"
+            "help": "ヘルプ",
+            "add": "追加"
         },
         "status": {
             "loading": "読み込み中...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "アップデート",
             "updateAvailable": "アップデートがあります"
+        },
+        "usage": {
+            "timesUsed": "使用回数"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "レシピデータの修復",
+            "loading": "レシピデータを修復中...",
+            "success": "{count} 件のレシピを正常に修復しました。",
+            "cancelled": "修復がキャンセルされました。{count}個のレシピが修復されました。",
+            "error": "レシピの修復に失敗しました: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "作成者",
                 "title": "レシピタイトル",
                 "loraName": "LoRAファイル名",
-                "loraModel": "LoRAモデル名"
+                "loraModel": "LoRAモデル名",
+                "prompt": "プロンプト"
             }
         },
         "filter": {
             "title": "モデルをフィルタ",
+            "presets": "プリセット",
+            "savePreset": "現在のアクティブフィルタを新しいプリセットとして保存。",
+            "savePresetDisabledActive": "保存できません：プリセットがすでにアクティブです。フィルタを変更して新しいプリセットを保存してください",
+            "savePresetDisabledNoFilters": "先にフィルタを選択してからプリセットとして保存",
+            "savePresetPrompt": "プリセット名を入力：",
+            "presetClickTooltip": "プリセット \"{name}\" を適用するにはクリック",
+            "presetDeleteTooltip": "プリセットを削除",
+            "presetDeleteConfirm": "プリセット \"{name}\" を削除しますか？",
+            "presetDeleteConfirmClick": "もう一度クリックして確認",
+            "presetOverwriteConfirm": "プリセット「{name}」は既に存在します。上書きしますか？",
+            "presetNamePlaceholder": "プリセット名...",
             "baseModel": "ベースモデル",
             "modelTags": "タグ（上位20）",
             "modelTypes": "Model Types",
             "license": "ライセンス",
             "noCreditRequired": "クレジット不要",
             "allowSellingGeneratedContent": "販売許可",
-            "clearAll": "すべてのフィルタをクリア"
+            "noTags": "タグなし",
+            "clearAll": "すべてのフィルタをクリア",
+            "any": "いずれか",
+            "all": "すべて",
+            "tagLogicAny": "いずれかのタグに一致 (OR)",
+            "tagLogicAll": "すべてのタグに一致 (AND)"
         },
         "theme": {
             "toggle": "テーマの切り替え",
@@ -221,7 +249,9 @@
             "label": "設定フォルダーを開く",
             "tooltip": "settings.json を含むフォルダーを開きます",
             "success": "settings.json フォルダーを開きました",
-            "failed": "settings.json フォルダーを開けませんでした"
+            "failed": "settings.json フォルダーを開けませんでした",
+            "copied": "設定パスをクリップボードにコピーしました: {{path}}",
+            "clipboardFallback": "設定パス: {{path}}"
         },
         "sections": {
             "contentFiltering": "コンテンツフィルタリング",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "ダウンロード、インポート、移動用のデフォルトLoRAルートディレクトリを設定",
             "defaultCheckpointRoot": "デフォルトCheckpointルート",
             "defaultCheckpointRootHelp": "ダウンロード、インポート、移動用のデフォルトcheckpointルートディレクトリを設定",
+            "defaultUnetRoot": "デフォルトDiffusion Modelルート",
+            "defaultUnetRootHelp": "ダウンロード、インポート、移動用のデフォルトDiffusion Model (UNET)ルートディレクトリを設定",
             "defaultEmbeddingRoot": "デフォルトEmbeddingルート",
             "defaultEmbeddingRootHelp": "ダウンロード、インポート、移動用のデフォルトembeddingルートディレクトリを設定",
             "noDefault": "デフォルトなし"
@@ -443,7 +475,10 @@
                 "dateAsc": "古い順",
                 "size": "ファイルサイズ",
                 "sizeDesc": "大きい順",
-                "sizeAsc": "小さい順"
+                "sizeAsc": "小さい順",
+                "usage": "使用回数",
+                "usageDesc": "多い",
+                "usageAsc": "少ない"
             },
             "refresh": {
                 "title": "モデルリストを更新",
@@ -518,6 +553,7 @@
             "replacePreview": "プレビューを置換",
             "setContentRating": "コンテンツレーティングを設定",
             "moveToFolder": "フォルダに移動",
+            "repairMetadata": "メタデータを修復",
             "excludeModel": "モデルを除外",
             "deleteModel": "モデルを削除",
             "shareRecipe": "レシピを共有",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "LoRAルートディレクトリを選択してください"
                 }
             },
+            "sort": {
+                "title": "レシピの並び替え...",
+                "name": "名前",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "日付",
+                "dateDesc": "新しい順",
+                "dateAsc": "古い順",
+                "lorasCount": "LoRA数",
+                "lorasCountDesc": "多い順",
+                "lorasCountAsc": "少ない順"
+            },
             "refresh": {
                 "title": "レシピリストを更新"
             },
-            "filteredByLora": "LoRAでフィルタ済み"
+            "filteredByLora": "LoRAでフィルタ済み",
+            "favorites": {
+                "title": "お気に入りのみ表示",
+                "action": "お気に入り"
+            }
         },
         "duplicates": {
             "found": "{count} 個の重複グループが見つかりました",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "ダウンロードする不足LoRAがありません",
                 "getInfoFailed": "不足LoRAの情報取得に失敗しました",
                 "prepareError": "ダウンロード用LoRAの準備中にエラー：{message}"
+            },
+            "repair": {
+                "starting": "レシピのメタデータを修復中...",
+                "success": "レシピのメタデータが正常に修復されました",
+                "skipped": "レシピはすでに最新バージョンです。修復は不要です",
+                "failed": "レシピの修復に失敗しました: {message}",
+                "missingId": "レシピを修復できません: レシピIDがありません"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpointモデル"
+        "title": "Checkpointモデル",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "{otherType} フォルダに移動"
+        }
     },
     "embeddings": {
         "title": "Embeddingモデル"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "再帰検索はツリービューでのみ利用できます",
         "collapseAllDisabled": "リストビューでは利用できません",
         "dragDrop": {
-            "unableToResolveRoot": "移動先のパスを特定できません。"
+            "unableToResolveRoot": "移動先のパスを特定できません。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "ファイルの場所を正常に開きました",
-                "failed": "ファイルの場所を開くのに失敗しました"
+                "failed": "ファイルの場所を開くのに失敗しました",
+                "copied": "パスをクリップボードにコピーしました: {{path}}",
+                "clipboardFallback": "パス: {{path}}"
             },
             "metadata": {
                 "version": "バージョン",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "プリセットパラメータを追加...",
                 "strengthMin": "強度最小",
                 "strengthMax": "強度最大",
+                "strengthRange": "強度範囲",
                 "strength": "強度",
                 "clipStrength": "クリップ強度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "値",
-                "add": "追加"
+                "add": "追加",
+                "invalidRange": "無効な範囲形式です。x.x-y.y を使用してください"
             },
             "triggerWords": {
                 "label": "トリガーワード",
@@ -914,6 +985,13 @@
                 "recipes": "レシピ",
                 "versions": "バージョン"
             },
+            "navigation": {
+                "label": "モデルナビゲーション",
+                "previousWithShortcut": "前のモデル（←）",
+                "nextWithShortcut": "次のモデル（→）",
+                "noPrevious": "前のモデルがありません",
+                "noNext": "次のモデルがありません"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "例画像フォルダが開かれました",
             "openingFolder": "例画像フォルダを開いています",
-            "failedToOpen": "例画像フォルダを開くのに失敗しました"
+            "failedToOpen": "例画像フォルダを開くのに失敗しました",
+            "setupRequired": "例画像ストレージ",
+            "setupDescription": "カスタム例画像を追加するには、まずダウンロード場所を設定する必要があります。",
+            "setupUsage": "このパスは、ダウンロードした例画像とカスタム画像の両方に使用されます。",
+            "openSettings": "設定を開く"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "更新を確認中...",
         "checkingMessage": "最新バージョンを確認しています。お待ちください。",
         "showNotifications": "更新通知を表示",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "更新を準備中...",
             "installing": "更新をインストール中...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "検証完了。すべてのファイルが重複であることが確認されました。",
             "verificationFailed": "ハッシュの検証に失敗しました：{message}",
             "noTagsToAdd": "追加するタグがありません",
+            "bulkTagsUpdating": "{count} 個のモデルのタグを更新しています...",
             "tagsAddedSuccessfully": "{count} {type} に {tagCount} 個のタグを追加しました",
             "tagsReplacedSuccessfully": "{count} {type} のタグを {tagCount} 個に置換しました",
             "tagsAddFailed": "{count} モデルへのタグ追加に失敗しました",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "LoRAルートの読み込みに失敗しました：{message}",
             "checkpointRootsFailed": "checkpointルートの読み込みに失敗しました：{message}",
+            "unetRootsFailed": "Diffusion Modelルートの読み込みに失敗しました：{message}",
             "embeddingRootsFailed": "embeddingルートの読み込みに失敗しました：{message}",
             "mappingsUpdated": "ベースモデルパスマッピングが更新されました（{count} マッピング{plural}）",
             "mappingsCleared": "ベースモデルパスマッピングがクリアされました",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "フィルタがクリアされました",
-            "noCustomFilterToClear": "クリアするカスタムフィルタがありません"
+            "noCustomFilterToClear": "クリアするカスタムフィルタがありません",
+            "noActiveFilters": "保存するアクティブフィルタがありません"
+        },
+        "presets": {
+            "created": "プリセット \"{name}\" が作成されました",
+            "deleted": "プリセット \"{name}\" が削除されました",
+            "applied": "プリセット \"{name}\" が適用されました",
+            "overwritten": "プリセット「{name}」を上書きしました",
+            "restored": "デフォルトのプリセットを復元しました"
+        },
+        "error": {
+            "presetNameEmpty": "プリセット名を入力してください",
+            "presetNameTooLong": "プリセット名は{max}文字以内にしてください",
+            "presetNameInvalidChars": "プリセット名に使用できない文字が含まれています",
+            "presetNameExists": "同じ名前のプリセットが既に存在します",
+            "maxPresetsReached": "プリセットは最大{max}個までです。追加するには既存のものを削除してください。",
+            "presetNotFound": "プリセットが見つかりません",
+            "invalidPreset": "無効なプリセットデータです",
+            "deletePresetFailed": "プリセットの削除に失敗しました",
+            "applyPresetFailed": "プリセットの適用に失敗しました"
         },
         "downloads": {
             "imagesCompleted": "例画像 {action} が完了しました",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "メタデータが正常に更新されました",
             "metadataRefreshFailed": "メタデータの更新に失敗しました：{message}",
             "metadataUpdateComplete": "メタデータ更新完了",
+            "operationCancelled": "ユーザーによって操作がキャンセルされました",
+            "operationCancelledPartial": "操作がキャンセルされました。{success} 個の項目が処理されました。",
             "metadataFetchFailed": "メタデータの取得に失敗しました：{message}",
             "bulkMetadataCompleteAll": "{count} {type}すべてが正常に更新されました",
             "bulkMetadataCompletePartial": "{total} {type}のうち {success} が更新されました",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "失敗した移動：\n{failures}",
             "bulkMoveSuccess": "{successCount} {type}が正常に移動されました",
             "exampleImagesDownloadSuccess": "例画像が正常にダウンロードされました！",
-            "exampleImagesDownloadFailed": "例画像のダウンロードに失敗しました：{message}"
+            "exampleImagesDownloadFailed": "例画像のダウンロードに失敗しました：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "キャッシュの破損が検出されました"
+            },
+            "degraded": {
+                "title": "キャッシュの問題が検出されました"
+            },
+            "content": "{total}個のキャッシュエントリのうち{invalid}個が無効です（{rate}）。モデルが見つからない原因になったり、エラーが発生する可能性があります。キャッシュの再構築を推奨します。",
+            "rebuildCache": "キャッシュを再構築",
+            "dismiss": "閉じる",
+            "rebuilding": "キャッシュを再構築中...",
+            "rebuildFailed": "キャッシュの再構築に失敗しました: {error}",
+            "retry": "再試行"
         }
     }
 }

locales/ko.json

@@ -10,7 +10,8 @@
             "next": "다음",
             "backToTop": "맨 위로",
             "settings": "설정",
-            "help": "도움말"
+            "help": "도움말",
+            "add": "추가"
         },
         "status": {
             "loading": "로딩 중...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "업데이트",
             "updateAvailable": "업데이트 가능"
+        },
+        "usage": {
+            "timesUsed": "사용 횟수"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "레시피 데이터 복구",
+            "loading": "레시피 데이터 복구 중...",
+            "success": "{count}개의 레시피가 성공적으로 복구되었습니다.",
+            "cancelled": "수리가 취소되었습니다. {count}개의 레시피가 수리되었습니다.",
+            "error": "레시피 복구 실패: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "제작자",
                 "title": "레시피 제목",
                 "loraName": "LoRA 파일명",
-                "loraModel": "LoRA 모델명"
+                "loraModel": "LoRA 모델명",
+                "prompt": "프롬프트"
             }
         },
         "filter": {
             "title": "모델 필터",
+            "presets": "프리셋",
+            "savePreset": "현재 활성 필터를 새 프리셋으로 저장.",
+            "savePresetDisabledActive": "저장할 수 없음: 프리셋이 이미 활성화되어 있습니다. 필터를 수정한 후 새 프리셋을 저장하세요",
+            "savePresetDisabledNoFilters": "먼저 필터를 선택한 후 프리셋으로 저장",
+            "savePresetPrompt": "프리셋 이름 입력:",
+            "presetClickTooltip": "프리셋 \"{name}\" 적용하려면 클릭",
+            "presetDeleteTooltip": "프리셋 삭제",
+            "presetDeleteConfirm": "프리셋 \"{name}\" 삭제하시겠습니까?",
+            "presetDeleteConfirmClick": "다시 클릭하여 확인",
+            "presetOverwriteConfirm": "프리셋 \"{name}\"이(가) 이미 존재합니다. 덮어쓰시겠습니까?",
+            "presetNamePlaceholder": "프리셋 이름...",
             "baseModel": "베이스 모델",
             "modelTags": "태그 (상위 20개)",
             "modelTypes": "Model Types",
             "license": "라이선스",
             "noCreditRequired": "크레딧 표기 없음",
             "allowSellingGeneratedContent": "판매 허용",
-            "clearAll": "모든 필터 지우기"
+            "noTags": "태그 없음",
+            "clearAll": "모든 필터 지우기",
+            "any": "아무",
+            "all": "모두",
+            "tagLogicAny": "모든 태그 일치 (OR)",
+            "tagLogicAll": "모든 태그 일치 (AND)"
         },
         "theme": {
             "toggle": "테마 토글",
@@ -221,7 +249,9 @@
             "label": "설정 폴더 열기",
             "tooltip": "settings.json이 있는 폴더를 엽니다",
             "success": "settings.json 폴더를 열었습니다",
-            "failed": "settings.json 폴더를 열지 못했습니다"
+            "failed": "settings.json 폴더를 열지 못했습니다",
+            "copied": "설정 경로가 클립보드에 복사되었습니다: {{path}}",
+            "clipboardFallback": "설정 경로: {{path}}"
         },
         "sections": {
             "contentFiltering": "콘텐츠 필터링",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 LoRA 루트 디렉토리를 설정합니다",
             "defaultCheckpointRoot": "기본 Checkpoint 루트",
             "defaultCheckpointRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Checkpoint 루트 디렉토리를 설정합니다",
+            "defaultUnetRoot": "기본 Diffusion Model 루트",
+            "defaultUnetRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Diffusion Model (UNET) 루트 디렉토리를 설정합니다",
             "defaultEmbeddingRoot": "기본 Embedding 루트",
             "defaultEmbeddingRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Embedding 루트 디렉토리를 설정합니다",
             "noDefault": "기본값 없음"
@@ -443,7 +475,10 @@
                 "dateAsc": "오래된순",
                 "size": "파일 크기",
                 "sizeDesc": "큰 순서",
-                "sizeAsc": "작은 순서"
+                "sizeAsc": "작은 순서",
+                "usage": "사용 횟수",
+                "usageDesc": "많은 순",
+                "usageAsc": "적은 순"
             },
             "refresh": {
                 "title": "모델 목록 새로고침",
@@ -518,6 +553,7 @@
             "replacePreview": "미리보기 교체",
             "setContentRating": "콘텐츠 등급 설정",
             "moveToFolder": "폴더로 이동",
+            "repairMetadata": "메타데이터 복구",
             "excludeModel": "모델 제외",
             "deleteModel": "모델 삭제",
             "shareRecipe": "레시피 공유",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "LoRA 루트 디렉토리를 선택해주세요"
                 }
             },
+            "sort": {
+                "title": "레시피 정렬...",
+                "name": "이름",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "날짜",
+                "dateDesc": "최신순",
+                "dateAsc": "오래된순",
+                "lorasCount": "LoRA 수",
+                "lorasCountDesc": "많은순",
+                "lorasCountAsc": "적은순"
+            },
             "refresh": {
                 "title": "레시피 목록 새로고침"
             },
-            "filteredByLora": "LoRA로 필터링됨"
+            "filteredByLora": "LoRA로 필터링됨",
+            "favorites": {
+                "title": "즐겨찾기만 표시",
+                "action": "즐겨찾기"
+            }
         },
         "duplicates": {
             "found": "{count}개의 중복 그룹 발견",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "다운로드할 누락된 LoRA가 없습니다",
                 "getInfoFailed": "누락된 LoRA 정보를 가져오는데 실패했습니다",
                 "prepareError": "LoRA 다운로드 준비 중 오류: {message}"
+            },
+            "repair": {
+                "starting": "레시피 메타데이터 복구 중...",
+                "success": "레시피 메타데이터가 성공적으로 복구되었습니다",
+                "skipped": "레시피가 이미 최신 버전입니다. 복구가 필요하지 않습니다",
+                "failed": "레시피 복구 실패: {message}",
+                "missingId": "레시피를 복구할 수 없음: 레시피 ID 누락"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpoint 모델"
+        "title": "Checkpoint 모델",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "{otherType} 폴더로 이동"
+        }
     },
     "embeddings": {
         "title": "Embedding 모델"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "재귀 검색은 트리 보기에서만 사용할 수 있습니다",
         "collapseAllDisabled": "목록 보기에서는 사용할 수 없습니다",
         "dragDrop": {
-            "unableToResolveRoot": "이동할 대상 경로를 확인할 수 없습니다."
+            "unableToResolveRoot": "이동할 대상 경로를 확인할 수 없습니다.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "파일 위치가 성공적으로 열렸습니다",
-                "failed": "파일 위치 열기에 실패했습니다"
+                "failed": "파일 위치 열기에 실패했습니다",
+                "copied": "경로가 클립보드에 복사되었습니다: {{path}}",
+                "clipboardFallback": "경로: {{path}}"
             },
             "metadata": {
                 "version": "버전",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "프리셋 매개변수 추가...",
                 "strengthMin": "최소 강도",
                 "strengthMax": "최대 강도",
+                "strengthRange": "강도 범위",
                 "strength": "강도",
                 "clipStrength": "클립 강도",
                 "clipSkip": "클립 스킵",
                 "valuePlaceholder": "값",
-                "add": "추가"
+                "add": "추가",
+                "invalidRange": "잘못된 범위 형식입니다. x.x-y.y를 사용하세요"
             },
             "triggerWords": {
                 "label": "트리거 단어",
@@ -914,6 +985,13 @@
                 "recipes": "레시피",
                 "versions": "버전"
             },
+            "navigation": {
+                "label": "모델 탐색",
+                "previousWithShortcut": "이전 모델(←)",
+                "nextWithShortcut": "다음 모델(→)",
+                "noPrevious": "이전 모델이 없습니다",
+                "noNext": "다음 모델이 없습니다"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "예시 이미지 폴더가 열렸습니다",
             "openingFolder": "예시 이미지 폴더를 여는 중",
-            "failedToOpen": "예시 이미지 폴더 열기 실패"
+            "failedToOpen": "예시 이미지 폴더 열기 실패",
+            "setupRequired": "예시 이미지 저장소",
+            "setupDescription": "사용자 지정 예시 이미지를 추가하려면 먼저 다운로드 위치를 설정해야 합니다.",
+            "setupUsage": "이 경로는 다운로드한 예시 이미지와 사용자 지정 이미지 모두에 사용됩니다.",
+            "openSettings": "설정 열기"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "업데이트 확인 중...",
         "checkingMessage": "최신 버전을 확인하는 동안 잠시 기다려주세요.",
         "showNotifications": "업데이트 알림 표시",
+        "latestBadge": "최신",
         "updateProgress": {
             "preparing": "업데이트 준비 중...",
             "installing": "업데이트 설치 중...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "검증 완료. 모든 파일이 중복임을 확인했습니다.",
             "verificationFailed": "해시 검증 실패: {message}",
             "noTagsToAdd": "추가할 태그가 없습니다",
+            "bulkTagsUpdating": "{count}개 모델의 태그를 업데이트 중입니다...",
             "tagsAddedSuccessfully": "{count}개의 {type}에 {tagCount}개의 태그가 성공적으로 추가되었습니다",
             "tagsReplacedSuccessfully": "{count}개의 {type}의 태그가 {tagCount}개의 태그로 성공적으로 교체되었습니다",
             "tagsAddFailed": "{count}개의 모델에 태그 추가에 실패했습니다",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "LoRA 루트 로딩 실패: {message}",
             "checkpointRootsFailed": "Checkpoint 루트 로딩 실패: {message}",
+            "unetRootsFailed": "Diffusion Model 루트 로딩 실패: {message}",
             "embeddingRootsFailed": "Embedding 루트 로딩 실패: {message}",
             "mappingsUpdated": "베이스 모델 경로 매핑이 업데이트되었습니다 ({count}개 매핑)",
             "mappingsCleared": "베이스 모델 경로 매핑이 지워졌습니다",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "필터가 지워졌습니다",
-            "noCustomFilterToClear": "지울 사용자 정의 필터가 없습니다"
+            "noCustomFilterToClear": "지울 사용자 정의 필터가 없습니다",
+            "noActiveFilters": "저장할 활성 필터가 없습니다"
+        },
+        "presets": {
+            "created": "프리셋 \"{name}\" 생성됨",
+            "deleted": "프리셋 \"{name}\" 삭제됨",
+            "applied": "프리셋 \"{name}\" 적용됨",
+            "overwritten": "프리셋 \"{name}\" 덮어쓰기 완료",
+            "restored": "기본 프리셋 복원 완료"
+        },
+        "error": {
+            "presetNameEmpty": "프리셋 이름을 입력하세요",
+            "presetNameTooLong": "프리셋 이름은 {max}자 이하여야 합니다",
+            "presetNameInvalidChars": "프리셋 이름에 유효하지 않은 문자가 포함되어 있습니다",
+            "presetNameExists": "동일한 이름의 프리셋이 이미 존재합니다",
+            "maxPresetsReached": "최대 {max}개의 프리셋만 허용됩니다. 더 추가하려면 기존 것을 삭제하세요.",
+            "presetNotFound": "프리셋을 찾을 수 없습니다",
+            "invalidPreset": "잘못된 프리셋 데이터입니다",
+            "deletePresetFailed": "프리셋 삭제에 실패했습니다",
+            "applyPresetFailed": "프리셋 적용에 실패했습니다"
         },
         "downloads": {
             "imagesCompleted": "예시 이미지 {action}이(가) 완료되었습니다",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "메타데이터가 성공적으로 새로고침되었습니다",
             "metadataRefreshFailed": "메타데이터 새로고침 실패: {message}",
             "metadataUpdateComplete": "메타데이터 업데이트 완료",
+            "operationCancelled": "사용자에 의해 작업이 취소되었습니다",
+            "operationCancelledPartial": "작업이 취소되었습니다. {success}개 항목이 처리되었습니다.",
             "metadataFetchFailed": "메타데이터 가져오기 실패: {message}",
             "bulkMetadataCompleteAll": "모든 {count}개 {type}이(가) 성공적으로 새로고침되었습니다",
             "bulkMetadataCompletePartial": "{total}개 중 {success}개 {type}이(가) 새로고침되었습니다",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "실패한 이동:\n{failures}",
             "bulkMoveSuccess": "{successCount}개 {type}이(가) 성공적으로 이동되었습니다",
             "exampleImagesDownloadSuccess": "예시 이미지가 성공적으로 다운로드되었습니다!",
-            "exampleImagesDownloadFailed": "예시 이미지 다운로드 실패: {message}"
+            "exampleImagesDownloadFailed": "예시 이미지 다운로드 실패: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "캐시 손상이 감지되었습니다"
+            },
+            "degraded": {
+                "title": "캐시 문제가 감지되었습니다"
+            },
+            "content": "{total}개의 캐시 항목 중 {invalid}개가 유효하지 않습니다 ({rate}). 모델 누락이나 오류가 발생할 수 있습니다. 캐시를 재구축하는 것이 좋습니다.",
+            "rebuildCache": "캐시 재구축",
+            "dismiss": "무시",
+            "rebuilding": "캐시 재구축 중...",
+            "rebuildFailed": "캐시 재구축 실패: {error}",
+            "retry": "다시 시도"
         }
     }
 }

locales/ru.json

@@ -10,7 +10,8 @@
             "next": "Далее",
             "backToTop": "Наверх",
             "settings": "Настройки",
-            "help": "Справка"
+            "help": "Справка",
+            "add": "Добавить"
         },
         "status": {
             "loading": "Загрузка...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "Обновление",
             "updateAvailable": "Доступно обновление"
+        },
+        "usage": {
+            "timesUsed": "Количество использований"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "Восстановить данные рецептов",
+            "loading": "Восстановление данных рецептов...",
+            "success": "Успешно восстановлено {count} рецептов.",
+            "cancelled": "Восстановление отменено. {count} рецептов было восстановлено.",
+            "error": "Ошибка восстановления рецептов: {message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "Автор",
                 "title": "Название рецепта",
                 "loraName": "Имя файла LoRA",
-                "loraModel": "Название модели LoRA"
+                "loraModel": "Название модели LoRA",
+                "prompt": "Запрос"
             }
         },
         "filter": {
             "title": "Фильтр моделей",
+            "presets": "Пресеты",
+            "savePreset": "Сохранить текущие активные фильтры как новый пресет.",
+            "savePresetDisabledActive": "Невозможно сохранить: Пресет уже активен. Измените фильтры, чтобы сохранить новый пресет",
+            "savePresetDisabledNoFilters": "Сначала выберите фильтры для сохранения как пресет",
+            "savePresetPrompt": "Введите имя пресета:",
+            "presetClickTooltip": "Нажмите чтобы применить пресет \"{name}\"",
+            "presetDeleteTooltip": "Удалить пресет",
+            "presetDeleteConfirm": "Удалить пресет \"{name}\"?",
+            "presetDeleteConfirmClick": "Нажмите еще раз для подтверждения",
+            "presetOverwriteConfirm": "Пресет \"{name}\" уже существует. Перезаписать?",
+            "presetNamePlaceholder": "Имя пресета...",
             "baseModel": "Базовая модель",
             "modelTags": "Теги (Топ 20)",
             "modelTypes": "Model Types",
             "license": "Лицензия",
             "noCreditRequired": "Без указания авторства",
             "allowSellingGeneratedContent": "Продажа разрешена",
-            "clearAll": "Очистить все фильтры"
+            "noTags": "Без тегов",
+            "clearAll": "Очистить все фильтры",
+            "any": "Любой",
+            "all": "Все",
+            "tagLogicAny": "Совпадение с любым тегом (ИЛИ)",
+            "tagLogicAll": "Совпадение со всеми тегами (И)"
         },
         "theme": {
             "toggle": "Переключить тему",
@@ -221,7 +249,9 @@
             "label": "Открыть папку настроек",
             "tooltip": "Открыть папку, содержащую settings.json",
             "success": "Папка settings.json открыта",
-            "failed": "Не удалось открыть папку settings.json"
+            "failed": "Не удалось открыть папку settings.json",
+            "copied": "Путь настроек скопирован в буфер обмена: {{path}}",
+            "clipboardFallback": "Путь настроек: {{path}}"
         },
         "sections": {
             "contentFiltering": "Фильтрация контента",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "Установить корневую папку LoRA по умолчанию для загрузок, импорта и перемещений",
             "defaultCheckpointRoot": "Корневая папка Checkpoint по умолчанию",
             "defaultCheckpointRootHelp": "Установить корневую папку checkpoint по умолчанию для загрузок, импорта и перемещений",
+            "defaultUnetRoot": "Корневая папка Diffusion Model по умолчанию",
+            "defaultUnetRootHelp": "Установить корневую папку Diffusion Model (UNET) по умолчанию для загрузок, импорта и перемещений",
             "defaultEmbeddingRoot": "Корневая папка Embedding по умолчанию",
             "defaultEmbeddingRootHelp": "Установить корневую папку embedding по умолчанию для загрузок, импорта и перемещений",
             "noDefault": "Не задано"
@@ -443,7 +475,10 @@
                 "dateAsc": "Старейшим",
                 "size": "Размеру файла",
                 "sizeDesc": "Наибольшим",
-                "sizeAsc": "Наименьшим"
+                "sizeAsc": "Наименьшим",
+                "usage": "Число использований",
+                "usageDesc": "Больше",
+                "usageAsc": "Меньше"
             },
             "refresh": {
                 "title": "Обновить список моделей",
@@ -518,6 +553,7 @@
             "replacePreview": "Заменить превью",
             "setContentRating": "Установить рейтинг контента",
             "moveToFolder": "Переместить в папку",
+            "repairMetadata": "Восстановить метаданные",
             "excludeModel": "Исключить модель",
             "deleteModel": "Удалить модель",
             "shareRecipe": "Поделиться рецептом",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "Пожалуйста, выберите корневую папку LoRA"
                 }
             },
+            "sort": {
+                "title": "Сортировка рецептов...",
+                "name": "Имя",
+                "nameAsc": "А - Я",
+                "nameDesc": "Я - А",
+                "date": "Дата",
+                "dateDesc": "Сначала новые",
+                "dateAsc": "Сначала старые",
+                "lorasCount": "Кол-во LoRA",
+                "lorasCountDesc": "Больше всего",
+                "lorasCountAsc": "Меньше всего"
+            },
             "refresh": {
                 "title": "Обновить список рецептов"
             },
-            "filteredByLora": "Фильтр по LoRA"
+            "filteredByLora": "Фильтр по LoRA",
+            "favorites": {
+                "title": "Только избранные",
+                "action": "Избранное"
+            }
         },
         "duplicates": {
             "found": "Найдено {count} групп дубликатов",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "Нет отсутствующих LoRAs для загрузки",
                 "getInfoFailed": "Не удалось получить информацию для отсутствующих LoRAs",
                 "prepareError": "Ошибка подготовки LoRAs для загрузки: {message}"
+            },
+            "repair": {
+                "starting": "Восстановление метаданных рецепта...",
+                "success": "Метаданные рецепта успешно восстановлены",
+                "skipped": "Рецепт уже последней версии, восстановление не требуется",
+                "failed": "Не удалось восстановить рецепт: {message}",
+                "missingId": "Не удалось восстановить рецепт: отсутствует ID рецепта"
             }
         }
     },
     "checkpoints": {
-        "title": "Модели Checkpoint"
+        "title": "Модели Checkpoint",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "Переместить в папку {otherType}"
+        }
     },
     "embeddings": {
         "title": "Модели Embedding"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "Рекурсивный поиск доступен только в режиме дерева",
         "collapseAllDisabled": "Недоступно в виде списка",
         "dragDrop": {
-            "unableToResolveRoot": "Не удалось определить путь назначения для перемещения."
+            "unableToResolveRoot": "Не удалось определить путь назначения для перемещения.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "Расположение файла успешно открыто",
-                "failed": "Не удалось открыть расположение файла"
+                "failed": "Не удалось открыть расположение файла",
+                "copied": "Путь скопирован в буфер обмена: {{path}}",
+                "clipboardFallback": "Путь: {{path}}"
             },
             "metadata": {
                 "version": "Версия",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "Добавить предустановленный параметр...",
                 "strengthMin": "Мин. сила",
                 "strengthMax": "Макс. сила",
+                "strengthRange": "Диапазон силы",
                 "strength": "Сила",
                 "clipStrength": "Сила клипа",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Значение",
-                "add": "Добавить"
+                "add": "Добавить",
+                "invalidRange": "Неверный формат диапазона. Используйте x.x-y.y"
             },
             "triggerWords": {
                 "label": "Триггерные слова",
@@ -914,6 +985,13 @@
                 "recipes": "Рецепты",
                 "versions": "Версии"
             },
+            "navigation": {
+                "label": "Навигация по моделям",
+                "previousWithShortcut": "Предыдущая модель (←)",
+                "nextWithShortcut": "Следующая модель (→)",
+                "noPrevious": "Предыдущая модель отсутствует",
+                "noNext": "Следующая модель отсутствует"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "Папка с примерами изображений открыта",
             "openingFolder": "Открытие папки с примерами изображений",
-            "failedToOpen": "Не удалось открыть папку с примерами изображений"
+            "failedToOpen": "Не удалось открыть папку с примерами изображений",
+            "setupRequired": "Хранилище примеров изображений",
+            "setupDescription": "Чтобы добавить собственные примеры изображений, сначала нужно установить место загрузки.",
+            "setupUsage": "Этот путь используется как для загруженных, так и для пользовательских примеров изображений.",
+            "openSettings": "Открыть настройки"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "Проверка обновлений...",
         "checkingMessage": "Пожалуйста, подождите, пока мы проверяем последнюю версию.",
         "showNotifications": "Показывать уведомления об обновлениях",
+        "latestBadge": "Последний",
         "updateProgress": {
             "preparing": "Подготовка обновления...",
             "installing": "Установка обновления...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "Проверка завершена. Все файлы подтверждены как дубликаты.",
             "verificationFailed": "Не удалось проверить хеши: {message}",
             "noTagsToAdd": "Нет тегов для добавления",
+            "bulkTagsUpdating": "Обновление тегов для {count} модел(ей)...",
             "tagsAddedSuccessfully": "Успешно добавлено {tagCount} тег(ов) к {count} {type}(ам)",
             "tagsReplacedSuccessfully": "Успешно заменены теги для {count} {type}(ов) на {tagCount} тег(ов)",
             "tagsAddFailed": "Не удалось добавить теги к {count} модель(ям)",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "Не удалось загрузить корни LoRA: {message}",
             "checkpointRootsFailed": "Не удалось загрузить корни checkpoint: {message}",
+            "unetRootsFailed": "Не удалось загрузить корни Diffusion Model: {message}",
             "embeddingRootsFailed": "Не удалось загрузить корни embedding: {message}",
             "mappingsUpdated": "Сопоставления путей базовых моделей обновлены ({count} сопоставлени{plural})",
             "mappingsCleared": "Сопоставления путей базовых моделей очищены",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "Фильтры очищены",
-            "noCustomFilterToClear": "Нет пользовательского фильтра для очистки"
+            "noCustomFilterToClear": "Нет пользовательского фильтра для очистки",
+            "noActiveFilters": "Нет активных фильтров для сохранения"
+        },
+        "presets": {
+            "created": "Пресет \"{name}\" создан",
+            "deleted": "Пресет \"{name}\" удален",
+            "applied": "Пресет \"{name}\" применен",
+            "overwritten": "Пресет \"{name}\" перезаписан",
+            "restored": "Пресеты по умолчанию восстановлены"
+        },
+        "error": {
+            "presetNameEmpty": "Имя пресета не может быть пустым",
+            "presetNameTooLong": "Имя пресета должно содержать не более {max} символов",
+            "presetNameInvalidChars": "Имя пресета содержит недопустимые символы",
+            "presetNameExists": "Пресет с таким именем уже существует",
+            "maxPresetsReached": "Допустимо максимум {max} пресетов. Удалите один, чтобы добавить больше.",
+            "presetNotFound": "Пресет не найден",
+            "invalidPreset": "Недопустимые данные пресета",
+            "deletePresetFailed": "Не удалось удалить пресет",
+            "applyPresetFailed": "Не удалось применить пресет"
         },
         "downloads": {
             "imagesCompleted": "Примеры изображений {action} завершены",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "Метаданные успешно обновлены",
             "metadataRefreshFailed": "Не удалось обновить метаданные: {message}",
             "metadataUpdateComplete": "Обновление метаданных завершено",
+            "operationCancelled": "Операция отменена пользователем",
+            "operationCancelledPartial": "Операция отменена. Обработано {success} элементов.",
             "metadataFetchFailed": "Не удалось получить метаданные: {message}",
             "bulkMetadataCompleteAll": "Успешно обновлены все {count} {type}s",
             "bulkMetadataCompletePartial": "Обновлено {success} из {total} {type}s",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "Неудачные перемещения:\n{failures}",
             "bulkMoveSuccess": "Успешно перемещено {successCount} {type}s",
             "exampleImagesDownloadSuccess": "Примеры изображений успешно загружены!",
-            "exampleImagesDownloadFailed": "Не удалось загрузить примеры изображений: {message}"
+            "exampleImagesDownloadFailed": "Не удалось загрузить примеры изображений: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "Обнаружено повреждение кэша"
+            },
+            "degraded": {
+                "title": "Обнаружены проблемы с кэшем"
+            },
+            "content": "{invalid} из {total} записей кэша недействительны ({rate}). Это может привести к отсутствию моделей или ошибкам. Рекомендуется перестроить кэш.",
+            "rebuildCache": "Перестроить кэш",
+            "dismiss": "Отклонить",
+            "rebuilding": "Перестроение кэша...",
+            "rebuildFailed": "Не удалось перестроить кэш: {error}",
+            "retry": "Повторить"
         }
     }
 }

locales/zh-CN.json

@@ -10,7 +10,8 @@
             "next": "下一步",
             "backToTop": "返回顶部",
             "settings": "设置",
-            "help": "帮助"
+            "help": "帮助",
+            "add": "添加"
         },
         "status": {
             "loading": "加载中...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "更新",
             "updateAvailable": "有可用更新"
+        },
+        "usage": {
+            "timesUsed": "使用次数"
         }
     },
     "globalContextMenu": {
@@ -159,6 +163,13 @@
             "success": "Updated license metadata for {count} {typePlural}",
             "none": "All {typePlural} already have license metadata",
             "error": "Failed to refresh license metadata for {typePlural}: {message}"
+        },
+        "repairRecipes": {
+            "label": "修复配方数据",
+            "loading": "正在修复配方数据...",
+            "success": "成功修复了 {count} 个配方。",
+            "cancelled": "修复已取消。已修复 {count} 个配方。",
+            "error": "配方修复失败：{message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "创作者",
                 "title": "配方标题",
                 "loraName": "LoRA 文件名",
-                "loraModel": "LoRA 模型名称"
+                "loraModel": "LoRA 模型名称",
+                "prompt": "提示词"
             }
         },
         "filter": {
             "title": "筛选模型",
+            "presets": "预设",
+            "savePreset": "将当前激活的筛选器保存为新预设。",
+            "savePresetDisabledActive": "无法保存：已有预设处于激活状态。修改筛选器后可保存新预设",
+            "savePresetDisabledNoFilters": "先选择筛选器，然后保存为预设",
+            "savePresetPrompt": "输入预设名称：",
+            "presetClickTooltip": "点击应用预设 \"{name}\"",
+            "presetDeleteTooltip": "删除预设",
+            "presetDeleteConfirm": "删除预设 \"{name}\"？",
+            "presetDeleteConfirmClick": "再次点击确认",
+            "presetOverwriteConfirm": "预设 \"{name}\" 已存在。是否覆盖？",
+            "presetNamePlaceholder": "预设名称...",
             "baseModel": "基础模型",
             "modelTags": "标签（前20）",
             "modelTypes": "Model Types",
             "license": "许可证",
             "noCreditRequired": "无需署名",
             "allowSellingGeneratedContent": "允许销售",
-            "clearAll": "清除所有筛选"
+            "noTags": "无标签",
+            "clearAll": "清除所有筛选",
+            "any": "任一",
+            "all": "全部",
+            "tagLogicAny": "匹配任一标签 (或)",
+            "tagLogicAll": "匹配所有标签 (与)"
         },
         "theme": {
             "toggle": "切换主题",
@@ -221,7 +249,9 @@
             "label": "打开设置文件夹",
             "tooltip": "打开包含 settings.json 的文件夹",
             "success": "已打开 settings.json 文件夹",
-            "failed": "无法打开 settings.json 文件夹"
+            "failed": "无法打开 settings.json 文件夹",
+            "copied": "设置路径已复制到剪贴板：{{path}}",
+            "clipboardFallback": "设置路径：{{path}}"
         },
         "sections": {
             "contentFiltering": "内容过滤",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "设置下载、导入和移动时的默认 LoRA 根目录",
             "defaultCheckpointRoot": "默认 Checkpoint 根目录",
             "defaultCheckpointRootHelp": "设置下载、导入和移动时的默认 Checkpoint 根目录",
+            "defaultUnetRoot": "默认 Diffusion Model 根目录",
+            "defaultUnetRootHelp": "设置下载、导入和移动时的默认 Diffusion Model (UNET) 根目录",
             "defaultEmbeddingRoot": "默认 Embedding 根目录",
             "defaultEmbeddingRootHelp": "设置下载、导入和移动时的默认 Embedding 根目录",
             "noDefault": "无默认"
@@ -443,7 +475,10 @@
                 "dateAsc": "最旧",
                 "size": "文件大小",
                 "sizeDesc": "最大",
-                "sizeAsc": "最小"
+                "sizeAsc": "最小",
+                "usage": "使用次数",
+                "usageDesc": "最多",
+                "usageAsc": "最少"
             },
             "refresh": {
                 "title": "刷新模型列表",
@@ -518,6 +553,7 @@
             "replacePreview": "替换预览",
             "setContentRating": "设置内容评级",
             "moveToFolder": "移动到文件夹",
+            "repairMetadata": "修复元数据",
             "excludeModel": "排除模型",
             "deleteModel": "删除模型",
             "shareRecipe": "分享配方",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "请选择 LoRA 根目录"
                 }
             },
+            "sort": {
+                "title": "配方排序...",
+                "name": "名称",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "时间",
+                "dateDesc": "最新",
+                "dateAsc": "最早",
+                "lorasCount": "LoRA 数量",
+                "lorasCountDesc": "最多",
+                "lorasCountAsc": "最少"
+            },
             "refresh": {
                 "title": "刷新配方列表"
             },
-            "filteredByLora": "按 LoRA 筛选"
+            "filteredByLora": "按 LoRA 筛选",
+            "favorites": {
+                "title": "仅显示收藏",
+                "action": "收藏"
+            }
         },
         "duplicates": {
             "found": "发现 {count} 个重复组",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "没有缺失的 LoRA 可下载",
                 "getInfoFailed": "获取缺失 LoRA 信息失败",
                 "prepareError": "准备下载 LoRA 时出错：{message}"
+            },
+            "repair": {
+                "starting": "正在修复配方元数据...",
+                "success": "配方元数据修复成功",
+                "skipped": "配方已是最新版本，无需修复",
+                "failed": "修复配方失败：{message}",
+                "missingId": "无法修复配方：缺少配方 ID"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpoint 模型"
+        "title": "Checkpoint 模型",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "移动到 {otherType} 文件夹"
+        }
     },
     "embeddings": {
         "title": "Embedding 模型"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "仅在树形视图中可使用递归搜索",
         "collapseAllDisabled": "列表视图下不可用",
         "dragDrop": {
-            "unableToResolveRoot": "无法确定移动的目标路径。"
+            "unableToResolveRoot": "无法确定移动的目标路径。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "文件位置已成功打开",
-                "failed": "打开文件位置失败"
+                "failed": "打开文件位置失败",
+                "copied": "路径已复制到剪贴板：{{path}}",
+                "clipboardFallback": "路径：{{path}}"
             },
             "metadata": {
                 "version": "版本",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "添加预设参数...",
                 "strengthMin": "最小强度",
                 "strengthMax": "最大强度",
+                "strengthRange": "强度范围",
                 "strength": "强度",
                 "clipStrength": "Clip 强度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "数值",
-                "add": "添加"
+                "add": "添加",
+                "invalidRange": "无效的范围格式。请使用 x.x-y.y"
             },
             "triggerWords": {
                 "label": "触发词",
@@ -914,6 +985,13 @@
                 "recipes": "配方",
                 "versions": "版本"
             },
+            "navigation": {
+                "label": "模型导航",
+                "previousWithShortcut": "上一个模型（←）",
+                "nextWithShortcut": "下一个模型（→）",
+                "noPrevious": "没有上一个模型",
+                "noNext": "没有下一个模型"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "示例图片文件夹已打开",
             "openingFolder": "正在打开示例图片文件夹",
-            "failedToOpen": "打开示例图片文件夹失败"
+            "failedToOpen": "打开示例图片文件夹失败",
+            "setupRequired": "示例图片存储",
+            "setupDescription": "要添加自定义示例图片，您需要先设置下载位置。",
+            "setupUsage": "此路径用于存储下载的示例图片和自定义图片。",
+            "openSettings": "打开设置"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "正在检查更新...",
         "checkingMessage": "请稍候，正在检查最新版本。",
         "showNotifications": "显示更新通知",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "正在准备更新...",
             "installing": "正在安装更新...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "验证完成。所有文件均为重复项。",
             "verificationFailed": "验证哈希失败：{message}",
             "noTagsToAdd": "没有可添加的标签",
+            "bulkTagsUpdating": "正在更新 {count} 个模型的标签...",
             "tagsAddedSuccessfully": "已成功为 {count} 个 {type} 添加 {tagCount} 个标签",
             "tagsReplacedSuccessfully": "已成功为 {count} 个 {type} 替换为 {tagCount} 个标签",
             "tagsAddFailed": "为 {count} 个模型添加标签失败",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "加载 LoRA 根目录失败：{message}",
             "checkpointRootsFailed": "加载 Checkpoint 根目录失败：{message}",
+            "unetRootsFailed": "加载 Diffusion Model 根目录失败：{message}",
             "embeddingRootsFailed": "加载 Embedding 根目录失败：{message}",
             "mappingsUpdated": "基础模型路径映射已更新（{count} 条映射{plural}）",
             "mappingsCleared": "基础模型路径映射已清除",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "筛选已清除",
-            "noCustomFilterToClear": "没有自定义筛选可清除"
+            "noCustomFilterToClear": "没有自定义筛选可清除",
+            "noActiveFilters": "没有可保存的激活筛选"
+        },
+        "presets": {
+            "created": "预设 \"{name}\" 已创建",
+            "deleted": "预设 \"{name}\" 已删除",
+            "applied": "预设 \"{name}\" 已应用",
+            "overwritten": "预设 \"{name}\" 已覆盖",
+            "restored": "默认预设已恢复"
+        },
+        "error": {
+            "presetNameEmpty": "预设名称不能为空",
+            "presetNameTooLong": "预设名称不能超过 {max} 个字符",
+            "presetNameInvalidChars": "预设名称包含无效字符",
+            "presetNameExists": "已存在同名预设",
+            "maxPresetsReached": "最多允许 {max} 个预设。删除一个以添加更多。",
+            "presetNotFound": "预设未找到",
+            "invalidPreset": "无效的预设数据",
+            "deletePresetFailed": "删除预设失败",
+            "applyPresetFailed": "应用预设失败"
         },
         "downloads": {
             "imagesCompleted": "示例图片{action}完成",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "元数据刷新成功",
             "metadataRefreshFailed": "刷新元数据失败：{message}",
             "metadataUpdateComplete": "元数据更新完成",
+            "operationCancelled": "操作已由用户取消",
+            "operationCancelledPartial": "操作已取消。已处理 {success} 个项目。",
             "metadataFetchFailed": "获取元数据失败：{message}",
             "bulkMetadataCompleteAll": "全部 {count} 个 {type} 元数据刷新成功",
             "bulkMetadataCompletePartial": "已刷新 {success}/{total} 个 {type} 元数据",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "移动失败：\n{failures}",
             "bulkMoveSuccess": "成功移动 {successCount} 个 {type}",
             "exampleImagesDownloadSuccess": "示例图片下载成功！",
-            "exampleImagesDownloadFailed": "示例图片下载失败：{message}"
+            "exampleImagesDownloadFailed": "示例图片下载失败：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "来爱发电为Lora Manager项目发电，支持项目持续开发的同时，获取浏览器插件验证码，按季支付更优惠！支付宝/微信方便支付。感谢支持！🚀",
             "supportCta": "为LM发电",
             "learnMore": "浏览器插件教程"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "检测到缓存损坏"
+            },
+            "degraded": {
+                "title": "检测到缓存问题"
+            },
+            "content": "{total} 个缓存条目中有 {invalid} 个无效（{rate}）。这可能导致模型丢失或错误。建议重建缓存。",
+            "rebuildCache": "重建缓存",
+            "dismiss": "忽略",
+            "rebuilding": "正在重建缓存...",
+            "rebuildFailed": "重建缓存失败：{error}",
+            "retry": "重试"
         }
     }
 }

locales/zh-TW.json

@@ -10,7 +10,8 @@
             "next": "下一步",
             "backToTop": "回到頂部",
             "settings": "設定",
-            "help": "說明"
+            "help": "說明",
+            "add": "新增"
         },
         "status": {
             "loading": "載入中...",
@@ -131,6 +132,9 @@
         "badges": {
             "update": "更新",
             "updateAvailable": "有可用更新"
+        },
+        "usage": {
+            "timesUsed": "使用次數"
         }
     },
     "globalContextMenu": {
@@ -154,11 +158,18 @@
             "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": "修復配方資料",
+            "loading": "正在修復配方資料...",
+            "success": "成功修復 {count} 個配方。",
+            "cancelled": "修復已取消。已修復 {count} 個配方。",
+            "error": "配方修復失敗：{message}"
         }
     },
     "header": {
@@ -188,18 +199,35 @@
                 "creator": "創作者",
                 "title": "配方標題",
                 "loraName": "LoRA 檔案名稱",
-                "loraModel": "LoRA 模型名稱"
+                "loraModel": "LoRA 模型名稱",
+                "prompt": "提示詞"
             }
         },
         "filter": {
             "title": "篩選模型",
+            "presets": "預設",
+            "savePreset": "將目前啟用的篩選器儲存為新預設。",
+            "savePresetDisabledActive": "無法儲存：已有預設處於啟用狀態。修改篩選器後可儲存新預設",
+            "savePresetDisabledNoFilters": "先選擇篩選器，然後儲存為預設",
+            "savePresetPrompt": "輸入預設名稱：",
+            "presetClickTooltip": "點擊套用預設 \"{name}\"",
+            "presetDeleteTooltip": "刪除預設",
+            "presetDeleteConfirm": "刪除預設 \"{name}\"？",
+            "presetDeleteConfirmClick": "再次點擊確認",
+            "presetOverwriteConfirm": "預設 \"{name}\" 已存在。是否覆蓋？",
+            "presetNamePlaceholder": "預設名稱...",
             "baseModel": "基礎模型",
             "modelTags": "標籤（前 20）",
             "modelTypes": "Model Types",
             "license": "授權",
             "noCreditRequired": "無需署名",
             "allowSellingGeneratedContent": "允許銷售",
-            "clearAll": "清除所有篩選"
+            "noTags": "無標籤",
+            "clearAll": "清除所有篩選",
+            "any": "任一",
+            "all": "全部",
+            "tagLogicAny": "符合任一票籤 (或)",
+            "tagLogicAll": "符合所有標籤 (與)"
         },
         "theme": {
             "toggle": "切換主題",
@@ -221,7 +249,9 @@
             "label": "開啟設定資料夾",
             "tooltip": "開啟包含 settings.json 的資料夾",
             "success": "已開啟 settings.json 資料夾",
-            "failed": "無法開啟 settings.json 資料夾"
+            "failed": "無法開啟 settings.json 資料夾",
+            "copied": "設定路徑已複製到剪貼簿：{{path}}",
+            "clipboardFallback": "設定路徑：{{path}}"
         },
         "sections": {
             "contentFiltering": "內容過濾",
@@ -305,6 +335,8 @@
             "defaultLoraRootHelp": "設定下載、匯入和移動時的預設 LoRA 根目錄",
             "defaultCheckpointRoot": "預設 Checkpoint 根目錄",
             "defaultCheckpointRootHelp": "設定下載、匯入和移動時的預設 Checkpoint 根目錄",
+            "defaultUnetRoot": "預設 Diffusion Model 根目錄",
+            "defaultUnetRootHelp": "設定下載、匯入和移動時的預設 Diffusion Model (UNET) 根目錄",
             "defaultEmbeddingRoot": "預設 Embedding 根目錄",
             "defaultEmbeddingRootHelp": "設定下載、匯入和移動時的預設 Embedding 根目錄",
             "noDefault": "未設定預設"
@@ -443,7 +475,10 @@
                 "dateAsc": "最舊",
                 "size": "檔案大小",
                 "sizeDesc": "最大",
-                "sizeAsc": "最小"
+                "sizeAsc": "最小",
+                "usage": "使用次數",
+                "usageDesc": "最多",
+                "usageAsc": "最少"
             },
             "refresh": {
                 "title": "重新整理模型列表",
@@ -518,6 +553,7 @@
             "replacePreview": "更換預覽圖",
             "setContentRating": "設定內容分級",
             "moveToFolder": "移動到資料夾",
+            "repairMetadata": "修復元數據",
             "excludeModel": "排除模型",
             "deleteModel": "刪除模型",
             "shareRecipe": "分享配方",
@@ -588,10 +624,26 @@
                     "selectLoraRoot": "請選擇 LoRA 根目錄"
                 }
             },
+            "sort": {
+                "title": "配方排序...",
+                "name": "名稱",
+                "nameAsc": "A - Z",
+                "nameDesc": "Z - A",
+                "date": "時間",
+                "dateDesc": "最新",
+                "dateAsc": "最舊",
+                "lorasCount": "LoRA 數量",
+                "lorasCountDesc": "最多",
+                "lorasCountAsc": "最少"
+            },
             "refresh": {
                 "title": "重新整理配方列表"
             },
-            "filteredByLora": "已依 LoRA 篩選"
+            "filteredByLora": "已依 LoRA 篩選",
+            "favorites": {
+                "title": "僅顯示收藏",
+                "action": "收藏"
+            }
         },
         "duplicates": {
             "found": "發現 {count} 組重複項",
@@ -617,11 +669,25 @@
                 "noMissingLoras": "無缺少的 LoRA 可下載",
                 "getInfoFailed": "取得缺少 LoRA 資訊失敗",
                 "prepareError": "準備下載 LoRA 時發生錯誤：{message}"
+            },
+            "repair": {
+                "starting": "正在修復配方元數據...",
+                "success": "配方元數據修復成功",
+                "skipped": "配方已是最新版本，無需修復",
+                "failed": "修復配方失敗：{message}",
+                "missingId": "無法修復配方：缺少配方 ID"
             }
         }
     },
     "checkpoints": {
-        "title": "Checkpoint 模型"
+        "title": "Checkpoint 模型",
+        "modelTypes": {
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusion Model"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "移動到 {otherType} 資料夾"
+        }
     },
     "embeddings": {
         "title": "Embedding 模型"
@@ -638,7 +704,8 @@
         "recursiveUnavailable": "遞迴搜尋僅能在樹狀檢視中使用",
         "collapseAllDisabled": "列表檢視下不可用",
         "dragDrop": {
-            "unableToResolveRoot": "無法確定移動的目標路徑。"
+            "unableToResolveRoot": "無法確定移動的目標路徑。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +915,9 @@
             },
             "openFileLocation": {
                 "success": "檔案位置已成功開啟",
-                "failed": "開啟檔案位置失敗"
+                "failed": "開啟檔案位置失敗",
+                "copied": "路徑已複製到剪貼簿：{{path}}",
+                "clipboardFallback": "路徑：{{path}}"
             },
             "metadata": {
                 "version": "版本",
@@ -871,11 +940,13 @@
                 "addPresetParameter": "新增預設參數...",
                 "strengthMin": "最小強度",
                 "strengthMax": "最大強度",
+                "strengthRange": "強度範圍",
                 "strength": "強度",
                 "clipStrength": "Clip 強度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "數值",
-                "add": "新增"
+                "add": "新增",
+                "invalidRange": "無效的範圍格式。請使用 x.x-y.y"
             },
             "triggerWords": {
                 "label": "觸發詞",
@@ -914,6 +985,13 @@
                 "recipes": "配方",
                 "versions": "版本"
             },
+            "navigation": {
+                "label": "模型導覽",
+                "previousWithShortcut": "上一個模型（←）",
+                "nextWithShortcut": "下一個模型（→）",
+                "noPrevious": "沒有上一個模型",
+                "noNext": "沒有下一個模型"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1103,7 +1181,11 @@
         "exampleImages": {
             "opened": "範例圖片資料夾已開啟",
             "openingFolder": "正在開啟範例圖片資料夾",
-            "failedToOpen": "開啟範例圖片資料夾失敗"
+            "failedToOpen": "開啟範例圖片資料夾失敗",
+            "setupRequired": "範例圖片儲存",
+            "setupDescription": "要新增自訂範例圖片，您需要先設定下載位置。",
+            "setupUsage": "此路徑用於儲存下載的範例圖片和自訂圖片。",
+            "openSettings": "開啟設定"
         }
     },
     "help": {
@@ -1152,6 +1234,7 @@
         "checkingUpdates": "正在檢查更新...",
         "checkingMessage": "請稍候，正在檢查最新版本。",
         "showNotifications": "顯示更新通知",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "正在準備更新...",
             "installing": "正在安裝更新...",
@@ -1317,6 +1400,7 @@
             "verificationCompleteSuccess": "驗證完成。所有檔案均確認為重複項。",
             "verificationFailed": "驗證雜湊失敗：{message}",
             "noTagsToAdd": "沒有可新增的標籤",
+            "bulkTagsUpdating": "正在更新 {count} 個模型的標籤...",
             "tagsAddedSuccessfully": "已成功將 {tagCount} 個標籤新增到 {count} 個 {type}",
             "tagsReplacedSuccessfully": "已成功以 {tagCount} 個標籤取代 {count} 個 {type} 的標籤",
             "tagsAddFailed": "新增標籤到 {count} 個模型失敗",
@@ -1330,6 +1414,7 @@
         "settings": {
             "loraRootsFailed": "載入 LoRA 根目錄失敗：{message}",
             "checkpointRootsFailed": "載入 checkpoint 根目錄失敗：{message}",
+            "unetRootsFailed": "載入 Diffusion Model 根目錄失敗：{message}",
             "embeddingRootsFailed": "載入 embedding 根目錄失敗：{message}",
             "mappingsUpdated": "基礎模型路徑對應已更新（{count} 個對應）",
             "mappingsCleared": "基礎模型路徑對應已清除",
@@ -1350,7 +1435,26 @@
         "filters": {
             "applied": "{message}",
             "cleared": "篩選已清除",
-            "noCustomFilterToClear": "無自訂篩選可清除"
+            "noCustomFilterToClear": "無自訂篩選可清除",
+            "noActiveFilters": "沒有可儲存的啟用篩選"
+        },
+        "presets": {
+            "created": "預設 \"{name}\" 已建立",
+            "deleted": "預設 \"{name}\" 已刪除",
+            "applied": "預設 \"{name}\" 已套用",
+            "overwritten": "預設 \"{name}\" 已覆蓋",
+            "restored": "預設設定已恢復"
+        },
+        "error": {
+            "presetNameEmpty": "預設名稱不能為空",
+            "presetNameTooLong": "預設名稱不能超過 {max} 個字元",
+            "presetNameInvalidChars": "預設名稱包含無效字元",
+            "presetNameExists": "已存在同名預設",
+            "maxPresetsReached": "最多允許 {max} 個預設。刪除一個以新增更多。",
+            "presetNotFound": "預設未找到",
+            "invalidPreset": "無效的預設資料",
+            "deletePresetFailed": "刪除預設失敗",
+            "applyPresetFailed": "套用預設失敗"
         },
         "downloads": {
             "imagesCompleted": "範例圖片{action}完成",
@@ -1437,6 +1541,8 @@
             "metadataRefreshed": "metadata 已成功刷新",
             "metadataRefreshFailed": "刷新 metadata 失敗：{message}",
             "metadataUpdateComplete": "metadata 更新完成",
+            "operationCancelled": "操作已由用戶取消",
+            "operationCancelledPartial": "操作已取消。已處理 {success} 個項目。",
             "metadataFetchFailed": "取得 metadata 失敗：{message}",
             "bulkMetadataCompleteAll": "已成功刷新全部 {count} 個 {type}",
             "bulkMetadataCompletePartial": "已刷新 {success} / {total} 個 {type}",
@@ -1453,7 +1559,8 @@
             "bulkMoveFailures": "移動失敗：\n{failures}",
             "bulkMoveSuccess": "已成功移動 {successCount} 個 {type}",
             "exampleImagesDownloadSuccess": "範例圖片下載成功！",
-            "exampleImagesDownloadFailed": "下載範例圖片失敗：{message}"
+            "exampleImagesDownloadFailed": "下載範例圖片失敗：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {
@@ -1469,6 +1576,20 @@
             "content": "LoRA Manager is a passion project maintained full-time by a solo developer. Your support on Ko-fi helps cover development costs, keeps new updates coming, and unlocks a license key for the LM Civitai Extension as a thank-you gift. Every contribution truly makes a difference.",
             "supportCta": "Support on Ko-fi",
             "learnMore": "LM Civitai Extension Tutorial"
+        },
+        "cacheHealth": {
+            "corrupted": {
+                "title": "檢測到快取損壞"
+            },
+            "degraded": {
+                "title": "檢測到快取問題"
+            },
+            "content": "{total} 個快取項目中有 {invalid} 個無效（{rate}）。這可能會導致模型遺失或錯誤。建議重建快取。",
+            "rebuildCache": "重建快取",
+            "dismiss": "關閉",
+            "rebuilding": "重建快取中...",
+            "rebuildFailed": "重建快取失敗：{error}",
+            "retry": "重試"
         }
     }
 }

package.json

@@ -4,7 +4,9 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "test": "vitest run",
+    "test": "npm run test:js && npm run test:vue",
+    "test:js": "vitest run",
+    "test:vue": "cd vue-widgets && npx vitest run",
     "test:watch": "vitest",
     "test:coverage": "node scripts/run_frontend_coverage.js"
   },

py/config.py

@@ -1,13 +1,16 @@
 import os
 import platform
+import threading
 from pathlib import Path
 import folder_paths # type: ignore
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Set
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Set, Tuple
 import logging
 import json
 import urllib.parse
+import time
 
-from .utils.settings_paths import ensure_settings_file, load_settings_template
+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
 
 # 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"
@@ -80,6 +83,8 @@ class Config:
         self._path_mappings: Dict[str, str] = {}
         # Normalized preview root directories used to validate preview access
         self._preview_root_paths: Set[Path] = set()
+        # Fingerprint of the symlink layout from the last successful scan
+        self._cached_fingerprint: Optional[Dict[str, object]] = None
         self.loras_roots = self._init_lora_paths()
         self.checkpoints_roots = None
         self.unet_roots = None
@@ -87,8 +92,7 @@ class Config:
         self.base_models_roots = self._init_checkpoint_paths()
         self.embeddings_roots = self._init_embedding_paths()
         # Scan symbolic links during initialization
-        self._scan_symbolic_links()
-        self._rebuild_preview_roots()
+        self._initialize_symlink_mappings()
         
         if not standalone_mode:
             # Save the paths to settings.json when running in ComfyUI mode
@@ -220,45 +224,302 @@ class Config:
             logger.error(f"Error checking link status for {path}: {e}")
             return False
 
+    def _entry_is_symlink(self, entry: os.DirEntry) -> bool:
+        """Check if a directory entry is a symlink, including Windows junctions."""
+        if entry.is_symlink():
+            return True
+        if platform.system() == 'Windows':
+            try:
+                import ctypes
+                FILE_ATTRIBUTE_REPARSE_POINT = 0x400
+                attrs = ctypes.windll.kernel32.GetFileAttributesW(entry.path)
+                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, '/')
+
+    def _get_symlink_cache_path(self) -> Path:
+        canonical_path = get_cache_file_path(CacheType.SYMLINK, create_dir=True)
+        return Path(canonical_path)
+
+    def _symlink_roots(self) -> List[str]:
+        roots: List[str] = []
+        roots.extend(self.loras_roots or [])
+        roots.extend(self.base_models_roots or [])
+        roots.extend(self.embeddings_roots or [])
+        return roots
+
+    def _build_symlink_fingerprint(self) -> Dict[str, object]:
+        roots = [self._normalize_path(path) for path in self._symlink_roots() if path]
+        unique_roots = sorted(set(roots))
+
+        # Include first-level symlinks in fingerprint for change detection.
+        # This ensures new symlinks under roots trigger a cache invalidation.
+        # Use lists (not tuples) for JSON serialization compatibility.
+        direct_symlinks: List[List[str]] = []
+        for root in unique_roots:
+            try:
+                if os.path.isdir(root):
+                    with os.scandir(root) as it:
+                        for entry in it:
+                            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)
+                                    ])
+                                except OSError:
+                                    pass
+            except (OSError, PermissionError):
+                pass
+
+        return {
+            "roots": unique_roots,
+            "direct_symlinks": sorted(direct_symlinks)
+        }
+
+    def _initialize_symlink_mappings(self) -> None:
+        start = time.perf_counter()
+        cache_loaded = self._load_persisted_cache_into_mappings()
+
+        if cache_loaded:
+            logger.info(
+                "Symlink mappings restored from cache in %.2f ms",
+                (time.perf_counter() - start) * 1000,
+            )
+            self._rebuild_preview_roots()
+
+            current_fingerprint = self._build_symlink_fingerprint()
+            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
+
+            # Check 2: All cached mappings still valid (catches changes at any depth)
+            mappings_valid = self._validate_cached_mappings() if fingerprint_valid else False
+
+            if fingerprint_valid and mappings_valid:
+                return
+
+            logger.info("Symlink configuration changed; rescanning symbolic links")
+
+        self.rebuild_symlink_cache()
+        logger.info(
+            "Symlink mappings rebuilt and cached in %.2f ms",
+            (time.perf_counter() - start) * 1000,
+        )
+
+    def rebuild_symlink_cache(self) -> None:
+        """Force a fresh scan of all symbolic links and update the persistent cache."""
+        self._scan_symbolic_links()
+        self._save_symlink_cache()
+        self._rebuild_preview_roots()
+
+    def _load_persisted_cache_into_mappings(self) -> bool:
+        """Load the symlink cache and store its fingerprint for comparison."""
+        cache_path = self._get_symlink_cache_path()
+
+        # Check canonical path first, then legacy paths for migration
+        paths_to_check = [cache_path]
+        legacy_paths = get_legacy_cache_paths(CacheType.SYMLINK)
+        paths_to_check.extend(Path(p) for p in legacy_paths if p != str(cache_path))
+
+        loaded_path = None
+        payload = None
+
+        for check_path in paths_to_check:
+            if not check_path.exists():
+                continue
+            try:
+                with check_path.open("r", encoding="utf-8") as handle:
+                    payload = json.load(handle)
+                    loaded_path = check_path
+                    break
+            except Exception as exc:
+                logger.info("Failed to load symlink cache %s: %s", check_path, exc)
+                continue
+
+        if payload is None:
+            return False
+
+        if not isinstance(payload, dict):
+            return False
+
+        cached_mappings = payload.get("path_mappings")
+        if not isinstance(cached_mappings, Mapping):
+            return False
+
+        # Store the cached fingerprint for comparison during initialization
+        self._cached_fingerprint = payload.get("fingerprint")
+
+        normalized_mappings: Dict[str, str] = {}
+        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)
+
+        self._path_mappings = normalized_mappings
+
+        # Log migration if loaded from legacy path
+        if loaded_path is not None and loaded_path != cache_path:
+            logger.info(
+                "Symlink cache migrated from %s (will save to %s)",
+                loaded_path,
+                cache_path,
+            )
+
+            try:
+                if loaded_path.exists():
+                    loaded_path.unlink()
+                    logger.info("Cleaned up legacy symlink cache: %s", loaded_path)
+
+                    try:
+                        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)
+                    except Exception:
+                        pass
+
+            except Exception as exc:
+                logger.warning(
+                    "Failed to cleanup legacy symlink cache %s: %s",
+                    loaded_path,
+                    exc,
+                )
+        else:
+            logger.info("Symlink cache loaded with %d mappings", len(self._path_mappings))
+
+        return True
+
+    def _validate_cached_mappings(self) -> bool:
+        """Verify all cached symlink mappings are still valid.
+
+        Returns True if all mappings are valid, False if rescan is needed.
+        This catches removed or retargeted symlinks at ANY depth.
+        """
+        for target, link in self._path_mappings.items():
+            # Convert normalized paths back to OS paths
+            link_path = link.replace('/', os.sep)
+
+            # Check if symlink still exists
+            if not self._is_link(link_path):
+                logger.debug("Cached symlink no longer exists: %s", link_path)
+                return False
+
+            # Check if target is still the same
+            try:
+                actual_target = self._normalize_path(os.path.realpath(link_path))
+                if actual_target != target:
+                    logger.debug(
+                        "Symlink target changed: %s -> %s (cached: %s)",
+                        link_path, actual_target, target
+                    )
+                    return False
+            except OSError:
+                logger.debug("Cannot resolve symlink: %s", link_path)
+                return False
+
+        return True
+
+    def _save_symlink_cache(self) -> None:
+        cache_path = self._get_symlink_cache_path()
+        payload = {
+            "fingerprint": self._build_symlink_fingerprint(),
+            "path_mappings": self._path_mappings,
+        }
+
+        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))
+        except Exception as exc:
+            logger.info("Failed to write symlink cache %s: %s", cache_path, exc)
+
     def _scan_symbolic_links(self):
-        """Scan all symbolic links in LoRA, Checkpoint, and Embedding root directories"""
-        for root in self.loras_roots:
-            self._scan_directory_links(root)
+        """Scan symbolic links in LoRA, Checkpoint, and Embedding root directories.
 
-        for root in self.base_models_roots:
-            self._scan_directory_links(root)
+        Only scans the first level of each root directory to avoid performance
+        issues with large file systems. Detects symlinks and Windows junctions
+        at the root level only (not nested symlinks in subdirectories).
+        """
+        start = time.perf_counter()
         
-        for root in self.embeddings_roots:
-            self._scan_directory_links(root)
+        # Reset mappings before rescanning to avoid stale entries
+        self._path_mappings.clear()
+        self._seed_root_symlink_mappings()
+        for root in self._symlink_roots():
+            self._scan_first_level_symlinks(root)
+        logger.debug(
+            "Symlink scan finished in %.2f ms with %d mappings",
+            (time.perf_counter() - start) * 1000,
+            len(self._path_mappings),
+        )
 
-    def _scan_directory_links(self, root: str):
-        """Recursively scan symbolic links in a directory"""
+    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.
+        """
         try:
             with os.scandir(root) as it:
                 for entry in it:
-                    if self._is_link(entry.path):
+                    try:
+                        # Only detect symlinks including Windows junctions
+                        # Skip normal directories to avoid deep traversal
+                        if not self._entry_is_symlink(entry):
+                            continue
+
+                        # Resolve the symlink target
                         target_path = os.path.realpath(entry.path)
-                        if os.path.isdir(target_path):
-                            self.add_path_mapping(entry.path, target_path)
-                            self._scan_directory_links(target_path)
-                    elif entry.is_dir(follow_symlinks=False):
-                        self._scan_directory_links(entry.path)
+                        if not os.path.isdir(target_path):
+                            continue
+
+                        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
+                        )
         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
         link_path: symbolic link path
         """
-        normalized_link = os.path.normpath(link_path).replace(os.sep, '/')
-        normalized_target = os.path.normpath(target_path).replace(os.sep, '/')
+        normalized_link = self._normalize_path(link_path)
+        normalized_target = self._normalize_path(target_path)
         # Keep the original mapping: target path -> link path
         self._path_mappings[normalized_target] = normalized_link
         logger.info(f"Added path mapping: {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))
 
+    def _seed_root_symlink_mappings(self) -> None:
+        """Ensure symlinked root folders are recorded before deep scanning."""
+
+        for root in self._symlink_roots():
+            if not root:
+                continue
+            try:
+                if not self._is_link(root):
+                    continue
+                target_path = os.path.realpath(root)
+                if not os.path.isdir(target_path):
+                    continue
+                self.add_path_mapping(root, target_path)
+            except Exception as exc:
+                logger.debug("Skipping root symlink %s: %s", root, exc)
+
     def _expand_preview_root(self, path: str) -> Set[Path]:
         """Return normalized ``Path`` objects representing a preview root."""
 
@@ -315,28 +576,44 @@ class Config:
             preview_roots.update(self._expand_preview_root(link))
 
         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",
+            len(self._preview_root_paths),
+            len(self.loras_roots or []),
+            len(self.base_models_roots or []),
+            len(self.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, '/')
         # Check if the path is contained in any mapped target path
         for target_path, link_path in self._path_mappings.items():
-            if normalized_path.startswith(target_path):
+            # 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 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 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, '/')
         # Check if the path is contained in any mapped target path
-        for target_path, link_path in self._path_mappings.items():
-            if normalized_link.startswith(target_path):
-                # If the path starts with the target path, replace with actual path
-                mapped_path = normalized_link.replace(target_path, link_path, 1)
+        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 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
-        return link_path
+        return normalized_link
 
     def _dedupe_existing_paths(self, raw_paths: Iterable[str]) -> Dict[str, str]:
         dedup: Dict[str, str] = {}
@@ -368,6 +645,23 @@ class Config:
         checkpoint_map = self._dedupe_existing_paths(checkpoint_paths)
         unet_map = self._dedupe_existing_paths(unet_paths)
 
+        # Detect when checkpoints and unet share the same physical location
+        # This is a configuration issue that can cause duplicate model entries
+        overlapping_real_paths = set(checkpoint_map.keys()) & set(unet_map.keys())
+        if overlapping_real_paths:
+            logger.warning(
+                "Detected overlapping paths between 'checkpoints' and 'diffusion_models' (unet). "
+                "They should not point to the same physical folder as they are different model types. "
+                "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]
+            )
+            # Remove overlapping paths from unet_map to prioritize checkpoints
+            for rp in overlapping_real_paths:
+                if rp in unet_map:
+                    del unet_map[rp]
+
         merged_map: Dict[str, str] = {}
         for real_path, original in {**checkpoint_map, **unet_map}.items():
             if real_path not in merged_map:
@@ -411,8 +705,7 @@ class Config:
         self.base_models_roots = self._prepare_checkpoint_paths(checkpoint_paths, unet_paths)
         self.embeddings_roots = self._prepare_embedding_paths(embedding_paths)
 
-        self._scan_symbolic_links()
-        self._rebuild_preview_roots()
+        self._initialize_symlink_mappings()
 
     def _init_lora_paths(self) -> List[str]:
         """Initialize and validate LoRA paths from ComfyUI settings"""
@@ -473,7 +766,23 @@ class Config:
         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."""
+        """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.
+        """
+
+        if self._is_path_in_allowed_roots(preview_path):
+            return True
+
+        if self._try_discover_deep_symlink(preview_path):
+            return self._is_path_in_allowed_roots(preview_path)
+
+        return False
+
+    def _is_path_in_allowed_roots(self, preview_path: str) -> bool:
+        """Check if preview_path is within allowed preview roots without modification."""
 
         if not preview_path:
             return False
@@ -483,12 +792,72 @@ class Config:
         except Exception:
             return False
 
+        candidate_str = os.path.normcase(str(candidate))
         for root in self._preview_root_paths:
-            try:
-                candidate.relative_to(root)
+            root_str = os.path.normcase(str(root))
+            if candidate_str == root_str or candidate_str.startswith(root_str + os.sep):
                 return True
-            except ValueError:
-                continue
+
+        logger.debug(
+            "Path not in allowed roots: %s (candidate=%s, num_roots=%d)",
+            preview_path,
+            candidate_str,
+            len(self._preview_root_paths),
+        )
+
+        return False
+
+    def _try_discover_deep_symlink(self, preview_path: str) -> bool:
+        """Attempt to discover a deep symlink that contains the preview_path.
+
+        Walks up from the preview path to the root directories, checking each
+        parent directory for symlinks. If a symlink is found, updates the
+        in-memory path mappings and preview roots.
+
+        Only updates in-memory state (self._path_mappings and self._preview_root_paths),
+        does not modify the persistent cache file.
+
+        Returns:
+            True if a symlink was discovered and mappings updated, False otherwise.
+        """
+        if not preview_path:
+            return False
+
+        try:
+            candidate = Path(preview_path).expanduser()
+        except Exception:
+            return False
+
+        current = candidate
+        while True:
+            try:
+                if self._is_link(str(current)):
+                    try:
+                        target = os.path.realpath(str(current))
+                        normalized_target = self._normalize_path(target)
+                        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))
+
+                        logger.debug(
+                            "Discovered deep symlink: %s -> %s (preview path: %s)",
+                            normalized_link,
+                            normalized_target,
+                            preview_path
+                        )
+
+                        return True
+                    except OSError:
+                        pass
+            except OSError:
+                pass
+
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
 
         return False
 

py/lora_manager.py

@@ -2,6 +2,15 @@ import asyncio
 import sys
 import os
 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"
+
+# Only setup logging prefix if not in standalone mode
+if not standalone_mode:
+    setup_logging()
+
 from server import PromptServer # type: ignore
 
 from .config import config
@@ -17,12 +26,10 @@ from .services.settings_manager import get_settings_manager
 from .utils.example_images_migration import ExampleImagesMigration
 from .services.websocket_manager import ws_manager
 from .services.example_images_cleanup_service import ExampleImagesCleanupService
+from .middleware.csp_middleware import relax_csp_for_remote_media
 
 logger = logging.getLogger(__name__)
 
-# Check if we're in standalone mode
-STANDALONE_MODE = 'nodes' not in sys.modules
-
 HEADER_SIZE_LIMIT = 16384
 
 
@@ -62,6 +69,23 @@ class LoraManager:
         """Initialize and register all routes using the new refactored architecture"""
         app = PromptServer.instance.app
 
+        if relax_csp_for_remote_media not in app.middlewares:
+            # Ensure CSP relaxer executes after ComfyUI's block_external_middleware so it can
+            # see and extend the restrictive header instead of being overwritten by it.
+            block_middleware_index = next(
+                (
+                    idx
+                    for idx, middleware in enumerate(app.middlewares)
+                    if getattr(middleware, "__name__", "") == "block_external_middleware"
+                ),
+                None,
+            )
+
+            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)
+
         # 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
         # limits. Cookies for unrelated apps are still sent to the plugin and
@@ -140,8 +164,6 @@ class LoraManager:
         # Add cleanup
         app.on_shutdown.append(cls._cleanup)
         
-        logger.info(f"LoRA Manager: Set up routes for {len(ModelServiceFactory.get_registered_types())} model types: {', '.join(ModelServiceFactory.get_registered_types())}")
-    
     @classmethod
     async def _initialize_services(cls):
         """Initialize all services using the ServiceRegistry"""

py/metadata_collector/__init__.py

@@ -1,4 +1,7 @@
 import os
+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"
@@ -14,7 +17,7 @@ if not standalone_mode:
         # Initialize registry
         registry = MetadataRegistry()
         
-        print("ComfyUI Metadata Collector initialized")
+        logger.info("ComfyUI Metadata Collector initialized")
         
     def get_metadata(prompt_id=None):
         """Helper function to get metadata from the registry"""
@@ -23,7 +26,7 @@ if not standalone_mode:
 else:
     # Standalone mode - provide dummy implementations
     def init():
-        print("ComfyUI Metadata Collector disabled in standalone mode")
+        logger.info("ComfyUI Metadata Collector disabled in standalone mode")
         
     def get_metadata(prompt_id=None):
         """Dummy implementation for standalone mode"""

py/metadata_collector/metadata_hook.py

@@ -1,7 +1,10 @@
 import sys
 import inspect
+import logging
 from .metadata_registry import MetadataRegistry
 
+logger = logging.getLogger(__name__)
+
 class MetadataHook:
     """Install hooks for metadata collection"""
     
@@ -23,7 +26,7 @@ class MetadataHook:
                     
             # If we can't find the execution module, we can't install hooks
             if execution is None:
-                print("Could not locate ComfyUI execution module, metadata collection disabled")
+                logger.warning("Could not locate ComfyUI execution module, metadata collection disabled")
                 return
             
             # Detect whether we're using the new async version of ComfyUI
@@ -37,16 +40,16 @@ class MetadataHook:
                 is_async = inspect.iscoroutinefunction(execution._map_node_over_list)
             
             if is_async:
-                print("Detected async ComfyUI execution, installing async metadata hooks")
+                logger.info("Detected async ComfyUI execution, installing async metadata hooks")
                 MetadataHook._install_async_hooks(execution, map_node_func_name)
             else:
-                print("Detected sync ComfyUI execution, installing sync metadata hooks")
+                logger.info("Detected sync ComfyUI execution, installing sync metadata hooks")
                 MetadataHook._install_sync_hooks(execution)
             
-            print("Metadata collection hooks installed for runtime values")
+            logger.info("Metadata collection hooks installed for runtime values")
             
         except Exception as e:
-            print(f"Error installing metadata hooks: {str(e)}")
+            logger.error(f"Error installing metadata hooks: {str(e)}")
     
     @staticmethod
     def _install_sync_hooks(execution):
@@ -82,7 +85,7 @@ class MetadataHook:
                         if node_id is not None:
                             registry.record_node_execution(node_id, class_type, input_data_all, None)
                 except Exception as e:
-                    print(f"Error collecting metadata (pre-execution): {str(e)}")
+                    logger.error(f"Error collecting metadata (pre-execution): {str(e)}")
             
             # Execute the original function
             results = original_map_node_over_list(obj, input_data_all, func, allow_interrupt, execution_block_cb, pre_execute_cb)
@@ -113,7 +116,7 @@ class MetadataHook:
                         if node_id is not None:
                             registry.update_node_execution(node_id, class_type, results)
                 except Exception as e:
-                    print(f"Error collecting metadata (post-execution): {str(e)}")
+                    logger.error(f"Error collecting metadata (post-execution): {str(e)}")
             
             return results
             
@@ -159,7 +162,7 @@ class MetadataHook:
                         if node_id is not None:
                             registry.record_node_execution(node_id, class_type, input_data_all, None)
                 except Exception as e:
-                    print(f"Error collecting metadata (pre-execution): {str(e)}")
+                    logger.error(f"Error collecting metadata (pre-execution): {str(e)}")
             
             # Call original function with all args/kwargs
             results = await original_map_node_over_list(
@@ -176,7 +179,7 @@ class MetadataHook:
                         if node_id is not None:
                             registry.update_node_execution(node_id, class_type, results)
                 except Exception as e:
-                    print(f"Error collecting metadata (post-execution): {str(e)}")
+                    logger.error(f"Error collecting metadata (post-execution): {str(e)}")
             
             return results
         

py/metadata_collector/metadata_processor.py

@@ -39,8 +39,39 @@ class MetadataProcessor:
                     if node_id in metadata.get(SAMPLING, {}) and metadata[SAMPLING][node_id].get(IS_SAMPLER, False):
                         candidate_samplers[node_id] = metadata[SAMPLING][node_id]
                 
-                # If we found candidate samplers, apply primary sampler logic to these candidates only
-                if candidate_samplers:
+                    # If we found candidate samplers, apply primary sampler logic to these candidates only
+                    
+                    # PRE-PROCESS: Ensure all candidate samplers have their parameters populated
+                    # This is especially important for SamplerCustomAdvanced which needs tracing
+                    prompt = metadata.get("current_prompt")
+                    for node_id in candidate_samplers:
+                        # If a sampler is missing common parameters like steps or denoise, 
+                        # try to populate them using tracing before ranking
+                        sampler_info = candidate_samplers[node_id]
+                        params = sampler_info.get("parameters", {})
+                        
+                        if prompt and (params.get("steps") is None or params.get("denoise") is None):
+                            # Create a temporary params dict to use the handler
+                            temp_params = {
+                                "steps": params.get("steps"),
+                                "denoise": params.get("denoise"),
+                                "sampler": params.get("sampler_name"),
+                                "scheduler": params.get("scheduler")
+                            }
+                            
+                            # Check if it's SamplerCustomAdvanced
+                            if prompt.original_prompt and node_id in prompt.original_prompt:
+                                if prompt.original_prompt[node_id].get("class_type") == "SamplerCustomAdvanced":
+                                    MetadataProcessor.handle_custom_advanced_sampler(metadata, prompt, node_id, temp_params)
+                                    
+                                    # Update the actual parameters with found values
+                                    params["steps"] = temp_params.get("steps")
+                                    params["denoise"] = temp_params.get("denoise")
+                                    if temp_params.get("sampler"):
+                                        params["sampler_name"] = temp_params.get("sampler")
+                                    if temp_params.get("scheduler"):
+                                        params["scheduler"] = temp_params.get("scheduler")
+
                     # Collect potential primary samplers based on different criteria
                     custom_advanced_samplers = []
                     advanced_add_noise_samplers = []
@@ -49,7 +80,6 @@ class MetadataProcessor:
                     high_denoise_id = None
                     
                     # First, check for SamplerCustomAdvanced among candidates
-                    prompt = metadata.get("current_prompt")
                     if prompt and prompt.original_prompt:
                         for node_id in candidate_samplers:
                             node_info = prompt.original_prompt.get(node_id, {})
@@ -77,15 +107,16 @@ class MetadataProcessor:
                     # Combine all potential primary samplers
                     potential_samplers = custom_advanced_samplers + advanced_add_noise_samplers + high_denoise_samplers
                     
-                    # Find the most recent potential primary sampler (closest to downstream node)
-                    for i in range(downstream_index - 1, -1, -1):
+                    # Find the first potential primary sampler (prefer base sampler over refine)
+                    # Use forward search to prioritize the first one in execution order
+                    for i in range(downstream_index):
                         node_id = execution_order[i]
                         if node_id in potential_samplers:
                             return node_id, candidate_samplers[node_id]
                     
-                    # If no potential sampler found from our criteria, return the most recent sampler
+                    # If no potential sampler found from our criteria, return the first sampler
                     if candidate_samplers:
-                        for i in range(downstream_index - 1, -1, -1):
+                        for i in range(downstream_index):
                             node_id = execution_order[i]
                             if node_id in candidate_samplers:
                                 return node_id, candidate_samplers[node_id]
@@ -176,8 +207,11 @@ class MetadataProcessor:
                 found_node_id = input_value[0]  # Connected node_id
                 
                 # If we're looking for a specific node class
-                if target_class and prompt.original_prompt[found_node_id].get("class_type") == target_class:
-                    return found_node_id
+                if target_class:
+                    if found_node_id not in prompt.original_prompt:
+                        return None
+                    if prompt.original_prompt[found_node_id].get("class_type") == target_class:
+                        return found_node_id
                 
                 # If we're not looking for a specific class, update the last valid node
                 if not target_class:
@@ -185,11 +219,19 @@ class MetadataProcessor:
                 
                 # Continue tracing through intermediate nodes
                 current_node_id = found_node_id
-                # For most conditioning nodes, the input we want to follow is named "conditioning"
-                if "conditioning" in prompt.original_prompt[current_node_id].get("inputs", {}):
+                
+                # Check if current source node exists
+                if current_node_id not in prompt.original_prompt:
+                    return found_node_id if not target_class else None
+                    
+                # Determine which input to follow next on the source node
+                source_node_inputs = prompt.original_prompt[current_node_id].get("inputs", {})
+                if input_name in source_node_inputs:
+                    current_input = input_name
+                elif "conditioning" in source_node_inputs:
                     current_input = "conditioning"
                 else:
-                    # If there's no "conditioning" input, return the current node
+                    # If there's no suitable input to follow, return the current node
                     # if we're not looking for a specific target_class
                     return found_node_id if not target_class else None
             else:
@@ -202,12 +244,89 @@ class MetadataProcessor:
         return last_valid_node if not target_class else None
     
     @staticmethod
-    def find_primary_checkpoint(metadata):
-        """Find the primary checkpoint model in the workflow"""
+    def trace_model_path(metadata, prompt, start_node_id):
+        """
+        Trace the model connection path upstream to find the checkpoint
+        """
+        if not prompt or not prompt.original_prompt:
+            return None
+            
+        current_node_id = start_node_id
+        depth = 0
+        max_depth = 50
+        
+        while depth < max_depth:
+            # Check if current node is a registered checkpoint in our metadata
+            # This handles cached nodes correctly because metadata contains info for all nodes in the graph
+            if current_node_id in metadata.get(MODELS, {}):
+                if metadata[MODELS][current_node_id].get("type") == "checkpoint":
+                    return current_node_id
+            
+            if current_node_id not in prompt.original_prompt:
+                return None
+                
+            node = prompt.original_prompt[current_node_id]
+            inputs = node.get("inputs", {})
+            class_type = node.get("class_type", "")
+            
+            # Determine which input to follow next
+            next_input_name = "model"
+            
+            # Special handling for initial node
+            if depth == 0:
+                if class_type == "SamplerCustomAdvanced":
+                    next_input_name = "guider"
+            
+            # If the specific input doesn't exist, try generic 'model' 
+            if next_input_name not in inputs:
+                if "model" in inputs:
+                    next_input_name = "model"
+                elif "basic_pipe" in inputs:
+                    # Handle pipe nodes like FromBasicPipe by following the pipeline
+                    next_input_name = "basic_pipe"
+                else:
+                    # Dead end - no model input to follow
+                    return None
+            
+            # Get connected node
+            input_val = inputs[next_input_name]
+            if isinstance(input_val, list) and len(input_val) > 0:
+                current_node_id = input_val[0]
+            else:
+                return None
+                
+            depth += 1
+            
+        return None
+
+    @staticmethod
+    def find_primary_checkpoint(metadata, downstream_id=None, primary_sampler_id=None):
+        """
+        Find the primary checkpoint model in the workflow
+        
+        Parameters:
+        - metadata: The workflow metadata
+        - downstream_id: Optional ID of a downstream node to help identify the specific primary sampler
+        - primary_sampler_id: Optional ID of the primary sampler if already known
+        """
         if not metadata.get(MODELS):
             return None
         
-        # In most workflows, there's only one checkpoint, so we can just take the first one
+        # Method 1: Topology-based tracing (More accurate for complex workflows)
+        # First, find the primary sampler if not provided
+        if not primary_sampler_id:
+            primary_sampler_id, _ = MetadataProcessor.find_primary_sampler(metadata, downstream_id)
+        
+        if primary_sampler_id:
+            prompt = metadata.get("current_prompt")
+            if prompt:
+                # Trace back from the sampler to find the checkpoint
+                checkpoint_id = MetadataProcessor.trace_model_path(metadata, prompt, primary_sampler_id)
+                if checkpoint_id and checkpoint_id in metadata.get(MODELS, {}):
+                    return metadata[MODELS][checkpoint_id].get("name")
+            
+        # Method 2: Fallback to the first available checkpoint (Original behavior)
+        # In most simple workflows, there's only one checkpoint, so we can just take the first one
         for node_id, model_info in metadata.get(MODELS, {}).items():
             if model_info.get("type") == "checkpoint":
                 return model_info.get("name")
@@ -311,7 +430,8 @@ class MetadataProcessor:
         primary_sampler_id, primary_sampler = MetadataProcessor.find_primary_sampler(metadata, id)
         
         # Directly get checkpoint from metadata instead of tracing
-        checkpoint = MetadataProcessor.find_primary_checkpoint(metadata)
+        # Pass primary_sampler_id to avoid redundant calculation
+        checkpoint = MetadataProcessor.find_primary_checkpoint(metadata, id, primary_sampler_id)
         if checkpoint:
             params["checkpoint"] = checkpoint
         
@@ -445,6 +565,7 @@ class MetadataProcessor:
                 scheduler_params = metadata[SAMPLING][scheduler_node_id].get("parameters", {})
                 params["steps"] = scheduler_params.get("steps")
                 params["scheduler"] = scheduler_params.get("scheduler")
+                params["denoise"] = scheduler_params.get("denoise")
         
         # 2. Trace sampler input to find KSamplerSelect (only if sampler input exists)
         if "sampler" in sampler_inputs:

py/metadata_collector/metadata_registry.py

@@ -196,9 +196,11 @@ class MetadataRegistry:
                     node_metadata[category] = {}
                 node_metadata[category][node_id] = current_metadata[category][node_id]
         
-        # Save to cache if we have any metadata for this node
+        # 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"""

py/metadata_collector/node_extractors.py

@@ -714,10 +714,10 @@ NODE_EXTRACTORS = {
     "UNETLoader": UNETLoaderExtractor,          # Updated to use dedicated extractor
     "UnetLoaderGGUF": UNETLoaderExtractor,  # Updated to use dedicated extractor
     "LoraLoader": LoraLoaderExtractor,
-    "LoraManagerLoader": LoraLoaderManagerExtractor,
+    "LoraLoaderLM": LoraLoaderManagerExtractor,
     # Conditioning
     "CLIPTextEncode": CLIPTextEncodeExtractor,
-    "PromptLoraManager": CLIPTextEncodeExtractor,
+    "PromptLM": CLIPTextEncodeExtractor,
     "CLIPTextEncodeFlux": CLIPTextEncodeFluxExtractor,  # Add CLIPTextEncodeFlux
     "WAS_Text_to_Conditioning": CLIPTextEncodeExtractor,
     "AdvancedCLIPTextEncode": CLIPTextEncodeExtractor,  # From https://github.com/BlenderNeko/ComfyUI_ADV_CLIP_emb

py/middleware/csp_middleware.py

@@ -0,0 +1,65 @@
+"""Middleware helpers for adjusting Content Security Policy headers."""
+
+from typing import Awaitable, Callable, Dict, List
+
+from aiohttp import web
+
+REMOTE_MEDIA_SOURCES = (
+    "https://image.civitai.com",
+    "https://img.genur.art",
+)
+
+
+@web.middleware
+async def relax_csp_for_remote_media(
+    request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
+) -> web.StreamResponse:
+    """Allow LoRA Manager media previews to load from trusted remote domains.
+
+    When ComfyUI is started with ``--disable-api-nodes`` it injects a restrictive
+    ``Content-Security-Policy`` header that blocks remote images and videos. The
+    LoRA Manager UI legitimately needs to fetch previews from Civitai and Genur,
+    so this middleware augments the existing CSP to whitelist those hosts while
+    preserving all other directives.
+    """
+
+    response: web.StreamResponse = await handler(request)
+    header_value = response.headers.get("Content-Security-Policy")
+
+    if not header_value:
+        return response
+
+    directive_order: List[str] = []
+    directives: Dict[str, List[str]] = {}
+
+    for raw_directive in header_value.split(";"):
+        directive = raw_directive.strip()
+        if not directive:
+            continue
+
+        parts = directive.split()
+        name, values = parts[0], parts[1:]
+        if name not in directive_order:
+            directive_order.append(name)
+        directives[name] = values
+
+    def merge_sources(name: str, sources: List[str], defaults: List[str] | None = None) -> None:
+        existing = directives.get(name, list(defaults or []))
+
+        for source in sources:
+            if source not in existing:
+                existing.append(source)
+
+        directives[name] = existing
+        if name not in directive_order:
+            directive_order.append(name)
+
+    merge_sources("img-src", list(REMOTE_MEDIA_SOURCES))
+    merge_sources("media-src", ["'self'", *REMOTE_MEDIA_SOURCES], defaults=["'self'"])
+
+    updated_header = "; ".join(
+        f"{name} {' '.join(directives[name])}".rstrip() for name in directive_order
+    )
+
+    response.headers["Content-Security-Policy"] = f"{updated_header};"
+    return response

py/nodes/debug_metadata.py

@@ -1,10 +1,10 @@
 import logging
-from server import PromptServer   # type: ignore
 from ..metadata_collector.metadata_processor import MetadataProcessor
 
 logger = logging.getLogger(__name__)
 
-class DebugMetadata:
+
+class DebugMetadataLM:
     NAME = "Debug Metadata (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = "Debug node to verify metadata_processor functionality"
@@ -25,21 +25,37 @@ class DebugMetadata:
     FUNCTION = "process_metadata"
 
     def process_metadata(self, images, id):
+        """
+        Process metadata from the execution context and return it for UI display.
+
+        The metadata is returned via the 'ui' key in the return dict, which triggers
+        node.onExecuted on the frontend to update the JsonDisplayWidget.
+
+        Args:
+            images: Input images (required for execution flow)
+            id: Node's unique ID (hidden)
+
+        Returns:
+            Dict with 'result' (empty tuple) and 'ui' (metadata dict for widget display)
+        """
         try:
             # Get the current execution context's metadata
             from ..metadata_collector import get_metadata
+
             metadata = get_metadata()
 
-            # Use the MetadataProcessor to convert it to JSON string
-            metadata_json = MetadataProcessor.to_json(metadata, id)
+            # Use the MetadataProcessor to convert it to dict
+            metadata_dict = MetadataProcessor.to_dict(metadata, id)
 
-            # Send metadata to frontend for display
-            PromptServer.instance.send_sync("metadata_update", {
-                "id": id,
-                "metadata": metadata_json
-            })
+            return {
+                "result": (),
+                # ComfyUI expects ui values to be lists, wrap the dict in a list
+                "ui": {"metadata": [metadata_dict]},
+            }
 
         except Exception as e:
             logger.error(f"Error processing metadata: {e}")
-        
-        return ()
+            return {
+                "result": (),
+                "ui": {"metadata": [{"error": str(e)}]},
+            }

py/nodes/lora_cycler.py

@@ -0,0 +1,134 @@
+"""
+Lora Cycler Node - Sequentially cycles through LoRAs from a pool.
+
+This node accepts optional pool_config input to filter available LoRAs, and outputs
+a LORA_STACK with one LoRA at a time. Returns UI updates with current/next LoRA info
+and tracks the cycle progress which persists across workflow save/load.
+"""
+
+import logging
+import os
+from ..utils.utils import get_lora_info
+
+logger = logging.getLogger(__name__)
+
+
+class LoraCyclerLM:
+    """Node that sequentially cycles through LoRAs from a pool"""
+
+    NAME = "Lora Cycler (LoraManager)"
+    CATEGORY = "Lora Manager/randomizer"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "cycler_config": ("CYCLER_CONFIG", {}),
+            },
+            "optional": {
+                "pool_config": ("POOL_CONFIG", {}),
+            },
+        }
+
+    RETURN_TYPES = ("LORA_STACK",)
+    RETURN_NAMES = ("LORA_STACK",)
+
+    FUNCTION = "cycle"
+    OUTPUT_NODE = False
+
+    async def cycle(self, cycler_config, pool_config=None):
+        """
+        Cycle through LoRAs based on configuration and pool filters.
+
+        Args:
+            cycler_config: Dict with cycler settings (current_index, model_strength, clip_strength, sort_by)
+            pool_config: Optional config from LoRA Pool node for filtering
+
+        Returns:
+            Dictionary with 'result' (LORA_STACK tuple) and 'ui' (for widget display)
+        """
+        from ..services.service_registry import ServiceRegistry
+        from ..services.lora_service import LoraService
+
+        # Extract settings from cycler_config
+        current_index = cycler_config.get("current_index", 1)  # 1-based
+        model_strength = float(cycler_config.get("model_strength", 1.0))
+        clip_strength = float(cycler_config.get("clip_strength", 1.0))
+        sort_by = "filename"
+
+        # Dual-index mechanism for batch queue synchronization
+        execution_index = cycler_config.get("execution_index")  # Can be None
+        # next_index_from_config = cycler_config.get("next_index")  # Not used on backend
+
+        # Get scanner and service
+        scanner = await ServiceRegistry.get_lora_scanner()
+        lora_service = LoraService(scanner)
+
+        # Get filtered and sorted LoRA list
+        lora_list = await lora_service.get_cycler_list(
+            pool_config=pool_config, sort_by=sort_by
+        )
+
+        total_count = len(lora_list)
+
+        if total_count == 0:
+            logger.warning("[LoraCyclerLM] No LoRAs available in pool")
+            return {
+                "result": ([],),
+                "ui": {
+                    "current_index": [1],
+                    "next_index": [1],
+                    "total_count": [0],
+                    "current_lora_name": [""],
+                    "current_lora_filename": [""],
+                    "error": ["No LoRAs available in pool"],
+                },
+            }
+
+        # Determine which index to use for this execution
+        # If execution_index is provided (batch queue case), use it
+        # Otherwise use current_index (first execution or non-batch case)
+        if execution_index is not None:
+            actual_index = execution_index
+        else:
+            actual_index = current_index
+
+        # Clamp index to valid range (1-based)
+        clamped_index = max(1, min(actual_index, total_count))
+
+        # Get LoRA at current index (convert to 0-based for list access)
+        current_lora = lora_list[clamped_index - 1]
+
+        # Build LORA_STACK with single LoRA
+        lora_path, _ = get_lora_info(current_lora["file_name"])
+        if not lora_path:
+            logger.warning(
+                f"[LoraCyclerLM] Could not find path for LoRA: {current_lora['file_name']}"
+            )
+            lora_stack = []
+        else:
+            # Normalize path separators
+            lora_path = lora_path.replace("/", os.sep)
+            lora_stack = [(lora_path, model_strength, clip_strength)]
+
+        # Calculate next index (wrap to 1 if at end)
+        next_index = clamped_index + 1
+        if next_index > total_count:
+            next_index = 1
+
+        # Get next LoRA for UI display (what will be used next generation)
+        next_lora = lora_list[next_index - 1]
+        next_display_name = next_lora["file_name"]
+
+        return {
+            "result": (lora_stack,),
+            "ui": {
+                "current_index": [clamped_index],
+                "next_index": [next_index],
+                "total_count": [total_count],
+                "current_lora_name": [current_lora["file_name"]],
+                "current_lora_filename": [current_lora["file_name"]],
+                "next_lora_name": [next_display_name],
+                "next_lora_filename": [next_lora["file_name"]],
+            },
+        }

py/nodes/lora_loader.py

@@ -6,7 +6,7 @@ from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_l
 
 logger = logging.getLogger(__name__)
 
-class LoraManagerLoader:
+class LoraLoaderLM:
     NAME = "Lora Loader (LoraManager)"
     CATEGORY = "Lora Manager/loaders"
     
@@ -16,12 +16,9 @@ class LoraManagerLoader:
             "required": {
                 "model": ("MODEL",),
                 # "clip": ("CLIP",),
-                "text": ("STRING", {
-                    "multiline": True,
-                    "pysssss.autocomplete": False, 
-                    "dynamicPrompts": True, 
+                "text": ("AUTOCOMPLETE_TEXT_LORAS", {
+                    "placeholder": "Search LoRAs to add...",
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
-                    "placeholder": "LoRA syntax input: <lora:name:strength>"
                 }),
             },
             "optional": FlexibleOptionalInputType(any_type),
@@ -131,7 +128,7 @@ class LoraManagerLoader:
 
         return (model, clip, trigger_words_text, formatted_loras_text)
 
-class LoraManagerTextLoader:
+class LoraTextLoaderLM:
     NAME = "LoRA Text Loader (LoraManager)"
     CATEGORY = "Lora Manager/loaders"
     

py/nodes/lora_pool.py

@@ -0,0 +1,87 @@
+"""
+LoRA Pool Node - Defines filter configuration for LoRA selection.
+
+This node provides a visual filter editor that generates a LORA_POOL_CONFIG
+object for use by downstream nodes (like LoRA Randomizer).
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LoraPoolLM:
+    """
+    A node that defines LoRA filter criteria through a Vue-based widget.
+
+    Outputs a LORA_POOL_CONFIG that can be consumed by:
+    - Frontend: LoRA Randomizer widget reads connected pool's widget value
+    - Backend: LoRA Randomizer receives config during workflow execution
+    """
+
+    NAME = "Lora Pool (LoraManager)"
+    CATEGORY = "Lora Manager/randomizer"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "pool_config": ("LORA_POOL_CONFIG", {}),
+            },
+            "hidden": {
+                # Hidden input to pass through unique node ID for frontend
+                "unique_id": "UNIQUE_ID",
+            },
+        }
+
+    RETURN_TYPES = ("POOL_CONFIG",)
+    RETURN_NAMES = ("POOL_CONFIG",)
+
+    FUNCTION = "process"
+    OUTPUT_NODE = False
+
+    def process(self, pool_config, unique_id=None):
+        """
+        Pass through the pool configuration filters.
+
+        The config is generated entirely by the frontend widget.
+        This function validates and returns only the filters field.
+
+        Args:
+            pool_config: Dict containing filter criteria from widget
+            unique_id: Node's unique ID (hidden)
+
+        Returns:
+            Tuple containing the filters dict from pool_config
+        """
+        # Validate required structure
+        if not isinstance(pool_config, dict):
+            logger.warning("Invalid pool_config type, using empty config")
+            pool_config = self._default_config()
+
+        # Ensure version field exists
+        if "version" not in pool_config:
+            pool_config["version"] = 1
+
+        # Extract filters field
+        filters = pool_config.get("filters", self._default_config()["filters"])
+
+        # Log for debugging
+        logger.debug(f"[LoraPoolLM] Processing filters: {filters}")
+
+        return (filters,)
+
+    @staticmethod
+    def _default_config():
+        """Return default empty configuration."""
+        return {
+            "version": 1,
+            "filters": {
+                "baseModels": [],
+                "tags": {"include": [], "exclude": []},
+                "folders": {"include": [], "exclude": []},
+                "favoritesOnly": False,
+                "license": {"noCreditRequired": False, "allowSelling": False},
+            },
+            "preview": {"matchCount": 0, "lastUpdated": 0},
+        }

py/nodes/lora_randomizer.py

@@ -0,0 +1,206 @@
+"""
+Lora Randomizer Node - Randomly selects LoRAs from a pool with configurable settings.
+
+This node accepts optional pool_config input to filter available LoRAs, and outputs
+a LORA_STACK with randomly selected LoRAs. Returns UI updates with new random LoRAs
+and tracks the last used combination for reuse.
+"""
+
+import logging
+import random
+import os
+from ..utils.utils import get_lora_info
+from .utils import extract_lora_name
+
+logger = logging.getLogger(__name__)
+
+
+class LoraRandomizerLM:
+    """Node that randomly selects LoRAs from a pool"""
+
+    NAME = "Lora Randomizer (LoraManager)"
+    CATEGORY = "Lora Manager/randomizer"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "randomizer_config": ("RANDOMIZER_CONFIG", {}),
+                "loras": ("LORAS", {}),
+            },
+            "optional": {
+                "pool_config": ("POOL_CONFIG", {}),
+            },
+        }
+
+    RETURN_TYPES = ("LORA_STACK",)
+    RETURN_NAMES = ("LORA_STACK",)
+
+    FUNCTION = "randomize"
+    OUTPUT_NODE = False
+
+    def _preprocess_loras_input(self, loras):
+        """
+        Preprocess loras input to handle different widget formats.
+
+        Args:
+            loras: Input from widget, either:
+                  - List of LoRA dicts (expected format)
+                  - Dict with '__value__' key containing the list
+
+        Returns:
+            List of LoRA dicts
+        """
+        if isinstance(loras, dict) and "__value__" in loras:
+            return loras["__value__"]
+        return loras
+
+    async def randomize(self, randomizer_config, loras, pool_config=None):
+        """
+        Randomize LoRAs based on configuration and pool filters.
+
+        Args:
+            randomizer_config: Dict with randomizer settings (count, strength ranges, roll_mode)
+            loras: List of LoRA dicts from LORAS widget (includes locked state)
+            pool_config: Optional config from LoRA Pool node for filtering
+
+        Returns:
+            Dictionary with 'result' (LORA_STACK tuple) and 'ui' (for widget display)
+        """
+        from ..services.service_registry import ServiceRegistry
+
+        loras = self._preprocess_loras_input(loras)
+
+        roll_mode = randomizer_config.get("roll_mode", "always")
+        logger.debug(f"[LoraRandomizerLM] roll_mode: {roll_mode}")
+
+        # Dual seed mechanism for batch queue synchronization
+        # execution_seed: seed for generating execution_stack (= previous next_seed)
+        # next_seed: seed for generating ui_loras (= what will be displayed after execution)
+        execution_seed = randomizer_config.get("execution_seed", None)
+        next_seed = randomizer_config.get("next_seed", None)
+
+        if roll_mode == "fixed":
+            ui_loras = loras
+            execution_loras = loras
+        else:
+            scanner = await ServiceRegistry.get_lora_scanner()
+
+            # Generate execution_loras from execution_seed (if available)
+            if execution_seed is not None:
+                # Use execution_seed to regenerate the same loras that were shown to user
+                execution_loras = await self._generate_random_loras_for_ui(
+                    scanner, randomizer_config, loras, pool_config, seed=execution_seed
+                )
+            else:
+                # First execution: use loras input (what user sees in the widget)
+                execution_loras = loras
+
+            # Generate ui_loras from next_seed (for display after execution)
+            ui_loras = await self._generate_random_loras_for_ui(
+                scanner, randomizer_config, loras, pool_config, seed=next_seed
+            )
+
+        execution_stack = self._build_execution_stack_from_input(execution_loras)
+
+        return {
+            "result": (execution_stack,),
+            "ui": {"loras": ui_loras, "last_used": execution_loras},
+        }
+
+    def _build_execution_stack_from_input(self, loras):
+        """
+        Build LORA_STACK tuple from input loras list for execution.
+
+        Args:
+            loras: List of LoRA dicts with name, strength, clipStrength, active
+
+        Returns:
+            List of tuples (lora_path, model_strength, clip_strength)
+        """
+        lora_stack = []
+        for lora in loras:
+            if not lora.get("active", False):
+                continue
+
+            # Get file path
+            lora_path, trigger_words = get_lora_info(lora["name"])
+            if not lora_path:
+                logger.warning(
+                    f"[LoraRandomizerLM] Could not find path for LoRA: {lora['name']}"
+                )
+                continue
+
+            # Normalize path separators
+            lora_path = lora_path.replace("/", os.sep)
+
+            # Extract strengths (convert to float to prevent string subtraction errors)
+            model_strength = float(lora.get("strength", 1.0))
+            clip_strength = float(lora.get("clipStrength", model_strength))
+
+            lora_stack.append((lora_path, model_strength, clip_strength))
+
+        return lora_stack
+
+    async def _generate_random_loras_for_ui(
+        self, scanner, randomizer_config, input_loras, pool_config=None, seed=None
+    ):
+        """
+        Generate new random loras for UI display.
+
+        Args:
+            scanner: LoraScanner instance
+            randomizer_config: Dict with randomizer settings
+            input_loras: Current input loras (for extracting locked loras)
+            pool_config: Optional pool filters
+            seed: Optional seed for deterministic randomization
+
+        Returns:
+            List of LoRA dicts for UI display
+        """
+        from ..services.lora_service import LoraService
+
+        # Parse randomizer settings (convert numeric values to float to prevent type errors)
+        count_mode = randomizer_config.get("count_mode", "range")
+        count_fixed = int(randomizer_config.get("count_fixed", 5))
+        count_min = int(randomizer_config.get("count_min", 3))
+        count_max = int(randomizer_config.get("count_max", 7))
+        model_strength_min = float(randomizer_config.get("model_strength_min", 0.0))
+        model_strength_max = float(randomizer_config.get("model_strength_max", 1.0))
+        use_same_clip_strength = randomizer_config.get("use_same_clip_strength", True)
+        clip_strength_min = float(randomizer_config.get("clip_strength_min", 0.0))
+        clip_strength_max = float(randomizer_config.get("clip_strength_max", 1.0))
+        use_recommended_strength = randomizer_config.get(
+            "use_recommended_strength", False
+        )
+        recommended_strength_scale_min = float(
+            randomizer_config.get("recommended_strength_scale_min", 0.5)
+        )
+        recommended_strength_scale_max = float(
+            randomizer_config.get("recommended_strength_scale_max", 1.0)
+        )
+
+        # Extract locked LoRAs from input
+        locked_loras = [lora for lora in input_loras if lora.get("locked", False)]
+
+        # Use LoraService to generate random LoRAs
+        lora_service = LoraService(scanner)
+        result_loras = await lora_service.get_random_loras(
+            count=count_fixed,
+            model_strength_min=model_strength_min,
+            model_strength_max=model_strength_max,
+            use_same_clip_strength=use_same_clip_strength,
+            clip_strength_min=clip_strength_min,
+            clip_strength_max=clip_strength_max,
+            locked_loras=locked_loras,
+            pool_config=pool_config,
+            count_mode=count_mode,
+            count_min=count_min,
+            count_max=count_max,
+            use_recommended_strength=use_recommended_strength,
+            recommended_strength_scale_min=recommended_strength_scale_min,
+            recommended_strength_scale_max=recommended_strength_scale_max,
+            seed=seed,
+        )
+
+        return result_loras

py/nodes/lora_stacker.py

@@ -6,7 +6,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-class LoraStacker:
+class LoraStackerLM:
     NAME = "Lora Stacker (LoraManager)"
     CATEGORY = "Lora Manager/stackers"
 
@@ -14,12 +14,9 @@ class LoraStacker:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "text": ("STRING", {
-                    "multiline": True, 
-                    "pysssss.autocomplete": False, 
-                    "dynamicPrompts": True, 
+                "text": ("AUTOCOMPLETE_TEXT_LORAS", {
+                    "placeholder": "Search LoRAs to add...",
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
-                    "placeholder": "LoRA syntax input: <lora:name:strength>"
                 }),
             },
             "optional": FlexibleOptionalInputType(any_type),

py/nodes/prompt.py

@@ -1,6 +1,6 @@
 from typing import Any, Optional
 
-class PromptLoraManager:
+class PromptLM:
     """Encodes text (and optional trigger words) into CLIP conditioning."""
 
     NAME = "Prompt (LoraManager)"
@@ -15,11 +15,10 @@ class PromptLoraManager:
         return {
             "required": {
                 "text": (
-                    'STRING',
+                    "AUTOCOMPLETE_TEXT_PROMPT,STRING",
                     {
-                        "multiline": True,
-                        "pysssss.autocomplete": False, 
-                        "dynamicPrompts": True,
+                        "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
+                        "placeholder": "Enter prompt... /char, /artist for quick tag search",
                         "tooltip": "The text to be encoded.",
                     },
                 ),

py/nodes/save_image.py

@@ -8,8 +8,11 @@ from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
 from PIL import Image, PngImagePlugin
 import piexif
+import logging
 
-class SaveImage:
+logger = logging.getLogger(__name__)
+
+class SaveImageLM:
     NAME = "Save Image (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = "Save images with embedded generation metadata in compatible format"
@@ -385,7 +388,7 @@ class SaveImage:
                             exif_bytes = piexif.dump(exif_dict)
                             save_kwargs["exif"] = exif_bytes
                         except Exception as e:
-                            print(f"Error adding EXIF data: {e}")
+                            logger.error(f"Error adding EXIF data: {e}")
                     img.save(file_path, format="JPEG", **save_kwargs)
                 elif file_format == "webp":
                     try:
@@ -403,7 +406,7 @@ class SaveImage:
                         exif_bytes = piexif.dump(exif_dict)
                         save_kwargs["exif"] = exif_bytes
                     except Exception as e:
-                        print(f"Error adding EXIF data: {e}")
+                        logger.error(f"Error adding EXIF data: {e}")
                     
                     img.save(file_path, format="WEBP", **save_kwargs)
                 
@@ -414,7 +417,7 @@ class SaveImage:
                 })
                 
             except Exception as e:
-                print(f"Error saving image: {e}")
+                logger.error(f"Error saving image: {e}")
         
         return results
 

py/nodes/text.py

@@ -0,0 +1,33 @@
+class TextLM:
+    """A simple text node with autocomplete support."""
+
+    NAME = "Text (LoraManager)"
+    CATEGORY = "Lora Manager/utils"
+    DESCRIPTION = (
+        "A simple text input node with autocomplete support for tags and styles."
+    )
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": (
+                    "AUTOCOMPLETE_TEXT_PROMPT,STRING",
+                    {
+                        "widgetType": "AUTOCOMPLETE_TEXT_PROMPT",
+                        "placeholder": "Enter text... /char, /artist for quick tag search",
+                        "tooltip": "The text output.",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("STRING",)
+    OUTPUT_TOOLTIPS = (
+        "The text output.",
+    )
+    FUNCTION = "process"
+
+    def process(self, text: str):
+        return (text,)

py/nodes/trigger_word_toggle.py

@@ -6,7 +6,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-class TriggerWordToggle:
+class TriggerWordToggleLM:
     NAME = "TriggerWord Toggle (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = "Toggle trigger words on/off"
@@ -15,18 +15,27 @@ class TriggerWordToggle:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "group_mode": ("BOOLEAN", {
-                    "default": True,
-                    "tooltip": "When enabled, treats each group of trigger words as a single toggleable unit."
-                }),
-                "default_active": ("BOOLEAN", {
-                    "default": True,
-                    "tooltip": "Sets the default initial state (active or inactive) when trigger words are added."
-                }),
-                "allow_strength_adjustment": ("BOOLEAN", {
-                    "default": False,
-                    "tooltip": "Enable mouse wheel adjustment of each trigger word's strength."
-                }),
+                "group_mode": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "When enabled, treats each group of trigger words as a single toggleable unit.",
+                    },
+                ),
+                "default_active": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Sets the default initial state (active or inactive) when trigger words are added.",
+                    },
+                ),
+                "allow_strength_adjustment": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "Enable mouse wheel adjustment of each trigger word's strength.",
+                    },
+                ),
             },
             "optional": FlexibleOptionalInputType(any_type),
             "hidden": {
@@ -38,19 +47,35 @@ class TriggerWordToggle:
     RETURN_NAMES = ("filtered_trigger_words",)
     FUNCTION = "process_trigger_words"
 
-    def _get_toggle_data(self, kwargs, key='toggle_trigger_words'):
+    def _get_toggle_data(self, kwargs, key="toggle_trigger_words"):
         """Helper to extract data from either old or new kwargs format"""
         if key not in kwargs:
             return None
 
         data = kwargs[key]
         # Handle new format: {'key': {'__value__': ...}}
-        if isinstance(data, dict) and '__value__' in data:
-            return data['__value__']
+        if isinstance(data, dict) and "__value__" in data:
+            return data["__value__"]
         # Handle old format: {'key': ...}
         else:
             return data
 
+    def _normalize_trigger_words(self, trigger_words):
+        """Normalize trigger words by splitting by both single and double commas, stripping whitespace, and filtering empty strings"""
+        if not trigger_words or not isinstance(trigger_words, str):
+            return set()
+        
+        # Split by double commas first to preserve groups, then by single commas
+        groups = re.split(r",{2,}", trigger_words)
+        words = []
+        for group in groups:
+            # Split each group by single comma
+            group_words = [word.strip() for word in group.split(",")]
+            words.extend(group_words)
+        
+        # Filter out empty strings and return as set
+        return set(word for word in words if word)
+
     def process_trigger_words(
         self,
         id,
@@ -60,115 +85,116 @@ class TriggerWordToggle:
         **kwargs,
     ):
         # Handle both old and new formats for trigger_words
-        trigger_words_data = self._get_toggle_data(kwargs, 'orinalMessage')
-        trigger_words = trigger_words_data if isinstance(trigger_words_data, str) else ""
+        trigger_words_data = self._get_toggle_data(kwargs, "orinalMessage")
+        trigger_words = (
+            trigger_words_data if isinstance(trigger_words_data, str) else ""
+        )
 
         filtered_triggers = trigger_words
 
+        # Check if trigger_words is provided and different from orinalMessage
+        trigger_words_override = self._get_toggle_data(kwargs, "trigger_words")
+        if (
+            trigger_words_override
+            and isinstance(trigger_words_override, str)
+            and self._normalize_trigger_words(trigger_words_override) != self._normalize_trigger_words(trigger_words)
+        ):
+            filtered_triggers = trigger_words_override
+            return (filtered_triggers,)
+
         # Get toggle data with support for both formats
-        trigger_data = self._get_toggle_data(kwargs, 'toggle_trigger_words')
+        trigger_data = self._get_toggle_data(kwargs, "toggle_trigger_words")
         if trigger_data:
             try:
                 # Convert to list if it's a JSON string
                 if isinstance(trigger_data, str):
                     trigger_data = json.loads(trigger_data)
 
-                # Create dictionaries to track active state of words or groups
-                # Also track strength values for each trigger word
-                active_state = {}
-                strength_map = {}
-                
-                for item in trigger_data:
-                    text = item['text']
-                    active = item.get('active', False)
-                    # Extract strength if it's in the format "(word:strength)"
-                    strength_match = re.match(r'\((.+):([\d.]+)\)', text)
-                    if strength_match:
-                        original_word = strength_match.group(1).strip()
-                        strength = float(strength_match.group(2))
-                        active_state[original_word] = active
+                if isinstance(trigger_data, list):
+                    if group_mode:
                         if allow_strength_adjustment:
-                            strength_map[original_word] = strength
-                    else:
-                        active_state[text.strip()] = active
-
-                if group_mode:
-                    if isinstance(trigger_data, list):
-                        filtered_groups = []
-                        for item in trigger_data:
-                            text = (item.get('text') or "").strip()
-                            if not text:
-                                continue
-                            if item.get('active', False):
-                                filtered_groups.append(text)
-
-                        if filtered_groups:
-                            filtered_triggers = ', '.join(filtered_groups)
-                        else:
-                            filtered_triggers = ""
-                    else:
-                        # Split by two or more consecutive commas to get groups
-                        groups = re.split(r',{2,}', trigger_words)
-                        # Remove leading/trailing whitespace from each group
-                        groups = [group.strip() for group in groups]
-                        
-                        # Process groups: keep those not in toggle_trigger_words or those that are active
-                        filtered_groups = []
-                        for group in groups:
-                            # Check if this group contains any words that are in the active_state
-                            group_words = [word.strip() for word in group.split(',')]
-                            active_group_words = []
-                            
-                            for word in group_words:
-                                word_comparison = re.sub(r'\((.+):([\d.]+)\)', r'\1', word).strip()
-                                
-                                if word_comparison not in active_state or active_state[word_comparison]:
-                                    active_group_words.append(
-                                        self._format_word_output(
-                                            word_comparison,
-                                            strength_map,
-                                            allow_strength_adjustment,
-                                        )
-                                    )
-                            
-                            if active_group_words:
-                                filtered_groups.append(', '.join(active_group_words))
-                        
-                        if filtered_groups:
-                            filtered_triggers = ', '.join(filtered_groups)
-                        else:
-                            filtered_triggers = ""
-                else:
-                    # Normal mode: split by commas and treat each word as a separate tag
-                    original_words = [word.strip() for word in trigger_words.split(',')]
-                    # Filter out empty strings
-                    original_words = [word for word in original_words if word]
-                    
-                    filtered_words = []
-                    for word in original_words:
-                        # Remove any existing strength formatting for comparison
-                        word_comparison = re.sub(r'\((.+):([\d.]+)\)', r'\1', word).strip()
-                        
-                        if word_comparison not in active_state or active_state[word_comparison]:
-                            filtered_words.append(
+                            parsed_items = [
+                                self._parse_trigger_item(
+                                    item, allow_strength_adjustment
+                                )
+                                for item in trigger_data
+                            ]
+                            filtered_groups = [
                                 self._format_word_output(
-                                    word_comparison,
-                                    strength_map,
+                                    item["text"],
+                                    item["strength"],
                                     allow_strength_adjustment,
                                 )
-                            )
-                    
-                    if filtered_words:
-                        filtered_triggers = ', '.join(filtered_words)
+                                for item in parsed_items
+                                if item["text"] and item["active"]
+                            ]
+                        else:
+                            filtered_groups = [
+                                (item.get("text") or "").strip()
+                                for item in trigger_data
+                                if (item.get("text") or "").strip()
+                                and item.get("active", False)
+                            ]
+                        filtered_triggers = (
+                            ", ".join(filtered_groups) if filtered_groups else ""
+                        )
                     else:
-                        filtered_triggers = ""
+                        parsed_items = [
+                            self._parse_trigger_item(item, allow_strength_adjustment)
+                            for item in trigger_data
+                        ]
+                        filtered_words = [
+                            self._format_word_output(
+                                item["text"],
+                                item["strength"],
+                                allow_strength_adjustment,
+                            )
+                            for item in parsed_items
+                            if item["text"] and item["active"]
+                        ]
+                        filtered_triggers = (
+                            ", ".join(filtered_words) if filtered_words else ""
+                        )
+                else:
+                    # Fallback to original message parsing if data is not in the expected list format
+                    if group_mode:
+                        groups = re.split(r",{2,}", trigger_words)
+                        groups = [group.strip() for group in groups if group.strip()]
+                        filtered_triggers = ", ".join(groups)
+                    else:
+                        words = [
+                            word.strip()
+                            for word in trigger_words.split(",")
+                            if word.strip()
+                        ]
+                        filtered_triggers = ", ".join(words)
 
             except Exception as e:
                 logger.error(f"Error processing trigger words: {e}")
 
         return (filtered_triggers,)
 
-    def _format_word_output(self, base_word, strength_map, allow_strength_adjustment):
-        if allow_strength_adjustment and base_word in strength_map:
-            return f"({base_word}:{strength_map[base_word]:.2f})"
+    def _parse_trigger_item(self, item, allow_strength_adjustment):
+        text = (item.get("text") or "").strip()
+        active = bool(item.get("active", False))
+        strength = item.get("strength")
+
+        strength_match = re.match(r"^\((.+):([\d.]+)\)$", text)
+        if strength_match:
+            text = strength_match.group(1).strip()
+            if strength is None:
+                try:
+                    strength = float(strength_match.group(2))
+                except ValueError:
+                    strength = None
+
+        return {
+            "text": text,
+            "active": active,
+            "strength": strength if allow_strength_adjustment else None,
+        }
+
+    def _format_word_output(self, base_word, strength, allow_strength_adjustment):
+        if allow_strength_adjustment and strength is not None:
+            return f"({base_word}:{strength:.2f})"
         return base_word

py/nodes/utils.py

@@ -36,6 +36,7 @@ any_type = AnyType("*")
 import os
 import logging
 import copy
+import sys
 import folder_paths
 
 logger = logging.getLogger(__name__)
@@ -98,25 +99,37 @@ def to_diffusers(input_lora):
 
 def nunchaku_load_lora(model, lora_name, lora_strength):
     """Load a Flux LoRA for Nunchaku model"""   
-    model_wrapper = model.model.diffusion_model
-    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
-    
     # 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)
     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
 
-    ret_model_wrapper.loras.append((lora_path, lora_strength))
+    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)
+    copy_with_ctx = getattr(module, "copy_with_ctx", None)
+
+    if copy_with_ctx is not None:
+        # New logic using copy_with_ctx from ComfyUI-nunchaku 1.1.0+
+        ret_model_wrapper, ret_model = copy_with_ctx(model_wrapper)
+        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.")
+        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
+        ret_model_wrapper.loras.append((lora_path, lora_strength))
 
     # Convert the LoRA to diffusers format
     sd = to_diffusers(lora_path)

py/nodes/wanvideo_lora_select.py

@@ -5,7 +5,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-class WanVideoLoraSelect:
+class WanVideoLoraSelectLM:
     NAME = "WanVideo Lora Select (LoraManager)"
     CATEGORY = "Lora Manager/stackers"
 
@@ -15,12 +15,9 @@ class WanVideoLoraSelect:
             "required": {
                 "low_mem_load": ("BOOLEAN", {"default": False, "tooltip": "Load LORA models with less VRAM usage, slower loading. This affects ALL LoRAs, not just the current ones. No effect if merge_loras is False"}),
                 "merge_loras": ("BOOLEAN", {"default": True, "tooltip": "Merge LoRAs into the model, otherwise they are loaded on the fly. Always disabled for GGUF and scaled fp8 models. This affects ALL LoRAs, not just the current one"}),
-                "text": ("STRING", {
-                    "multiline": True, 
-                    "pysssss.autocomplete": False, 
-                    "dynamicPrompts": True, 
+                "text": ("AUTOCOMPLETE_TEXT_LORAS", {
+                    "placeholder": "Search LoRAs to add...",
                     "tooltip": "Format: <lora:lora_name:strength> separated by spaces or punctuation",
-                    "placeholder": "LoRA syntax input: <lora:name:strength>"
                 }),
             },
             "optional": FlexibleOptionalInputType(any_type),

py/nodes/wanvideo_lora_select_from_text.py

@@ -7,7 +7,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 # 定义新节点的类
-class WanVideoLoraSelectFromText:
+class WanVideoLoraTextSelectLM:
     # 节点在UI中显示的名称
     NAME = "WanVideo Lora Select From Text (LoraManager)"
     # 节点所属的分类
@@ -115,11 +115,3 @@ class WanVideoLoraSelectFromText:
         active_loras_text = " ".join(formatted_loras)
 
         return (loras_list, trigger_words_text, active_loras_text)
-
-NODE_CLASS_MAPPINGS = {
-    "WanVideoLoraSelectFromText": WanVideoLoraSelectFromText
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "WanVideoLoraSelectFromText": "WanVideo Lora Select From Text (LoraManager)"
-}

py/recipes/base.py

@@ -37,7 +37,8 @@ class RecipeMetadataParser(ABC):
         """
         pass
     
-    async def populate_lora_from_civitai(self, lora_entry: Dict[str, Any], civitai_info_tuple: Tuple[Dict[str, Any], Optional[str]], 
+    @staticmethod
+    async def populate_lora_from_civitai(lora_entry: Dict[str, Any], civitai_info_tuple: Tuple[Dict[str, Any], Optional[str]], 
                                          recipe_scanner=None, base_model_counts=None, hash_value=None) -> Optional[Dict[str, Any]]:
         """
         Populate a lora entry with information from Civitai API response
@@ -149,7 +150,8 @@ class RecipeMetadataParser(ABC):
             
         return lora_entry
     
-    async def populate_checkpoint_from_civitai(self, checkpoint: Dict[str, Any], civitai_info: Dict[str, Any]) -> Dict[str, Any]:
+    @staticmethod
+    async def populate_checkpoint_from_civitai(checkpoint: Dict[str, Any], civitai_info: Dict[str, Any]) -> Dict[str, Any]:
         """
         Populate checkpoint information from Civitai API response
         
@@ -187,6 +189,7 @@ class RecipeMetadataParser(ABC):
             checkpoint['downloadUrl'] = civitai_data.get('downloadUrl', '')
 
             checkpoint['modelId'] = civitai_data.get('modelId', checkpoint.get('modelId', 0))
+            checkpoint['id'] = civitai_data.get('id', 0)
 
             if 'files' in civitai_data:
                 model_file = next(

py/recipes/enrichment.py

@@ -0,0 +1,216 @@
+import logging
+import json
+import re
+import os
+from typing import Any, Dict, Optional
+from .merger import GenParamsMerger
+from .base import RecipeMetadataParser
+from ..services.metadata_service import get_default_metadata_provider
+
+logger = logging.getLogger(__name__)
+
+class RecipeEnricher:
+    """Service to enrich recipe metadata from multiple sources (Civitai, Embedded, User)."""
+
+    @staticmethod
+    async def enrich_recipe(
+        recipe: Dict[str, Any],
+        civitai_client: Any,
+        request_params: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Enrich a recipe dictionary in-place with metadata from Civitai and embedded params.
+        
+        Args:
+            recipe: The recipe dictionary to enrich. Must have 'gen_params' initialized.
+            civitai_client: Authenticated Civitai client instance.
+            request_params: (Optional) Parameters from a user request (e.g. import).
+            
+        Returns:
+            bool: True if the recipe was modified, False otherwise.
+        """
+        updated = False
+        gen_params = recipe.get("gen_params", {})
+        
+        # 1. Fetch Civitai Info if available
+        civitai_meta = None
+        model_version_id = None
+        
+        source_url = recipe.get("source_url") or recipe.get("source_path", "")
+        
+        # Check if it's a Civitai image URL
+        image_id_match = re.search(r'civitai\.com/images/(\d+)', str(source_url))
+        if image_id_match:
+            image_id = image_id_match.group(1)
+            try:
+                image_info = await civitai_client.get_image_info(image_id)
+                if image_info:
+                    # Handle nested meta often found in Civitai API responses
+                    raw_meta = image_info.get("meta")
+                    if isinstance(raw_meta, dict):
+                        if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
+                            civitai_meta = raw_meta["meta"]
+                        else:
+                            civitai_meta = raw_meta
+                    
+                    model_version_id = image_info.get("modelVersionId")
+                    
+                    # If not at top level, check resources in meta
+                    if not model_version_id and civitai_meta:
+                        resources = civitai_meta.get("civitaiResources", [])
+                        for res in resources:
+                            if res.get("type") == "checkpoint":
+                                model_version_id = res.get("modelVersionId")
+                                break
+            except Exception as e:
+                logger.warning(f"Failed to fetch Civitai image info: {e}")
+
+        # 2. Merge Parameters
+        # Priority: request_params > civitai_meta > embedded (existing gen_params)
+        new_gen_params = GenParamsMerger.merge(
+            request_params=request_params,
+            civitai_meta=civitai_meta,
+            embedded_metadata=gen_params
+        )
+        
+        if new_gen_params != gen_params:
+            recipe["gen_params"] = new_gen_params
+            updated = True
+        
+        # 3. Checkpoint Enrichment
+        # If we have a checkpoint entry, or we can find one
+        # Use 'id' (from Civitai version) as a marker that it's been enriched
+        checkpoint_entry = recipe.get("checkpoint")
+        has_full_checkpoint = checkpoint_entry and checkpoint_entry.get("name") and checkpoint_entry.get("id")
+        
+        if not has_full_checkpoint:
+            # Helper to look up values in priority order
+            def start_lookup(keys):
+                for source in [request_params, civitai_meta, gen_params]:
+                    if source:
+                        if isinstance(keys, list):
+                            for k in keys:
+                                if k in source: return source[k]
+                        else:
+                            if keys in source: return source[keys]
+                return None
+
+            target_version_id = model_version_id or start_lookup("modelVersionId")
+            
+            # Also check existing checkpoint entry
+            if not target_version_id and checkpoint_entry:
+                target_version_id = checkpoint_entry.get("modelVersionId") or checkpoint_entry.get("id")
+            
+            # Check for version ID in resources (which might be a string in gen_params)
+            if not target_version_id:
+                # Look in all sources for "Civitai resources"
+                resources_val = start_lookup(["Civitai resources", "civitai_resources", "resources"])
+                if resources_val:
+                    target_version_id = RecipeEnricher._extract_version_id_from_resources({"Civitai resources": resources_val})
+            
+            target_hash = start_lookup(["Model hash", "checkpoint_hash", "hashes"])
+            if not target_hash and checkpoint_entry:
+                target_hash = checkpoint_entry.get("hash") or checkpoint_entry.get("model_hash")
+            
+            # Look for 'Model' which sometimes is the hash or name
+            model_val = start_lookup("Model")
+
+            # Look for Checkpoint name fallback
+            checkpoint_val = checkpoint_entry.get("name") if checkpoint_entry else None
+            if not checkpoint_val:
+                checkpoint_val = start_lookup(["Checkpoint", "checkpoint"])
+
+            checkpoint_updated = await RecipeEnricher._resolve_and_populate_checkpoint(
+                recipe, target_version_id, target_hash, model_val, checkpoint_val
+            )
+            if checkpoint_updated:
+                updated = True
+        else:
+            # Checkpoint exists, no need to sync to gen_params anymore.
+            pass
+        # base_model resolution moved to _resolve_and_populate_checkpoint to support strict formatting
+        return updated
+        
+    @staticmethod
+    def _extract_version_id_from_resources(gen_params: Dict[str, Any]) -> Optional[Any]:
+        """Try to find modelVersionId in Civitai resources parameter."""
+        civitai_resources_raw = gen_params.get("Civitai resources")
+        if not civitai_resources_raw:
+            return None
+            
+        resources_list = None
+        if isinstance(civitai_resources_raw, str):
+            try:
+                resources_list = json.loads(civitai_resources_raw)
+            except Exception:
+                pass
+        elif isinstance(civitai_resources_raw, list):
+            resources_list = civitai_resources_raw
+            
+        if isinstance(resources_list, list):
+            for res in resources_list:
+                if res.get("type") == "checkpoint":
+                    return res.get("modelVersionId")
+        return None
+
+    @staticmethod
+    async def _resolve_and_populate_checkpoint(
+        recipe: Dict[str, Any], 
+        target_version_id: Optional[Any], 
+        target_hash: Optional[str],
+        model_val: Optional[str],
+        checkpoint_val: Optional[str]
+    ) -> bool:
+        """Find checkpoint metadata and populate it in the recipe."""
+        metadata_provider = await get_default_metadata_provider()
+        civitai_info = None
+        
+        if target_version_id:
+            civitai_info = await metadata_provider.get_model_version_info(str(target_version_id))
+        elif target_hash:
+            civitai_info = await metadata_provider.get_model_by_hash(target_hash)
+        else:
+            # Look for 'Model' which sometimes is the hash or name
+            if model_val and len(model_val) == 10: # Likely a short hash
+                civitai_info = await metadata_provider.get_model_by_hash(model_val)
+                
+        if civitai_info and not (isinstance(civitai_info, tuple) and civitai_info[1] == "Model not found"):
+            # If we already have a partial checkpoint, use it as base
+            existing_cp = recipe.get("checkpoint")
+            if existing_cp is None:
+                existing_cp = {}
+            checkpoint_data = await RecipeMetadataParser.populate_checkpoint_from_civitai(existing_cp, civitai_info)
+            # 1. First, resolve base_model using full data before we format it away
+            current_base_model = recipe.get("base_model")
+            resolved_base_model = checkpoint_data.get("baseModel")
+            if resolved_base_model:
+                # Update if empty OR if it matches our generic prefix but is less specific
+                is_generic = not current_base_model or current_base_model.lower() in ["flux", "sdxl", "sd15"]
+                if is_generic and resolved_base_model != current_base_model:
+                    recipe["base_model"] = resolved_base_model
+            
+            # 2. Format according to requirements: type, modelId, modelVersionId, modelName, modelVersionName
+            formatted_checkpoint = {
+                "type": "checkpoint",
+                "modelId": checkpoint_data.get("modelId"),
+                "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
+                "modelName": checkpoint_data.get("name"), # In base.py, 'name' is populated from civitai_data['model']['name']
+                "modelVersionName": checkpoint_data.get("version") # In base.py, 'version' is populated from civitai_data['name']
+            }
+            # Remove None values
+            recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
+            
+            return True
+        else:
+            # Fallback to name extraction if we don't already have one
+            existing_cp = recipe.get("checkpoint")
+            if not existing_cp or not existing_cp.get("modelName"):
+                cp_name = checkpoint_val
+                if cp_name:
+                    recipe["checkpoint"] = {
+                        "type": "checkpoint",
+                        "modelName": cp_name
+                    }
+                    return True
+                
+        return False

py/recipes/merger.py

@@ -0,0 +1,98 @@
+from typing import Any, Dict, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GenParamsMerger:
+    """Utility to merge generation parameters from multiple sources with priority."""
+
+    BLACKLISTED_KEYS = {
+        "id", "url", "userId", "username", "createdAt", "updatedAt", "hash", "meta",
+        "draft", "extra", "width", "height", "process", "quantity", "workflow",
+        "baseModel", "resources", "disablePoi", "aspectRatio", "Created Date",
+        "experimental", "civitaiResources", "civitai_resources", "Civitai resources",
+        "modelVersionId", "modelId", "hashes", "Model", "Model hash", "checkpoint_hash",
+        "checkpoint", "checksum", "model_checksum"
+    }
+    
+    NORMALIZATION_MAPPING = {
+        # Civitai specific
+        "cfgScale": "cfg_scale",
+        "clipSkip": "clip_skip",
+        "negativePrompt": "negative_prompt",
+        # Case variations
+        "Sampler": "sampler",
+        "Steps": "steps",
+        "Seed": "seed",
+        "Size": "size",
+        "Prompt": "prompt",
+        "Negative prompt": "negative_prompt",
+        "Cfg scale": "cfg_scale",
+        "Clip skip": "clip_skip",
+        "Denoising strength": "denoising_strength",
+    }
+
+    @staticmethod
+    def merge(
+        request_params: Optional[Dict[str, Any]] = None,
+        civitai_meta: Optional[Dict[str, Any]] = None,
+        embedded_metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Merge generation parameters from three sources.
+        
+        Priority: request_params > civitai_meta > embedded_metadata
+        
+        Args:
+            request_params: Params provided directly in the import request
+            civitai_meta: Params from Civitai Image API 'meta' field
+            embedded_metadata: Params extracted from image EXIF/embedded metadata
+            
+        Returns:
+            Merged parameters dictionary
+        """
+        result = {}
+
+        # 1. Start with embedded metadata (lowest priority)
+        if embedded_metadata:
+            # If it's a full recipe metadata, we use its gen_params
+            if "gen_params" in embedded_metadata and isinstance(embedded_metadata["gen_params"], dict):
+                GenParamsMerger._update_normalized(result, embedded_metadata["gen_params"])
+            else:
+                # Otherwise assume the dict itself contains gen_params
+                GenParamsMerger._update_normalized(result, embedded_metadata)
+
+        # 2. Layer Civitai meta (medium priority)
+        if civitai_meta:
+            GenParamsMerger._update_normalized(result, civitai_meta)
+
+        # 3. Layer request params (highest priority)
+        if request_params:
+            GenParamsMerger._update_normalized(result, request_params)
+
+        # Filter out blacklisted keys and also the original camelCase keys if they were normalized
+        final_result = {}
+        for k, v in result.items():
+            if k in GenParamsMerger.BLACKLISTED_KEYS:
+                continue
+            if k in GenParamsMerger.NORMALIZATION_MAPPING:
+                continue
+            final_result[k] = v
+            
+        return final_result
+
+    @staticmethod
+    def _update_normalized(target: Dict[str, Any], source: Dict[str, Any]) -> None:
+        """Update target dict with normalized keys from source."""
+        for k, v in source.items():
+            normalized_key = GenParamsMerger.NORMALIZATION_MAPPING.get(k, k)
+            target[normalized_key] = v
+            # Also keep the original key for now if it's not the same, 
+            # so we can filter at the end or avoid losing it if it wasn't supposed to be renamed?
+            # Actually, if we rename it, we should probably NOT keep both in 'target' 
+            # because we want to filter them out at the end anyway.
+            if normalized_key != k:
+                # If we are overwriting an existing snake_case key with a camelCase one's value,
+                # that's fine because of the priority order of calls to _update_normalized.
+                pass
+            target[k] = v

py/recipes/parsers/automatic.py

@@ -1,6 +1,7 @@
 """Parser for Automatic1111 metadata format."""
 
 import re
+import os
 import json
 import logging
 from typing import Dict, Any
@@ -22,6 +23,7 @@ class AutomaticMetadataParser(RecipeMetadataParser):
     CIVITAI_METADATA_REGEX = r', Civitai metadata:\s*(\{.*?\})'
     EXTRANETS_REGEX = r'<(lora|hypernet):([^:]+):(-?[0-9.]+)>'
     MODEL_HASH_PATTERN = r'Model hash: ([a-zA-Z0-9]+)'
+    MODEL_NAME_PATTERN = r'Model: ([^,]+)'
     VAE_HASH_PATTERN = r'VAE hash: ([a-zA-Z0-9]+)'
     
     def is_metadata_matching(self, user_comment: str) -> bool:
@@ -115,6 +117,12 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         except json.JSONDecodeError:
                             logger.error("Error parsing hashes JSON")
                     
+                    # Pick up model hash from parsed hashes if available
+                    if "hashes" in metadata and not metadata.get("model_hash"):
+                        model_hash_from_hashes = metadata["hashes"].get("model")
+                        if model_hash_from_hashes:
+                            metadata["model_hash"] = model_hash_from_hashes
+                    
                     # Extract Lora hashes in alternative format
                     lora_hashes_match = re.search(self.LORA_HASHES_REGEX, params_section)
                     if not hashes_match and lora_hashes_match:
@@ -138,6 +146,17 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         except Exception as e:
                             logger.error(f"Error parsing Lora hashes: {e}")
 
+                    # Extract checkpoint model hash/name when provided outside Civitai resources
+                    model_hash_match = re.search(self.MODEL_HASH_PATTERN, params_section)
+                    if model_hash_match:
+                        metadata["model_hash"] = model_hash_match.group(1).strip()
+                        params_section = params_section.replace(model_hash_match.group(0), '')
+
+                    model_name_match = re.search(self.MODEL_NAME_PATTERN, params_section)
+                    if model_name_match:
+                        metadata["model_name"] = model_name_match.group(1).strip()
+                        params_section = params_section.replace(model_name_match.group(0), '')
+                    
                     # Extract basic parameters
                     param_pattern = r'([A-Za-z\s]+): ([^,]+)'
                     params = re.findall(param_pattern, params_section)
@@ -178,9 +197,10 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                     
                     metadata["gen_params"] = gen_params
             
-            # Extract LoRA information 
+            # Extract LoRA and checkpoint information 
             loras = []
             base_model_counts = {}
+            checkpoint = None
             
             # First use Civitai resources if available (more reliable source)
             if metadata.get("civitai_resources"):
@@ -202,6 +222,50 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                             resource["modelVersionId"] = air_modelVersionId
                     # --- End added ---
 
+                    if resource.get("type") == "checkpoint" and resource.get("modelVersionId"):
+                        version_id = resource.get("modelVersionId")
+                        version_id_str = str(version_id)
+                        checkpoint_entry = {
+                            'id': version_id,
+                            'modelId': resource.get("modelId", 0),
+                            'name': resource.get("modelName", "Unknown Checkpoint"),
+                            'version': resource.get("modelVersionName", resource.get("versionName", "")),
+                            '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 metadata_provider:
+                            try:
+                                civitai_info = await metadata_provider.get_model_version_info(version_id_str)
+                                checkpoint_entry = await self.populate_checkpoint_from_civitai(
+                                    checkpoint_entry,
+                                    civitai_info
+                                )
+                            except Exception as e:
+                                logger.error(
+                                    "Error fetching Civitai info for checkpoint version %s: %s",
+                                    version_id,
+                                    e,
+                                )
+
+                        # Prefer the first checkpoint found
+                        if checkpoint_entry.get("baseModel"):
+                            base_model_value = checkpoint_entry["baseModel"]
+                            base_model_counts[base_model_value] = base_model_counts.get(base_model_value, 0) + 1
+
+                        if checkpoint is None:
+                            checkpoint = checkpoint_entry
+
+                        continue
+
                     if resource.get("type") in ["lora", "lycoris", "hypernet"] and resource.get("modelVersionId"):
                         # Initialize lora entry
                         lora_entry = {
@@ -237,6 +301,52 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         
                         loras.append(lora_entry)
             
+            # Fallback checkpoint parsing from generic "Model" and "Model hash" fields
+            if checkpoint is None:
+                model_hash = metadata.get("model_hash")
+                if not model_hash and metadata.get("hashes"):
+                    model_hash = metadata["hashes"].get("model")
+
+                model_name = metadata.get("model_name")
+                file_name = ""
+                if model_name:
+                    cleaned_name = re.split(r"[\\\\/]", model_name)[-1]
+                    file_name = os.path.splitext(cleaned_name)[0]
+
+                if model_hash or model_name:
+                    checkpoint_entry = {
+                        'id': 0,
+                        'modelId': 0,
+                        'name': model_name or "Unknown Checkpoint",
+                        'version': '',
+                        'type': 'checkpoint',
+                        'hash': model_hash or "",
+                        'existsLocally': False,
+                        'localPath': None,
+                        'file_name': file_name,
+                        'thumbnailUrl': '/loras_static/images/no-preview.png',
+                        'baseModel': '',
+                        'size': 0,
+                        'downloadUrl': '',
+                        'isDeleted': False
+                    }
+
+                    if metadata_provider and model_hash:
+                        try:
+                            civitai_info = await metadata_provider.get_model_by_hash(model_hash)
+                            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 hash {model_hash}: {e}")
+
+                    if checkpoint_entry.get("baseModel"):
+                        base_model_value = checkpoint_entry["baseModel"]
+                        base_model_counts[base_model_value] = base_model_counts.get(base_model_value, 0) + 1
+
+                    checkpoint = checkpoint_entry
+
             # If no LoRAs from Civitai resources or to supplement, extract from metadata["hashes"]
             if not loras or len(loras) == 0:
                 # Extract lora weights from extranet tags in prompt (for later use)
@@ -300,7 +410,9 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                 
             # Try to get base model from resources or make educated guess
             base_model = None
-            if base_model_counts:
+            if checkpoint and checkpoint.get("baseModel"):
+                base_model = checkpoint.get("baseModel")
+            elif base_model_counts:
                 # Use the most common base model from the loras
                 base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
             
@@ -318,6 +430,10 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                 'from_automatic_metadata': True
             }
 
+            if checkpoint:
+                result['checkpoint'] = checkpoint
+                result['model'] = checkpoint
+            
             return result
             
         except Exception as e:

py/recipes/parsers/civitai_image.py

@@ -24,12 +24,47 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
         if not metadata or not isinstance(metadata, dict):
             return False
 
-        # Check for key markers specific to Civitai image metadata
-        return any([
-            "resources" in metadata,
-            "civitaiResources" in metadata,
-            "additionalResources" in metadata
-        ])
+        def has_markers(payload: Dict[str, Any]) -> bool:
+            # Check for common CivitAI image metadata fields
+            civitai_image_fields = (
+                "resources",
+                "civitaiResources", 
+                "additionalResources",
+                "hashes",
+                "prompt",
+                "negativePrompt",
+                "steps",
+                "sampler",
+                "cfgScale",
+                "seed",
+                "width",
+                "height",
+                "Model",
+                "Model hash"
+            )
+            return any(key in payload for key in civitai_image_fields)
+
+        # Check the main metadata object
+        if has_markers(metadata):
+            return True
+
+        # Check for LoRA hash patterns
+        hashes = metadata.get("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)
+        nested_meta = metadata.get("meta")
+        if isinstance(nested_meta, dict):
+            if has_markers(nested_meta):
+                return True
+
+            # 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):
+                return True
+
+        return False
     
     async def parse_metadata(self, metadata, recipe_scanner=None, civitai_client=None) -> Dict[str, Any]:
         """Parse metadata from Civitai image format
@@ -46,6 +81,26 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             # Get metadata provider instead of using civitai_client directly
             metadata_provider = await get_default_metadata_provider()
 
+            # Civitai image responses may wrap the actual metadata inside a "meta" key
+            if (
+                isinstance(metadata, dict)
+                and "meta" in metadata
+                and isinstance(metadata["meta"], dict)
+            ):
+                inner_meta = metadata["meta"]
+                if any(
+                    key in inner_meta
+                    for key in (
+                        "resources",
+                        "civitaiResources",
+                        "additionalResources",
+                        "hashes",
+                        "prompt",
+                        "negativePrompt",
+                    )
+                ):
+                    metadata = inner_meta
+            
             # Initialize result structure
             result = {
                 'base_model': None,
@@ -62,8 +117,9 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             lora_hashes = {}
             if "hashes" in metadata and isinstance(metadata["hashes"], dict):
                 for key, hash_value in metadata["hashes"].items():
-                    if key.startswith("LORA:"):
-                        lora_name = key.replace("LORA:", "")
+                    key_str = str(key)
+                    if key_str.lower().startswith("lora:"):
+                        lora_name = key_str.split(":", 1)[1]
                         lora_hashes[lora_name] = hash_value
             
             # Extract prompt and negative prompt

py/recipes/parsers/comfy.py

@@ -36,9 +36,6 @@ class ComfyMetadataParser(RecipeMetadataParser):
             # Find all LoraLoader nodes
             lora_nodes = {k: v for k, v in data.items() if isinstance(v, dict) and v.get('class_type') == 'LoraLoader'}
             
-            if not lora_nodes:
-                return {"error": "No LoRA information found in this ComfyUI workflow", "loras": []}
-            
             # Process each LoraLoader node
             for node_id, node in lora_nodes.items():
                 if 'inputs' not in node or 'lora_name' not in node['inputs']:

py/recipes/parsers/meta_format.py

@@ -1,5 +1,6 @@
 """Parser for meta format (Lora_N Model hash) metadata."""
 
+import os
 import re
 import logging
 from typing import Dict, Any
@@ -145,14 +146,53 @@ class MetaFormatParser(RecipeMetadataParser):
                 
                 loras.append(lora_entry)
             
-            # Extract model information
-            model = None
-            if 'model' in metadata:
-                model = metadata['model']
+            # Extract checkpoint information from generic Model/Model hash fields
+            checkpoint = None
+            model_hash = metadata.get("model_hash")
+            model_name = metadata.get("model")
 
-            # Set base_model to the most common one from civitai_info
-            base_model = None
-            if base_model_counts:
+            if model_hash or model_name:
+                cleaned_name = None
+                if model_name:
+                    cleaned_name = re.split(r"[\\\\/]", model_name)[-1]
+                    cleaned_name = os.path.splitext(cleaned_name)[0]
+
+                checkpoint_entry = {
+                    'id': 0,
+                    'modelId': 0,
+                    'name': model_name or "Unknown Checkpoint",
+                    'version': '',
+                    'type': 'checkpoint',
+                    'hash': model_hash or "",
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': cleaned_name or (model_name or ""),
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+
+                if metadata_provider and model_hash:
+                    try:
+                        civitai_info = await metadata_provider.get_model_by_hash(model_hash)
+                        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 hash {model_hash}: {e}")
+
+                if checkpoint_entry.get("baseModel"):
+                    base_model_value = checkpoint_entry["baseModel"]
+                    base_model_counts[base_model_value] = base_model_counts.get(base_model_value, 0) + 1
+
+                checkpoint = checkpoint_entry
+            
+            # Set base_model to the most common one from civitai_info or checkpoint
+            base_model = checkpoint["baseModel"] if checkpoint and checkpoint.get("baseModel") else None
+            if not base_model and base_model_counts:
                 base_model = max(base_model_counts.items(), key=lambda x: x[1])[0]
             
             # Extract generation parameters for recipe metadata
@@ -170,7 +210,8 @@ class MetaFormatParser(RecipeMetadataParser):
                 'loras': loras,
                 'gen_params': gen_params,
                 'raw_metadata': metadata,
-                'from_meta_format': True
+                'from_meta_format': True,
+                **({'checkpoint': checkpoint, 'model': checkpoint} if checkpoint else {})
             }
             
         except Exception as e:

py/recipes/parsers/recipe_format.py

@@ -3,7 +3,7 @@
 import re
 import json
 import logging
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 from ...config import config
 from ..base import RecipeMetadataParser
 from ..constants import GEN_PARAM_KEYS
@@ -17,6 +17,28 @@ class RecipeFormatParser(RecipeMetadataParser):
     # Regular expression pattern for extracting recipe metadata
     METADATA_MARKER = r'Recipe metadata: (\{.*\})'
 
+    async def _get_lora_from_version_index(self, recipe_scanner, model_version_id: Any) -> Optional[Dict[str, Any]]:
+        """Return a cached LoRA entry by modelVersionId if available."""
+
+        if not recipe_scanner or not getattr(recipe_scanner, "_lora_scanner", None):
+            return None
+
+        try:
+            normalized_id = int(model_version_id)
+        except (TypeError, ValueError):
+            return None
+
+        try:
+            cache = await recipe_scanner._lora_scanner.get_cached_data()
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.debug("Unable to load lora cache for version lookup: %s", exc)
+            return None
+
+        if not cache or not getattr(cache, "version_index", None):
+            return None
+
+        return cache.version_index.get(normalized_id)
+    
     def is_metadata_matching(self, user_comment: str) -> bool:
         """Check if the user comment matches the metadata format"""
         return re.search(self.METADATA_MARKER, user_comment, re.IGNORECASE | re.DOTALL) is not None
@@ -53,50 +75,111 @@ class RecipeFormatParser(RecipeMetadataParser):
                     'type': 'lora',
                     'weight': lora.get('strength', 1.0),
                     'file_name': lora.get('file_name', ''),
-                    'hash': lora.get('hash', '')
+                    'hash': lora.get('hash', ''),
+                    'existsLocally': False,
+                    'inLibrary': False,
+                    'localPath': None,
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'size': 0
                 }
                 
                 # Check if this LoRA exists locally by SHA256 hash
-                if lora.get('hash') and recipe_scanner:
+                if recipe_scanner:
                     lora_scanner = recipe_scanner._lora_scanner
-                    exists_locally = lora_scanner.has_hash(lora['hash'])
-                    if exists_locally:
-                        lora_cache = await lora_scanner.get_cached_data()
-                        lora_item = next((item for item in lora_cache.raw_data if item['sha256'].lower() == lora['hash'].lower()), None)
-                        if lora_item:
+
+                    if lora.get('hash'):
+                        exists_locally = lora_scanner.has_hash(lora['hash'])
+                        if exists_locally:
+                            lora_cache = await lora_scanner.get_cached_data()
+                            lora_item = next((item for item in lora_cache.raw_data if item['sha256'].lower() == lora['hash'].lower()), None)
+                            if lora_item:
+                                lora_entry['existsLocally'] = True
+                                lora_entry['inLibrary'] = True
+                                lora_entry['localPath'] = lora_item['file_path']
+                                lora_entry['file_name'] = lora_item['file_name']
+                                lora_entry['size'] = lora_item['size']
+                                lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
+                                
+                        else:
+                            lora_entry['existsLocally'] = False
+                            lora_entry['inLibrary'] = False
+                            lora_entry['localPath'] = None
+
+                    # If we still don't have a local match, try matching by modelVersionId
+                    if not lora_entry['existsLocally'] and lora.get('modelVersionId') is not None:
+                        cached_lora = await self._get_lora_from_version_index(recipe_scanner, lora.get('modelVersionId'))
+                        if cached_lora:
                             lora_entry['existsLocally'] = True
-                            lora_entry['localPath'] = lora_item['file_path']
-                            lora_entry['file_name'] = lora_item['file_name']
-                            lora_entry['size'] = lora_item['size']
-                            lora_entry['thumbnailUrl'] = config.get_preview_static_url(lora_item['preview_url'])
+                            lora_entry['inLibrary'] = True
+                            lora_entry['localPath'] = cached_lora.get('file_path')
+                            lora_entry['file_name'] = cached_lora.get('file_name') or lora_entry['file_name']
+                            lora_entry['size'] = cached_lora.get('size', lora_entry['size'])
+                            if cached_lora.get('sha256'):
+                                lora_entry['hash'] = cached_lora['sha256']
+                            preview_url = cached_lora.get('preview_url')
+                            if preview_url:
+                                lora_entry['thumbnailUrl'] = config.get_preview_static_url(preview_url)
 
-                    else:
-                        lora_entry['existsLocally'] = False
-                        lora_entry['localPath'] = None
-                        
-                        # Try to get additional info from Civitai if we have a model version ID
-                        if lora.get('modelVersionId') and metadata_provider:
-                            try:
-                                civitai_info_tuple = await metadata_provider.get_model_version_info(lora['modelVersionId'])
-                                # Populate lora entry with Civitai info
-                                populated_entry = await self.populate_lora_from_civitai(
-                                    lora_entry, 
-                                    civitai_info_tuple, 
-                                    recipe_scanner,
-                                    None,  # No need to track base model counts
-                                    lora['hash']
-                                )
-                                if populated_entry is None:
-                                    continue  # Skip invalid LoRA types
-                                lora_entry = populated_entry
-                            except Exception as e:
-                                logger.error(f"Error fetching Civitai info for LoRA: {e}")
-                                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                    # Try to get additional info from Civitai if we have a model version ID and still missing locally
+                    if not lora_entry['existsLocally'] and lora.get('modelVersionId') and metadata_provider:
+                        try:
+                            civitai_info_tuple = await metadata_provider.get_model_version_info(lora['modelVersionId'])
+                            # Populate lora entry with Civitai info
+                            populated_entry = await self.populate_lora_from_civitai(
+                                lora_entry, 
+                                civitai_info_tuple, 
+                                recipe_scanner,
+                                None,  # No need to track base model counts
+                                lora_entry.get('hash', '')
+                            )
+                            if populated_entry is None:
+                                continue  # Skip invalid LoRA types
+                            lora_entry = populated_entry
+                        except Exception as e:
+                            logger.error(f"Error fetching Civitai info for LoRA: {e}")
+                            lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
                 
                 loras.append(lora_entry)
             
             logger.info(f"Found {len(loras)} loras in recipe metadata")
 
+            # Process checkpoint information if present
+            checkpoint = None
+            checkpoint_data = recipe_metadata.get('checkpoint') or {}
+            if isinstance(checkpoint_data, dict) and checkpoint_data:
+                version_id = checkpoint_data.get('modelVersionId') or checkpoint_data.get('id')
+                checkpoint_entry = {
+                    'id': version_id or 0,
+                    'modelId': checkpoint_data.get('modelId', 0),
+                    'name': checkpoint_data.get('name', 'Unknown Checkpoint'),
+                    'version': checkpoint_data.get('version', ''),
+                    'type': checkpoint_data.get('type', 'checkpoint'),
+                    'hash': checkpoint_data.get('hash', ''),
+                    'existsLocally': False,
+                    'localPath': None,
+                    'file_name': checkpoint_data.get('file_name', ''),
+                    'thumbnailUrl': '/loras_static/images/no-preview.png',
+                    'baseModel': '',
+                    'size': 0,
+                    'downloadUrl': '',
+                    'isDeleted': False
+                }
+
+                if metadata_provider:
+                    try:
+                        civitai_info = None
+                        if version_id:
+                            civitai_info = await metadata_provider.get_model_version_info(str(version_id))
+                        elif checkpoint_entry.get('hash'):
+                            civitai_info = await metadata_provider.get_model_by_hash(checkpoint_entry['hash'])
+
+                        if 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 in recipe metadata: {e}")
+
+                checkpoint = checkpoint_entry
+            
             # Filter gen_params to only include recognized keys
             filtered_gen_params = {}
             if 'gen_params' in recipe_metadata:
@@ -105,12 +188,13 @@ class RecipeFormatParser(RecipeMetadataParser):
                         filtered_gen_params[key] = value
             
             return {
-                'base_model': recipe_metadata.get('base_model', ''),
+                'base_model': checkpoint['baseModel'] if checkpoint and checkpoint.get('baseModel') else recipe_metadata.get('base_model', ''),
                 'loras': loras,
                 'gen_params': filtered_gen_params,
                 'tags': recipe_metadata.get('tags', []),
                 'title': recipe_metadata.get('title', ''),
-                'from_recipe_metadata': True
+                'from_recipe_metadata': True,
+                **({'checkpoint': checkpoint, 'model': checkpoint} if checkpoint else {})
             }
             
         except Exception as e:

py/routes/base_model_routes.py

@@ -120,7 +120,7 @@ class BaseModelRoutes(ABC):
         self.service = service
         self.model_type = service.model_type
         self.model_file_service = ModelFileService(service.scanner, service.model_type)
-        self.model_move_service = ModelMoveService(service.scanner)
+        self.model_move_service = ModelMoveService(service.scanner, service.model_type)
         self.model_lifecycle_service = ModelLifecycleService(
             scanner=service.scanner,
             metadata_manager=MetadataManager,
@@ -270,7 +270,7 @@ class BaseModelRoutes(ABC):
     def _ensure_move_service(self) -> ModelMoveService:
         if self.model_move_service is None:
             service = self._ensure_service()
-            self.model_move_service = ModelMoveService(service.scanner)
+            self.model_move_service = ModelMoveService(service.scanner, service.model_type)
         return self.model_move_service
 
     def _ensure_lifecycle_service(self) -> ModelLifecycleService:

py/routes/base_recipe_routes.py

@@ -79,26 +79,8 @@ class BaseRecipeRoutes:
             return
 
         app.on_startup.append(self.attach_dependencies)
-        app.on_startup.append(self.prewarm_cache)
         self._startup_hooks_registered = True
 
-    async def prewarm_cache(self, app: web.Application | None = None) -> None:
-        """Pre-load recipe and LoRA caches on startup."""
-
-        try:
-            await self.attach_dependencies(app)
-
-            if self.lora_scanner is not None:
-                await self.lora_scanner.get_cached_data()
-                hash_index = getattr(self.lora_scanner, "_hash_index", None)
-                if hash_index is not None and hasattr(hash_index, "_hash_to_path"):
-                    _ = len(hash_index._hash_to_path)
-
-            if self.recipe_scanner is not None:
-                await self.recipe_scanner.get_cached_data(force_refresh=True)
-        except Exception as exc:
-            logger.error("Error pre-warming recipe cache: %s", exc, exc_info=True)
-
     def to_route_mapping(self) -> Mapping[str, Callable]:
         """Return a mapping of handler name to coroutine for registrar binding."""
 

py/routes/example_images_route_registrar.py

@@ -29,6 +29,8 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/delete-example-image", "delete_example_image"),
     RouteDefinition("POST", "/api/lm/force-download-example-images", "force_download_example_images"),
     RouteDefinition("POST", "/api/lm/cleanup-example-image-folders", "cleanup_example_image_folders"),
+    RouteDefinition("POST", "/api/lm/example-images/set-nsfw-level", "set_example_image_nsfw_level"),
+    RouteDefinition("POST", "/api/lm/check-example-images-needed", "check_example_images_needed"),
 )
 
 

py/routes/handlers/example_images_handlers.py

@@ -92,6 +92,19 @@ class ExampleImagesDownloadHandler:
         except ExampleImagesDownloadError as exc:
             return web.json_response({'success': False, 'error': str(exc)}, status=500)
 
+    async def check_example_images_needed(self, request: web.Request) -> web.StreamResponse:
+        """Lightweight check to see if any models need example images downloaded."""
+        try:
+            payload = await request.json()
+            model_types = payload.get('model_types', ['lora', 'checkpoint', 'embedding'])
+            result = await self._download_manager.check_pending_models(model_types)
+            return web.json_response(result)
+        except Exception as exc:
+            return web.json_response(
+                {'success': False, 'error': str(exc)},
+                status=500
+            )
+
 
 class ExampleImagesManagementHandler:
     """HTTP adapters for import/delete endpoints."""
@@ -113,6 +126,9 @@ class ExampleImagesManagementHandler:
     async def delete_example_image(self, request: web.Request) -> web.StreamResponse:
         return await self._processor.delete_custom_image(request)
 
+    async def set_example_image_nsfw_level(self, request: web.Request) -> web.StreamResponse:
+        return await self._processor.set_example_image_nsfw_level(request)
+
     async def cleanup_example_image_folders(self, request: web.Request) -> web.StreamResponse:
         result = await self._cleanup_service.cleanup_example_image_folders()
 
@@ -158,8 +174,10 @@ class ExampleImagesHandlerSet:
             "resume_example_images": self.download.resume_example_images,
             "stop_example_images": self.download.stop_example_images,
             "force_download_example_images": self.download.force_download_example_images,
+            "check_example_images_needed": self.download.check_example_images_needed,
             "import_example_images": self.management.import_example_images,
             "delete_example_image": self.management.delete_example_image,
+            "set_example_image_nsfw_level": self.management.set_example_image_nsfw_level,
             "cleanup_example_image_folders": self.management.cleanup_example_image_folders,
             "open_example_images_folder": self.files.open_example_images_folder,
             "get_example_image_files": self.files.get_example_image_files,

py/routes/handlers/misc_handlers.py

@@ -43,12 +43,55 @@ from ...utils.usage_stats import UsageStats
 logger = logging.getLogger(__name__)
 
 
+def _is_wsl() -> bool:
+    """Check if running in WSL environment."""
+    try:
+        with open("/proc/version", "r") as f:
+            version_info = f.read().lower()
+            return "microsoft" in version_info or "wsl" in version_info
+    except (OSError, IOError):
+        return False
+
+
+def _is_docker() -> bool:
+    """Check if running in Docker container."""
+    dockerenv_exists = os.path.exists("/.dockerenv")
+    if dockerenv_exists:
+        return True
+
+    try:
+        with open("/proc/1/cgroup", "r") as f:
+            cgroup_content = f.read()
+            return (
+                "docker" in cgroup_content.lower()
+                or "kubepods" in cgroup_content.lower()
+            )
+    except (OSError, IOError):
+        return False
+
+
+def _wsl_to_windows_path(wsl_path: str) -> str | None:
+    """Convert WSL path to Windows path using wslpath."""
+    try:
+        result = subprocess.run(
+            ["wslpath", "-w", wsl_path],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+        return None
+
+
 class PromptServerProtocol(Protocol):
     """Subset of PromptServer used by the handlers."""
 
     instance: "PromptServerProtocol"
 
-    def send_sync(self, event: str, payload: dict) -> None:  # pragma: no cover - protocol
+    def send_sync(
+        self, event: str, payload: dict
+    ) -> None:  # pragma: no cover - protocol
         ...
 
 
@@ -63,7 +106,9 @@ class UsageStatsFactory(Protocol):
 
 
 class MetadataProviderProtocol(Protocol):
-    async def get_model_versions(self, model_id: int) -> dict | None:  # pragma: no cover - protocol
+    async def get_model_versions(
+        self, model_id: int
+    ) -> dict | None:  # pragma: no cover - protocol
         ...
 
 
@@ -109,7 +154,11 @@ class NodeRegistry:
                 raw_widget_names: list | None = node.get("widget_names")
                 if not isinstance(raw_widget_names, list):
                     capability_widget_names = capabilities.get("widget_names")
-                    raw_widget_names = capability_widget_names if isinstance(capability_widget_names, list) else None
+                    raw_widget_names = (
+                        capability_widget_names
+                        if isinstance(capability_widget_names, list)
+                        else None
+                    )
 
                 widget_names: list[str] = []
                 if isinstance(raw_widget_names, list):
@@ -175,12 +224,15 @@ class SettingsHandler:
         "civitai_api_key",
         "default_lora_root",
         "default_checkpoint_root",
+        "default_unet_root",
         "default_embedding_root",
         "base_model_path_mappings",
         "download_path_templates",
         "enable_metadata_archive_db",
         "language",
         "use_portable_settings",
+        "onboarding_completed",
+        "dismissed_banners",
         "proxy_enabled",
         "proxy_type",
         "proxy_host",
@@ -203,16 +255,28 @@ class SettingsHandler:
         "model_name_display",
         "update_flag_strategy",
         "auto_organize_exclusions",
+        "filter_presets",
     )
 
-    _PROXY_KEYS = {"proxy_enabled", "proxy_host", "proxy_port", "proxy_username", "proxy_password", "proxy_type"}
+    _PROXY_KEYS = {
+        "proxy_enabled",
+        "proxy_host",
+        "proxy_port",
+        "proxy_username",
+        "proxy_password",
+        "proxy_type",
+    }
 
     def __init__(
         self,
         *,
         settings_service=None,
-        metadata_provider_updater: Callable[[], Awaitable[None]] = update_metadata_providers,
-        downloader_factory: Callable[[], Awaitable[DownloaderProtocol]] = get_downloader,
+        metadata_provider_updater: Callable[
+            [], Awaitable[None]
+        ] = update_metadata_providers,
+        downloader_factory: Callable[
+            [], Awaitable[DownloaderProtocol]
+        ] = get_downloader,
     ) -> None:
         self._settings = settings_service or get_settings_manager()
         self._metadata_provider_updater = metadata_provider_updater
@@ -248,11 +312,13 @@ class SettingsHandler:
                 response_data["settings_file"] = settings_file
             messages_getter = getattr(self._settings, "get_startup_messages", None)
             messages = list(messages_getter()) if callable(messages_getter) else []
-            return web.json_response({
-                "success": True,
-                "settings": response_data,
-                "messages": messages,
-            })
+            return web.json_response(
+                {
+                    "success": True,
+                    "settings": response_data,
+                    "messages": messages,
+                }
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Error getting settings: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -271,8 +337,12 @@ class SettingsHandler:
         try:
             data = await request.json()
         except Exception as exc:  # pragma: no cover - defensive logging
-            logger.error("Error parsing activate library request: %s", exc, exc_info=True)
-            return web.json_response({"success": False, "error": "Invalid JSON payload"}, status=400)
+            logger.error(
+                "Error parsing activate library request: %s", exc, exc_info=True
+            )
+            return web.json_response(
+                {"success": False, "error": "Invalid JSON payload"}, status=400
+            )
 
         library_name = data.get("library") or data.get("library_name")
         if not isinstance(library_name, str) or not library_name.strip():
@@ -297,7 +367,9 @@ class SettingsHandler:
             logger.debug("Attempted to activate unknown library '%s'", library_name)
             return web.json_response({"success": False, "error": str(exc)}, status=404)
         except Exception as exc:  # pragma: no cover - defensive logging
-            logger.error("Error activating library '%s': %s", library_name, exc, exc_info=True)
+            logger.error(
+                "Error activating library '%s': %s", library_name, exc, exc_info=True
+            )
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
     async def update_settings(self, request: web.Request) -> web.Response:
@@ -312,9 +384,14 @@ class SettingsHandler:
                 if key == "example_images_path" and value:
                     validation_error = self._validate_example_images_path(value)
                     if validation_error:
-                        return web.json_response({"success": False, "error": validation_error})
+                        return web.json_response(
+                            {"success": False, "error": validation_error}
+                        )
 
-                if value == "__DELETE__" and key in ("proxy_username", "proxy_password"):
+                if value == "__DELETE__" and key in (
+                    "proxy_username",
+                    "proxy_password",
+                ):
                     self._settings.delete(key)
                 else:
                     self._settings.set(key, value)
@@ -356,7 +433,9 @@ class UsageStatsHandler:
             data = await request.json()
             prompt_id = data.get("prompt_id")
             if not prompt_id:
-                return web.json_response({"success": False, "error": "Missing prompt_id"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing prompt_id"}, status=400
+                )
             usage_stats = self._usage_stats_factory()
             await usage_stats.process_execution(prompt_id)
             return web.json_response({"success": True})
@@ -387,18 +466,24 @@ class LoraCodeHandler:
             mode = data.get("mode", "append")
 
             if not lora_code:
-                return web.json_response({"success": False, "error": "Missing lora_code parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing lora_code parameter"},
+                    status=400,
+                )
 
             results = []
             if node_ids is None:
                 try:
                     self._prompt_server.instance.send_sync(
-                        "lora_code_update", {"id": -1, "lora_code": lora_code, "mode": mode}
+                        "lora_code_update",
+                        {"id": -1, "lora_code": lora_code, "mode": mode},
                     )
                     results.append({"node_id": "broadcast", "success": True})
                 except Exception as exc:  # pragma: no cover - defensive logging
                     logger.error("Error broadcasting lora code: %s", exc)
-                    results.append({"node_id": "broadcast", "success": False, "error": str(exc)})
+                    results.append(
+                        {"node_id": "broadcast", "success": False, "error": str(exc)}
+                    )
             else:
                 for entry in node_ids:
                     node_identifier = entry
@@ -471,11 +556,19 @@ class TrainedWordsHandler:
         try:
             file_path = request.query.get("file_path")
             if not file_path:
-                return web.json_response({"success": False, "error": "Missing file_path parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing file_path parameter"},
+                    status=400,
+                )
             if not os.path.exists(file_path):
-                return web.json_response({"success": False, "error": "File not found"}, status=404)
+                return web.json_response(
+                    {"success": False, "error": "File not found"}, status=404
+                )
             if not file_path.endswith(".safetensors"):
-                return web.json_response({"success": False, "error": "File must be a safetensors file"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "File must be a safetensors file"},
+                    status=400,
+                )
 
             trained_words, class_tokens = await extract_trained_words(file_path)
             return web.json_response(
@@ -495,10 +588,15 @@ class ModelExampleFilesHandler:
         try:
             model_path = request.query.get("model_path")
             if not model_path:
-                return web.json_response({"success": False, "error": "Missing model_path parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing model_path parameter"},
+                    status=400,
+                )
             model_dir = os.path.dirname(model_path)
             if not os.path.exists(model_dir):
-                return web.json_response({"success": False, "error": "Model directory not found"}, status=404)
+                return web.json_response(
+                    {"success": False, "error": "Model directory not found"}, status=404
+                )
 
             base_name = os.path.splitext(os.path.basename(model_path))[0]
             files = []
@@ -510,7 +608,10 @@ class ModelExampleFilesHandler:
                 if not os.path.isfile(file_full_path):
                     continue
                 file_ext = os.path.splitext(file)[1].lower()
-                if file_ext not in SUPPORTED_MEDIA_EXTENSIONS["images"] and file_ext not in SUPPORTED_MEDIA_EXTENSIONS["videos"]:
+                if (
+                    file_ext not in SUPPORTED_MEDIA_EXTENSIONS["images"]
+                    and file_ext not in SUPPORTED_MEDIA_EXTENSIONS["videos"]
+                ):
                     continue
                 try:
                     index = int(file[len(pattern) :].split(".")[0])
@@ -545,7 +646,13 @@ class ServiceRegistryAdapter:
 
 
 class ModelLibraryHandler:
-    def __init__(self, service_registry: ServiceRegistryAdapter, metadata_provider_factory: Callable[[], Awaitable[MetadataProviderProtocol | None]]) -> None:
+    def __init__(
+        self,
+        service_registry: ServiceRegistryAdapter,
+        metadata_provider_factory: Callable[
+            [], Awaitable[MetadataProviderProtocol | None]
+        ],
+    ) -> None:
         self._service_registry = service_registry
         self._metadata_provider_factory = metadata_provider_factory
 
@@ -554,11 +661,17 @@ class ModelLibraryHandler:
             model_id_str = request.query.get("modelId")
             model_version_id_str = request.query.get("modelVersionId")
             if not model_id_str:
-                return web.json_response({"success": False, "error": "Missing required parameter: modelId"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing required parameter: modelId"},
+                    status=400,
+                )
             try:
                 model_id = int(model_id_str)
             except ValueError:
-                return web.json_response({"success": False, "error": "Parameter modelId must be an integer"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelId must be an integer"},
+                    status=400,
+                )
 
             lora_scanner = await self._service_registry.get_lora_scanner()
             checkpoint_scanner = await self._service_registry.get_checkpoint_scanner()
@@ -568,29 +681,55 @@ class ModelLibraryHandler:
                 try:
                     model_version_id = int(model_version_id_str)
                 except ValueError:
-                    return web.json_response({"success": False, "error": "Parameter modelVersionId must be an integer"}, status=400)
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": "Parameter modelVersionId must be an integer",
+                        },
+                        status=400,
+                    )
 
                 exists = False
                 model_type = None
                 if await lora_scanner.check_model_version_exists(model_version_id):
                     exists = True
                     model_type = "lora"
-                elif checkpoint_scanner and await checkpoint_scanner.check_model_version_exists(model_version_id):
+                elif (
+                    checkpoint_scanner
+                    and await checkpoint_scanner.check_model_version_exists(
+                        model_version_id
+                    )
+                ):
                     exists = True
                     model_type = "checkpoint"
-                elif embedding_scanner and await embedding_scanner.check_model_version_exists(model_version_id):
+                elif (
+                    embedding_scanner
+                    and await embedding_scanner.check_model_version_exists(
+                        model_version_id
+                    )
+                ):
                     exists = True
                     model_type = "embedding"
 
-                return web.json_response({"success": True, "exists": exists, "modelType": model_type if exists else None})
+                return web.json_response(
+                    {
+                        "success": True,
+                        "exists": exists,
+                        "modelType": model_type if exists else None,
+                    }
+                )
 
             lora_versions = await lora_scanner.get_model_versions_by_id(model_id)
             checkpoint_versions = []
             embedding_versions = []
             if not lora_versions and checkpoint_scanner:
-                checkpoint_versions = await checkpoint_scanner.get_model_versions_by_id(model_id)
+                checkpoint_versions = await checkpoint_scanner.get_model_versions_by_id(
+                    model_id
+                )
             if not lora_versions and not checkpoint_versions and embedding_scanner:
-                embedding_versions = await embedding_scanner.get_model_versions_by_id(model_id)
+                embedding_versions = await embedding_scanner.get_model_versions_by_id(
+                    model_id
+                )
 
             model_type = None
             versions = []
@@ -604,7 +743,9 @@ class ModelLibraryHandler:
                 model_type = "embedding"
                 versions = embedding_versions
 
-            return web.json_response({"success": True, "modelType": model_type, "versions": versions})
+            return web.json_response(
+                {"success": True, "modelType": model_type, "versions": versions}
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to check model existence: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -613,22 +754,35 @@ class ModelLibraryHandler:
         try:
             model_id_str = request.query.get("modelId")
             if not model_id_str:
-                return web.json_response({"success": False, "error": "Missing required parameter: modelId"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing required parameter: modelId"},
+                    status=400,
+                )
             try:
                 model_id = int(model_id_str)
             except ValueError:
-                return web.json_response({"success": False, "error": "Parameter modelId must be an integer"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelId must be an integer"},
+                    status=400,
+                )
 
             metadata_provider = await self._metadata_provider_factory()
             if not metadata_provider:
-                return web.json_response({"success": False, "error": "Metadata provider not available"}, status=503)
+                return web.json_response(
+                    {"success": False, "error": "Metadata provider not available"},
+                    status=503,
+                )
 
             try:
                 response = await metadata_provider.get_model_versions(model_id)
             except ResourceNotFoundError:
-                return web.json_response({"success": False, "error": "Model not found"}, status=404)
+                return web.json_response(
+                    {"success": False, "error": "Model not found"}, status=404
+                )
             if not response or not response.get("modelVersions"):
-                return web.json_response({"success": False, "error": "Model not found"}, status=404)
+                return web.json_response(
+                    {"success": False, "error": "Model not found"}, status=404
+                )
 
             versions = response.get("modelVersions", [])
             model_name = response.get("name", "")
@@ -646,10 +800,22 @@ class ModelLibraryHandler:
                 scanner = await self._service_registry.get_embedding_scanner()
                 normalized_type = "embedding"
             else:
-                return web.json_response({"success": False, "error": f'Model type "{model_type}" is not supported'}, status=400)
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": f'Model type "{model_type}" is not supported',
+                    },
+                    status=400,
+                )
 
             if not scanner:
-                return web.json_response({"success": False, "error": f'Scanner for type "{normalized_type}" is not available'}, status=503)
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": f'Scanner for type "{normalized_type}" is not available',
+                    },
+                    status=503,
+                )
 
             local_versions = await scanner.get_model_versions_by_id(model_id)
             local_version_ids = {version["versionId"] for version in local_versions}
@@ -661,7 +827,9 @@ class ModelLibraryHandler:
                     {
                         "id": version_id,
                         "name": version.get("name", ""),
-                        "thumbnailUrl": version.get("images")[0]["url"] if version.get("images") else None,
+                        "thumbnailUrl": version.get("images")[0]["url"]
+                        if version.get("images")
+                        else None,
                         "inLibrary": version_id in local_version_ids,
                     }
                 )
@@ -683,19 +851,34 @@ class ModelLibraryHandler:
         try:
             username = request.query.get("username")
             if not username:
-                return web.json_response({"success": False, "error": "Missing required parameter: username"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing required parameter: username"},
+                    status=400,
+                )
 
             metadata_provider = await self._metadata_provider_factory()
             if not metadata_provider:
-                return web.json_response({"success": False, "error": "Metadata provider not available"}, status=503)
+                return web.json_response(
+                    {"success": False, "error": "Metadata provider not available"},
+                    status=503,
+                )
 
             try:
                 models = await metadata_provider.get_user_models(username)
             except NotImplementedError:
-                return web.json_response({"success": False, "error": "Metadata provider does not support user model queries"}, status=501)
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "Metadata provider does not support user model queries",
+                    },
+                    status=501,
+                )
 
             if models is None:
-                return web.json_response({"success": False, "error": "Failed to fetch user models"}, status=502)
+                return web.json_response(
+                    {"success": False, "error": "Failed to fetch user models"},
+                    status=502,
+                )
 
             if not isinstance(models, list):
                 models = []
@@ -704,7 +887,9 @@ class ModelLibraryHandler:
             checkpoint_scanner = await self._service_registry.get_checkpoint_scanner()
             embedding_scanner = await self._service_registry.get_embedding_scanner()
 
-            normalized_allowed_types = {model_type.lower() for model_type in CIVITAI_USER_MODEL_TYPES}
+            normalized_allowed_types = {
+                model_type.lower() for model_type in CIVITAI_USER_MODEL_TYPES
+            }
             lora_type_aliases = {model_type.lower() for model_type in VALID_LORA_TYPES}
 
             type_scanner_map: Dict[str, object | None] = {
@@ -724,7 +909,13 @@ class ModelLibraryHandler:
 
                 scanner = type_scanner_map.get(model_type)
                 if scanner is None:
-                    return web.json_response({"success": False, "error": f'Scanner for type "{model_type}" is not available'}, status=503)
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": f'Scanner for type "{model_type}" is not available',
+                        },
+                        status=503,
+                    )
 
                 tags_value = model.get("tags")
                 tags = tags_value if isinstance(tags_value, list) else []
@@ -759,7 +950,9 @@ class ModelLibraryHandler:
                             rewritten_url, _ = rewrite_preview_url(raw_url, media_type)
                             thumbnail_url = rewritten_url
 
-                    in_library = await scanner.check_model_version_exists(version_id_int)
+                    in_library = await scanner.check_model_version_exists(
+                        version_id_int
+                    )
 
                     versions.append(
                         {
@@ -775,7 +968,9 @@ class ModelLibraryHandler:
                         }
                     )
 
-            return web.json_response({"success": True, "username": username, "versions": versions})
+            return web.json_response(
+                {"success": True, "username": username, "versions": versions}
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to get Civitai user models: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -785,9 +980,13 @@ class MetadataArchiveHandler:
     def __init__(
         self,
         *,
-        metadata_archive_manager_factory: Callable[[], Awaitable[MetadataArchiveManagerProtocol]] = get_metadata_archive_manager,
+        metadata_archive_manager_factory: Callable[
+            [], Awaitable[MetadataArchiveManagerProtocol]
+        ] = get_metadata_archive_manager,
         settings_service=None,
-        metadata_provider_updater: Callable[[], Awaitable[None]] = update_metadata_providers,
+        metadata_provider_updater: Callable[
+            [], Awaitable[None]
+        ] = update_metadata_providers,
     ) -> None:
         self._metadata_archive_manager_factory = metadata_archive_manager_factory
         self._settings = settings_service or get_settings_manager()
@@ -799,18 +998,37 @@ class MetadataArchiveHandler:
             download_id = request.query.get("download_id")
 
             def progress_callback(stage: str, message: str) -> None:
-                data = {"stage": stage, "message": message, "type": "metadata_archive_download"}
+                data = {
+                    "stage": stage,
+                    "message": message,
+                    "type": "metadata_archive_download",
+                }
                 if download_id:
-                    asyncio.create_task(ws_manager.broadcast_download_progress(download_id, data))
+                    asyncio.create_task(
+                        ws_manager.broadcast_download_progress(download_id, data)
+                    )
                 else:
                     asyncio.create_task(ws_manager.broadcast(data))
 
-            success = await archive_manager.download_and_extract_database(progress_callback)
+            success = await archive_manager.download_and_extract_database(
+                progress_callback
+            )
             if success:
                 self._settings.set("enable_metadata_archive_db", True)
                 await self._metadata_provider_updater()
-                return web.json_response({"success": True, "message": "Metadata archive database downloaded and extracted successfully"})
-            return web.json_response({"success": False, "error": "Failed to download and extract metadata archive database"}, status=500)
+                return web.json_response(
+                    {
+                        "success": True,
+                        "message": "Metadata archive database downloaded and extracted successfully",
+                    }
+                )
+            return web.json_response(
+                {
+                    "success": False,
+                    "error": "Failed to download and extract metadata archive database",
+                },
+                status=500,
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Error downloading metadata archive: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -822,8 +1040,19 @@ class MetadataArchiveHandler:
             if success:
                 self._settings.set("enable_metadata_archive_db", False)
                 await self._metadata_provider_updater()
-                return web.json_response({"success": True, "message": "Metadata archive database removed successfully"})
-            return web.json_response({"success": False, "error": "Failed to remove metadata archive database"}, status=500)
+                return web.json_response(
+                    {
+                        "success": True,
+                        "message": "Metadata archive database removed successfully",
+                    }
+                )
+            return web.json_response(
+                {
+                    "success": False,
+                    "error": "Failed to remove metadata archive database",
+                },
+                status=500,
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Error removing metadata archive: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -844,39 +1073,210 @@ class MetadataArchiveHandler:
                     "isAvailable": is_available,
                     "isEnabled": is_enabled,
                     "databaseSize": db_size,
-                    "databasePath": archive_manager.get_database_path() if is_available else None,
+                    "databasePath": archive_manager.get_database_path()
+                    if is_available
+                    else None,
                 }
             )
         except Exception as exc:  # pragma: no cover - defensive logging
-            logger.error("Error getting metadata archive status: %s", exc, exc_info=True)
+            logger.error(
+                "Error getting metadata archive status: %s", exc, exc_info=True
+            )
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
 
 class FileSystemHandler:
+    def __init__(self, settings_service=None) -> None:
+        self._settings = settings_service or get_settings_manager()
+
     async def open_file_location(self, request: web.Request) -> web.Response:
         try:
             data = await request.json()
             file_path = data.get("file_path")
             if not file_path:
-                return web.json_response({"success": False, "error": "Missing file_path parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing file_path parameter"},
+                    status=400,
+                )
             file_path = os.path.abspath(file_path)
             if not os.path.isfile(file_path):
-                return web.json_response({"success": False, "error": "File does not exist"}, status=404)
+                return web.json_response(
+                    {"success": False, "error": "File does not exist"}, status=404
+                )
 
             if os.name == "nt":
                 subprocess.Popen(["explorer", "/select,", file_path])
             elif os.name == "posix":
-                if sys.platform == "darwin":
+                if _is_docker():
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "message": "Running in Docker: Path available for copying",
+                            "path": file_path,
+                            "mode": "clipboard",
+                        }
+                    )
+                elif _is_wsl():
+                    windows_path = _wsl_to_windows_path(file_path)
+                    if windows_path:
+                        subprocess.Popen(["explorer.exe", "/select,", windows_path])
+                    else:
+                        logger.error(
+                            "Failed to convert WSL path to Windows path: %s", file_path
+                        )
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "Failed to open file location: path conversion error",
+                            },
+                            status=500,
+                        )
+                elif sys.platform == "darwin":
                     subprocess.Popen(["open", "-R", file_path])
                 else:
                     folder = os.path.dirname(file_path)
                     subprocess.Popen(["xdg-open", folder])
 
-            return web.json_response({"success": True, "message": f"Opened folder and selected file: {file_path}"})
+            return web.json_response(
+                {
+                    "success": True,
+                    "message": f"Opened folder and selected file: {file_path}",
+                }
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to open file location: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    async def open_settings_location(self, request: web.Request) -> web.Response:
+        try:
+            settings_file = getattr(self._settings, "settings_file", None)
+            if not settings_file:
+                return web.json_response(
+                    {"success": False, "error": "Settings file not found"}, status=404
+                )
+
+            settings_file = os.path.abspath(settings_file)
+            if not os.path.isfile(settings_file):
+                return web.json_response(
+                    {"success": False, "error": "Settings file does not exist"},
+                    status=404,
+                )
+
+            if os.name == "nt":
+                subprocess.Popen(["explorer", "/select,", settings_file])
+            elif os.name == "posix":
+                if _is_docker():
+                    return web.json_response(
+                        {
+                            "success": True,
+                            "message": "Running in Docker: Path available for copying",
+                            "path": settings_file,
+                            "mode": "clipboard",
+                        }
+                    )
+                elif _is_wsl():
+                    windows_path = _wsl_to_windows_path(settings_file)
+                    if windows_path:
+                        subprocess.Popen(["explorer.exe", "/select,", windows_path])
+                    else:
+                        logger.error(
+                            "Failed to convert WSL path to Windows path: %s",
+                            settings_file,
+                        )
+                        return web.json_response(
+                            {
+                                "success": False,
+                                "error": "Failed to open settings location: path conversion error",
+                            },
+                            status=500,
+                        )
+                elif sys.platform == "darwin":
+                    subprocess.Popen(["open", "-R", settings_file])
+                else:
+                    folder = os.path.dirname(settings_file)
+                    subprocess.Popen(["xdg-open", folder])
+
+            return web.json_response(
+                {"success": True, "message": f"Opened settings folder: {settings_file}"}
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error("Failed to open settings location: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+
+class CustomWordsHandler:
+    """Handler for autocomplete via TagFTSIndex."""
+
+    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:
+        """Search custom words with autocomplete.
+
+        Query parameters:
+            search: The search term to match against.
+            limit: Maximum number of results to return (default: 20).
+            category: Optional category filter. Can be:
+                - A category name (e.g., "character", "artist", "general")
+                - Comma-separated category IDs (e.g., "4,11" for character)
+            enriched: If "true", return enriched results with category and post_count
+                      even without category filtering.
+        """
+        try:
+            search_term = request.query.get("search", "")
+            limit = int(request.query.get("limit", "20"))
+            category_param = request.query.get("category", "")
+            enriched_param = request.query.get("enriched", "").lower() == "true"
+
+            # Parse category parameter
+            categories = None
+            if category_param:
+                categories = self._parse_category_param(category_param)
+
+            results = self._service.search_words(
+                search_term, limit, categories=categories, enriched=enriched_param
+            )
+
+            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)
+
+    def _parse_category_param(self, param: str) -> list[int] | None:
+        """Parse category parameter into list of category IDs.
+
+        Args:
+            param: Category parameter value (name or comma-separated IDs).
+
+        Returns:
+            List of category IDs, or None if parsing fails.
+        """
+        from ...services.tag_fts_index import CATEGORY_NAME_TO_IDS
+
+        param = param.strip().lower()
+        if not param:
+            return None
+
+        # Try to parse as category name first
+        if param in CATEGORY_NAME_TO_IDS:
+            return CATEGORY_NAME_TO_IDS[param]
+
+        # Try to parse as comma-separated integers
+        try:
+            category_ids = []
+            for part in param.split(","):
+                part = part.strip()
+                if part:
+                    category_ids.append(int(part))
+            return category_ids if category_ids else None
+        except ValueError:
+            logger.debug("Invalid category parameter: %s", param)
+            return None
+
 
 class NodeRegistryHandler:
     def __init__(
@@ -895,21 +1295,44 @@ class NodeRegistryHandler:
             data = await request.json()
             nodes = data.get("nodes", [])
             if not isinstance(nodes, list):
-                return web.json_response({"success": False, "error": "nodes must be a list"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "nodes must be a list"}, status=400
+                )
             for index, node in enumerate(nodes):
                 if not isinstance(node, dict):
-                    return web.json_response({"success": False, "error": f"Node {index} must be an object"}, status=400)
+                    return web.json_response(
+                        {"success": False, "error": f"Node {index} must be an object"},
+                        status=400,
+                    )
                 node_id = node.get("node_id")
                 if node_id is None:
-                    return web.json_response({"success": False, "error": f"Node {index} missing node_id parameter"}, status=400)
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": f"Node {index} missing node_id parameter",
+                        },
+                        status=400,
+                    )
                 graph_id = node.get("graph_id")
                 if graph_id is None:
-                    return web.json_response({"success": False, "error": f"Node {index} missing graph_id parameter"}, status=400)
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": f"Node {index} missing graph_id parameter",
+                        },
+                        status=400,
+                    )
                 graph_name = node.get("graph_name")
                 try:
                     node["node_id"] = int(node_id)
                 except (TypeError, ValueError):
-                    return web.json_response({"success": False, "error": f"Node {index} node_id must be an integer"}, status=400)
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": f"Node {index} node_id must be an integer",
+                        },
+                        status=400,
+                    )
                 node["graph_id"] = str(graph_id)
                 if graph_name is None:
                     node["graph_name"] = None
@@ -919,7 +1342,12 @@ class NodeRegistryHandler:
                     node["graph_name"] = str(graph_name)
 
             await self._node_registry.register_nodes(nodes)
-            return web.json_response({"success": True, "message": f"{len(nodes)} nodes registered successfully"})
+            return web.json_response(
+                {
+                    "success": True,
+                    "message": f"{len(nodes)} nodes registered successfully",
+                }
+            )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to register nodes: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
@@ -967,7 +1395,10 @@ class NodeRegistryHandler:
             return web.json_response({"success": True, "data": registry_info})
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to get registry: %s", exc, exc_info=True)
-            return web.json_response({"success": False, "error": "Internal Error", "message": str(exc)}, status=500)
+            return web.json_response(
+                {"success": False, "error": "Internal Error", "message": str(exc)},
+                status=500,
+            )
 
     async def update_node_widget(self, request: web.Request) -> web.Response:
         try:
@@ -977,10 +1408,15 @@ class NodeRegistryHandler:
             node_ids = data.get("node_ids")
 
             if not isinstance(widget_name, str) or not widget_name:
-                return web.json_response({"success": False, "error": "Missing widget_name parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing widget_name parameter"},
+                    status=400,
+                )
 
             if not isinstance(value, str) or not value:
-                return web.json_response({"success": False, "error": "Missing value parameter"}, status=400)
+                return web.json_response(
+                    {"success": False, "error": "Missing value parameter"}, status=400
+                )
 
             if not isinstance(node_ids, list) or not node_ids:
                 return web.json_response(
@@ -1068,6 +1504,7 @@ class MiscHandlerSet:
         model_library: ModelLibraryHandler,
         metadata_archive: MetadataArchiveHandler,
         filesystem: FileSystemHandler,
+        custom_words: CustomWordsHandler,
     ) -> None:
         self.health = health
         self.settings = settings
@@ -1079,8 +1516,11 @@ class MiscHandlerSet:
         self.model_library = model_library
         self.metadata_archive = metadata_archive
         self.filesystem = filesystem
+        self.custom_words = custom_words
 
-    def to_route_mapping(self) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
+    def to_route_mapping(
+        self,
+    ) -> Mapping[str, Callable[[web.Request], Awaitable[web.StreamResponse]]]:
         return {
             "health_check": self.health.health_check,
             "get_settings": self.settings.get_settings,
@@ -1103,6 +1543,8 @@ class MiscHandlerSet:
             "get_metadata_archive_status": self.metadata_archive.get_metadata_archive_status,
             "get_model_versions_status": self.model_library.get_model_versions_status,
             "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,
         }
 
 

py/routes/handlers/preview_handlers.py

@@ -33,6 +33,10 @@ class PreviewHandler:
             raise web.HTTPBadRequest(text="Invalid preview path encoding") from exc
 
         normalized = decoded_path.replace("\\", "/")
+
+        if not self._config.is_preview_path_allowed(normalized):
+            raise web.HTTPForbidden(text="Preview path is not within an allowed directory")
+
         candidate = Path(normalized)
         try:
             resolved = candidate.expanduser().resolve(strict=False)
@@ -40,13 +44,8 @@ class PreviewHandler:
             logger.debug("Failed to resolve preview path %s: %s", normalized, exc)
             raise web.HTTPBadRequest(text="Unable to resolve preview path") from exc
 
-        resolved_str = str(resolved)
-        if not self._config.is_preview_path_allowed(resolved_str):
-            logger.debug("Rejected preview outside allowed roots: %s", resolved_str)
-            raise web.HTTPForbidden(text="Preview path is not within an allowed directory")
-
         if not resolved.is_file():
-            logger.debug("Preview file not found at %s", resolved_str)
+            logger.debug("Preview file not found at %s", str(resolved))
             raise web.HTTPNotFound(text="Preview file not found")
 
         # aiohttp's FileResponse handles range requests and content headers for us.

py/routes/handlers/recipe_handlers.py

@@ -5,6 +5,7 @@ import json
 import logging
 import os
 import re
+import asyncio
 import tempfile
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Dict, List, Mapping, Optional
@@ -23,6 +24,11 @@ from ...services.recipes import (
     RecipeValidationError,
 )
 from ...services.metadata_service import get_default_metadata_provider
+from ...utils.civitai_utils import rewrite_preview_url
+from ...utils.exif_utils import ExifUtils
+from ...recipes.merger import GenParamsMerger
+from ...recipes.enrichment import RecipeEnricher
+from ...services.websocket_manager import ws_manager as default_ws_manager
 
 Logger = logging.Logger
 EnsureDependenciesCallable = Callable[[], Awaitable[None]]
@@ -55,16 +61,26 @@ class RecipeHandlerSet:
             "delete_recipe": self.management.delete_recipe,
             "get_top_tags": self.query.get_top_tags,
             "get_base_models": self.query.get_base_models,
+            "get_roots": self.query.get_roots,
+            "get_folders": self.query.get_folders,
+            "get_folder_tree": self.query.get_folder_tree,
+            "get_unified_folder_tree": self.query.get_unified_folder_tree,
             "share_recipe": self.sharing.share_recipe,
             "download_shared_recipe": self.sharing.download_shared_recipe,
             "get_recipe_syntax": self.query.get_recipe_syntax,
             "update_recipe": self.management.update_recipe,
             "reconnect_lora": self.management.reconnect_lora,
             "find_duplicates": self.query.find_duplicates,
+            "move_recipes_bulk": self.management.move_recipes_bulk,
             "bulk_delete": self.management.bulk_delete,
             "save_recipe_from_widget": self.management.save_recipe_from_widget,
             "get_recipes_for_lora": self.query.get_recipes_for_lora,
             "scan_recipes": self.query.scan_recipes,
+            "move_recipe": self.management.move_recipe,
+            "repair_recipes": self.management.repair_recipes,
+            "cancel_repair": self.management.cancel_repair,
+            "repair_recipe": self.management.repair_recipe,
+            "get_repair_progress": self.management.get_repair_progress,
         }
 
 
@@ -148,12 +164,15 @@ class RecipeListingHandler:
             page_size = int(request.query.get("page_size", "20"))
             sort_by = request.query.get("sort_by", "date")
             search = request.query.get("search")
+            folder = request.query.get("folder")
+            recursive = request.query.get("recursive", "true").lower() == "true"
 
             search_options = {
                 "title": request.query.get("search_title", "true").lower() == "true",
                 "tags": request.query.get("search_tags", "true").lower() == "true",
                 "lora_name": request.query.get("search_lora_name", "true").lower() == "true",
                 "lora_model": request.query.get("search_lora_model", "true").lower() == "true",
+                "prompt": request.query.get("search_prompt", "true").lower() == "true",
             }
 
             filters: Dict[str, Any] = {}
@@ -161,6 +180,9 @@ class RecipeListingHandler:
             if base_models:
                 filters["base_model"] = base_models.split(",")
 
+            if request.query.get("favorite", "false").lower() == "true":
+                filters["favorite"] = True
+
             tag_filters: Dict[str, str] = {}
             legacy_tags = request.query.get("tags")
             if legacy_tags:
@@ -192,6 +214,8 @@ class RecipeListingHandler:
                 filters=filters,
                 search_options=search_options,
                 lora_hash=lora_hash,
+                folder=folder,
+                recursive=recursive,
             )
 
             for item in result.get("items", []):
@@ -298,6 +322,58 @@ class RecipeQueryHandler:
             self._logger.error("Error retrieving base models: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    async def get_roots(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            roots = [recipe_scanner.recipes_dir] if recipe_scanner.recipes_dir else []
+            return web.json_response({"success": True, "roots": roots})
+        except Exception as exc:
+            self._logger.error("Error retrieving recipe roots: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_folders(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            folders = await recipe_scanner.get_folders()
+            return web.json_response({"success": True, "folders": folders})
+        except Exception as exc:
+            self._logger.error("Error retrieving recipe folders: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_folder_tree(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            folder_tree = await recipe_scanner.get_folder_tree()
+            return web.json_response({"success": True, "tree": folder_tree})
+        except Exception as exc:
+            self._logger.error("Error retrieving recipe folder tree: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_unified_folder_tree(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            folder_tree = await recipe_scanner.get_folder_tree()
+            return web.json_response({"success": True, "tree": folder_tree})
+        except Exception as exc:
+            self._logger.error("Error retrieving unified recipe folder tree: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def get_recipes_for_lora(self, request: web.Request) -> web.Response:
         try:
             await self._ensure_dependencies_ready()
@@ -336,10 +412,11 @@ class RecipeQueryHandler:
             if recipe_scanner is None:
                 raise RuntimeError("Recipe scanner unavailable")
 
-            duplicate_groups = await recipe_scanner.find_all_duplicate_recipes()
+            fingerprint_groups = await recipe_scanner.find_all_duplicate_recipes()
+            url_groups = await recipe_scanner.find_duplicate_recipes_by_source()
             response_data = []
 
-            for fingerprint, recipe_ids in duplicate_groups.items():
+            for fingerprint, recipe_ids in fingerprint_groups.items():
                 if len(recipe_ids) <= 1:
                     continue
 
@@ -363,12 +440,44 @@ class RecipeQueryHandler:
                     recipes.sort(key=lambda entry: entry.get("modified", 0), reverse=True)
                     response_data.append(
                         {
+                            "type": "fingerprint",
                             "fingerprint": fingerprint,
                             "count": len(recipes),
                             "recipes": recipes,
                         }
                     )
 
+            for url, recipe_ids in url_groups.items():
+                if len(recipe_ids) <= 1:
+                    continue
+
+                recipes = []
+                for recipe_id in recipe_ids:
+                    recipe = await recipe_scanner.get_recipe_by_id(recipe_id)
+                    if recipe:
+                        recipes.append(
+                            {
+                                "id": recipe.get("id"),
+                                "title": recipe.get("title"),
+                                "file_url": recipe.get("file_url")
+                                or self._format_recipe_file_url(recipe.get("file_path", "")),
+                                "modified": recipe.get("modified"),
+                                "created_date": recipe.get("created_date"),
+                                "lora_count": len(recipe.get("loras", [])),
+                            }
+                        )
+
+                if len(recipes) >= 2:
+                    recipes.sort(key=lambda entry: entry.get("modified", 0), reverse=True)
+                    response_data.append(
+                        {
+                            "type": "source_url",
+                            "fingerprint": url,
+                            "count": len(recipes),
+                            "recipes": recipes,
+                        }
+                    )
+
             response_data.sort(key=lambda entry: entry["count"], reverse=True)
             return web.json_response({"success": True, "duplicate_groups": response_data})
         except Exception as exc:
@@ -410,6 +519,7 @@ class RecipeManagementHandler:
         analysis_service: RecipeAnalysisService,
         downloader_factory,
         civitai_client_getter: CivitaiClientGetter,
+        ws_manager=default_ws_manager,
     ) -> None:
         self._ensure_dependencies_ready = ensure_dependencies_ready
         self._recipe_scanner_getter = recipe_scanner_getter
@@ -418,6 +528,7 @@ class RecipeManagementHandler:
         self._analysis_service = analysis_service
         self._downloader_factory = downloader_factory
         self._civitai_client_getter = civitai_client_getter
+        self._ws_manager = ws_manager
 
     async def save_recipe(self, request: web.Request) -> web.Response:
         try:
@@ -436,6 +547,7 @@ class RecipeManagementHandler:
                 name=payload["name"],
                 tags=payload["tags"],
                 metadata=payload["metadata"],
+                extension=payload.get("extension"),
             )
             return web.json_response(result.payload, status=result.status)
         except RecipeValidationError as exc:
@@ -444,6 +556,88 @@ class RecipeManagementHandler:
             self._logger.error("Error saving recipe: %s", exc, exc_info=True)
             return web.json_response({"error": str(exc)}, status=500)
 
+    async def repair_recipes(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response({"success": False, "error": "Recipe scanner unavailable"}, status=503)
+
+            # Check if already running
+            if self._ws_manager.is_recipe_repair_running():
+                return web.json_response({"success": False, "error": "Recipe repair already in progress"}, status=409)
+
+            recipe_scanner.reset_cancellation()
+
+            async def progress_callback(data):
+                await self._ws_manager.broadcast_recipe_repair_progress(data)
+
+            # Run in background to avoid timeout
+            async def run_repair():
+                try:
+                    await recipe_scanner.repair_all_recipes(
+                        progress_callback=progress_callback
+                    )
+                except Exception as e:
+                    self._logger.error(f"Error in recipe repair task: {e}", exc_info=True)
+                    await self._ws_manager.broadcast_recipe_repair_progress({
+                        "status": "error",
+                        "error": str(e)
+                    })
+                finally:
+                    # Keep the final status for a while so the UI can see it
+                    await asyncio.sleep(5)
+                    # Don't cleanup if it was cancelled, let the UI see the cancelled state for a bit?
+                    # Actually cleanup_recipe_repair_progress is fine as long as we waited enough.
+                    self._ws_manager.cleanup_recipe_repair_progress()
+
+            asyncio.create_task(run_repair())
+
+            return web.json_response({"success": True, "message": "Recipe repair started"})
+        except Exception as exc:
+            self._logger.error("Error starting recipe repair: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def cancel_repair(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response({"success": False, "error": "Recipe scanner unavailable"}, status=503)
+
+            recipe_scanner.cancel_task()
+            return web.json_response({"success": True, "message": "Cancellation requested"})
+        except Exception as exc:
+            self._logger.error("Error cancelling recipe repair: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def repair_recipe(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response({"success": False, "error": "Recipe scanner unavailable"}, status=503)
+
+            recipe_id = request.match_info["recipe_id"]
+            result = await recipe_scanner.repair_recipe_by_id(recipe_id)
+            return web.json_response(result)
+        except RecipeNotFoundError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            self._logger.error("Error repairing single recipe: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_repair_progress(self, request: web.Request) -> web.Response:
+        try:
+            progress = self._ws_manager.get_recipe_repair_progress()
+            if progress:
+                return web.json_response({"success": True, "progress": progress})
+            return web.json_response({"success": False, "message": "No repair in progress"}, status=404)
+        except Exception as exc:
+            self._logger.error("Error getting repair progress: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+
     async def import_remote_recipe(self, request: web.Request) -> web.Response:
         try:
             await self._ensure_dependencies_ready()
@@ -451,10 +645,12 @@ class RecipeManagementHandler:
             if recipe_scanner is None:
                 raise RuntimeError("Recipe scanner unavailable")
             
+            # 1. Parse Parameters
             params = request.rel_url.query
             image_url = params.get("image_url")
             name = params.get("name")
             resources_raw = params.get("resources")
+            
             if not image_url:
                 raise RecipeValidationError("Missing required field: image_url")
             if not name:
@@ -463,27 +659,93 @@ class RecipeManagementHandler:
                 raise RecipeValidationError("Missing required field: resources")
 
             checkpoint_entry, lora_entries = self._parse_resources_payload(resources_raw)
-            gen_params = self._parse_gen_params(params.get("gen_params"))
+            gen_params_request = self._parse_gen_params(params.get("gen_params"))
+            
+            # 2. Initial Metadata Construction
             metadata: Dict[str, Any] = {
                 "base_model": params.get("base_model", "") or "",
                 "loras": lora_entries,
+                "gen_params": gen_params_request or {},
+                "source_url": image_url
             }
+            
             source_path = params.get("source_path")
             if source_path:
                 metadata["source_path"] = source_path
-            if gen_params is not None:
-                metadata["gen_params"] = gen_params
+                
+            # Checkpoint handling
             if checkpoint_entry:
                 metadata["checkpoint"] = checkpoint_entry
-                gen_params_ref = metadata.setdefault("gen_params", {})
-                if "checkpoint" not in gen_params_ref:
-                    gen_params_ref["checkpoint"] = checkpoint_entry
-                base_model_from_metadata = await self._resolve_base_model_from_checkpoint(checkpoint_entry)
-                if base_model_from_metadata:
-                    metadata["base_model"] = base_model_from_metadata
+                # Ensure checkpoint is also in gen_params for consistency if needed by enricher?
+                # Actually enricher looks at metadata['checkpoint'], so this is fine.
+                
+                # Try to resolve base model from checkpoint if not explicitly provided
+                if not metadata["base_model"]:
+                    base_model_from_metadata = await self._resolve_base_model_from_checkpoint(checkpoint_entry)
+                    if base_model_from_metadata:
+                        metadata["base_model"] = base_model_from_metadata
 
             tags = self._parse_tags(params.get("tags"))
-            image_bytes = await self._download_image_bytes(image_url)
+            
+            # 3. Download Image
+            image_bytes, extension, civitai_meta_from_download = await self._download_remote_media(image_url)
+
+            # 4. Extract Embedded Metadata
+            # Note: We still extract this here because Enricher currently expects 'gen_params' to already be populated 
+            # with embedded data if we want it to merge it. 
+            # However, logic in Enricher merges: request > civitai > embedded.
+            # So we should gather embedded params and put them into the recipe's gen_params (as initial state) 
+            # OR pass them to enricher to handle?
+            # The interface of Enricher.enrich_recipe takes `recipe` (with gen_params) and `request_params`.
+            # So let's extract embedded and put it into recipe['gen_params'] but careful not to overwrite request params.
+            # Actually, `GenParamsMerger` which `Enricher` uses handles 3 layers.
+            # But `Enricher` interface is: recipe['gen_params'] (as embedded) + request_params + civitai (fetched internally).
+            # Wait, `Enricher` fetches Civitai info internally based on URL. 
+            # `civitai_meta_from_download` is returned by `_download_remote_media` which might be useful if URL didn't have ID.
+            
+            # Let's extract embedded metadata first
+            embedded_gen_params = {}
+            try:
+                with tempfile.NamedTemporaryFile(suffix=extension, delete=False) as temp_img:
+                    temp_img.write(image_bytes)
+                    temp_img_path = temp_img.name
+                
+                try:
+                    raw_embedded = ExifUtils.extract_image_metadata(temp_img_path)
+                    if raw_embedded:
+                        parser = self._analysis_service._recipe_parser_factory.create_parser(raw_embedded)
+                        if parser:
+                            parsed_embedded = await parser.parse_metadata(raw_embedded, recipe_scanner=recipe_scanner)
+                            if parsed_embedded and "gen_params" in parsed_embedded:
+                                embedded_gen_params = parsed_embedded["gen_params"]
+                        else:
+                            embedded_gen_params = {"raw_metadata": raw_embedded}
+                finally:
+                    if os.path.exists(temp_img_path):
+                        os.unlink(temp_img_path)
+            except Exception as exc:
+                self._logger.warning("Failed to extract embedded metadata during import: %s", exc)
+
+            # Pre-populate gen_params with embedded data so Enricher treats it as the "base" layer
+            if embedded_gen_params:
+                # Merge embedded into existing gen_params (which currently only has request params if any)
+                # But wait, we want request params to override everything.
+                # So we should set recipe['gen_params'] = embedded, and pass request params to enricher.
+                metadata["gen_params"] = embedded_gen_params
+            
+            # 5. Enrich with unified logic
+            # This will fetch Civitai info (if URL matches) and merge: request > civitai > embedded
+            civitai_client = self._civitai_client_getter()
+            await RecipeEnricher.enrich_recipe(
+                recipe=metadata, 
+                civitai_client=civitai_client,
+                request_params=gen_params_request # Pass explicit request params here to override
+            )
+            
+            # If we got civitai_meta from download but Enricher didn't fetch it (e.g. not a civitai URL or failed),
+            # we might want to manually merge it? 
+            # But usually `import_remote_recipe` is used with Civitai URLs.
+            # For now, relying on Enricher's internal fetch is consistent with repair.
 
             result = await self._persistence_service.save_recipe(
                 recipe_scanner=recipe_scanner,
@@ -492,6 +754,7 @@ class RecipeManagementHandler:
                 name=name,
                 tags=tags,
                 metadata=metadata,
+                extension=extension,
             )
             return web.json_response(result.payload, status=result.status)
         except RecipeValidationError as exc:
@@ -541,6 +804,64 @@ class RecipeManagementHandler:
             self._logger.error("Error updating recipe: %s", exc, exc_info=True)
             return web.json_response({"error": str(exc)}, status=500)
 
+    async def move_recipe(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            data = await request.json()
+            recipe_id = data.get("recipe_id")
+            target_path = data.get("target_path")
+            if not recipe_id or not target_path:
+                return web.json_response(
+                    {"success": False, "error": "recipe_id and target_path are required"}, status=400
+                )
+
+            result = await self._persistence_service.move_recipe(
+                recipe_scanner=recipe_scanner,
+                recipe_id=str(recipe_id),
+                target_path=str(target_path),
+            )
+            return web.json_response(result.payload, status=result.status)
+        except RecipeValidationError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=400)
+        except RecipeNotFoundError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            self._logger.error("Error moving recipe: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def move_recipes_bulk(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            data = await request.json()
+            recipe_ids = data.get("recipe_ids") or []
+            target_path = data.get("target_path")
+            if not recipe_ids or not target_path:
+                return web.json_response(
+                    {"success": False, "error": "recipe_ids and target_path are required"}, status=400
+                )
+
+            result = await self._persistence_service.move_recipes_bulk(
+                recipe_scanner=recipe_scanner,
+                recipe_ids=recipe_ids,
+                target_path=str(target_path),
+            )
+            return web.json_response(result.payload, status=result.status)
+        except RecipeValidationError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=400)
+        except RecipeNotFoundError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            self._logger.error("Error moving recipes in bulk: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def reconnect_lora(self, request: web.Request) -> web.Response:
         try:
             await self._ensure_dependencies_ready()
@@ -622,6 +943,7 @@ class RecipeManagementHandler:
         name: Optional[str] = None
         tags: list[str] = []
         metadata: Optional[Dict[str, Any]] = None
+        extension: Optional[str] = None
 
         while True:
             field = await reader.next()
@@ -652,6 +974,8 @@ class RecipeManagementHandler:
                     metadata = json.loads(metadata_text)
                 except Exception:
                     metadata = {}
+            elif field.name == "extension":
+                extension = await field.text()
 
         return {
             "image_bytes": image_bytes,
@@ -659,6 +983,7 @@ class RecipeManagementHandler:
             "name": name,
             "tags": tags,
             "metadata": metadata,
+            "extension": extension,
         }
 
     def _parse_tags(self, tag_text: Optional[str]) -> list[str]:
@@ -729,7 +1054,7 @@ class RecipeManagementHandler:
             "exclude": False,
         }
 
-    async def _download_image_bytes(self, image_url: str) -> bytes:
+    async def _download_remote_media(self, image_url: str) -> tuple[bytes, str, Any]:
         civitai_client = self._civitai_client_getter()
         downloader = await self._downloader_factory()
         temp_path = None
@@ -737,6 +1062,7 @@ class RecipeManagementHandler:
             with tempfile.NamedTemporaryFile(delete=False) as temp_file:
                 temp_path = temp_file.name
             download_url = image_url
+            image_info = None
             civitai_match = re.match(r"https://civitai\.com/images/(\d+)", image_url)
             if civitai_match:
                 if civitai_client is None:
@@ -744,15 +1070,31 @@ class RecipeManagementHandler:
                 image_info = await civitai_client.get_image_info(civitai_match.group(1))
                 if not image_info:
                     raise RecipeDownloadError("Failed to fetch image information from Civitai")
-                download_url = image_info.get("url")
-                if not download_url:
+                
+                media_url = image_info.get("url")
+                if not media_url:
                     raise RecipeDownloadError("No image URL found in Civitai response")
                 
+                # Use optimized preview URLs if possible
+                media_type = image_info.get("type")
+                rewritten_url, _ = rewrite_preview_url(media_url, media_type=media_type)
+                if rewritten_url:
+                    download_url = rewritten_url
+                else:
+                    download_url = media_url
+
             success, result = await downloader.download_file(download_url, temp_path, use_auth=False)
             if not success:
                 raise RecipeDownloadError(f"Failed to download image: {result}")
+            
+            # Extract extension from URL
+            url_path = download_url.split('?')[0].split('#')[0]
+            extension = os.path.splitext(url_path)[1].lower()
+            if not extension:
+                extension = ".webp" # Default to webp if unknown
+
             with open(temp_path, "rb") as file_obj:
-                return file_obj.read()
+                return file_obj.read(), extension, image_info.get("meta") if civitai_match and image_info else None
         except RecipeDownloadError:
             raise
         except RecipeValidationError:
@@ -766,6 +1108,7 @@ class RecipeManagementHandler:
                 except FileNotFoundError:
                     pass
 
+
     def _safe_int(self, value: Any) -> int:
         try:
             return int(value)

py/routes/lora_routes.py

@@ -12,6 +12,7 @@ from ..utils.utils import get_lora_info
 
 logger = logging.getLogger(__name__)
 
+
 class LoraRoutes(BaseModelRoutes):
     """LoRA-specific route controller"""
 
@@ -36,45 +37,72 @@ class LoraRoutes(BaseModelRoutes):
         app.on_startup.append(lambda _: self.initialize_services())
 
         # Setup common routes with 'loras' prefix (includes page route)
-        super().setup_routes(app, 'loras')
+        super().setup_routes(app, "loras")
 
     def setup_specific_routes(self, registrar: ModelRouteRegistrar, prefix: str):
         """Setup LoRA-specific routes"""
         # LoRA-specific query routes
-        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/letter-counts', prefix, self.get_letter_counts)
-        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/get-trigger-words', prefix, self.get_lora_trigger_words)
-        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/usage-tips-by-path', prefix, self.get_lora_usage_tips_by_path)
+        registrar.add_prefixed_route(
+            "GET", "/api/lm/{prefix}/letter-counts", prefix, self.get_letter_counts
+        )
+        registrar.add_prefixed_route(
+            "GET",
+            "/api/lm/{prefix}/get-trigger-words",
+            prefix,
+            self.get_lora_trigger_words,
+        )
+        registrar.add_prefixed_route(
+            "GET",
+            "/api/lm/{prefix}/usage-tips-by-path",
+            prefix,
+            self.get_lora_usage_tips_by_path,
+        )
+
+        # Randomizer routes
+        registrar.add_prefixed_route(
+            "POST", "/api/lm/{prefix}/random-sample", prefix, self.get_random_loras
+        )
+
+        # Cycler routes
+        registrar.add_prefixed_route(
+            "POST", "/api/lm/{prefix}/cycler-list", prefix, self.get_cycler_list
+        )
 
         # ComfyUI integration
-        registrar.add_prefixed_route('POST', '/api/lm/{prefix}/get_trigger_words', prefix, self.get_trigger_words)
+        registrar.add_prefixed_route(
+            "POST", "/api/lm/{prefix}/get_trigger_words", prefix, self.get_trigger_words
+        )
 
     def _parse_specific_params(self, request: web.Request) -> Dict:
         """Parse LoRA-specific parameters"""
         params = {}
 
         # LoRA-specific parameters
-        if 'first_letter' in request.query:
-            params['first_letter'] = request.query.get('first_letter')
+        if "first_letter" in request.query:
+            params["first_letter"] = request.query.get("first_letter")
 
         # Handle fuzzy search parameter name variation
-        if request.query.get('fuzzy') == 'true':
-            params['fuzzy_search'] = True
+        if request.query.get("fuzzy") == "true":
+            params["fuzzy_search"] = True
 
         # Handle additional filter parameters for LoRAs
-        if 'lora_hash' in request.query:
-            if not params.get('hash_filters'):
-                params['hash_filters'] = {}
-            params['hash_filters']['single_hash'] = request.query['lora_hash'].lower()
-        elif 'lora_hashes' in request.query:
-            if not params.get('hash_filters'):
-                params['hash_filters'] = {}
-            params['hash_filters']['multiple_hashes'] = [h.lower() for h in request.query['lora_hashes'].split(',')]
+        if "lora_hash" in request.query:
+            if not params.get("hash_filters"):
+                params["hash_filters"] = {}
+            params["hash_filters"]["single_hash"] = request.query["lora_hash"].lower()
+        elif "lora_hashes" in request.query:
+            if not params.get("hash_filters"):
+                params["hash_filters"] = {}
+            params["hash_filters"]["multiple_hashes"] = [
+                h.lower() for h in request.query["lora_hashes"].split(",")
+            ]
 
         return params
 
     def _validate_civitai_model_type(self, model_type: str) -> bool:
         """Validate CivitAI model type for LoRA"""
         from ..utils.constants import VALID_LORA_TYPES
+
         return model_type.lower() in VALID_LORA_TYPES
 
     def _get_expected_model_types(self) -> str:
@@ -86,134 +114,202 @@ class LoraRoutes(BaseModelRoutes):
         """Get count of LoRAs for each letter of the alphabet"""
         try:
             letter_counts = await self.service.get_letter_counts()
-            return web.json_response({
-                'success': True,
-                'letter_counts': letter_counts
-            })
+            return web.json_response({"success": True, "letter_counts": letter_counts})
         except Exception as e:
             logger.error(f"Error getting letter counts: {e}")
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_lora_notes(self, request: web.Request) -> web.Response:
         """Get notes for a specific LoRA file"""
         try:
-            lora_name = request.query.get('name')
+            lora_name = request.query.get("name")
             if not lora_name:
-                return web.Response(text='Lora file name is required', status=400)
+                return web.Response(text="Lora file name is required", status=400)
 
             notes = await self.service.get_lora_notes(lora_name)
             if notes is not None:
-                return web.json_response({
-                    'success': True,
-                    'notes': notes
-                })
+                return web.json_response({"success": True, "notes": notes})
             else:
-                return web.json_response({
-                    'success': False,
-                    'error': 'LoRA not found in cache'
-                }, status=404)
+                return web.json_response(
+                    {"success": False, "error": "LoRA not found in cache"}, status=404
+                )
 
         except Exception as e:
             logger.error(f"Error getting lora notes: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_lora_trigger_words(self, request: web.Request) -> web.Response:
         """Get trigger words for a specific LoRA file"""
         try:
-            lora_name = request.query.get('name')
+            lora_name = request.query.get("name")
             if not lora_name:
-                return web.Response(text='Lora file name is required', status=400)
+                return web.Response(text="Lora file name is required", status=400)
 
             trigger_words = await self.service.get_lora_trigger_words(lora_name)
-            return web.json_response({
-                'success': True,
-                'trigger_words': trigger_words
-            })
+            return web.json_response({"success": True, "trigger_words": trigger_words})
 
         except Exception as e:
             logger.error(f"Error getting lora trigger words: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_lora_usage_tips_by_path(self, request: web.Request) -> web.Response:
         """Get usage tips for a LoRA by its relative path"""
         try:
-            relative_path = request.query.get('relative_path')
+            relative_path = request.query.get("relative_path")
             if not relative_path:
-                return web.Response(text='Relative path is required', status=400)
+                return web.Response(text="Relative path is required", status=400)
 
-            usage_tips = await self.service.get_lora_usage_tips_by_relative_path(relative_path)
-            return web.json_response({
-                'success': True,
-                'usage_tips': usage_tips or ''
-            })
+            usage_tips = await self.service.get_lora_usage_tips_by_relative_path(
+                relative_path
+            )
+            return web.json_response({"success": True, "usage_tips": usage_tips or ""})
 
         except Exception as e:
             logger.error(f"Error getting lora usage tips by path: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_lora_preview_url(self, request: web.Request) -> web.Response:
         """Get the static preview URL for a LoRA file"""
         try:
-            lora_name = request.query.get('name')
+            lora_name = request.query.get("name")
             if not lora_name:
-                return web.Response(text='Lora file name is required', status=400)
+                return web.Response(text="Lora file name is required", status=400)
 
             preview_url = await self.service.get_lora_preview_url(lora_name)
             if preview_url:
-                return web.json_response({
-                    'success': True,
-                    'preview_url': preview_url
-                })
+                return web.json_response({"success": True, "preview_url": preview_url})
             else:
-                return web.json_response({
-                    'success': False,
-                    'error': 'No preview URL found for the specified lora'
-                }, status=404)
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "No preview URL found for the specified lora",
+                    },
+                    status=404,
+                )
 
         except Exception as e:
             logger.error(f"Error getting lora preview URL: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_lora_civitai_url(self, request: web.Request) -> web.Response:
         """Get the Civitai URL for a LoRA file"""
         try:
-            lora_name = request.query.get('name')
+            lora_name = request.query.get("name")
             if not lora_name:
-                return web.Response(text='Lora file name is required', status=400)
+                return web.Response(text="Lora file name is required", status=400)
 
             result = await self.service.get_lora_civitai_url(lora_name)
-            if result['civitai_url']:
-                return web.json_response({
-                    'success': True,
-                    **result
-                })
+            if result["civitai_url"]:
+                return web.json_response({"success": True, **result})
             else:
-                return web.json_response({
-                    'success': False,
-                    'error': 'No Civitai data found for the specified lora'
-                }, status=404)
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "No Civitai data found for the specified lora",
+                    },
+                    status=404,
+                )
 
         except Exception as e:
             logger.error(f"Error getting lora Civitai URL: {e}", exc_info=True)
-            return web.json_response({
-                'success': False,
-                'error': str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    async def get_random_loras(self, request: web.Request) -> web.Response:
+        """Get random LoRAs based on filters and strength ranges"""
+        try:
+            json_data = await request.json()
+
+            # Parse parameters
+            count = json_data.get("count", 5)
+            count_min = json_data.get("count_min")
+            count_max = json_data.get("count_max")
+            model_strength_min = float(json_data.get("model_strength_min", 0.0))
+            model_strength_max = float(json_data.get("model_strength_max", 1.0))
+            use_same_clip_strength = json_data.get("use_same_clip_strength", True)
+            clip_strength_min = float(json_data.get("clip_strength_min", 0.0))
+            clip_strength_max = float(json_data.get("clip_strength_max", 1.0))
+            locked_loras = json_data.get("locked_loras", [])
+            pool_config = json_data.get("pool_config")
+            use_recommended_strength = json_data.get("use_recommended_strength", False)
+            recommended_strength_scale_min = float(
+                json_data.get("recommended_strength_scale_min", 0.5)
+            )
+            recommended_strength_scale_max = float(
+                json_data.get("recommended_strength_scale_max", 1.0)
+            )
+
+            # Determine target count
+            if count_min is not None and count_max is not None:
+                import random
+
+                target_count = random.randint(count_min, count_max)
+            else:
+                target_count = count
+
+            # Validate parameters
+            if target_count < 1 or target_count > 100:
+                return web.json_response(
+                    {"success": False, "error": "Count must be between 1 and 100"},
+                    status=400,
+                )
+
+            if model_strength_min < -10 or model_strength_max > 10:
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "Model strength must be between -10 and 10",
+                    },
+                    status=400,
+                )
+
+            # Get random LoRAs from service
+            result_loras = await self.service.get_random_loras(
+                count=target_count,
+                model_strength_min=model_strength_min,
+                model_strength_max=model_strength_max,
+                use_same_clip_strength=use_same_clip_strength,
+                clip_strength_min=clip_strength_min,
+                clip_strength_max=clip_strength_max,
+                locked_loras=locked_loras,
+                pool_config=pool_config,
+                use_recommended_strength=use_recommended_strength,
+                recommended_strength_scale_min=recommended_strength_scale_min,
+                recommended_strength_scale_max=recommended_strength_scale_max,
+            )
+
+            return web.json_response(
+                {"success": True, "loras": result_loras, "count": len(result_loras)}
+            )
+
+        except ValueError as e:
+            logger.error(f"Invalid parameter for random LoRAs: {e}")
+            return web.json_response({"success": False, "error": str(e)}, status=400)
+        except Exception as e:
+            logger.error(f"Error getting random LoRAs: {e}", exc_info=True)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
+
+    async def get_cycler_list(self, request: web.Request) -> web.Response:
+        """Get filtered and sorted LoRA list for cycler widget"""
+        try:
+            json_data = await request.json()
+
+            # Parse parameters
+            pool_config = json_data.get("pool_config")
+            sort_by = json_data.get("sort_by", "filename")
+
+            # Get cycler list from service
+            lora_list = await self.service.get_cycler_list(
+                pool_config=pool_config,
+                sort_by=sort_by
+            )
+
+            return web.json_response(
+                {"success": True, "loras": lora_list, "count": len(lora_list)}
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting cycler list: {e}", exc_info=True)
+            return web.json_response({"success": False, "error": str(e)}, status=500)
 
     async def get_trigger_words(self, request: web.Request) -> web.Response:
         """Get trigger words for specified LoRA models"""
@@ -228,7 +324,9 @@ class LoraRoutes(BaseModelRoutes):
                 all_trigger_words.extend(trigger_words)
 
             # Format the trigger words
-            trigger_words_text = ",, ".join(all_trigger_words) if all_trigger_words else ""
+            trigger_words_text = (
+                ",, ".join(all_trigger_words) if all_trigger_words else ""
+            )
 
             # Send update to all connected trigger word toggle nodes
             for entry in node_ids:
@@ -243,10 +341,7 @@ class LoraRoutes(BaseModelRoutes):
                 except (TypeError, ValueError):
                     parsed_node_id = node_identifier
 
-                payload = {
-                    "id": parsed_node_id,
-                    "message": trigger_words_text
-                }
+                payload = {"id": parsed_node_id, "message": trigger_words_text}
 
                 if graph_identifier is not None:
                     payload["graph_id"] = str(graph_identifier)
@@ -257,7 +352,4 @@ class LoraRoutes(BaseModelRoutes):
 
         except Exception as e:
             logger.error(f"Error getting trigger words: {e}")
-            return web.json_response({
-                "success": False,
-                "error": str(e)
-            }, status=500)
+            return web.json_response({"success": False, "error": str(e)}, status=500)

py/routes/misc_route_registrar.py

@@ -41,6 +41,8 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     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"),
 )
 
 

py/routes/misc_routes.py

@@ -18,6 +18,7 @@ from ..services.settings_manager import get_settings_manager
 from ..services.downloader import get_downloader
 from ..utils.usage_stats import UsageStats
 from .handlers.misc_handlers import (
+    CustomWordsHandler,
     FileSystemHandler,
     HealthCheckHandler,
     LoraCodeHandler,
@@ -107,7 +108,7 @@ class MiscRoutes:
             settings_service=self._settings,
             metadata_provider_updater=self._metadata_provider_updater,
         )
-        filesystem = FileSystemHandler()
+        filesystem = FileSystemHandler(settings_service=self._settings)
         node_registry_handler = NodeRegistryHandler(
             node_registry=self._node_registry,
             prompt_server=self._prompt_server,
@@ -117,6 +118,7 @@ class MiscRoutes:
             service_registry=self._service_registry_adapter,
             metadata_provider_factory=self._metadata_provider_factory,
         )
+        custom_words = CustomWordsHandler()
 
         return self._handler_set_factory(
             health=health,
@@ -129,6 +131,7 @@ class MiscRoutes:
             model_library=model_library,
             metadata_archive=metadata_archive,
             filesystem=filesystem,
+            custom_words=custom_words,
         )
 
 

py/routes/model_route_registrar.py

@@ -68,6 +68,7 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     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("POST", "/api/lm/{prefix}/cancel-task", "cancel_task"),
     RouteDefinition("GET", "/{prefix}", "handle_models_page"),
 )
 

py/routes/recipe_route_registrar.py

@@ -27,16 +27,26 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("DELETE", "/api/lm/recipe/{recipe_id}", "delete_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/top-tags", "get_top_tags"),
     RouteDefinition("GET", "/api/lm/recipes/base-models", "get_base_models"),
+    RouteDefinition("GET", "/api/lm/recipes/roots", "get_roots"),
+    RouteDefinition("GET", "/api/lm/recipes/folders", "get_folders"),
+    RouteDefinition("GET", "/api/lm/recipes/folder-tree", "get_folder_tree"),
+    RouteDefinition("GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share", "share_recipe"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/syntax", "get_recipe_syntax"),
     RouteDefinition("PUT", "/api/lm/recipe/{recipe_id}/update", "update_recipe"),
+    RouteDefinition("POST", "/api/lm/recipe/move", "move_recipe"),
+    RouteDefinition("POST", "/api/lm/recipes/move-bulk", "move_recipes_bulk"),
     RouteDefinition("POST", "/api/lm/recipe/lora/reconnect", "reconnect_lora"),
     RouteDefinition("GET", "/api/lm/recipes/find-duplicates", "find_duplicates"),
     RouteDefinition("POST", "/api/lm/recipes/bulk-delete", "bulk_delete"),
     RouteDefinition("POST", "/api/lm/recipes/save-from-widget", "save_recipe_from_widget"),
     RouteDefinition("GET", "/api/lm/recipes/for-lora", "get_recipes_for_lora"),
     RouteDefinition("GET", "/api/lm/recipes/scan", "scan_recipes"),
+    RouteDefinition("POST", "/api/lm/recipes/repair", "repair_recipes"),
+    RouteDefinition("POST", "/api/lm/recipes/cancel-repair", "cancel_repair"),
+    RouteDefinition("POST", "/api/lm/recipe/{recipe_id}/repair", "repair_recipe"),
+    RouteDefinition("GET", "/api/lm/recipes/repair-progress", "get_repair_progress"),
 )
 
 

py/routes/update_routes.py

@@ -45,8 +45,9 @@ class UpdateRoutes:
             # Fetch remote version from GitHub
             if nightly:
                 remote_version, changelog = await UpdateRoutes._get_nightly_version()
+                releases = None
             else:
-                remote_version, changelog = await UpdateRoutes._get_remote_version()
+                remote_version, changelog, releases = await UpdateRoutes._get_remote_version()
             
             # Compare versions
             if nightly:
@@ -59,7 +60,7 @@ class UpdateRoutes:
                     remote_version.replace('v', '')
                 )
             
-            return web.json_response({
+            response_data = {
                 'success': True,
                 'current_version': local_version,
                 'latest_version': remote_version,
@@ -67,7 +68,13 @@ class UpdateRoutes:
                 'changelog': changelog,
                 'git_info': git_info,
                 'nightly': nightly
-            })
+            }
+            
+            # Include releases list for stable mode
+            if releases is not None:
+                response_data['releases'] = releases
+            
+            return web.json_response(response_data)
             
         except NETWORK_EXCEPTIONS as e:
             logger.warning("Network unavailable during update check: %s", e)
@@ -443,42 +450,58 @@ class UpdateRoutes:
         return git_info
     
     @staticmethod
-    async def _get_remote_version() -> tuple[str, List[str]]:
+    async def _get_remote_version() -> tuple[str, List[str], List[Dict]]:
         """
         Fetch remote version from GitHub
         Returns:
-            tuple: (version string, changelog list)
+            tuple: (version string, changelog list, releases list)
         """
         repo_owner = "willmiao"
         repo_name = "ComfyUI-Lora-Manager"
         
-        # Use GitHub API to fetch the latest release
-        github_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/latest"
+        # Use GitHub API to fetch the last 5 releases
+        github_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases?per_page=5"
         
         try:
             downloader = await get_downloader()
             success, data = await downloader.make_request('GET', github_url, custom_headers={'Accept': 'application/vnd.github+json'})
             
             if not success:
-                logger.warning(f"Failed to fetch GitHub release: {data}")
-                return "v0.0.0", []
+                logger.warning(f"Failed to fetch GitHub releases: {data}")
+                return "v0.0.0", [], []
             
-            version = data.get('tag_name', '')
-            if not version.startswith('v'):
-                version = f"v{version}"
+            # Parse releases
+            releases = []
+            for i, release in enumerate(data):
+                version = release.get('tag_name', '')
+                if not version.startswith('v'):
+                    version = f"v{version}"
                 
-            # Extract changelog from release notes
-            body = data.get('body', '')
-            changelog = UpdateRoutes._parse_changelog(body)
+                # Extract changelog from release notes
+                body = release.get('body', '')
+                changelog = UpdateRoutes._parse_changelog(body)
                 
-            return version, changelog
+                releases.append({
+                    'version': version,
+                    'changelog': changelog,
+                    'published_at': release.get('published_at', ''),
+                    'is_latest': i == 0
+                })
+            
+            # Get latest version and its changelog
+            if releases:
+                latest_version = releases[0]['version']
+                latest_changelog = releases[0]['changelog']
+                return latest_version, latest_changelog, releases
+            
+            return "v0.0.0", [], []
         
         except NETWORK_EXCEPTIONS as e:
             logger.warning("Unable to reach GitHub for release info: %s", e)
-            return "v0.0.0", []
+            return "v0.0.0", [], []
         except Exception as e:
             logger.error(f"Error fetching remote version: {e}", exc_info=True)
-            return "v0.0.0", []
+            return "v0.0.0", [], []
     
     @staticmethod
     def _parse_changelog(release_notes: str) -> List[str]:

py/services/base_model_service.py

@@ -3,18 +3,20 @@ import asyncio
 from typing import Any, Dict, List, Optional, Type, TYPE_CHECKING
 import logging
 import os
+import time
 
-from ..utils.constants import VALID_LORA_TYPES
+from ..utils.constants import VALID_LORA_SUB_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.models import BaseModelMetadata
 from ..utils.metadata_manager import MetadataManager
+from ..utils.usage_stats import UsageStats
 from .model_query import (
     FilterCriteria,
     ModelCacheRepository,
     ModelFilterSet,
     SearchStrategy,
     SettingsProvider,
-    normalize_civitai_model_type,
-    resolve_civitai_model_type,
+    normalize_sub_type,
+    resolve_sub_type,
 )
 from .settings_manager import get_settings_manager
 
@@ -23,6 +25,7 @@ logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from .model_update_service import ModelUpdateService
 
+
 class BaseModelService(ABC):
     """Base service class for all model types"""
 
@@ -63,8 +66,10 @@ class BaseModelService(ABC):
         self,
         page: int,
         page_size: int,
-        sort_by: str = 'name',
+        sort_by: str = "name",
         folder: str = None,
+        folder_include: list = None,
+        folder_exclude: list = None,
         search: str = None,
         fuzzy_search: bool = False,
         base_models: list = None,
@@ -76,24 +81,36 @@ class BaseModelService(ABC):
         update_available_only: bool = False,
         credit_required: Optional[bool] = None,
         allow_selling_generated_content: Optional[bool] = None,
+        tag_logic: str = "any",
         **kwargs,
     ) -> Dict:
         """Get paginated and filtered model data"""
+        overall_start = time.perf_counter()
 
         sort_params = self.cache_repository.parse_sort(sort_by)
-        sorted_data = await self.cache_repository.fetch_sorted(sort_params)
+        t0 = time.perf_counter()
+        if sort_params.key == "usage":
+            sorted_data = await self._fetch_with_usage_sort(sort_params)
+        else:
+            sorted_data = await self.cache_repository.fetch_sorted(sort_params)
+        fetch_duration = time.perf_counter() - t0
+        initial_count = len(sorted_data)
 
+        t1 = time.perf_counter()
         if hash_filters:
             filtered_data = await self._apply_hash_filters(sorted_data, hash_filters)
         else:
             filtered_data = await self._apply_common_filters(
                 sorted_data,
                 folder=folder,
+                folder_include=folder_include,
+                folder_exclude=folder_exclude,
                 base_models=base_models,
                 model_types=model_types,
                 tags=tags,
                 favorites_only=favorites_only,
                 search_options=search_options,
+                tag_logic=tag_logic,
             )
 
             if search:
@@ -108,50 +125,110 @@ class BaseModelService(ABC):
 
             # Apply license-based filters
             if credit_required is not None:
-                filtered_data = await self._apply_credit_required_filter(filtered_data, credit_required)
+                filtered_data = await self._apply_credit_required_filter(
+                    filtered_data, credit_required
+                )
 
             if allow_selling_generated_content is not None:
-                filtered_data = await self._apply_allow_selling_filter(filtered_data, allow_selling_generated_content)
+                filtered_data = await self._apply_allow_selling_filter(
+                    filtered_data, allow_selling_generated_content
+                )
+        filter_duration = time.perf_counter() - t1
+        post_filter_count = len(filtered_data)
 
         annotated_for_filter: Optional[List[Dict]] = None
+        t2 = time.perf_counter()
         if update_available_only:
             annotated_for_filter = await self._annotate_update_flags(filtered_data)
             filtered_data = [
-                item for item in annotated_for_filter
-                if item.get('update_available')
+                item for item in annotated_for_filter if item.get("update_available")
             ]
+        update_filter_duration = time.perf_counter() - t2
+        final_count = len(filtered_data)
 
+        t3 = time.perf_counter()
         paginated = self._paginate(filtered_data, page, page_size)
+        pagination_duration = time.perf_counter() - t3
 
+        t4 = time.perf_counter()
         if update_available_only:
             # Items already include update flags thanks to the pre-filter annotation.
-            paginated['items'] = list(paginated['items'])
+            paginated["items"] = list(paginated["items"])
         else:
-            paginated['items'] = await self._annotate_update_flags(
-                paginated['items'],
+            paginated["items"] = await self._annotate_update_flags(
+                paginated["items"],
             )
+        annotate_duration = time.perf_counter() - t4
+
+        overall_duration = time.perf_counter() - overall_start
+        logger.debug(
+            "%s.get_paginated_data took %.3fs (fetch: %.3fs, filter: %.3fs, update_filter: %.3fs, pagination: %.3fs, annotate: %.3fs). "
+            "Counts: initial=%d, post_filter=%d, final=%d",
+            self.__class__.__name__,
+            overall_duration,
+            fetch_duration,
+            filter_duration,
+            update_filter_duration,
+            pagination_duration,
+            annotate_duration,
+            initial_count,
+            post_filter_count,
+            final_count,
+        )
         return paginated
 
+    async def _fetch_with_usage_sort(self, sort_params):
+        """Fetch data sorted by usage count (desc/asc)."""
+        cache = await self.cache_repository.get_cache()
+        raw_items = cache.raw_data or []
 
-    async def _apply_hash_filters(self, data: List[Dict], hash_filters: Dict) -> List[Dict]:
+        # Map model type to usage stats bucket
+        bucket_map = {
+            "lora": "loras",
+            "checkpoint": "checkpoints",
+            # 'embedding': 'embeddings',  # TODO: Enable when embedding usage tracking is implemented
+        }
+        bucket_key = bucket_map.get(self.model_type, "")
+
+        usage_stats = UsageStats()
+        stats = await usage_stats.get_stats()
+        usage_bucket = stats.get(bucket_key, {}) if bucket_key else {}
+
+        annotated = []
+        for item in raw_items:
+            sha = (item.get("sha256") or "").lower()
+            usage_info = (
+                usage_bucket.get(sha, {}) if isinstance(usage_bucket, dict) else {}
+            )
+            usage_count = (
+                usage_info.get("total", 0) if isinstance(usage_info, dict) else 0
+            )
+            annotated.append({**item, "usage_count": usage_count})
+
+        reverse = sort_params.order == "desc"
+        annotated.sort(
+            key=lambda x: (x.get("usage_count", 0), x.get("model_name", "").lower()),
+            reverse=reverse,
+        )
+        return annotated
+
+    async def _apply_hash_filters(
+        self, data: List[Dict], hash_filters: Dict
+    ) -> List[Dict]:
         """Apply hash-based filtering"""
-        single_hash = hash_filters.get('single_hash')
-        multiple_hashes = hash_filters.get('multiple_hashes')
+        single_hash = hash_filters.get("single_hash")
+        multiple_hashes = hash_filters.get("multiple_hashes")
 
         if single_hash:
             # Filter by single hash
             single_hash = single_hash.lower()
             return [
-                item for item in data
-                if item.get('sha256', '').lower() == single_hash
+                item for item in data if item.get("sha256", "").lower() == single_hash
             ]
         elif multiple_hashes:
             # Filter by multiple hashes
             hash_set = set(hash.lower() for hash in multiple_hashes)
-            return [
-                item for item in data
-                if item.get('sha256', '').lower() in hash_set
-            ]
+            return [item for item in data if item.get("sha256", "").lower() in hash_set]
 
         return data
 
@@ -159,21 +236,27 @@ class BaseModelService(ABC):
         self,
         data: List[Dict],
         folder: str = None,
+        folder_include: list = None,
+        folder_exclude: list = None,
         base_models: list = None,
         model_types: list = None,
         tags: Optional[Dict[str, str]] = None,
         favorites_only: bool = False,
         search_options: dict = None,
+        tag_logic: str = "any",
     ) -> List[Dict]:
         """Apply common filters that work across all model types"""
         normalized_options = self.search_strategy.normalize_options(search_options)
         criteria = FilterCriteria(
             folder=folder,
+            folder_include=folder_include,
+            folder_exclude=folder_exclude,
             base_models=base_models,
             model_types=model_types,
             tags=tags,
             favorites_only=favorites_only,
             search_options=normalized_options,
+            tag_logic=tag_logic,
         )
         return self.filter_set.apply(data, criteria)
 
@@ -186,13 +269,17 @@ class BaseModelService(ABC):
     ) -> List[Dict]:
         """Apply search filtering"""
         normalized_options = self.search_strategy.normalize_options(search_options)
-        return self.search_strategy.apply(data, search, normalized_options, fuzzy_search)
+        return self.search_strategy.apply(
+            data, search, normalized_options, fuzzy_search
+        )
 
     async def _apply_specific_filters(self, data: List[Dict], **kwargs) -> List[Dict]:
         """Apply model-specific filters - to be overridden by subclasses if needed"""
         return data
 
-    async def _apply_credit_required_filter(self, data: List[Dict], credit_required: bool) -> List[Dict]:
+    async def _apply_credit_required_filter(
+        self, data: List[Dict], credit_required: bool
+    ) -> List[Dict]:
         """Apply credit required filtering based on license_flags.
 
         Args:
@@ -203,7 +290,9 @@ class BaseModelService(ABC):
         """
         filtered_data = []
         for item in data:
-            license_flags = item.get("license_flags", 127)  # Default to all permissions enabled
+            license_flags = item.get(
+                "license_flags", 127
+            )  # Default to all permissions enabled
 
             # Bit 0 represents allowNoCredit (1 = no credit required, 0 = credit required)
             allow_no_credit = bool(license_flags & (1 << 0))
@@ -219,7 +308,9 @@ class BaseModelService(ABC):
 
         return filtered_data
 
-    async def _apply_allow_selling_filter(self, data: List[Dict], allow_selling: bool) -> List[Dict]:
+    async def _apply_allow_selling_filter(
+        self, data: List[Dict], allow_selling: bool
+    ) -> List[Dict]:
         """Apply allow selling generated content filtering based on license_flags.
 
         Args:
@@ -230,7 +321,9 @@ class BaseModelService(ABC):
         """
         filtered_data = []
         for item in data:
-            license_flags = item.get("license_flags", 127)  # Default to all permissions enabled
+            license_flags = item.get(
+                "license_flags", 127
+            )  # Default to all permissions enabled
 
             # Bits 1-4 represent commercial use permissions
             # Bit 1 specifically represents Image permission (allowCommercialUse contains Image)
@@ -262,7 +355,7 @@ class BaseModelService(ABC):
 
         if self.update_service is None:
             for item in annotated:
-                item['update_available'] = False
+                item["update_available"] = False
             return annotated
 
         id_to_items: Dict[int, List[Dict]] = {}
@@ -270,7 +363,7 @@ class BaseModelService(ABC):
         for item in annotated:
             model_id = self._extract_model_id(item)
             if model_id is None:
-                item['update_available'] = False
+                item["update_available"] = False
                 continue
             if model_id not in id_to_items:
                 id_to_items[model_id] = []
@@ -346,13 +439,19 @@ class BaseModelService(ABC):
             default_flag = bool(resolved.get(model_id, False)) if resolved else False
             record = records.get(model_id) if records else None
             base_highest_versions = (
-                self._build_highest_local_versions_by_base(record) if same_base_mode and record else {}
+                self._build_highest_local_versions_by_base(record)
+                if same_base_mode and record
+                else {}
             )
             for item in items_for_id:
                 if same_base_mode and record is not None:
                     base_model = self._extract_base_model(item)
                     normalized_base = self._normalize_base_model_name(base_model)
-                    threshold_version = base_highest_versions.get(normalized_base) if normalized_base else None
+                    threshold_version = (
+                        base_highest_versions.get(normalized_base)
+                        if normalized_base
+                        else None
+                    )
                     if threshold_version is None:
                         threshold_version = self._extract_version_id(item)
                     flag = record.has_update_for_base(
@@ -361,17 +460,17 @@ class BaseModelService(ABC):
                     )
                 else:
                     flag = default_flag
-                item['update_available'] = flag
+                item["update_available"] = flag
 
         return annotated
 
     @staticmethod
     def _extract_model_id(item: Dict) -> Optional[int]:
-        civitai = item.get('civitai') if isinstance(item, dict) else None
+        civitai = item.get("civitai") if isinstance(item, dict) else None
         if not isinstance(civitai, dict):
             return None
         try:
-            value = civitai.get('modelId')
+            value = civitai.get("modelId")
             if value is None:
                 return None
             return int(value)
@@ -380,10 +479,10 @@ class BaseModelService(ABC):
 
     @staticmethod
     def _extract_version_id(item: Dict) -> Optional[int]:
-        civitai = item.get('civitai') if isinstance(item, dict) else None
+        civitai = item.get("civitai") if isinstance(item, dict) else None
         if not isinstance(civitai, dict):
             return None
-        value = civitai.get('id')
+        value = civitai.get("id")
         if value is None:
             return None
         try:
@@ -393,7 +492,7 @@ class BaseModelService(ABC):
 
     @staticmethod
     def _extract_base_model(item: Dict) -> Optional[str]:
-        value = item.get('base_model')
+        value = item.get("base_model")
         if value is None:
             return None
         if isinstance(value, str):
@@ -430,7 +529,9 @@ class BaseModelService(ABC):
         for version in getattr(record, "versions", []):
             if not getattr(version, "is_in_library", False):
                 continue
-            normalized_base = self._normalize_base_model_name(getattr(version, "base_model", None))
+            normalized_base = self._normalize_base_model_name(
+                getattr(version, "base_model", None)
+            )
             if normalized_base is None:
                 continue
             version_id = getattr(version, "version_id", None)
@@ -449,11 +550,11 @@ class BaseModelService(ABC):
         end_idx = min(start_idx + page_size, total_items)
 
         return {
-            'items': data[start_idx:end_idx],
-            'total': total_items,
-            'page': page,
-            'page_size': page_size,
-            'total_pages': (total_items + page_size - 1) // page_size
+            "items": data[start_idx:end_idx],
+            "total": total_items,
+            "page": page,
+            "page_size": page_size,
+            "total_pages": (total_items + page_size - 1) // page_size,
         }
 
     @abstractmethod
@@ -471,18 +572,28 @@ class BaseModelService(ABC):
         return await self.scanner.get_base_models(limit)
 
     async def get_model_types(self, limit: int = 20) -> List[Dict[str, Any]]:
-        """Get counts of normalized CivitAI model types present in the cache."""
+        """Get counts of sub-types present in the cache."""
         cache = await self.scanner.get_cached_data()
 
         type_counts: Dict[str, int] = {}
         for entry in cache.raw_data:
-            normalized_type = normalize_civitai_model_type(resolve_civitai_model_type(entry))
-            if not normalized_type or normalized_type not in VALID_LORA_TYPES:
+            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:
+                continue
+            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(
-            [{"type": model_type, "count": count} for model_type, count in type_counts.items()],
+            [
+                {"type": model_type, "count": count}
+                for model_type, count in type_counts.items()
+            ],
             key=lambda value: value["count"],
             reverse=True,
         )
@@ -501,9 +612,13 @@ class BaseModelService(ABC):
         """Get hash for a model by its file path"""
         return self.scanner.get_hash_by_path(file_path)
 
-    async def scan_models(self, force_refresh: bool = False, rebuild_cache: bool = False):
+    async def scan_models(
+        self, force_refresh: bool = False, rebuild_cache: bool = False
+    ):
         """Trigger model scanning"""
-        return await self.scanner.get_cached_data(force_refresh=force_refresh, rebuild_cache=rebuild_cache)
+        return await self.scanner.get_cached_data(
+            force_refresh=force_refresh, rebuild_cache=rebuild_cache
+        )
 
     async def get_model_info_by_name(self, name: str):
         """Get model information by name"""
@@ -518,11 +633,25 @@ class BaseModelService(ABC):
         if not data:
             return {}
 
-        fields = ["id", "modelId", "name", "trainedWords"] if minimal else [
-            "id", "modelId", "name", "createdAt", "updatedAt",
-            "publishedAt", "trainedWords", "baseModel", "description",
-            "model", "images", "customImages", "creator"
-        ]
+        fields = (
+            ["id", "modelId", "name", "trainedWords"]
+            if minimal
+            else [
+                "id",
+                "modelId",
+                "name",
+                "createdAt",
+                "updatedAt",
+                "publishedAt",
+                "trainedWords",
+                "baseModel",
+                "description",
+                "model",
+                "images",
+                "customImages",
+                "creator",
+            ]
+        )
         return {k: data[k] for k in fields if k in data}
 
     async def get_folder_tree(self, model_root: str) -> Dict:
@@ -544,7 +673,7 @@ class BaseModelService(ABC):
                 continue
 
             # Split folder path into components
-            parts = folder.split('/') if folder else []
+            parts = folder.split("/") if folder else []
             current_level = tree
 
             for part in parts:
@@ -573,7 +702,7 @@ class BaseModelService(ABC):
             relative_path = folder
 
             # Split folder path into components
-            parts = relative_path.split('/')
+            parts = relative_path.split("/")
             current_level = unified_tree
 
             for part in parts:
@@ -588,8 +717,8 @@ class BaseModelService(ABC):
         cache = await self.scanner.get_cached_data()
 
         for model in cache.raw_data:
-            if model['file_name'] == model_name:
-                return model.get('notes', '')
+            if model["file_name"] == model_name:
+                return model.get("notes", "")
 
         return None
 
@@ -598,23 +727,24 @@ class BaseModelService(ABC):
         cache = await self.scanner.get_cached_data()
 
         for model in cache.raw_data:
-            if model['file_name'] == model_name:
-                preview_url = model.get('preview_url')
+            if model["file_name"] == model_name:
+                preview_url = model.get("preview_url")
                 if preview_url:
                     from ..config import config
+
                     return config.get_preview_static_url(preview_url)
 
-        return '/loras_static/images/no-preview.png'
+        return "/loras_static/images/no-preview.png"
 
     async def get_model_civitai_url(self, model_name: str) -> Dict[str, Optional[str]]:
         """Get the Civitai URL for a model file"""
         cache = await self.scanner.get_cached_data()
 
         for model in cache.raw_data:
-            if model['file_name'] == model_name:
-                civitai_data = model.get('civitai', {})
-                model_id = civitai_data.get('modelId')
-                version_id = civitai_data.get('id')
+            if model["file_name"] == model_name:
+                civitai_data = model.get("civitai", {})
+                model_id = civitai_data.get("modelId")
+                version_id = civitai_data.get("id")
 
                 if model_id:
                     civitai_url = f"https://civitai.com/models/{model_id}"
@@ -622,12 +752,12 @@ class BaseModelService(ABC):
                         civitai_url += f"?modelVersionId={version_id}"
 
                     return {
-                        'civitai_url': civitai_url,
-                        'model_id': str(model_id),
-                        'version_id': str(version_id) if version_id else None
+                        "civitai_url": civitai_url,
+                        "model_id": str(model_id),
+                        "version_id": str(version_id) if version_id else None,
                     }
 
-        return {'civitai_url': None, 'model_id': None, 'version_id': None}
+        return {"civitai_url": None, "model_id": None, "version_id": None}
 
     async def get_model_metadata(self, file_path: str) -> Optional[Dict]:
         """Load full metadata for a single model.
@@ -635,18 +765,21 @@ class BaseModelService(ABC):
         Listing/search endpoints return lightweight cache entries; this method performs
         a lazy read of the on-disk metadata snapshot when callers need full detail.
         """
-        metadata, should_skip = await MetadataManager.load_metadata(file_path, self.metadata_class)
+        metadata, should_skip = await MetadataManager.load_metadata(
+            file_path, self.metadata_class
+        )
         if should_skip or metadata is None:
             return None
         return self.filter_civitai_data(metadata.to_dict().get("civitai", {}))
 
-
     async def get_model_description(self, file_path: str) -> Optional[str]:
         """Return the stored modelDescription field for a model."""
-        metadata, should_skip = await MetadataManager.load_metadata(file_path, self.metadata_class)
+        metadata, should_skip = await MetadataManager.load_metadata(
+            file_path, self.metadata_class
+        )
         if should_skip or metadata is None:
             return None
-        return metadata.modelDescription or ''
+        return metadata.modelDescription or ""
 
     @staticmethod
     def _parse_search_tokens(search_term: str) -> tuple[List[str], List[str]]:
@@ -684,14 +817,21 @@ class BaseModelService(ABC):
     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()
-        prefix_hits = sum(1 for term in include_terms if term and path_lower.startswith(term))
-        match_positions = [path_lower.find(term) for term in include_terms if term and term in path_lower]
+        prefix_hits = sum(
+            1 for term in include_terms if term and path_lower.startswith(term)
+        )
+        match_positions = [
+            path_lower.find(term)
+            for term in include_terms
+            if term and term in path_lower
+        ]
         first_match_index = min(match_positions) if match_positions else 0
 
         return (-prefix_hits, first_match_index, len(relative_path), path_lower)
 
-
-    async def search_relative_paths(self, search_term: str, limit: int = 15) -> List[str]:
+    async def search_relative_paths(
+        self, search_term: str, limit: int = 15
+    ) -> List[str]:
         """Search model relative file paths for autocomplete functionality"""
         cache = await self.scanner.get_cached_data()
         include_terms, exclude_terms = self._parse_search_tokens(search_term)
@@ -702,7 +842,7 @@ class BaseModelService(ABC):
         model_roots = self.scanner.get_model_roots()
 
         for model in cache.raw_data:
-            file_path = model.get('file_path', '')
+            file_path = model.get("file_path", "")
             if not file_path:
                 continue
 
@@ -715,14 +855,18 @@ class BaseModelService(ABC):
 
                 if normalized_file.startswith(normalized_root):
                     # Remove root and leading separator to get relative path
-                    relative_path = normalized_file[len(normalized_root):].lstrip(os.sep)
+                    relative_path = normalized_file[len(normalized_root) :].lstrip(
+                        os.sep
+                    )
                     break
 
             if not relative_path:
                 continue
 
             relative_lower = relative_path.lower()
-            if self._relative_path_matches_tokens(relative_lower, include_terms, exclude_terms):
+            if self._relative_path_matches_tokens(
+                relative_lower, include_terms, exclude_terms
+            ):
                 matching_paths.append(relative_path)
 
                 if len(matching_paths) >= limit * 2:  # Get more for better sorting

py/services/cache_entry_validator.py

@@ -0,0 +1,259 @@
+"""
+Cache Entry Validator
+
+Validates and repairs cache entries to prevent runtime errors from
+missing or invalid critical fields.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ValidationResult:
+    """Result of validating a single cache entry."""
+    is_valid: bool
+    repaired: bool
+    errors: List[str] = field(default_factory=list)
+    entry: Optional[Dict[str, Any]] = None
+
+
+class CacheEntryValidator:
+    """
+    Validates and repairs cache entry core fields.
+
+    Critical fields that cause runtime errors when missing:
+    - file_path: KeyError in multiple locations
+    - sha256: KeyError/AttributeError in hash operations
+
+    Medium severity fields that may cause sorting/display issues:
+    - size: KeyError during sorting
+    - modified: KeyError during sorting
+    - model_name: AttributeError on .lower() calls
+
+    Low severity fields:
+    - tags: KeyError/TypeError in recipe operations
+    """
+
+    # Field definitions: (default_value, is_required)
+    CORE_FIELDS: Dict[str, Tuple[Any, bool]] = {
+        'file_path': ('', True),
+        'sha256': ('', True),
+        'file_name': ('', False),
+        'model_name': ('', False),
+        'folder': ('', False),
+        'size': (0, False),
+        'modified': (0.0, False),
+        'tags': ([], False),
+        'preview_url': ('', False),
+        'base_model': ('', False),
+        'from_civitai': (True, False),
+        'favorite': (False, False),
+        'exclude': (False, False),
+        'db_checked': (False, False),
+        'preview_nsfw_level': (0, False),
+        'notes': ('', False),
+        'usage_tips': ('', False),
+    }
+
+    @classmethod
+    def validate(cls, entry: Dict[str, Any], *, auto_repair: bool = True) -> ValidationResult:
+        """
+        Validate a single cache entry.
+
+        Args:
+            entry: The cache entry dictionary to validate
+            auto_repair: If True, attempt to repair missing/invalid fields
+
+        Returns:
+            ValidationResult with validation status and optionally repaired entry
+        """
+        if entry is None:
+            return ValidationResult(
+                is_valid=False,
+                repaired=False,
+                errors=['Entry is None'],
+                entry=None
+            )
+
+        if not isinstance(entry, dict):
+            return ValidationResult(
+                is_valid=False,
+                repaired=False,
+                errors=[f'Entry is not a dict: {type(entry).__name__}'],
+                entry=None
+            )
+
+        errors: List[str] = []
+        repaired = False
+        working_entry = dict(entry) if auto_repair else entry
+
+        for field_name, (default_value, is_required) in cls.CORE_FIELDS.items():
+            value = working_entry.get(field_name)
+
+            # Check if field is missing or None
+            if value is None:
+                if is_required:
+                    errors.append(f"Required field '{field_name}' is missing or None")
+                if auto_repair:
+                    working_entry[field_name] = cls._get_default_copy(default_value)
+                    repaired = True
+                continue
+
+            # Validate field type and value
+            field_error = cls._validate_field(field_name, value, default_value)
+            if field_error:
+                errors.append(field_error)
+                if auto_repair:
+                    working_entry[field_name] = cls._get_default_copy(default_value)
+                    repaired = True
+
+        # Special validation: file_path must not be empty for required field
+        file_path = working_entry.get('file_path', '')
+        if not file_path or (isinstance(file_path, str) and not file_path.strip()):
+            errors.append("Required field 'file_path' is empty")
+            # Cannot repair empty file_path - entry is invalid
+            return ValidationResult(
+                is_valid=False,
+                repaired=repaired,
+                errors=errors,
+                entry=working_entry if auto_repair else None
+            )
+
+        # Special validation: sha256 must not be empty for required field
+        sha256 = working_entry.get('sha256', '')
+        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
+            )
+
+        # Normalize sha256 to lowercase if needed
+        if isinstance(sha256, str):
+            normalized_sha = sha256.lower().strip()
+            if normalized_sha != sha256:
+                working_entry['sha256'] = normalized_sha
+                repaired = True
+
+        # Determine if entry is valid
+        # Entry is valid if no critical required field errors remain after repair
+        # Critical fields are file_path and sha256
+        CRITICAL_REQUIRED_FIELDS = {'file_path', 'sha256'}
+        has_critical_errors = any(
+            "Required field" in error and
+            any(f"'{field}'" in error for field in CRITICAL_REQUIRED_FIELDS)
+            for error in errors
+        )
+
+        is_valid = not has_critical_errors
+
+        return ValidationResult(
+            is_valid=is_valid,
+            repaired=repaired,
+            errors=errors,
+            entry=working_entry if auto_repair else entry
+        )
+
+    @classmethod
+    def validate_batch(
+        cls,
+        entries: List[Dict[str, Any]],
+        *,
+        auto_repair: bool = True
+    ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+        """
+        Validate a batch of cache entries.
+
+        Args:
+            entries: List of cache entry dictionaries to validate
+            auto_repair: If True, attempt to repair missing/invalid fields
+
+        Returns:
+            Tuple of (valid_entries, invalid_entries)
+        """
+        if not entries:
+            return [], []
+
+        valid_entries: List[Dict[str, Any]] = []
+        invalid_entries: List[Dict[str, Any]] = []
+
+        for entry in entries:
+            result = cls.validate(entry, auto_repair=auto_repair)
+
+            if result.is_valid:
+                # Use repaired entry if available, otherwise original
+                valid_entries.append(result.entry if result.entry else entry)
+            else:
+                invalid_entries.append(entry)
+                # Log invalid entries for debugging
+                file_path = entry.get('file_path', '<unknown>') if isinstance(entry, dict) else '<not a dict>'
+                logger.warning(
+                    f"Invalid cache entry for '{file_path}': {', '.join(result.errors)}"
+                )
+
+        return valid_entries, invalid_entries
+
+    @classmethod
+    def _validate_field(cls, field_name: str, value: Any, default_value: Any) -> Optional[str]:
+        """
+        Validate a specific field value.
+
+        Returns an error message if invalid, None if valid.
+        """
+        expected_type = type(default_value)
+
+        # Special handling for numeric types
+        if expected_type == int:
+            if not isinstance(value, (int, float)):
+                return f"Field '{field_name}' should be numeric, got {type(value).__name__}"
+        elif expected_type == float:
+            if not isinstance(value, (int, float)):
+                return f"Field '{field_name}' should be numeric, got {type(value).__name__}"
+        elif expected_type == bool:
+            # Be lenient with boolean fields - accept truthy/falsy values
+            pass
+        elif expected_type == str:
+            if not isinstance(value, str):
+                return f"Field '{field_name}' should be string, got {type(value).__name__}"
+        elif expected_type == list:
+            if not isinstance(value, (list, tuple)):
+                return f"Field '{field_name}' should be list, got {type(value).__name__}"
+
+        return None
+
+    @classmethod
+    def _get_default_copy(cls, default_value: Any) -> Any:
+        """Get a copy of the default value to avoid shared mutable state."""
+        if isinstance(default_value, list):
+            return list(default_value)
+        if isinstance(default_value, dict):
+            return dict(default_value)
+        return default_value
+
+    @classmethod
+    def get_file_path_safe(cls, entry: Dict[str, Any], default: str = '') -> str:
+        """Safely get file_path from an entry."""
+        if not isinstance(entry, dict):
+            return default
+        value = entry.get('file_path')
+        if isinstance(value, str):
+            return value
+        return default
+
+    @classmethod
+    def get_sha256_safe(cls, entry: Dict[str, Any], default: str = '') -> str:
+        """Safely get sha256 from an entry."""
+        if not isinstance(entry, dict):
+            return default
+        value = entry.get('sha256')
+        if isinstance(value, str):
+            return value.lower()
+        return default

py/services/cache_health_monitor.py

@@ -0,0 +1,201 @@
+"""
+Cache Health Monitor
+
+Monitors cache health status and determines when user intervention is needed.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+import logging
+
+from .cache_entry_validator import CacheEntryValidator, ValidationResult
+
+logger = logging.getLogger(__name__)
+
+
+class CacheHealthStatus(Enum):
+    """Health status of the cache."""
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    CORRUPTED = "corrupted"
+
+
+@dataclass
+class HealthReport:
+    """Report of cache health check."""
+    status: CacheHealthStatus
+    total_entries: int
+    valid_entries: int
+    invalid_entries: int
+    repaired_entries: int
+    invalid_paths: List[str] = field(default_factory=list)
+    message: str = ""
+
+    @property
+    def corruption_rate(self) -> float:
+        """Calculate the percentage of invalid entries."""
+        if self.total_entries <= 0:
+            return 0.0
+        return self.invalid_entries / self.total_entries
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            'status': self.status.value,
+            'total_entries': self.total_entries,
+            'valid_entries': self.valid_entries,
+            'invalid_entries': self.invalid_entries,
+            'repaired_entries': self.repaired_entries,
+            'corruption_rate': f"{self.corruption_rate:.1%}",
+            'invalid_paths': self.invalid_paths[:10],  # Limit to first 10
+            'message': self.message,
+        }
+
+
+class CacheHealthMonitor:
+    """
+    Monitors cache health and determines appropriate status.
+
+    Thresholds:
+    - HEALTHY: 0% invalid entries
+    - DEGRADED: 0-5% invalid entries (auto-repaired, user should rebuild)
+    - CORRUPTED: >5% invalid entries (significant data loss likely)
+    """
+
+    # Threshold percentages
+    DEGRADED_THRESHOLD = 0.01   # 1% - show warning
+    CORRUPTED_THRESHOLD = 0.05  # 5% - critical warning
+
+    def __init__(
+        self,
+        *,
+        degraded_threshold: float = DEGRADED_THRESHOLD,
+        corrupted_threshold: float = CORRUPTED_THRESHOLD
+    ):
+        """
+        Initialize the health monitor.
+
+        Args:
+            degraded_threshold: Corruption rate threshold for DEGRADED status
+            corrupted_threshold: Corruption rate threshold for CORRUPTED status
+        """
+        self.degraded_threshold = degraded_threshold
+        self.corrupted_threshold = corrupted_threshold
+
+    def check_health(
+        self,
+        entries: List[Dict[str, Any]],
+        *,
+        auto_repair: bool = True
+    ) -> HealthReport:
+        """
+        Check the health of cache entries.
+
+        Args:
+            entries: List of cache entry dictionaries to check
+            auto_repair: If True, attempt to repair entries during validation
+
+        Returns:
+            HealthReport with status and statistics
+        """
+        if not entries:
+            return HealthReport(
+                status=CacheHealthStatus.HEALTHY,
+                total_entries=0,
+                valid_entries=0,
+                invalid_entries=0,
+                repaired_entries=0,
+                message="Cache is empty"
+            )
+
+        total_entries = len(entries)
+        valid_entries: List[Dict[str, Any]] = []
+        invalid_entries: List[Dict[str, Any]] = []
+        repaired_count = 0
+        invalid_paths: List[str] = []
+
+        for entry in entries:
+            result = CacheEntryValidator.validate(entry, auto_repair=auto_repair)
+
+            if result.is_valid:
+                valid_entries.append(result.entry if result.entry else entry)
+                if result.repaired:
+                    repaired_count += 1
+            else:
+                invalid_entries.append(entry)
+                # Extract file path for reporting
+                file_path = CacheEntryValidator.get_file_path_safe(entry, '<unknown>')
+                invalid_paths.append(file_path)
+
+        invalid_count = len(invalid_entries)
+        valid_count = len(valid_entries)
+
+        # Determine status based on corruption rate
+        corruption_rate = invalid_count / total_entries if total_entries > 0 else 0.0
+
+        if invalid_count == 0:
+            status = CacheHealthStatus.HEALTHY
+            message = "Cache is healthy"
+        elif corruption_rate >= self.corrupted_threshold:
+            status = CacheHealthStatus.CORRUPTED
+            message = (
+                f"Cache is corrupted: {invalid_count} invalid entries "
+                f"({corruption_rate:.1%}). Rebuild recommended."
+            )
+        elif corruption_rate >= self.degraded_threshold or invalid_count > 0:
+            status = CacheHealthStatus.DEGRADED
+            message = (
+                f"Cache has {invalid_count} invalid entries "
+                f"({corruption_rate:.1%}). Consider rebuilding cache."
+            )
+        else:
+            # This shouldn't happen, but handle gracefully
+            status = CacheHealthStatus.HEALTHY
+            message = "Cache is healthy"
+
+        # Log the health check result
+        if status != CacheHealthStatus.HEALTHY:
+            logger.warning(
+                f"Cache health check: {status.value} - "
+                f"{invalid_count}/{total_entries} invalid, "
+                f"{repaired_count} repaired"
+            )
+            if invalid_paths:
+                logger.debug(f"Invalid entry paths: {invalid_paths[:5]}")
+
+        return HealthReport(
+            status=status,
+            total_entries=total_entries,
+            valid_entries=valid_count,
+            invalid_entries=invalid_count,
+            repaired_entries=repaired_count,
+            invalid_paths=invalid_paths,
+            message=message
+        )
+
+    def should_notify_user(self, report: HealthReport) -> bool:
+        """
+        Determine if the user should be notified about cache health.
+
+        Args:
+            report: The health report to evaluate
+
+        Returns:
+            True if user should be notified
+        """
+        return report.status != CacheHealthStatus.HEALTHY
+
+    def get_notification_severity(self, report: HealthReport) -> str:
+        """
+        Get the severity level for user notification.
+
+        Args:
+            report: The health report to evaluate
+
+        Returns:
+            Severity string: 'warning' or 'error'
+        """
+        if report.status == CacheHealthStatus.CORRUPTED:
+            return 'error'
+        return 'warning'

py/services/checkpoint_scanner.py

@@ -21,7 +21,8 @@ class CheckpointScanner(ModelScanner):
             hash_index=ModelHashIndex()
         )
 
-    def _resolve_model_type(self, root_path: Optional[str]) -> Optional[str]:
+    def _resolve_sub_type(self, root_path: Optional[str]) -> Optional[str]:
+        """Resolve the sub-type based on the root path."""
         if not root_path:
             return None
 
@@ -34,18 +35,19 @@ class CheckpointScanner(ModelScanner):
         return None
 
     def adjust_metadata(self, metadata, file_path, root_path):
-        if hasattr(metadata, "model_type"):
-            model_type = self._resolve_model_type(root_path)
-            if model_type:
-                metadata.model_type = model_type
+        """Adjust metadata during scanning to set sub_type."""
+        sub_type = self._resolve_sub_type(root_path)
+        if sub_type:
+            metadata.sub_type = sub_type
         return metadata
 
     def adjust_cached_entry(self, entry: Dict[str, Any]) -> Dict[str, Any]:
-        model_type = self._resolve_model_type(
+        """Adjust entries loaded from the persisted cache to ensure sub_type is set."""
+        sub_type = self._resolve_sub_type(
             self._find_root_for_file(entry.get("file_path"))
         )
-        if model_type:
-            entry["model_type"] = model_type
+        if sub_type:
+            entry["sub_type"] = sub_type
         return entry
 
     def get_model_roots(self) -> List[str]:

py/services/checkpoint_service.py

@@ -22,6 +22,9 @@ class CheckpointService(BaseModelService):
     
     async def format_response(self, checkpoint_data: Dict) -> Dict:
         """Format Checkpoint data for API response"""
+        # Get sub_type from cache entry (new canonical field)
+        sub_type = checkpoint_data.get("sub_type", "checkpoint")
+        
         return {
             "model_name": checkpoint_data["model_name"],
             "file_name": checkpoint_data["file_name"],
@@ -35,8 +38,9 @@ class CheckpointService(BaseModelService):
             "modified": checkpoint_data.get("modified", ""),
             "tags": checkpoint_data.get("tags", []),
             "from_civitai": checkpoint_data.get("from_civitai", True),
+            "usage_count": checkpoint_data.get("usage_count", 0),
             "notes": checkpoint_data.get("notes", ""),
-            "model_type": checkpoint_data.get("model_type", "checkpoint"),
+            "sub_type": sub_type,
             "favorite": checkpoint_data.get("favorite", False),
             "update_available": bool(checkpoint_data.get("update_available", False)),
             "civitai": self.filter_civitai_data(checkpoint_data.get("civitai", {}), minimal=True)

py/services/custom_words_service.py

@@ -0,0 +1,91 @@
+"""Service for managing autocomplete via TagFTSIndex.
+
+This service provides full-text search capabilities for Danbooru/e621 tags
+with category filtering and enriched results including post counts.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class CustomWordsService:
+    """Service for autocomplete via TagFTSIndex.
+
+    This service:
+    - Uses TagFTSIndex for fast full-text search of Danbooru/e621 tags
+    - Supports category-based filtering
+    - Returns enriched results with category and post_count
+    - Provides sub-100ms search times for 221k+ tags
+    """
+
+    _instance: Optional[CustomWordsService] = None
+    _initialized: bool = False
+
+    def __new__(cls) -> CustomWordsService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if self._initialized:
+            return
+
+        self._tag_index: Optional[Any] = None
+        self._initialized = True
+
+    @classmethod
+    def get_instance(cls) -> CustomWordsService:
+        """Get the singleton instance of CustomWordsService."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def _get_tag_index(self):
+        """Get or create the TagFTSIndex instance (lazy initialization)."""
+        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}")
+                self._tag_index = None
+        return self._tag_index
+
+    def search_words(
+        self,
+        search_term: str,
+        limit: int = 20,
+        categories: Optional[List[int]] = None,
+        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.
+            categories: Optional list of category IDs to filter by.
+            enriched: If True, always return enriched results with category
+                       and post_count (default behavior now).
+
+        Returns:
+            List of dicts with tag_name, category, and post_count.
+        """
+        tag_index = self._get_tag_index()
+        if tag_index is not None:
+            results = tag_index.search(search_term, categories=categories, limit=limit)
+            return results
+
+        logger.debug("TagFTSIndex not available, returning empty results")
+        return []
+
+
+def get_custom_words_service() -> CustomWordsService:
+    """Factory function to get the CustomWordsService singleton."""
+    return CustomWordsService.get_instance()
+
+
+__all__ = ["CustomWordsService", "get_custom_words_service"]

py/services/downloader.py

@@ -128,6 +128,7 @@ class Downloader:
         self._session = None
         self._session_created_at = None
         self._proxy_url = None  # Store proxy URL for current session
+        self._session_lock = asyncio.Lock()
         
         # Configuration
         self.chunk_size = 4 * 1024 * 1024  # 4MB chunks for better throughput
@@ -148,7 +149,10 @@ class Downloader:
     async def session(self) -> aiohttp.ClientSession:
         """Get or create the global aiohttp session with optimized settings"""
         if self._session is None or self._should_refresh_session():
-            await self._create_session()
+            async with self._session_lock:
+                # Double check after acquiring lock
+                if self._session is None or self._should_refresh_session():
+                    await self._create_session()
         return self._session
 
     @property
@@ -197,10 +201,18 @@ class Downloader:
         return False
     
     async def _create_session(self):
-        """Create a new aiohttp session with optimized settings"""
+        """Create a new aiohttp session with optimized settings.
+        
+        Note: This is private and caller MUST hold self._session_lock.
+        """
         # Close existing session if any
         if self._session is not None:
-            await self._session.close()
+            try:
+                await self._session.close()
+            except Exception as e: # pragma: no cover
+                logger.warning(f"Error closing previous session: {e}")
+            finally:
+                self._session = None
         
         # Check for app-level proxy settings
         proxy_url = None
@@ -808,7 +820,8 @@ class Downloader:
     
     async def refresh_session(self):
         """Force refresh the HTTP session (useful when proxy settings change)"""
-        await self._create_session()
+        async with self._session_lock:
+            await self._create_session()
         logger.info("HTTP session refreshed due to settings change")
 
     @staticmethod

py/services/embedding_service.py

@@ -22,6 +22,9 @@ class EmbeddingService(BaseModelService):
     
     async def format_response(self, embedding_data: Dict) -> Dict:
         """Format Embedding data for API response"""
+        # Get sub_type from cache entry (new canonical field)
+        sub_type = embedding_data.get("sub_type", "embedding")
+        
         return {
             "model_name": embedding_data["model_name"],
             "file_name": embedding_data["file_name"],
@@ -35,8 +38,9 @@ class EmbeddingService(BaseModelService):
             "modified": embedding_data.get("modified", ""),
             "tags": embedding_data.get("tags", []),
             "from_civitai": embedding_data.get("from_civitai", True),
+            # "usage_count": embedding_data.get("usage_count", 0), # TODO: Enable when embedding usage tracking is implemented
             "notes": embedding_data.get("notes", ""),
-            "model_type": embedding_data.get("model_type", "embedding"),
+            "sub_type": sub_type,
             "favorite": embedding_data.get("favorite", False),
             "update_available": bool(embedding_data.get("update_available", False)),
             "civitai": self.filter_civitai_data(embedding_data.get("civitai", {}), minimal=True)

py/services/lora_scanner.py

@@ -30,36 +30,36 @@ class LoraScanner(ModelScanner):
 
     async def diagnose_hash_index(self):
         """Diagnostic method to verify hash index functionality"""
-        print("\n\n*** DIAGNOSING LORA HASH INDEX ***\n\n", file=sys.stderr)
+        logger.debug("\n\n*** DIAGNOSING LORA HASH INDEX ***\n\n")
         
         # First check if the hash index has any entries
         if hasattr(self, '_hash_index'):
             index_entries = len(self._hash_index._hash_to_path)
-            print(f"Hash index has {index_entries} entries", file=sys.stderr)
+            logger.debug(f"Hash index has {index_entries} entries")
             
             # Print a few example entries if available
             if index_entries > 0:
-                print("\nSample hash index entries:", file=sys.stderr)
+                logger.debug("\nSample hash index entries:")
                 count = 0
                 for hash_val, path in self._hash_index._hash_to_path.items():
                     if count < 5:  # Just show the first 5
-                        print(f"Hash: {hash_val[:8]}... -> Path: {path}", file=sys.stderr)
+                        logger.debug(f"Hash: {hash_val[:8]}... -> Path: {path}")
                         count += 1
                     else:
                         break
         else:
-            print("Hash index not initialized", file=sys.stderr)
+            logger.debug("Hash index not initialized")
         
         # Try looking up by a known hash for testing
         if not hasattr(self, '_hash_index') or not self._hash_index._hash_to_path:
-            print("No hash entries to test lookup with", file=sys.stderr)
+            logger.debug("No hash entries to test lookup with")
             return
         
         test_hash = next(iter(self._hash_index._hash_to_path.keys()))
         test_path = self._hash_index.get_path(test_hash)
-        print(f"\nTest lookup by hash: {test_hash[:8]}... -> {test_path}", file=sys.stderr)
+        logger.debug(f"\nTest lookup by hash: {test_hash[:8]}... -> {test_path}")
         
         # Also test reverse lookup
         test_hash_result = self._hash_index.get_hash(test_path)
-        print(f"Test reverse lookup: {test_path} -> {test_hash_result[:8]}...\n\n", file=sys.stderr)
+        logger.debug(f"Test reverse lookup: {test_path} -> {test_hash_result[:8]}...\n\n")
 

py/services/lora_service.py

@@ -3,11 +3,13 @@ import logging
 from typing import Dict, List, Optional
 
 from .base_model_service import BaseModelService
+from .model_query import resolve_sub_type
 from ..utils.models import LoraMetadata
 from ..config import config
 
 logger = logging.getLogger(__name__)
 
+
 class LoraService(BaseModelService):
     """LoRA-specific service implementation"""
 
@@ -22,10 +24,16 @@ class LoraService(BaseModelService):
 
     async def format_response(self, lora_data: Dict) -> Dict:
         """Format LoRA data for API response"""
+        # Resolve sub_type using priority: sub_type > model_type > civitai.model.type > default
+        # Normalize to lowercase for consistent API responses
+        sub_type = resolve_sub_type(lora_data).lower()
+        
         return {
             "model_name": lora_data["model_name"],
             "file_name": lora_data["file_name"],
-            "preview_url": config.get_preview_static_url(lora_data.get("preview_url", "")),
+            "preview_url": config.get_preview_static_url(
+                lora_data.get("preview_url", "")
+            ),
             "preview_nsfw_level": lora_data.get("preview_nsfw_level", 0),
             "base_model": lora_data.get("base_model", ""),
             "folder": lora_data["folder"],
@@ -35,17 +43,21 @@ class LoraService(BaseModelService):
             "modified": lora_data.get("modified", ""),
             "tags": lora_data.get("tags", []),
             "from_civitai": lora_data.get("from_civitai", True),
+            "usage_count": lora_data.get("usage_count", 0),
             "usage_tips": lora_data.get("usage_tips", ""),
             "notes": lora_data.get("notes", ""),
             "favorite": lora_data.get("favorite", False),
             "update_available": bool(lora_data.get("update_available", False)),
-            "civitai": self.filter_civitai_data(lora_data.get("civitai", {}), minimal=True)
+            "sub_type": sub_type,
+            "civitai": self.filter_civitai_data(
+                lora_data.get("civitai", {}), minimal=True
+            ),
         }
 
     async def _apply_specific_filters(self, data: List[Dict], **kwargs) -> List[Dict]:
         """Apply LoRA-specific filters"""
         # Handle first_letter filter for LoRAs
-        first_letter = kwargs.get('first_letter')
+        first_letter = kwargs.get("first_letter")
         if first_letter:
             data = self._filter_by_first_letter(data, first_letter)
 
@@ -62,18 +74,18 @@ class LoraService(BaseModelService):
         filtered_data = []
 
         for lora in data:
-            model_name = lora.get('model_name', '')
+            model_name = lora.get("model_name", "")
             if not model_name:
                 continue
 
             first_char = model_name[0].upper()
 
-            if letter == '#' and first_char.isdigit():
+            if letter == "#" and first_char.isdigit():
                 filtered_data.append(lora)
-            elif letter == '@' and not first_char.isalnum():
+            elif letter == "@" and not first_char.isalnum():
                 # Special characters (not alphanumeric)
                 filtered_data.append(lora)
-            elif letter == '漢' and self._is_cjk_character(first_char):
+            elif letter == "漢" and self._is_cjk_character(first_char):
                 # CJK characters
                 filtered_data.append(lora)
             elif letter.upper() == first_char:
@@ -86,26 +98,26 @@ class LoraService(BaseModelService):
         """Check if character is a CJK character"""
         # Define Unicode ranges for CJK characters
         cjk_ranges = [
-            (0x4E00, 0x9FFF),   # CJK Unified Ideographs
-            (0x3400, 0x4DBF),   # CJK Unified Ideographs Extension A
-            (0x20000, 0x2A6DF), # CJK Unified Ideographs Extension B
-            (0x2A700, 0x2B73F), # CJK Unified Ideographs Extension C
-            (0x2B740, 0x2B81F), # CJK Unified Ideographs Extension D
-            (0x2B820, 0x2CEAF), # CJK Unified Ideographs Extension E
-            (0x2CEB0, 0x2EBEF), # CJK Unified Ideographs Extension F
-            (0x30000, 0x3134F), # CJK Unified Ideographs Extension G
-            (0xF900, 0xFAFF),   # CJK Compatibility Ideographs
-            (0x3300, 0x33FF),   # CJK Compatibility
-            (0x3200, 0x32FF),   # Enclosed CJK Letters and Months
-            (0x3100, 0x312F),   # Bopomofo
-            (0x31A0, 0x31BF),   # Bopomofo Extended
-            (0x3040, 0x309F),   # Hiragana
-            (0x30A0, 0x30FF),   # Katakana
-            (0x31F0, 0x31FF),   # Katakana Phonetic Extensions
-            (0xAC00, 0xD7AF),   # Hangul Syllables
-            (0x1100, 0x11FF),   # Hangul Jamo
-            (0xA960, 0xA97F),   # Hangul Jamo Extended-A
-            (0xD7B0, 0xD7FF),   # Hangul Jamo Extended-B
+            (0x4E00, 0x9FFF),  # CJK Unified Ideographs
+            (0x3400, 0x4DBF),  # CJK Unified Ideographs Extension A
+            (0x20000, 0x2A6DF),  # CJK Unified Ideographs Extension B
+            (0x2A700, 0x2B73F),  # CJK Unified Ideographs Extension C
+            (0x2B740, 0x2B81F),  # CJK Unified Ideographs Extension D
+            (0x2B820, 0x2CEAF),  # CJK Unified Ideographs Extension E
+            (0x2CEB0, 0x2EBEF),  # CJK Unified Ideographs Extension F
+            (0x30000, 0x3134F),  # CJK Unified Ideographs Extension G
+            (0xF900, 0xFAFF),  # CJK Compatibility Ideographs
+            (0x3300, 0x33FF),  # CJK Compatibility
+            (0x3200, 0x32FF),  # Enclosed CJK Letters and Months
+            (0x3100, 0x312F),  # Bopomofo
+            (0x31A0, 0x31BF),  # Bopomofo Extended
+            (0x3040, 0x309F),  # Hiragana
+            (0x30A0, 0x30FF),  # Katakana
+            (0x31F0, 0x31FF),  # Katakana Phonetic Extensions
+            (0xAC00, 0xD7AF),  # Hangul Syllables
+            (0x1100, 0x11FF),  # Hangul Jamo
+            (0xA960, 0xA97F),  # Hangul Jamo Extended-A
+            (0xD7B0, 0xD7FF),  # Hangul Jamo Extended-B
         ]
 
         code_point = ord(char)
@@ -119,31 +131,53 @@ class LoraService(BaseModelService):
 
         # Define letter categories
         letters = {
-            '#': 0,  # Numbers
-            'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 0,
-            'I': 0, 'J': 0, 'K': 0, 'L': 0, 'M': 0, 'N': 0, 'O': 0, 'P': 0,
-            'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 0, 'V': 0, 'W': 0, 'X': 0,
-            'Y': 0, 'Z': 0,
-            '@': 0,  # Special characters
-            '漢': 0   # CJK characters
+            "#": 0,  # Numbers
+            "A": 0,
+            "B": 0,
+            "C": 0,
+            "D": 0,
+            "E": 0,
+            "F": 0,
+            "G": 0,
+            "H": 0,
+            "I": 0,
+            "J": 0,
+            "K": 0,
+            "L": 0,
+            "M": 0,
+            "N": 0,
+            "O": 0,
+            "P": 0,
+            "Q": 0,
+            "R": 0,
+            "S": 0,
+            "T": 0,
+            "U": 0,
+            "V": 0,
+            "W": 0,
+            "X": 0,
+            "Y": 0,
+            "Z": 0,
+            "@": 0,  # Special characters
+            "漢": 0,  # CJK characters
         }
 
         # Count models for each letter
         for lora in data:
-            model_name = lora.get('model_name', '')
+            model_name = lora.get("model_name", "")
             if not model_name:
                 continue
 
             first_char = model_name[0].upper()
 
             if first_char.isdigit():
-                letters['#'] += 1
+                letters["#"] += 1
             elif first_char in letters:
                 letters[first_char] += 1
             elif self._is_cjk_character(first_char):
-                letters['漢'] += 1
+                letters["漢"] += 1
             elif not first_char.isalnum():
-                letters['@'] += 1
+                letters["@"] += 1
 
         return letters
 
@@ -152,25 +186,30 @@ class LoraService(BaseModelService):
         cache = await self.scanner.get_cached_data()
 
         for lora in cache.raw_data:
-            if lora['file_name'] == lora_name:
-                civitai_data = lora.get('civitai', {})
-                return civitai_data.get('trainedWords', [])
+            if lora["file_name"] == lora_name:
+                civitai_data = lora.get("civitai", {})
+                return civitai_data.get("trainedWords", [])
 
         return []
 
-    async def get_lora_usage_tips_by_relative_path(self, relative_path: str) -> Optional[str]:
+    async def get_lora_usage_tips_by_relative_path(
+        self, relative_path: str
+    ) -> Optional[str]:
         """Get usage tips for a LoRA by its relative path"""
         cache = await self.scanner.get_cached_data()
 
         for lora in cache.raw_data:
-            file_path = lora.get('file_path', '')
+            file_path = lora.get("file_path", "")
             if file_path:
                 # Convert to forward slashes and extract relative path
-                file_path_normalized = file_path.replace('\\', '/')
-                relative_path = relative_path.replace('\\', '/')
+                file_path_normalized = file_path.replace("\\", "/")
+                relative_path = relative_path.replace("\\", "/")
                 # Find the relative path part by looking for the relative_path in the full path
-                if file_path_normalized.endswith(relative_path) or relative_path in file_path_normalized:
-                    return lora.get('usage_tips', '')
+                if (
+                    file_path_normalized.endswith(relative_path)
+                    or relative_path in file_path_normalized
+                ):
+                    return lora.get("usage_tips", "")
 
         return None
 
@@ -181,3 +220,314 @@ class LoraService(BaseModelService):
     def find_duplicate_filenames(self) -> Dict:
         """Find LoRAs with conflicting filenames"""
         return self.scanner._hash_index.get_duplicate_filenames()
+
+    async def get_random_loras(
+        self,
+        count: int,
+        model_strength_min: float = 0.0,
+        model_strength_max: float = 1.0,
+        use_same_clip_strength: bool = True,
+        clip_strength_min: float = 0.0,
+        clip_strength_max: float = 1.0,
+        locked_loras: Optional[List[Dict]] = None,
+        pool_config: Optional[Dict] = None,
+        count_mode: str = "fixed",
+        count_min: int = 3,
+        count_max: int = 7,
+        use_recommended_strength: bool = False,
+        recommended_strength_scale_min: float = 0.5,
+        recommended_strength_scale_max: float = 1.0,
+        seed: Optional[int] = None,
+    ) -> List[Dict]:
+        """
+        Get random LoRAs with specified strength ranges.
+
+        Args:
+            count: Number of LoRAs to select (if count_mode='fixed')
+            model_strength_min: Minimum model strength
+            model_strength_max: Maximum model strength
+            use_same_clip_strength: Whether to use same strength for clip
+            clip_strength_min: Minimum clip strength
+            clip_strength_max: Maximum clip strength
+            locked_loras: List of locked LoRA dicts to preserve
+            pool_config: Optional pool config for filtering
+            count_mode: How to determine count ('fixed' or 'range')
+            count_min: Minimum count for range mode
+            count_max: Maximum count for range mode
+            use_recommended_strength: Whether to use recommended strength from usage_tips
+            recommended_strength_scale_min: Minimum scale factor for recommended strength
+            recommended_strength_scale_max: Maximum scale factor for recommended strength
+            seed: Optional random seed for reproducible/unique randomization per execution
+
+        Returns:
+            List of LoRA dicts with randomized strengths
+        """
+        import random
+        import json
+
+        # Use a local Random instance to avoid affecting global random state
+        # This ensures each execution with a different seed produces different results
+        rng = random.Random(seed)
+
+        def get_recommended_strength(lora_data: Dict) -> Optional[float]:
+            """Parse usage_tips JSON and extract recommended strength"""
+            try:
+                usage_tips = lora_data.get("usage_tips", "")
+                if not usage_tips:
+                    return None
+                tips_data = json.loads(usage_tips)
+                return tips_data.get("strength")
+            except (json.JSONDecodeError, TypeError, AttributeError):
+                return None
+
+        def get_recommended_clip_strength(lora_data: Dict) -> Optional[float]:
+            """Parse usage_tips JSON and extract recommended clip strength"""
+            try:
+                usage_tips = lora_data.get("usage_tips", "")
+                if not usage_tips:
+                    return None
+                tips_data = json.loads(usage_tips)
+                return tips_data.get("clipStrength")
+            except (json.JSONDecodeError, TypeError, AttributeError):
+                return None
+
+        if locked_loras is None:
+            locked_loras = []
+
+        # Determine target count based on count_mode
+        if count_mode == "fixed":
+            target_count = count
+        else:
+            target_count = rng.randint(count_min, count_max)
+
+        # Get available loras from cache
+        cache = await self.scanner.get_cached_data(force_refresh=False)
+        available_loras = cache.raw_data if cache else []
+
+        # Apply pool filters if provided
+        if pool_config:
+            available_loras = await self._apply_pool_filters(
+                available_loras, pool_config
+            )
+
+        # Calculate slots needed (total - locked)
+        locked_count = len(locked_loras)
+        slots_needed = target_count - locked_count
+
+        if slots_needed < 0:
+            slots_needed = 0
+            # Too many locked, trim to target
+            locked_loras = locked_loras[:target_count]
+
+        # Filter out locked LoRAs from available pool
+        locked_names = {lora["name"] for lora in locked_loras}
+        available_pool = [
+            l for l in available_loras if l["file_name"] not in locked_names
+        ]
+
+        # Ensure we don't try to select more than available
+        if slots_needed > len(available_pool):
+            slots_needed = len(available_pool)
+
+        # Random sample
+        selected = []
+        if slots_needed > 0:
+            selected = rng.sample(available_pool, slots_needed)
+
+        # Generate random strengths for selected LoRAs
+        result_loras = []
+        for lora in selected:
+            if use_recommended_strength:
+                recommended_strength = get_recommended_strength(lora)
+                if recommended_strength is not None:
+                    scale = rng.uniform(
+                        recommended_strength_scale_min, recommended_strength_scale_max
+                    )
+                    model_str = round(recommended_strength * scale, 2)
+                else:
+                    model_str = round(
+                        rng.uniform(model_strength_min, model_strength_max), 2
+                    )
+            else:
+                model_str = round(
+                    rng.uniform(model_strength_min, model_strength_max), 2
+                )
+
+            if use_same_clip_strength:
+                clip_str = model_str
+            elif use_recommended_strength:
+                recommended_clip_strength = get_recommended_clip_strength(lora)
+                if recommended_clip_strength is not None:
+                    scale = rng.uniform(
+                        recommended_strength_scale_min, recommended_strength_scale_max
+                    )
+                    clip_str = round(recommended_clip_strength * scale, 2)
+                else:
+                    clip_str = round(
+                        rng.uniform(clip_strength_min, clip_strength_max), 2
+                    )
+            else:
+                clip_str = round(
+                    rng.uniform(clip_strength_min, clip_strength_max), 2
+                )
+
+            result_loras.append(
+                {
+                    "name": lora["file_name"],
+                    "strength": model_str,
+                    "clipStrength": clip_str,
+                    "active": True,
+                    "expanded": abs(model_str - clip_str) > 0.001,
+                    "locked": False,
+                }
+            )
+
+        # Merge with locked LoRAs
+        result_loras.extend(locked_loras)
+
+        return result_loras
+
+    async def _apply_pool_filters(
+        self, available_loras: List[Dict], pool_config: Dict
+    ) -> List[Dict]:
+        """
+        Apply pool_config filters to available LoRAs.
+
+        Args:
+            available_loras: List of all LoRA dicts
+            pool_config: Dict with filter settings from LoRA Pool node
+
+        Returns:
+            Filtered list of LoRA dicts
+        """
+        from .model_query import FilterCriteria
+
+        filter_section = pool_config
+
+        # Extract filter parameters
+        selected_base_models = filter_section.get("baseModels", [])
+        tags_dict = filter_section.get("tags", {})
+        include_tags = tags_dict.get("include", [])
+        exclude_tags = tags_dict.get("exclude", [])
+        folders_dict = filter_section.get("folders", {})
+        include_folders = folders_dict.get("include", [])
+        exclude_folders = folders_dict.get("exclude", [])
+        license_dict = filter_section.get("license", {})
+        no_credit_required = license_dict.get("noCreditRequired", False)
+        allow_selling = license_dict.get("allowSelling", False)
+
+        # Build tag filters dict
+        tag_filters = {}
+        for tag in include_tags:
+            tag_filters[tag] = "include"
+        for tag in exclude_tags:
+            tag_filters[tag] = "exclude"
+
+        # Build folder filter
+        if include_folders or exclude_folders:
+            filtered = []
+            for lora in available_loras:
+                folder = lora.get("folder", "")
+
+                # Check exclude folders first
+                excluded = False
+                for exclude_folder in exclude_folders:
+                    if folder.startswith(exclude_folder):
+                        excluded = True
+                        break
+
+                if excluded:
+                    continue
+
+                # Check include folders
+                if include_folders:
+                    included = False
+                    for include_folder in include_folders:
+                        if folder.startswith(include_folder):
+                            included = True
+                            break
+                    if not included:
+                        continue
+
+                filtered.append(lora)
+
+            available_loras = filtered
+
+        # Apply base model filter
+        if selected_base_models:
+            available_loras = [
+                lora
+                for lora in available_loras
+                if lora.get("base_model") in selected_base_models
+            ]
+
+        # Apply tag filters
+        if tag_filters:
+            criteria = FilterCriteria(tags=tag_filters)
+            available_loras = self.filter_set.apply(available_loras, criteria)
+
+        # Apply license filters
+        # no_credit_required=True means keep only models where credit is NOT required
+        # (i.e., allowNoCredit=True, which is bit 0 = 1 in license_flags)
+        if no_credit_required:
+            available_loras = [
+                lora
+                for lora in available_loras
+                if bool(lora.get("license_flags", 127) & (1 << 0))
+            ]
+
+        # allow_selling=True means keep only models where selling generated content is allowed
+        if allow_selling:
+            available_loras = [
+                lora
+                for lora in available_loras
+                if bool(lora.get("license_flags", 127) & (1 << 1))
+            ]
+
+        return available_loras
+
+    async def get_cycler_list(
+        self,
+        pool_config: Optional[Dict] = None,
+        sort_by: str = "filename"
+    ) -> List[Dict]:
+        """
+        Get filtered and sorted LoRA list for cycling.
+
+        Args:
+            pool_config: Optional pool config for filtering (filters dict)
+            sort_by: Sort field - 'filename' or 'model_name'
+
+        Returns:
+            List of LoRA dicts with file_name and model_name
+        """
+        # Get cached data
+        cache = await self.scanner.get_cached_data(force_refresh=False)
+        available_loras = cache.raw_data if cache else []
+
+        # Apply pool filters if provided
+        if pool_config:
+            available_loras = await self._apply_pool_filters(
+                available_loras, pool_config
+            )
+
+        # Sort by specified field
+        if sort_by == "model_name":
+            available_loras = sorted(
+                available_loras,
+                key=lambda x: (x.get("model_name") or x.get("file_name", "")).lower()
+            )
+        else:  # Default to filename
+            available_loras = sorted(
+                available_loras,
+                key=lambda x: x.get("file_name", "").lower()
+            )
+
+        # Return minimal data needed for cycling
+        return [
+            {
+                "file_name": lora["file_name"],
+                "model_name": lora.get("model_name", lora["file_name"]),
+            }
+            for lora in available_loras
+        ]

py/services/metadata_service.py

@@ -44,6 +44,8 @@ async def initialize_metadata_providers():
                 logger.debug(f"SQLite metadata provider registered with database: {db_path}")
             else:
                 logger.warning("Metadata archive database is enabled but database file not found")
+                logger.info("Automatically disabling enable_metadata_archive_db setting")
+                settings_manager.set('enable_metadata_archive_db', False)
         except Exception as e:
             logger.error(f"Failed to initialize SQLite metadata provider: {e}")
     

py/services/metadata_sync_service.py

@@ -76,7 +76,7 @@ class MetadataSyncService:
         files = meta.get("files")
         images = meta.get("images")
         source = meta.get("source")
-        return bool(files) and bool(images) and source != "archive_db"
+        return bool(files) and bool(images) and source not in ("archive_db", "civarchive")
 
     async def update_model_metadata(
         self,
@@ -90,11 +90,11 @@ class MetadataSyncService:
         existing_civitai = local_metadata.get("civitai") or {}
 
         if (
-            civitai_metadata.get("source") == "archive_db"
+            not self.is_civitai_api_metadata(civitai_metadata)
             and self.is_civitai_api_metadata(existing_civitai)
         ):
             logger.info(
-                "Skip civitai update for %s (%s)",
+                "Skip civitai update for %s (%s) - existing metadata is higher quality",
                 local_metadata.get("model_name", ""),
                 existing_civitai.get("name", ""),
             )
@@ -243,17 +243,27 @@ class MetadataSyncService:
                 last_error = error or last_error
 
             if civitai_metadata is None or metadata_provider is None:
+                # Track if we need to save metadata
+                needs_save = False
+
                 if sqlite_attempted:
                     model_data["db_checked"] = True
+                    needs_save = True
 
                 if civitai_api_not_found:
                     model_data["from_civitai"] = False
                     model_data["civitai_deleted"] = True
                     model_data["db_checked"] = sqlite_attempted or (enable_archive and model_data.get("db_checked", False))
                     model_data["last_checked_at"] = datetime.now().timestamp()
+                    needs_save = True
 
+                # Save metadata if any state was updated
+                if needs_save:
                     data_to_save = model_data.copy()
                     data_to_save.pop("folder", None)
+                    # Update last_checked_at for sqlite-only attempts if not already set
+                    if "last_checked_at" not in data_to_save:
+                        data_to_save["last_checked_at"] = datetime.now().timestamp()
                     await self._metadata_manager.save_metadata(file_path, data_to_save)
 
                 default_error = (

py/services/model_cache.py

@@ -1,7 +1,10 @@
 import asyncio
+import time
+import logging
+
+logger = logging.getLogger(__name__)
 from typing import Any, Dict, List, Optional, Tuple
 from dataclasses import dataclass, field
-from operator import itemgetter
 from natsort import natsorted
 
 # Supported sort modes: (sort_key, order)
@@ -13,7 +16,10 @@ SUPPORTED_SORT_MODES = [
     ('date', 'desc'),
     ('size', 'asc'),
     ('size', 'desc'),
+    ('usage', 'asc'),
+    ('usage', 'desc'),
 ]
+# Is this in use?
 
 DISPLAY_NAME_MODES = {"model_name", "file_name"}
 
@@ -212,40 +218,63 @@ class ModelCache:
 
     def _sort_data(self, data: List[Dict], sort_key: str, order: str) -> List[Dict]:
         """Sort data by sort_key and order"""
+        start_time = time.perf_counter()
         reverse = (order == 'desc')
         if sort_key == 'name':
             # Natural sort by configured display name, case-insensitive
-            return natsorted(
+            result = natsorted(
                 data,
                 key=lambda x: self._get_display_name(x).lower(),
                 reverse=reverse
             )
         elif sort_key == 'date':
-            # Sort by modified timestamp
-            return sorted(
+            # Sort by modified timestamp (use .get() with default to handle missing fields)
+            result = sorted(
                 data,
-                key=itemgetter('modified'),
+                key=lambda x: x.get('modified', 0.0),
                 reverse=reverse
             )
         elif sort_key == 'size':
-            # Sort by file size
+            # Sort by file size (use .get() with default to handle missing fields)
+            result = sorted(
+                data,
+                key=lambda x: x.get('size', 0),
+                reverse=reverse
+            )
+        elif sort_key == 'usage':
+            # Sort by usage count, fallback to 0, then name for stability
             return sorted(
                 data,
-                key=itemgetter('size'),
+                key=lambda x: (
+                    x.get('usage_count', 0),
+                    self._get_display_name(x).lower()
+                ),
                 reverse=reverse
             )
         else:
             # Fallback: no sort
-            return list(data)
+            result = list(data)
+        
+        duration = time.perf_counter() - start_time
+        if duration > 0.05:
+            logger.debug("ModelCache._sort_data(%s, %s) for %d items took %.3fs", sort_key, order, len(data), duration)
+        return result
 
     async def get_sorted_data(self, sort_key: str = 'name', order: str = 'asc') -> List[Dict]:
         """Get sorted data by sort_key and order, using cache if possible"""
         async with self._lock:
             if (sort_key, order) == self._last_sort:
                 return self._last_sorted_data
+            
+            start_time = time.perf_counter()
             sorted_data = self._sort_data(self.raw_data, sort_key, order)
             self._last_sort = (sort_key, order)
             self._last_sorted_data = sorted_data
+            
+            duration = time.perf_counter() - start_time
+            if duration > 0.1:
+                logger.debug("ModelCache.get_sorted_data(%s, %s) took %.3fs", sort_key, order, duration)
+            
             return sorted_data
 
     async def update_name_display_mode(self, display_mode: str) -> None:

py/services/model_file_service.py

@@ -36,11 +36,13 @@ class AutoOrganizeResult:
         self.results_truncated: bool = False
         self.sample_results: List[Dict[str, Any]] = []
         self.is_flat_structure: bool = False
+        self.status: str = 'success'
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert result to dictionary"""
         result = {
-            'success': True,
+            'success': self.status != 'error',
+            'status': self.status,
             'message': f'Auto-organize {self.operation_type} completed: {self.success_count} moved, {self.skipped_count} skipped, {self.failure_count} failed out of {self.total} total',
             'summary': {
                 'total': self.total,
@@ -98,6 +100,8 @@ class ModelFileService:
         result = AutoOrganizeResult()
         source_directories: Set[str] = set()
         
+        self.scanner.reset_cancellation()
+        
         try:
             # Get all models from cache
             cache = await self.scanner.get_cached_data()
@@ -187,6 +191,21 @@ class ModelFileService:
                 source_directories  # Pass the set to track source directories
             )
 
+            if self.scanner.is_cancelled():
+                result.status = 'cancelled'
+                if progress_callback:
+                    await progress_callback.on_progress({
+                        'type': 'auto_organize_progress',
+                        'status': 'cancelled',
+                        'total': result.total,
+                        'processed': result.processed,
+                        'success': result.success_count,
+                        'failures': result.failure_count,
+                        'skipped': result.skipped_count,
+                        'operation_type': result.operation_type
+                    })
+                return result
+            
             # Send cleanup progress
             if progress_callback:
                 await progress_callback.on_progress({
@@ -246,9 +265,15 @@ class ModelFileService:
         """Process models in batches to avoid overwhelming the system"""
         
         for i in range(0, result.total, AUTO_ORGANIZE_BATCH_SIZE):
+            if self.scanner.is_cancelled():
+                logger.info(f"{self.model_type.capitalize()} File Service: Auto-organize cancelled by user")
+                break
+
             batch = all_models[i:i + AUTO_ORGANIZE_BATCH_SIZE]
             
             for model in batch:
+                if self.scanner.is_cancelled():
+                    break
                 await self._process_single_model(model, model_roots, result, source_directories)
                 result.processed += 1
             
@@ -446,25 +471,46 @@ class ModelFileService:
 class ModelMoveService:
     """Service for handling individual model moves"""
     
-    def __init__(self, scanner):
+    def __init__(self, scanner, model_type: str):
         """Initialize the service
         
         Args:
             scanner: Model scanner instance
+            model_type: Type of model (e.g., 'lora', 'checkpoint')
         """
         self.scanner = scanner
+        self.model_type = model_type
     
-    async def move_model(self, file_path: str, target_path: str) -> Dict[str, Any]:
+    async def move_model(self, file_path: str, target_path: str, use_default_paths: bool = False) -> Dict[str, Any]:
         """Move a single model file
         
         Args:
             file_path: Source file path
-            target_path: Target directory path
+            target_path: Target directory path (used as root if use_default_paths is True)
+            use_default_paths: Whether to use default path template for organization
             
         Returns:
             Dictionary with move result
         """
         try:
+            if use_default_paths:
+                # Find the model in cache to get metadata
+                cache = await self.scanner.get_cached_data()
+                model_data = next((m for m in cache.raw_data if m.get('file_path') == file_path), None)
+                
+                if model_data:
+                    from ..utils.utils import calculate_relative_path_for_model
+                    relative_path = calculate_relative_path_for_model(model_data, self.model_type)
+                    if relative_path:
+                        target_path = os.path.join(target_path, relative_path).replace(os.sep, '/')
+                    elif not get_settings_manager().get_download_path_template(self.model_type):
+                        # Flat structure, target_path remains the root
+                        pass
+                    else:
+                        # Could not calculate relative path (e.g. missing metadata)
+                        # Fallback to manual target_path or skip?
+                        pass
+
             source_dir = os.path.dirname(file_path)
             if os.path.normpath(source_dir) == os.path.normpath(target_path):
                 logger.info(f"Source and target directories are the same: {source_dir}")
@@ -475,12 +521,15 @@ class ModelMoveService:
                     'new_file_path': file_path
                 }
 
-            new_file_path = await self.scanner.move_model(file_path, target_path)
-            if new_file_path:
+            move_result = await self.scanner.move_model(file_path, target_path)
+            if move_result:
+                new_file_path = move_result.get("new_path")
+                cache_entry = move_result.get("cache_entry")
                 return {
                     'success': True, 
                     'original_file_path': file_path,
-                    'new_file_path': new_file_path
+                    'new_file_path': new_file_path,
+                    'cache_entry': cache_entry
                 }
             else:
                 return {
@@ -498,26 +547,32 @@ class ModelMoveService:
                 'new_file_path': None
             }
     
-    async def move_models_bulk(self, file_paths: List[str], target_path: str) -> Dict[str, Any]:
+    async def move_models_bulk(self, file_paths: List[str], target_path: str, use_default_paths: bool = False) -> Dict[str, Any]:
         """Move multiple model files
         
         Args:
             file_paths: List of source file paths
-            target_path: Target directory path
+            target_path: Target directory path (used as root if use_default_paths is True)
+            use_default_paths: Whether to use default path template for organization
             
         Returns:
             Dictionary with bulk move results
         """
         try:
             results = []
+            self.scanner.reset_cancellation()
             
             for file_path in file_paths:
-                result = await self.move_model(file_path, target_path)
+                if self.scanner.is_cancelled():
+                    logger.info(f"{self.model_type.capitalize()} Move Service: Bulk move cancelled by user")
+                    break
+                result = await self.move_model(file_path, target_path, use_default_paths=use_default_paths)
                 results.append({
                     "original_file_path": file_path,
                     "new_file_path": result.get('new_file_path'),
                     "success": result['success'],
-                    "message": result.get('message', result.get('error', 'Unknown'))
+                    "message": result.get('message', result.get('error', 'Unknown')),
+                    "cache_entry": result.get('cache_entry')
                 })
             
             success_count = sum(1 for r in results if r["success"])

py/services/model_metadata_provider.py

@@ -676,7 +676,9 @@ class ModelMetadataProviderManager:
         
     def _get_provider(self, provider_name: str = None) -> ModelMetadataProvider:
         """Get provider by name or default provider"""
-        if provider_name and provider_name in self.providers:
+        if provider_name:
+            if provider_name not in self.providers:
+                raise ValueError(f"Provider '{provider_name}' is not registered")
             return self.providers[provider_name]
 
         if self.default_provider is None:

py/services/model_query.py

@@ -1,10 +1,25 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Protocol, Callable
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Protocol,
+    Callable,
+)
 
 from ..utils.constants import NSFW_LEVELS
 from ..utils.utils import fuzzy_match as default_fuzzy_match
+import time
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 DEFAULT_CIVITAI_MODEL_TYPE = "LORA"
@@ -18,28 +33,42 @@ def _coerce_to_str(value: Any) -> Optional[str]:
     return candidate if candidate else None
 
 
-def normalize_civitai_model_type(value: Any) -> Optional[str]:
-    """Return a lowercase string suitable for comparisons."""
+def normalize_sub_type(value: Any) -> Optional[str]:
+    """Return a lowercase string suitable for sub_type comparisons."""
     candidate = _coerce_to_str(value)
     return candidate.lower() if candidate else None
 
 
-def resolve_civitai_model_type(entry: Mapping[str, Any]) -> str:
-    """Extract the model type from CivitAI metadata, defaulting to LORA."""
+def resolve_sub_type(entry: Mapping[str, Any]) -> str:
+    """Extract the sub-type from metadata, checking multiple sources.
+    
+    Priority:
+    1. entry['sub_type'] - new canonical field
+    2. entry['model_type'] - backward compatibility
+    3. civitai.model.type - CivitAI API data
+    4. DEFAULT_CIVITAI_MODEL_TYPE - fallback
+    """
     if not isinstance(entry, Mapping):
         return DEFAULT_CIVITAI_MODEL_TYPE
 
+    # Priority 1: Check new canonical field 'sub_type'
+    sub_type = _coerce_to_str(entry.get("sub_type"))
+    if sub_type:
+        return sub_type
+
+    # Priority 2: Backward compatibility - check 'model_type' field
+    model_type = _coerce_to_str(entry.get("model_type"))
+    if model_type:
+        return model_type
+
+    # Priority 3: Extract from CivitAI metadata
     civitai = entry.get("civitai")
     if isinstance(civitai, Mapping):
         civitai_model = civitai.get("model")
         if isinstance(civitai_model, Mapping):
-            model_type = _coerce_to_str(civitai_model.get("type"))
-            if model_type:
-                return model_type
-
-    model_type = _coerce_to_str(entry.get("model_type"))
-    if model_type:
-        return model_type
+            civitai_type = _coerce_to_str(civitai_model.get("type"))
+            if civitai_type:
+                return civitai_type
 
     return DEFAULT_CIVITAI_MODEL_TYPE
 
@@ -47,8 +76,7 @@ def resolve_civitai_model_type(entry: Mapping[str, Any]) -> str:
 class SettingsProvider(Protocol):
     """Protocol describing the SettingsManager contract used by query helpers."""
 
-    def get(self, key: str, default: Any = None) -> Any:
-        ...
+    def get(self, key: str, default: Any = None) -> Any: ...
 
 
 @dataclass(frozen=True)
@@ -64,11 +92,14 @@ class FilterCriteria:
     """Container for model list filtering options."""
 
     folder: Optional[str] = None
+    folder_include: Optional[Sequence[str]] = None
+    folder_exclude: Optional[Sequence[str]] = None
     base_models: Optional[Sequence[str]] = None
     tags: Optional[Dict[str, str]] = None
     favorites_only: bool = False
     search_options: Optional[Dict[str, Any]] = None
     model_types: Optional[Sequence[str]] = None
+    tag_logic: str = "any"  # "any" (OR) or "all" (AND)
 
 
 class ModelCacheRepository:
@@ -109,82 +140,240 @@ class ModelCacheRepository:
 class ModelFilterSet:
     """Applies common filtering rules to the model collection."""
 
-    def __init__(self, settings: SettingsProvider, nsfw_levels: Optional[Dict[str, int]] = None) -> None:
+    def __init__(
+        self, settings: SettingsProvider, nsfw_levels: Optional[Dict[str, int]] = None
+    ) -> None:
         self._settings = settings
         self._nsfw_levels = nsfw_levels or NSFW_LEVELS
 
-    def apply(self, data: Iterable[Dict[str, Any]], criteria: FilterCriteria) -> List[Dict[str, Any]]:
+    def apply(
+        self, data: Iterable[Dict[str, Any]], criteria: FilterCriteria
+    ) -> List[Dict[str, Any]]:
         """Return items that satisfy the provided criteria."""
+        overall_start = time.perf_counter()
         items = list(data)
+        initial_count = len(items)
 
         if self._settings.get("show_only_sfw", False):
+            t0 = time.perf_counter()
             threshold = self._nsfw_levels.get("R", 0)
             items = [
-                item for item in items
-                if not item.get("preview_nsfw_level") or item.get("preview_nsfw_level") < threshold
+                item
+                for item in items
+                if not item.get("preview_nsfw_level")
+                or item.get("preview_nsfw_level") < threshold
             ]
+            sfw_duration = time.perf_counter() - t0
+        else:
+            sfw_duration = 0
 
+        favorites_duration = 0
         if criteria.favorites_only:
+            t0 = time.perf_counter()
             items = [item for item in items if item.get("favorite", False)]
+            favorites_duration = time.perf_counter() - t0
 
+        folder_duration = 0
         folder = criteria.folder
+        folder_include = criteria.folder_include or []
+        folder_exclude = criteria.folder_exclude or []
         options = criteria.search_options or {}
         recursive = bool(options.get("recursive", True))
+
+        # Apply folder exclude filters first
+        if folder_exclude:
+            t0 = time.perf_counter()
+            for exclude_folder in folder_exclude:
+                if exclude_folder:
+                    # Check exact match OR prefix match (for subfolders)
+                    # Normalize exclude_folder for prefix matching
+                    if not exclude_folder.endswith("/"):
+                        exclude_prefix = f"{exclude_folder}/"
+                    else:
+                        exclude_prefix = exclude_folder
+                    items = [
+                        item
+                        for item in items
+                        if item.get("folder") != exclude_folder
+                        and not item.get("folder", "").startswith(exclude_prefix)
+                    ]
+            folder_duration = time.perf_counter() - t0
+
+        # Apply folder include filters
         if folder is not None:
+            t0 = time.perf_counter()
             if recursive:
                 if folder:
                     folder_with_sep = f"{folder}/"
                     items = [
-                        item for item in items
-                        if item.get("folder") == folder or item.get("folder", "").startswith(folder_with_sep)
+                        item
+                        for item in items
+                        if item.get("folder") == folder
+                        or item.get("folder", "").startswith(folder_with_sep)
                     ]
             else:
                 items = [item for item in items if item.get("folder") == folder]
+            folder_duration = time.perf_counter() - t0 + folder_duration
 
+        # Apply folder include filters
+        if folder_include:
+            t0 = time.perf_counter()
+            matched_items = []
+            for include_folder in folder_include:
+                if include_folder:
+                    if recursive:
+                        # Normalize folder for prefix matching (similar to exclude logic)
+                        if not include_folder.endswith("/"):
+                            folder_prefix = f"{include_folder}/"
+                        else:
+                            folder_prefix = include_folder
+                        folder_items = [
+                            item
+                            for item in items
+                            if item.get("folder") == include_folder
+                            or item.get("folder", "").startswith(folder_prefix)
+                        ]
+                    else:
+                        folder_items = [
+                            item
+                            for item in items
+                            if item.get("folder") == include_folder
+                        ]
+                    matched_items.extend(folder_items)
+            # Remove duplicates while preserving order
+            seen = set()
+            items = []
+            for item in matched_items:
+                # Use sha256 or id as unique identifier if available, otherwise use tuple representation
+                item_id = item.get("sha256") or item.get("id")
+                if item_id is not None:
+                    identifier = item_id
+                else:
+                    # For items without explicit id, use a tuple of key values
+                    identifier = tuple(sorted((k, str(v)) for k, v in item.items()))
+                if identifier not in seen:
+                    seen.add(identifier)
+                    items.append(item)
+            folder_duration = time.perf_counter() - t0 + folder_duration
+        # Apply folder include filters (legacy single folder)
+        elif folder is not None:
+            t0 = time.perf_counter()
+            if recursive:
+                if folder:
+                    # Normalize folder for prefix matching
+                    if not folder.endswith("/"):
+                        folder_prefix = f"{folder}/"
+                    else:
+                        folder_prefix = folder
+                    items = [
+                        item
+                        for item in items
+                        if item.get("folder") == folder
+                        or item.get("folder", "").startswith(folder_prefix)
+                    ]
+            else:
+                items = [item for item in items if item.get("folder") == folder]
+            folder_duration = time.perf_counter() - t0 + folder_duration
+
+        base_models_duration = 0
         base_models = criteria.base_models or []
         if base_models:
+            t0 = time.perf_counter()
             base_model_set = set(base_models)
             items = [item for item in items if item.get("base_model") in base_model_set]
+            base_models_duration = time.perf_counter() - t0
 
+        tags_duration = 0
         tag_filters = criteria.tags or {}
-        include_tags = set()
-        exclude_tags = set()
-        if isinstance(tag_filters, dict):
-            for tag, state in tag_filters.items():
-                if not tag:
-                    continue
-                if state == "exclude":
-                    exclude_tags.add(tag)
-                else:
-                    include_tags.add(tag)
-        else:
-            include_tags = {tag for tag in tag_filters if tag}
+        if tag_filters:
+            t0 = time.perf_counter()
+            include_tags = set()
+            exclude_tags = set()
+            if isinstance(tag_filters, dict):
+                for tag, state in tag_filters.items():
+                    if not tag:
+                        continue
+                    if state == "exclude":
+                        exclude_tags.add(tag)
+                    else:
+                        include_tags.add(tag)
+            else:
+                include_tags = {tag for tag in tag_filters if tag}
 
-        if include_tags:
-            items = [
-                item for item in items
-                if any(tag in include_tags for tag in (item.get("tags", []) or []))
-            ]
+            if include_tags:
+                tag_logic = criteria.tag_logic.lower() if criteria.tag_logic else "any"
 
-        if exclude_tags:
-            items = [
-                item for item in items
-                if not any(tag in exclude_tags for tag in (item.get("tags", []) or []))
-            ]
+                def matches_include(item_tags):
+                    if not item_tags and "__no_tags__" in include_tags:
+                        return True
+                    if tag_logic == "all":
+                        # AND logic: item must have ALL include tags
+                        # Special case: __no_tags__ is handled separately
+                        non_special_tags = include_tags - {"__no_tags__"}
+                        if "__no_tags__" in include_tags:
+                            # If __no_tags__ is selected along with other tags,
+                            # treat it as "no tags OR (all other tags)"
+                            if not item_tags:
+                                return True
+                            # Otherwise, check if all non-special tags match
+                            if non_special_tags:
+                                return all(tag in (item_tags or []) for tag in non_special_tags)
+                            return True
+                        # Normal case: all tags must match
+                        return all(tag in (item_tags or []) for tag in non_special_tags)
+                    else:
+                        # OR logic (default): item must have ANY include tag
+                        return any(tag in include_tags for tag in (item_tags or []))
 
+                items = [item for item in items if matches_include(item.get("tags"))]
+
+            if exclude_tags:
+
+                def matches_exclude(item_tags):
+                    if not item_tags and "__no_tags__" in exclude_tags:
+                        return True
+                    return any(tag in exclude_tags for tag in (item_tags or []))
+
+                items = [
+                    item for item in items if not matches_exclude(item.get("tags"))
+                ]
+            tags_duration = time.perf_counter() - t0
+
+        model_types_duration = 0
         model_types = criteria.model_types or []
-        normalized_model_types = {
-            model_type for model_type in (
-                normalize_civitai_model_type(value) for value in model_types
-            )
-            if model_type
-        }
-        if normalized_model_types:
-            items = [
-                item for item in items
-                if normalize_civitai_model_type(resolve_civitai_model_type(item)) in normalized_model_types
-            ]
+        if model_types:
+            t0 = time.perf_counter()
+            normalized_model_types = {
+                model_type
+                for model_type in (
+                    normalize_sub_type(value) for value in model_types
+                )
+                if model_type
+            }
+            if normalized_model_types:
+                items = [
+                    item
+                    for item in items
+                    if normalize_sub_type(resolve_sub_type(item))
+                    in normalized_model_types
+                ]
+            model_types_duration = time.perf_counter() - t0
 
+        duration = time.perf_counter() - overall_start
+        if duration > 0.1:  # Only log if it's potentially slow
+            logger.debug(
+                "ModelFilterSet.apply took %.3fs (sfw: %.3fs, fav: %.3fs, folder: %.3fs, base: %.3fs, tags: %.3fs, types: %.3fs). "
+                "Count: %d -> %d",
+                duration,
+                sfw_duration,
+                favorites_duration,
+                folder_duration,
+                base_models_duration,
+                tags_duration,
+                model_types_duration,
+                initial_count,
+                len(items),
+            )
         return items
 
 
@@ -199,7 +388,9 @@ class SearchStrategy:
         "creator": False,
     }
 
-    def __init__(self, fuzzy_matcher: Optional[Callable[[str, str], bool]] = None) -> None:
+    def __init__(
+        self, fuzzy_matcher: Optional[Callable[[str, str], bool]] = None
+    ) -> None:
         self._fuzzy_match = fuzzy_matcher or default_fuzzy_match
 
     def normalize_options(self, options: Optional[Dict[str, Any]]) -> Dict[str, Any]:
@@ -238,7 +429,9 @@ class SearchStrategy:
 
             if options.get("tags", False):
                 tags = item.get("tags", []) or []
-                if any(self._matches(tag, search_term, search_lower, fuzzy) for tag in tags):
+                if any(
+                    self._matches(tag, search_term, search_lower, fuzzy) for tag in tags
+                ):
                     results.append(item)
                     continue
 
@@ -249,13 +442,17 @@ class SearchStrategy:
                     creator = civitai.get("creator")
                     if isinstance(creator, dict):
                         creator_username = creator.get("username", "")
-                if creator_username and self._matches(creator_username, search_term, search_lower, fuzzy):
+                if creator_username and self._matches(
+                    creator_username, search_term, search_lower, fuzzy
+                ):
                     results.append(item)
                     continue
 
         return results
 
-    def _matches(self, candidate: str, search_term: str, search_lower: str, fuzzy: bool) -> bool:
+    def _matches(
+        self, candidate: str, search_term: str, search_lower: str, fuzzy: bool
+    ) -> bool:
         if not isinstance(candidate, str):
             candidate = "" if candidate is None else str(candidate)
 

py/services/model_scanner.py

@@ -20,6 +20,8 @@ from .service_registry import ServiceRegistry
 from .websocket_manager import ws_manager
 from .persistent_model_cache import get_persistent_cache
 from .settings_manager import get_settings_manager
+from .cache_entry_validator import CacheEntryValidator
+from .cache_health_monitor import CacheHealthMonitor, CacheHealthStatus
 
 logger = logging.getLogger(__name__)
 
@@ -84,6 +86,7 @@ class ModelScanner:
         self._excluded_models = []  # List to track excluded models
         self._persistent_cache = get_persistent_cache()
         self._name_display_mode = self._resolve_name_display_mode()
+        self._cancel_requested = False  # Flag for cancellation
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
@@ -274,9 +277,10 @@ class ModelScanner:
         _, license_flags = resolve_license_info(license_source or {})
         entry['license_flags'] = license_flags
 
-        model_type = get_value('model_type', None)
-        if model_type:
-            entry['model_type'] = model_type
+        # Handle sub_type (new canonical field)
+        sub_type = get_value('sub_type', None)
+        if sub_type:
+            entry['sub_type'] = sub_type
 
         return entry
 
@@ -466,6 +470,39 @@ class ModelScanner:
             for tag in adjusted_item.get('tags') or []:
                 tags_count[tag] = tags_count.get(tag, 0) + 1
 
+        # Validate cache entries and check health
+        valid_entries, invalid_entries = CacheEntryValidator.validate_batch(
+            adjusted_raw_data, auto_repair=True
+        )
+
+        if invalid_entries:
+            monitor = CacheHealthMonitor()
+            report = monitor.check_health(adjusted_raw_data, auto_repair=True)
+
+            if report.status != CacheHealthStatus.HEALTHY:
+                # Broadcast health warning to frontend
+                await ws_manager.broadcast_cache_health_warning(report, page_type)
+                logger.warning(
+                    f"{self.model_type.capitalize()} Scanner: Cache health issue detected - "
+                    f"{report.invalid_entries} invalid entries, {report.repaired_entries} repaired"
+                )
+
+            # Use only valid entries
+            adjusted_raw_data = valid_entries
+
+            # Rebuild tags count from valid entries only
+            tags_count = {}
+            for item in adjusted_raw_data:
+                for tag in item.get('tags') or []:
+                    tags_count[tag] = tags_count.get(tag, 0) + 1
+
+            # Remove invalid entries from hash index
+            for invalid_entry in invalid_entries:
+                file_path = CacheEntryValidator.get_file_path_safe(invalid_entry)
+                sha256 = CacheEntryValidator.get_sha256_safe(invalid_entry)
+                if file_path:
+                    hash_index.remove_by_path(file_path, sha256)
+
         scan_result = CacheBuildResult(
             raw_data=adjusted_raw_data,
             hash_index=hash_index,
@@ -649,16 +686,19 @@ class ModelScanner:
 
     async def _initialize_cache(self) -> None:
         """Initialize or refresh the cache"""
-        print("init start", flush=True)
         self._is_initializing = True  # Set flag
         try:
             start_time = time.time()
+            
+            # Manually trigger a symlink rescan during a full rebuild.
+            # This ensures that any new symlink mappings are correctly picked up.
+            config.rebuild_symlink_cache()
+
             # Determine the page type based on model type
             # Scan for new data
             scan_result = await self._gather_model_data()
             await self._apply_scan_result(scan_result)
             await self._save_persistent_cache(scan_result)
-            print("init end", flush=True)
 
             logger.info(
                 f"{self.model_type.capitalize()} Scanner: Cache initialization completed in {time.time() - start_time:.2f} seconds, "
@@ -678,6 +718,7 @@ class ModelScanner:
 
     async def _reconcile_cache(self) -> None:
         """Fast cache reconciliation - only process differences between cache and filesystem"""
+        self.reset_cancellation()
         self._is_initializing = True # Set flag for reconciliation duration
         try:
             start_time = time.time()
@@ -737,6 +778,9 @@ class ModelScanner:
                     
                     # Yield control periodically
                     await asyncio.sleep(0)
+                    if self.is_cancelled():
+                        logger.info(f"{self.model_type.capitalize()} Scanner: Reconcile scan cancelled")
+                        return
             
             # Process new files in batches
             total_added = 0
@@ -765,6 +809,18 @@ class ModelScanner:
                                     model_data = self.adjust_cached_entry(dict(model_data))
                                     if not model_data:
                                         continue
+
+                                    # Validate the new entry before adding
+                                    validation_result = CacheEntryValidator.validate(
+                                        model_data, auto_repair=True
+                                    )
+                                    if not validation_result.is_valid:
+                                        logger.warning(
+                                            f"Skipping invalid entry during reconcile: {path}"
+                                        )
+                                        continue
+                                    model_data = validation_result.entry
+
                                     self._ensure_license_flags(model_data)
                                     # Add to cache
                                     self._cache.raw_data.append(model_data)
@@ -785,6 +841,10 @@ class ModelScanner:
                         except Exception as e:
                             logger.error(f"Error adding {path} to cache: {e}")
                         
+                        if self.is_cancelled():
+                            logger.info(f"{self.model_type.capitalize()} Scanner: Reconcile processing cancelled")
+                            return
+            
             # Find missing files (in cache but not in filesystem)
             missing_files = cached_paths - found_paths
             total_removed = 0
@@ -838,6 +898,19 @@ class ModelScanner:
         """Check if the scanner is currently initializing"""
         return self._is_initializing
     
+    def cancel_task(self) -> None:
+        """Request cancellation of the current long-running task."""
+        self._cancel_requested = True
+        logger.info(f"{self.model_type.capitalize()} Scanner: Cancellation requested")
+
+    def reset_cancellation(self) -> None:
+        """Reset the cancellation flag."""
+        self._cancel_requested = False
+
+    def is_cancelled(self) -> bool:
+        """Check if cancellation has been requested."""
+        return self._cancel_requested
+    
     def get_model_roots(self) -> List[str]:
         """Get model root directories"""
         raise NotImplementedError("Subclasses must implement get_model_roots")
@@ -927,7 +1000,7 @@ class ModelScanner:
                         metadata = self.model_class.from_civitai_info(version_info, file_info, file_path)
                         metadata.preview_url = find_preview_file(file_name, os.path.dirname(file_path))
                         await MetadataManager.save_metadata(file_path, metadata)
-                        logger.debug(f"Created metadata from .civitai.info for {file_path}")
+                        logger.info(f"Created metadata from .civitai.info for {file_path} (Reason: .civitai.info was found but .metadata.json was missing)")
                 except Exception as e:
                     logger.error(f"Error creating metadata from .civitai.info for {file_path}: {e}")
         else:
@@ -1030,6 +1103,8 @@ class ModelScanner:
             except Exception as exc:  # pragma: no cover - defensive logging
                 logger.error(f"Error reporting progress for {self.model_type}: {exc}")
 
+        self.reset_cancellation()
+
         async def scan_recursive(current_path: str, root_path: str, visited_paths: Set[str]) -> None:
             nonlocal processed_files
 
@@ -1060,6 +1135,17 @@ class ModelScanner:
                             processed_files += 1
 
                             if result:
+                                # Validate the entry before adding
+                                validation_result = CacheEntryValidator.validate(
+                                    result, auto_repair=True
+                                )
+                                if not validation_result.is_valid:
+                                    logger.warning(
+                                        f"Skipping invalid scan result: {file_path}"
+                                    )
+                                    continue
+                                result = validation_result.entry
+
                                 self._ensure_license_flags(result)
                                 raw_data.append(result)
 
@@ -1073,6 +1159,8 @@ class ModelScanner:
 
                             await handle_progress()
                             await asyncio.sleep(0)
+                            if self.is_cancelled():
+                                return
                         elif entry.is_dir(follow_symlinks=True):
                             await scan_recursive(entry.path, root_path, visited_paths)
                     except Exception as entry_error:
@@ -1080,6 +1168,9 @@ class ModelScanner:
             except Exception as scan_error:
                 logger.error(f"Error scanning {current_path}: {scan_error}")
 
+            if self.is_cancelled():
+                return
+
         for model_root in self.get_model_roots():
             if not os.path.exists(model_root):
                 continue
@@ -1216,9 +1307,12 @@ class ModelScanner:
                 except Exception as e:
                     logger.error(f"Error moving metadata file: {e}")
             
-            await self.update_single_model_cache(source_path, target_file, metadata)
+            update_result = await self.update_single_model_cache(source_path, target_file, metadata, recalculate_type=True)
             
-            return target_file
+            return {
+                "new_path": target_file,
+                "cache_entry": update_result if isinstance(update_result, dict) else None
+            }
             
         except Exception as e:
             logger.error(f"Error moving model: {e}", exc_info=True)
@@ -1250,7 +1344,7 @@ class ModelScanner:
             logger.error(f"Error updating metadata paths: {e}", exc_info=True)
             return None
 
-    async def update_single_model_cache(self, original_path: str, new_path: str, metadata: Dict) -> bool:
+    async def update_single_model_cache(self, original_path: str, new_path: str, metadata: Dict, recalculate_type: bool = False) -> Union[bool, Dict]:
         """Update cache after a model has been moved or modified"""
         cache = await self.get_cached_data()
 
@@ -1287,6 +1381,9 @@ class ModelScanner:
                 file_path_override=normalized_new_path,
             )
 
+            if recalculate_type:
+                cache_entry = self.adjust_cached_entry(cache_entry)
+
             cache.raw_data.append(cache_entry)
             cache.add_to_version_index(cache_entry)
 
@@ -1307,7 +1404,7 @@ class ModelScanner:
         if cache_modified:
             await self._persist_current_cache()
 
-        return True
+        return cache_entry if metadata else True
         
     def has_hash(self, sha256: str) -> bool:
         """Check if a model with given hash exists"""
@@ -1442,6 +1539,10 @@ class ModelScanner:
             deleted_models = []
             
             for file_path in file_paths:
+                if self.is_cancelled():
+                    logger.info(f"{self.model_type.capitalize()} Scanner: Bulk delete cancelled by user")
+                    break
+
                 try:
                     target_dir = os.path.dirname(file_path)
                     base_name = os.path.basename(file_path)
@@ -1482,6 +1583,7 @@ class ModelScanner:
                 
             return {
                 'success': True,
+                'status': 'cancelled' if self.is_cancelled() else 'success',
                 'total_deleted': total_deleted,
                 'total_attempted': len(file_paths),
                 'cache_updated': cache_updated,

py/services/model_service_factory.py

@@ -22,7 +22,6 @@ class ModelServiceFactory:
         """
         cls._services[model_type] = service_class
         cls._routes[model_type] = route_class
-        logger.info(f"Registered model type '{model_type}' with service {service_class.__name__} and routes {route_class.__name__}")
     
     @classmethod
     def get_service_class(cls, model_type: str) -> Type:
@@ -80,13 +79,10 @@ class ModelServiceFactory:
         Args:
             app: The aiohttp application instance
         """
-        logger.info(f"Setting up routes for {len(cls._services)} registered model types")
-        
         for model_type in cls._services.keys():
             try:
                 routes_instance = cls.get_route_instance(model_type)
                 routes_instance.setup_routes(app)
-                logger.info(f"Successfully set up routes for {model_type}")
             except Exception as e:
                 logger.error(f"Failed to setup routes for {model_type}: {e}", exc_info=True)
     
@@ -138,5 +134,3 @@ def register_default_model_types():
     
     # Register Embedding model type
     ModelServiceFactory.register_model_type('embedding', EmbeddingService, EmbeddingRoutes)
-    
-    logger.info("Registered default model types: lora, checkpoint, embedding")

py/services/model_update_service.py

@@ -466,6 +466,7 @@ class ModelUpdateService:
         target_model_ids: Optional[Sequence[int]] = None,
     ) -> Dict[int, ModelUpdateRecord]:
         """Refresh update information for every model present in the cache."""
+        scanner.reset_cancellation()
 
         normalized_targets = (
             self._normalize_sequence(target_model_ids)
@@ -542,6 +543,9 @@ class ModelUpdateService:
                 force_refresh=force_refresh,
                 prefetched_response=prefetched.get(model_id),
             )
+            if scanner.is_cancelled():
+                logger.info(f"{model_type.capitalize()} Update Service: Refresh cancelled by user")
+                return results
             if record:
                 results[model_id] = record
             if index % progress_interval == 0 or index == total_models:
@@ -585,6 +589,8 @@ class ModelUpdateService:
         model_type: str,
         model_id: int,
         version_ids: Sequence[int],
+        *,
+        version_info: Optional[Mapping] = None,
     ) -> ModelUpdateRecord:
         """Persist a new set of in-library version identifiers."""
 
@@ -596,6 +602,7 @@ class ModelUpdateService:
                 normalized_versions,
                 model_type=model_type,
                 model_id=model_id,
+                version_info=version_info,
             )
             self._upsert_record(record)
             return record
@@ -940,6 +947,7 @@ class ModelUpdateService:
         model_type: Optional[str] = None,
         model_id: Optional[int] = None,
         last_checked_at: Optional[float] = None,
+        version_info: Optional[Mapping] = None,
     ) -> ModelUpdateRecord:
         local_set = set(normalized_local)
         versions: List[ModelVersionRecord] = []
@@ -961,19 +969,26 @@ class ModelUpdateService:
 
         seen_ids = {version.version_id for version in versions}
         for missing_id in sorted(local_set - seen_ids):
-            versions.append(
-                ModelVersionRecord(
-                    version_id=missing_id,
-                    name=None,
-                    base_model=None,
-                    released_at=None,
-                    size_bytes=None,
-                    preview_url=None,
-                    is_in_library=True,
-                    should_ignore=ignore_map.get(missing_id, False),
-                    sort_index=len(versions),
+            new_version: Optional[ModelVersionRecord] = None
+            if version_info and _normalize_int(version_info.get("id")) == missing_id:
+                new_version = self._extract_single_version(version_info, index=len(versions))
+
+            if new_version:
+                versions.append(replace(new_version, is_in_library=True))
+            else:
+                versions.append(
+                    ModelVersionRecord(
+                        version_id=missing_id,
+                        name=None,
+                        base_model=None,
+                        released_at=None,
+                        size_bytes=None,
+                        preview_url=None,
+                        is_in_library=True,
+                        should_ignore=ignore_map.get(missing_id, False),
+                        sort_index=len(versions),
+                    )
                 )
-            )
 
         return ModelUpdateRecord(
             model_type=model_type,
@@ -1079,33 +1094,45 @@ class ModelUpdateService:
             return []
         if not isinstance(versions, Iterable):
             return None
+
         extracted: List[ModelVersionRecord] = []
         for index, entry in enumerate(versions):
-            if not isinstance(entry, Mapping):
-                continue
-            version_id = _normalize_int(entry.get("id"))
-            if version_id is None:
-                continue
-            name = _normalize_string(entry.get("name"))
-            base_model = _normalize_string(entry.get("baseModel"))
-            released_at = _normalize_string(entry.get("publishedAt") or entry.get("createdAt"))
-            size_bytes = self._extract_size_bytes(entry.get("files"))
-            preview_url = self._extract_preview_url(entry.get("images"))
-            extracted.append(
-                ModelVersionRecord(
-                    version_id=version_id,
-                    name=name,
-                    base_model=base_model,
-                    released_at=released_at,
-                    size_bytes=size_bytes,
-                    preview_url=preview_url,
-                    is_in_library=False,
-                    should_ignore=False,
-                    sort_index=index,
-                )
-            )
+            version_record = self._extract_single_version(entry, index)
+            if version_record:
+                extracted.append(version_record)
+
         return extracted
 
+    def _extract_single_version(
+        self, entry: Any, index: int = 0
+    ) -> Optional[ModelVersionRecord]:
+        """Convert a raw metadata entry into a structured record."""
+
+        if not isinstance(entry, Mapping):
+            return None
+
+        version_id = _normalize_int(entry.get("id"))
+        if version_id is None:
+            return None
+
+        name = _normalize_string(entry.get("name"))
+        base_model = _normalize_string(entry.get("baseModel"))
+        released_at = _normalize_string(entry.get("publishedAt") or entry.get("createdAt"))
+        size_bytes = self._extract_size_bytes(entry.get("files"))
+        preview_url = self._extract_preview_url(entry.get("images"))
+
+        return ModelVersionRecord(
+            version_id=version_id,
+            name=name,
+            base_model=base_model,
+            released_at=released_at,
+            size_bytes=size_bytes,
+            preview_url=preview_url,
+            is_in_library=False,
+            should_ignore=False,
+            sort_index=index,
+        )
+
     def _extract_size_bytes(self, files) -> Optional[int]:
         if not isinstance(files, Iterable):
             return None