feat(misc): add VAE and Upscaler model management page

The no-presets placeholder element has been removed from the filter presets section in the header component. This change likely indicates that the application now handles empty presets states differently, possibly through dynamic content rendering or alternative UI patterns.

.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,17 @@ Enhance your Civitai browsing experience with our companion browser extension! S
 
 ## Release Notes
 
+### 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/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": {
@@ -168,6 +179,7 @@
             "recipes": "Rezepte",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "Statistiken"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "LoRAs suchen...",
                 "recipes": "Rezepte suchen...",
                 "checkpoints": "Checkpoints suchen...",
-                "embeddings": "Embeddings suchen..."
+                "embeddings": "Embeddings suchen...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "Suchoptionen",
             "searchIn": "Suchen in:",
@@ -188,17 +201,30 @@
                 "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",
+            "noTags": "Keine Tags",
             "clearAll": "Alle Filter löschen"
         },
         "theme": {
@@ -221,7 +247,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 +333,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 +473,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 +551,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 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "Stammverzeichnis",
         "collapseAll": "Alle Ordner einklappen",
@@ -638,7 +712,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 +923,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 +948,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 +993,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",
@@ -1030,6 +1116,10 @@
             "title": "Statistiken werden initialisiert",
             "message": "Modelldaten für Statistiken werden verarbeitet. Dies kann einige Minuten dauern..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "Tipps & Tricks",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "Rezept zum Workflow hinzugefügt",
             "recipeReplaced": "Rezept im Workflow ersetzt",
             "recipeFailedToSend": "Fehler beim Senden des Rezepts an den Workflow",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "Keine kompatiblen Knoten im aktuellen Workflow verfügbar",
             "noTargetNodeSelected": "Kein Zielknoten ausgewählt"
         },
         "nodeSelector": {
             "recipe": "Rezept",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "Ersetzen",
             "append": "Anhängen",
             "selectTargetNode": "Zielknoten auswählen",
@@ -1103,7 +1199,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 +1252,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 +1418,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 +1432,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 +1453,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 +1559,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 +1577,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": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "Recipes",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "Misc",
             "statistics": "Stats"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "Search LoRAs...",
                 "recipes": "Search recipes...",
                 "checkpoints": "Search checkpoints...",
-                "embeddings": "Search embeddings..."
+                "embeddings": "Search embeddings...",
+                "misc": "Search VAE/Upscaler models..."
             },
             "options": "Search Options",
             "searchIn": "Search In:",
@@ -188,17 +201,30 @@
                 "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",
+            "noTags": "No tags",
             "clearAll": "Clear All Filters"
         },
         "theme": {
@@ -219,9 +245,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 +330,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": {
@@ -336,7 +366,7 @@
             "templateOptions": {
                 "flatStructure": "Flat Structure",
                 "byBaseModel": "By Base Model",
-                "byAuthor": "By Author", 
+                "byAuthor": "By Author",
                 "byFirstTag": "By First Tag",
                 "baseModelFirstTag": "Base Model + First Tag",
                 "baseModelAuthor": "Base Model + Author",
@@ -347,7 +377,7 @@
             "customTemplatePlaceholder": "Enter custom template (e.g., {base_model}/{author}/{first_tag})",
             "modelTypes": {
                 "lora": "LoRA",
-                "checkpoint": "Checkpoint", 
+                "checkpoint": "Checkpoint",
                 "embedding": "Embedding"
             },
             "baseModelPathMappings": "Base Model Path Mappings",
@@ -420,11 +450,11 @@
             "proxyHost": "Proxy Host",
             "proxyHostPlaceholder": "proxy.example.com",
             "proxyHostHelp": "The hostname or IP address of your proxy server",
-            "proxyPort": "Proxy Port", 
+            "proxyPort": "Proxy Port",
             "proxyPortPlaceholder": "8080",
             "proxyPortHelp": "The port number of your proxy server",
             "proxyUsername": "Username (Optional)",
-            "proxyUsernamePlaceholder": "username", 
+            "proxyUsernamePlaceholder": "username",
             "proxyUsernameHelp": "Username for proxy authentication (if required)",
             "proxyPassword": "Password (Optional)",
             "proxyPasswordPlaceholder": "password",
@@ -443,7 +473,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 +551,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 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "VAE",
+            "upscaler": "Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "Root",
         "collapseAll": "Collapse All Folders",
@@ -638,7 +712,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": {
@@ -848,7 +923,9 @@
             },
             "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",
@@ -871,11 +948,13 @@
                 "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"
+                "add": "Add",
+                "invalidRange": "Invalid range format. Use x.x-y.y"
             },
             "triggerWords": {
                 "label": "Trigger Words",
@@ -914,6 +993,13 @@
                 "recipes": "Recipes",
                 "versions": "Versions"
             },
+            "navigation": {
+                "label": "Model navigation",
+                "previousWithShortcut": "Previous model (←)",
+                "nextWithShortcut": "Next model (→)",
+                "noPrevious": "No previous model available",
+                "noNext": "No next model available"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "Initializing Statistics",
             "message": "Processing model data for statistics. This may take a few minutes..."
         },
+        "misc": {
+            "title": "Initializing Misc Model Manager",
+            "message": "Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "Tips & Tricks",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "Recipe appended to workflow",
             "recipeReplaced": "Recipe replaced in workflow",
             "recipeFailedToSend": "Failed to send recipe to workflow",
+            "vaeUpdated": "VAE updated in workflow",
+            "vaeFailed": "Failed to update VAE in workflow",
+            "upscalerUpdated": "Upscaler updated in workflow",
+            "upscalerFailed": "Failed to update upscaler in workflow",
             "noMatchingNodes": "No compatible nodes available in the current workflow",
             "noTargetNodeSelected": "No target node selected"
         },
         "nodeSelector": {
             "recipe": "Recipe",
             "lora": "LoRA",
+            "vae": "VAE",
+            "upscaler": "Upscaler",
             "replace": "Replace",
             "append": "Append",
             "selectTargetNode": "Select target node",
@@ -1103,7 +1199,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 +1252,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 +1418,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 +1432,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 +1453,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 +1559,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 +1577,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": {
@@ -1471,4 +1596,4 @@
             "learnMore": "LM Civitai Extension Tutorial"
         }
     }
-}
+}

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": {
@@ -168,6 +179,7 @@
             "recipes": "Recetas",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "Estadísticas"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "Buscar LoRAs...",
                 "recipes": "Buscar recetas...",
                 "checkpoints": "Buscar checkpoints...",
-                "embeddings": "Buscar embeddings..."
+                "embeddings": "Buscar embeddings...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "Opciones de búsqueda",
             "searchIn": "Buscar en:",
@@ -188,17 +201,30 @@
                 "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",
+            "noTags": "Sin etiquetas",
             "clearAll": "Limpiar todos los filtros"
         },
         "theme": {
@@ -221,7 +247,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 +333,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 +473,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 +551,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 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "Raíz",
         "collapseAll": "Colapsar todas las carpetas",
@@ -638,7 +712,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 +923,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 +948,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 +993,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",
@@ -1030,6 +1116,10 @@
             "title": "Inicializando estadísticas",
             "message": "Procesando datos del modelo para estadísticas. Esto puede tomar unos minutos..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "Consejos y trucos",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "Receta añadida al flujo de trabajo",
             "recipeReplaced": "Receta reemplazada en el flujo de trabajo",
             "recipeFailedToSend": "Error al enviar receta al flujo de trabajo",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "No hay nodos compatibles disponibles en el flujo de trabajo actual",
             "noTargetNodeSelected": "No se ha seleccionado ningún nodo de destino"
         },
         "nodeSelector": {
             "recipe": "Receta",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "Reemplazar",
             "append": "Añadir",
             "selectTargetNode": "Seleccionar nodo de destino",
@@ -1103,7 +1199,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 +1252,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 +1418,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 +1432,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 +1453,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 +1559,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 +1577,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": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "Recipes",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "Statistiques"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "Rechercher des LoRAs...",
                 "recipes": "Rechercher des recipes...",
                 "checkpoints": "Rechercher des checkpoints...",
-                "embeddings": "Rechercher des embeddings..."
+                "embeddings": "Rechercher des embeddings...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "Options de recherche",
             "searchIn": "Rechercher dans :",
@@ -188,17 +201,30 @@
                 "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",
+            "noTags": "Aucun tag",
             "clearAll": "Effacer tous les filtres"
         },
         "theme": {
@@ -221,7 +247,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 +333,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 +473,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 +551,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 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "Racine",
         "collapseAll": "Réduire tous les dossiers",
@@ -638,7 +712,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 +923,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 +948,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 +993,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",
@@ -1030,6 +1116,10 @@
             "title": "Initialisation des statistiques",
             "message": "Traitement des données de modèle pour les statistiques. Cela peut prendre quelques minutes..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "Astuces et conseils",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "Recipe ajoutée au workflow",
             "recipeReplaced": "Recipe remplacée dans le workflow",
             "recipeFailedToSend": "Échec de l'envoi de la recipe au workflow",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "Aucun nœud compatible disponible dans le workflow actuel",
             "noTargetNodeSelected": "Aucun nœud cible sélectionné"
         },
         "nodeSelector": {
             "recipe": "Recipe",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "Remplacer",
             "append": "Ajouter",
             "selectTargetNode": "Sélectionner le nœud cible",
@@ -1103,7 +1199,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 +1252,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 +1418,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 +1432,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 +1453,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 +1559,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 +1577,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": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "מתכונים",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "סטטיסטיקה"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "חפש LoRAs...",
                 "recipes": "חפש מתכונים...",
                 "checkpoints": "חפש checkpoints...",
-                "embeddings": "חפש embeddings..."
+                "embeddings": "חפש embeddings...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "אפשרויות חיפוש",
             "searchIn": "חפש ב:",
@@ -188,17 +201,30 @@
                 "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": "אפשר מכירה",
+            "noTags": "ללא תגיות",
             "clearAll": "נקה את כל המסננים"
         },
         "theme": {
@@ -221,13 +247,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 +264,7 @@
             "misc": "שונות",
             "metadataArchive": "מסד נתונים של ארכיון מטא-דאטה",
             "storageLocation": "מיקום ההגדרות",
-            "proxySettings": "הגדרות פרוקסי",
-            "priorityTags": "תגיות עדיפות"
+            "proxySettings": "הגדרות פרוקסי"
         },
         "storage": {
             "locationLabel": "מצב נייד",
@@ -298,17 +326,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 +370,8 @@
                 "byFirstTag": "לפי תגית ראשונה",
                 "baseModelFirstTag": "מודל בסיס + תגית ראשונה",
                 "baseModelAuthor": "מודל בסיס + יוצר",
-                "baseModelAuthorFirstTag": "מודל בסיס + יוצר + תגית ראשונה",
                 "authorFirstTag": "יוצר + תגית ראשונה",
+                "baseModelAuthorFirstTag": "מודל בסיס + יוצר + תגית ראשונה",
                 "customTemplate": "תבנית מותאמת אישית"
             },
             "customTemplatePlaceholder": "הזן תבנית מותאמת אישית (למשל, {base_model}/{author}/{first_tag})",
@@ -409,26 +459,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 +473,10 @@
                 "dateAsc": "הישן ביותר",
                 "size": "גודל קובץ",
                 "sizeDesc": "הגדול ביותר",
-                "sizeAsc": "הקטן ביותר"
+                "sizeAsc": "הקטן ביותר",
+                "usage": "מספר שימושים",
+                "usageDesc": "הכי הרבה",
+                "usageAsc": "הכי פחות"
             },
             "refresh": {
                 "title": "רענן רשימת מודלים",
@@ -518,6 +551,7 @@
             "replacePreview": "החלף תצוגה מקדימה",
             "setContentRating": "הגדר דירוג תוכן",
             "moveToFolder": "העבר לתיקייה",
+            "repairMetadata": "תיקון מטא-דאטה",
             "excludeModel": "החרג מודל",
             "deleteModel": "מחק מודל",
             "shareRecipe": "שתף מתכון",
@@ -588,10 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "שורש",
         "collapseAll": "כווץ את כל התיקיות",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "חיפוש רקורסיבי זמין רק בתצוגת עץ",
         "collapseAllDisabled": "לא זמין בתצוגת רשימה",
         "dragDrop": {
-            "unableToResolveRoot": "לא ניתן לקבוע את נתיב היעד להעברה."
+            "unableToResolveRoot": "לא ניתן לקבוע את נתיב היעד להעברה.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "מיקום הקובץ נפתח בהצלחה",
-                "failed": "פתיחת מיקום הקובץ נכשלה"
+                "failed": "פתיחת מיקום הקובץ נכשלה",
+                "copied": "הנתיב הועתק ללוח העריכה: {{path}}",
+                "clipboardFallback": "נתיב: {{path}}"
             },
             "metadata": {
                 "version": "גרסה",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "הוסף פרמטר קבוע מראש...",
                 "strengthMin": "חוזק מינימלי",
                 "strengthMax": "חוזק מקסימלי",
+                "strengthRange": "טווח עוצמה",
                 "strength": "חוזק",
                 "clipStrength": "עוצמת CLIP",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "ערך",
-                "add": "הוסף"
+                "add": "הוסף",
+                "invalidRange": "פורמט טווח לא תקין. השתמש ב-x.x-y.y"
             },
             "triggerWords": {
                 "label": "מילות טריגר",
@@ -914,6 +993,13 @@
                 "recipes": "מתכונים",
                 "versions": "גרסאות"
             },
+            "navigation": {
+                "label": "ניווט מודלים",
+                "previousWithShortcut": "המודל הקודם (←)",
+                "nextWithShortcut": "המודל הבא (→)",
+                "noPrevious": "אין מודל קודם זמין",
+                "noNext": "אין מודל נוסף זמין"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "מאתחל סטטיסטיקה",
             "message": "מעבד נתוני מודלים עבור סטטיסטיקה. זה עשוי לקחת מספר דקות..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "טיפים וטריקים",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "מתכון נוסף ל-workflow",
             "recipeReplaced": "מתכון הוחלף ב-workflow",
             "recipeFailedToSend": "שליחת מתכון ל-workflow נכשלה",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "אין צמתים תואמים זמינים ב-workflow הנוכחי",
             "noTargetNodeSelected": "לא נבחר צומת יעד"
         },
         "nodeSelector": {
             "recipe": "מתכון",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "החלף",
             "append": "הוסף",
             "selectTargetNode": "בחר צומת יעד",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "תיקיית תמונות הדוגמה נפתחה",
             "openingFolder": "פותח תיקיית תמונות דוגמה",
-            "failedToOpen": "פתיחת תיקיית תמונות הדוגמה נכשלה"
+            "failedToOpen": "פתיחת תיקיית תמונות הדוגמה נכשלה",
+            "setupRequired": "אחסון תמונות דוגמה",
+            "setupDescription": "כדי להוסיף תמונות דוגמה מותאמות אישית, עליך קודם להגדיר מיקום הורדה.",
+            "setupUsage": "נתיב זה משמש הן עבור תמונות דוגמה שהורדו והן עבור תמונות מותאמות אישית.",
+            "openSettings": "פתח הגדרות"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "בודק עדכונים...",
         "checkingMessage": "אנא המתן בזמן שאנו בודקים את הגרסה האחרונה.",
         "showNotifications": "הצג התראות עדכון",
+        "latestBadge": "עדכן",
         "updateProgress": {
             "preparing": "מכין עדכון...",
             "installing": "מתקין עדכון...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "האימות הושלם. כל הקבצים אושרו ככפולים.",
             "verificationFailed": "אימות ה-hashes נכשל: {message}",
             "noTagsToAdd": "אין תגיות להוספה",
+            "bulkTagsUpdating": "מעדכן תגיות עבור {count} מודלים...",
             "tagsAddedSuccessfully": "נוספו בהצלחה {tagCount} תגית(ות) ל-{count} {type}(ים)",
             "tagsReplacedSuccessfully": "הוחלפו בהצלחה תגיות עבור {count} {type}(ים) ב-{tagCount} תגית(ות)",
             "tagsAddFailed": "הוספת תגיות ל-{count} מודל(ים) נכשלה",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "טעינת שורשי LoRA נכשלה: {message}",
             "checkpointRootsFailed": "טעינת שורשי checkpoint נכשלה: {message}",
+            "unetRootsFailed": "טעינת שורשי Diffusion Model נכשלה: {message}",
             "embeddingRootsFailed": "טעינת שורשי embedding נכשלה: {message}",
             "mappingsUpdated": "מיפויי נתיבי מודל בסיס עודכנו ({count} מיפוי{plural})",
             "mappingsCleared": "מיפויי נתיבי מודל בסיס נוקו",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "המטא-דאטה רועננה בהצלחה",
             "metadataRefreshFailed": "רענון המטא-דאטה נכשל: {message}",
             "metadataUpdateComplete": "עדכון המטא-דאטה הושלם",
+            "operationCancelled": "הפעולה בוטלה על ידי המשתמש",
+            "operationCancelledPartial": "הפעולה בוטלה. {success} פריטים עובדו.",
             "metadataFetchFailed": "אחזור המטא-דאטה נכשל: {message}",
             "bulkMetadataCompleteAll": "רועננו בהצלחה כל {count} ה-{type}s",
             "bulkMetadataCompletePartial": "רועננו {success} מתוך {total} {type}s",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "העברות שנכשלו:\n{failures}",
             "bulkMoveSuccess": "הועברו בהצלחה {successCount} {type}s",
             "exampleImagesDownloadSuccess": "תמונות הדוגמה הורדו בהצלחה!",
-            "exampleImagesDownloadFailed": "הורדת תמונות הדוגמה נכשלה: {message}"
+            "exampleImagesDownloadFailed": "הורדת תמונות הדוגמה נכשלה: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "レシピ",
             "checkpoints": "Checkpoint",
             "embeddings": "Embedding",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "統計"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "LoRAを検索...",
                 "recipes": "レシピを検索...",
                 "checkpoints": "checkpointを検索...",
-                "embeddings": "embeddingを検索..."
+                "embeddings": "embeddingを検索...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "検索オプション",
             "searchIn": "検索対象：",
@@ -188,17 +201,30 @@
                 "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": "販売許可",
+            "noTags": "タグなし",
             "clearAll": "すべてのフィルタをクリア"
         },
         "theme": {
@@ -221,7 +247,9 @@
             "label": "設定フォルダーを開く",
             "tooltip": "settings.json を含むフォルダーを開きます",
             "success": "settings.json フォルダーを開きました",
-            "failed": "settings.json フォルダーを開けませんでした"
+            "failed": "settings.json フォルダーを開けませんでした",
+            "copied": "設定パスをクリップボードにコピーしました: {{path}}",
+            "clipboardFallback": "設定パス: {{path}}"
         },
         "sections": {
             "contentFiltering": "コンテンツフィルタリング",
@@ -305,6 +333,8 @@
             "defaultLoraRootHelp": "ダウンロード、インポート、移動用のデフォルトLoRAルートディレクトリを設定",
             "defaultCheckpointRoot": "デフォルトCheckpointルート",
             "defaultCheckpointRootHelp": "ダウンロード、インポート、移動用のデフォルトcheckpointルートディレクトリを設定",
+            "defaultUnetRoot": "デフォルトDiffusion Modelルート",
+            "defaultUnetRootHelp": "ダウンロード、インポート、移動用のデフォルトDiffusion Model (UNET)ルートディレクトリを設定",
             "defaultEmbeddingRoot": "デフォルトEmbeddingルート",
             "defaultEmbeddingRootHelp": "ダウンロード、インポート、移動用のデフォルトembeddingルートディレクトリを設定",
             "noDefault": "デフォルトなし"
@@ -443,7 +473,10 @@
                 "dateAsc": "古い順",
                 "size": "ファイルサイズ",
                 "sizeDesc": "大きい順",
-                "sizeAsc": "小さい順"
+                "sizeAsc": "小さい順",
+                "usage": "使用回数",
+                "usageDesc": "多い",
+                "usageAsc": "少ない"
             },
             "refresh": {
                 "title": "モデルリストを更新",
@@ -518,6 +551,7 @@
             "replacePreview": "プレビューを置換",
             "setContentRating": "コンテンツレーティングを設定",
             "moveToFolder": "フォルダに移動",
+            "repairMetadata": "メタデータを修復",
             "excludeModel": "モデルを除外",
             "deleteModel": "モデルを削除",
             "shareRecipe": "レシピを共有",
@@ -588,10 +622,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,15 +667,39 @@
                 "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モデル"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "ルート",
         "collapseAll": "すべてのフォルダを折りたたむ",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "再帰検索はツリービューでのみ利用できます",
         "collapseAllDisabled": "リストビューでは利用できません",
         "dragDrop": {
-            "unableToResolveRoot": "移動先のパスを特定できません。"
+            "unableToResolveRoot": "移動先のパスを特定できません。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "ファイルの場所を正常に開きました",
-                "failed": "ファイルの場所を開くのに失敗しました"
+                "failed": "ファイルの場所を開くのに失敗しました",
+                "copied": "パスをクリップボードにコピーしました: {{path}}",
+                "clipboardFallback": "パス: {{path}}"
             },
             "metadata": {
                 "version": "バージョン",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "プリセットパラメータを追加...",
                 "strengthMin": "強度最小",
                 "strengthMax": "強度最大",
+                "strengthRange": "強度範囲",
                 "strength": "強度",
                 "clipStrength": "クリップ強度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "値",
-                "add": "追加"
+                "add": "追加",
+                "invalidRange": "無効な範囲形式です。x.x-y.y を使用してください"
             },
             "triggerWords": {
                 "label": "トリガーワード",
@@ -914,6 +993,13 @@
                 "recipes": "レシピ",
                 "versions": "バージョン"
             },
+            "navigation": {
+                "label": "モデルナビゲーション",
+                "previousWithShortcut": "前のモデル（←）",
+                "nextWithShortcut": "次のモデル（→）",
+                "noPrevious": "前のモデルがありません",
+                "noNext": "次のモデルがありません"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "統計を初期化中",
             "message": "統計用のモデルデータを処理中。数分かかる場合があります..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "ヒント&コツ",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "レシピがワークフローに追加されました",
             "recipeReplaced": "レシピがワークフローで置換されました",
             "recipeFailedToSend": "レシピをワークフローに送信できませんでした",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "現在のワークフローには互換性のあるノードがありません",
             "noTargetNodeSelected": "ターゲットノードが選択されていません"
         },
         "nodeSelector": {
             "recipe": "レシピ",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "置換",
             "append": "追加",
             "selectTargetNode": "ターゲットノードを選択",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "例画像フォルダが開かれました",
             "openingFolder": "例画像フォルダを開いています",
-            "failedToOpen": "例画像フォルダを開くのに失敗しました"
+            "failedToOpen": "例画像フォルダを開くのに失敗しました",
+            "setupRequired": "例画像ストレージ",
+            "setupDescription": "カスタム例画像を追加するには、まずダウンロード場所を設定する必要があります。",
+            "setupUsage": "このパスは、ダウンロードした例画像とカスタム画像の両方に使用されます。",
+            "openSettings": "設定を開く"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "更新を確認中...",
         "checkingMessage": "最新バージョンを確認しています。お待ちください。",
         "showNotifications": "更新通知を表示",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "更新を準備中...",
             "installing": "更新をインストール中...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "検証完了。すべてのファイルが重複であることが確認されました。",
             "verificationFailed": "ハッシュの検証に失敗しました：{message}",
             "noTagsToAdd": "追加するタグがありません",
+            "bulkTagsUpdating": "{count} 個のモデルのタグを更新しています...",
             "tagsAddedSuccessfully": "{count} {type} に {tagCount} 個のタグを追加しました",
             "tagsReplacedSuccessfully": "{count} {type} のタグを {tagCount} 個に置換しました",
             "tagsAddFailed": "{count} モデルへのタグ追加に失敗しました",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "LoRAルートの読み込みに失敗しました：{message}",
             "checkpointRootsFailed": "checkpointルートの読み込みに失敗しました：{message}",
+            "unetRootsFailed": "Diffusion Modelルートの読み込みに失敗しました：{message}",
             "embeddingRootsFailed": "embeddingルートの読み込みに失敗しました：{message}",
             "mappingsUpdated": "ベースモデルパスマッピングが更新されました（{count} マッピング{plural}）",
             "mappingsCleared": "ベースモデルパスマッピングがクリアされました",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "メタデータが正常に更新されました",
             "metadataRefreshFailed": "メタデータの更新に失敗しました：{message}",
             "metadataUpdateComplete": "メタデータ更新完了",
+            "operationCancelled": "ユーザーによって操作がキャンセルされました",
+            "operationCancelledPartial": "操作がキャンセルされました。{success} 個の項目が処理されました。",
             "metadataFetchFailed": "メタデータの取得に失敗しました：{message}",
             "bulkMetadataCompleteAll": "{count} {type}すべてが正常に更新されました",
             "bulkMetadataCompletePartial": "{total} {type}のうち {success} が更新されました",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "失敗した移動：\n{failures}",
             "bulkMoveSuccess": "{successCount} {type}が正常に移動されました",
             "exampleImagesDownloadSuccess": "例画像が正常にダウンロードされました！",
-            "exampleImagesDownloadFailed": "例画像のダウンロードに失敗しました：{message}"
+            "exampleImagesDownloadFailed": "例画像のダウンロードに失敗しました：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "레시피",
             "checkpoints": "Checkpoint",
             "embeddings": "Embedding",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "통계"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "LoRA 검색...",
                 "recipes": "레시피 검색...",
                 "checkpoints": "Checkpoint 검색...",
-                "embeddings": "Embedding 검색..."
+                "embeddings": "Embedding 검색...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "검색 옵션",
             "searchIn": "검색 범위:",
@@ -188,17 +201,30 @@
                 "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": "판매 허용",
+            "noTags": "태그 없음",
             "clearAll": "모든 필터 지우기"
         },
         "theme": {
@@ -221,7 +247,9 @@
             "label": "설정 폴더 열기",
             "tooltip": "settings.json이 있는 폴더를 엽니다",
             "success": "settings.json 폴더를 열었습니다",
-            "failed": "settings.json 폴더를 열지 못했습니다"
+            "failed": "settings.json 폴더를 열지 못했습니다",
+            "copied": "설정 경로가 클립보드에 복사되었습니다: {{path}}",
+            "clipboardFallback": "설정 경로: {{path}}"
         },
         "sections": {
             "contentFiltering": "콘텐츠 필터링",
@@ -305,6 +333,8 @@
             "defaultLoraRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 LoRA 루트 디렉토리를 설정합니다",
             "defaultCheckpointRoot": "기본 Checkpoint 루트",
             "defaultCheckpointRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Checkpoint 루트 디렉토리를 설정합니다",
+            "defaultUnetRoot": "기본 Diffusion Model 루트",
+            "defaultUnetRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Diffusion Model (UNET) 루트 디렉토리를 설정합니다",
             "defaultEmbeddingRoot": "기본 Embedding 루트",
             "defaultEmbeddingRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Embedding 루트 디렉토리를 설정합니다",
             "noDefault": "기본값 없음"
@@ -443,7 +473,10 @@
                 "dateAsc": "오래된순",
                 "size": "파일 크기",
                 "sizeDesc": "큰 순서",
-                "sizeAsc": "작은 순서"
+                "sizeAsc": "작은 순서",
+                "usage": "사용 횟수",
+                "usageDesc": "많은 순",
+                "usageAsc": "적은 순"
             },
             "refresh": {
                 "title": "모델 목록 새로고침",
@@ -518,6 +551,7 @@
             "replacePreview": "미리보기 교체",
             "setContentRating": "콘텐츠 등급 설정",
             "moveToFolder": "폴더로 이동",
+            "repairMetadata": "메타데이터 복구",
             "excludeModel": "모델 제외",
             "deleteModel": "모델 삭제",
             "shareRecipe": "레시피 공유",
@@ -588,10 +622,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,15 +667,39 @@
                 "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 모델"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "루트",
         "collapseAll": "모든 폴더 접기",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "재귀 검색은 트리 보기에서만 사용할 수 있습니다",
         "collapseAllDisabled": "목록 보기에서는 사용할 수 없습니다",
         "dragDrop": {
-            "unableToResolveRoot": "이동할 대상 경로를 확인할 수 없습니다."
+            "unableToResolveRoot": "이동할 대상 경로를 확인할 수 없습니다.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "파일 위치가 성공적으로 열렸습니다",
-                "failed": "파일 위치 열기에 실패했습니다"
+                "failed": "파일 위치 열기에 실패했습니다",
+                "copied": "경로가 클립보드에 복사되었습니다: {{path}}",
+                "clipboardFallback": "경로: {{path}}"
             },
             "metadata": {
                 "version": "버전",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "프리셋 매개변수 추가...",
                 "strengthMin": "최소 강도",
                 "strengthMax": "최대 강도",
+                "strengthRange": "강도 범위",
                 "strength": "강도",
                 "clipStrength": "클립 강도",
                 "clipSkip": "클립 스킵",
                 "valuePlaceholder": "값",
-                "add": "추가"
+                "add": "추가",
+                "invalidRange": "잘못된 범위 형식입니다. x.x-y.y를 사용하세요"
             },
             "triggerWords": {
                 "label": "트리거 단어",
@@ -914,6 +993,13 @@
                 "recipes": "레시피",
                 "versions": "버전"
             },
+            "navigation": {
+                "label": "모델 탐색",
+                "previousWithShortcut": "이전 모델(←)",
+                "nextWithShortcut": "다음 모델(→)",
+                "noPrevious": "이전 모델이 없습니다",
+                "noNext": "다음 모델이 없습니다"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "통계 초기화 중",
             "message": "통계를 위한 모델 데이터를 처리하고 있습니다. 몇 분이 걸릴 수 있습니다..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "팁 & 요령",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "레시피가 워크플로에 추가되었습니다",
             "recipeReplaced": "레시피가 워크플로에서 교체되었습니다",
             "recipeFailedToSend": "레시피를 워크플로로 전송하지 못했습니다",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "현재 워크플로에서 호환되는 노드가 없습니다",
             "noTargetNodeSelected": "대상 노드가 선택되지 않았습니다"
         },
         "nodeSelector": {
             "recipe": "레시피",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "교체",
             "append": "추가",
             "selectTargetNode": "대상 노드 선택",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "예시 이미지 폴더가 열렸습니다",
             "openingFolder": "예시 이미지 폴더를 여는 중",
-            "failedToOpen": "예시 이미지 폴더 열기 실패"
+            "failedToOpen": "예시 이미지 폴더 열기 실패",
+            "setupRequired": "예시 이미지 저장소",
+            "setupDescription": "사용자 지정 예시 이미지를 추가하려면 먼저 다운로드 위치를 설정해야 합니다.",
+            "setupUsage": "이 경로는 다운로드한 예시 이미지와 사용자 지정 이미지 모두에 사용됩니다.",
+            "openSettings": "설정 열기"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "업데이트 확인 중...",
         "checkingMessage": "최신 버전을 확인하는 동안 잠시 기다려주세요.",
         "showNotifications": "업데이트 알림 표시",
+        "latestBadge": "최신",
         "updateProgress": {
             "preparing": "업데이트 준비 중...",
             "installing": "업데이트 설치 중...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "검증 완료. 모든 파일이 중복임을 확인했습니다.",
             "verificationFailed": "해시 검증 실패: {message}",
             "noTagsToAdd": "추가할 태그가 없습니다",
+            "bulkTagsUpdating": "{count}개 모델의 태그를 업데이트 중입니다...",
             "tagsAddedSuccessfully": "{count}개의 {type}에 {tagCount}개의 태그가 성공적으로 추가되었습니다",
             "tagsReplacedSuccessfully": "{count}개의 {type}의 태그가 {tagCount}개의 태그로 성공적으로 교체되었습니다",
             "tagsAddFailed": "{count}개의 모델에 태그 추가에 실패했습니다",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "LoRA 루트 로딩 실패: {message}",
             "checkpointRootsFailed": "Checkpoint 루트 로딩 실패: {message}",
+            "unetRootsFailed": "Diffusion Model 루트 로딩 실패: {message}",
             "embeddingRootsFailed": "Embedding 루트 로딩 실패: {message}",
             "mappingsUpdated": "베이스 모델 경로 매핑이 업데이트되었습니다 ({count}개 매핑)",
             "mappingsCleared": "베이스 모델 경로 매핑이 지워졌습니다",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "메타데이터가 성공적으로 새로고침되었습니다",
             "metadataRefreshFailed": "메타데이터 새로고침 실패: {message}",
             "metadataUpdateComplete": "메타데이터 업데이트 완료",
+            "operationCancelled": "사용자에 의해 작업이 취소되었습니다",
+            "operationCancelledPartial": "작업이 취소되었습니다. {success}개 항목이 처리되었습니다.",
             "metadataFetchFailed": "메타데이터 가져오기 실패: {message}",
             "bulkMetadataCompleteAll": "모든 {count}개 {type}이(가) 성공적으로 새로고침되었습니다",
             "bulkMetadataCompletePartial": "{total}개 중 {success}개 {type}이(가) 새로고침되었습니다",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "실패한 이동:\n{failures}",
             "bulkMoveSuccess": "{successCount}개 {type}이(가) 성공적으로 이동되었습니다",
             "exampleImagesDownloadSuccess": "예시 이미지가 성공적으로 다운로드되었습니다!",
-            "exampleImagesDownloadFailed": "예시 이미지 다운로드 실패: {message}"
+            "exampleImagesDownloadFailed": "예시 이미지 다운로드 실패: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "Рецепты",
             "checkpoints": "Checkpoints",
             "embeddings": "Embeddings",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "Статистика"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "Поиск LoRAs...",
                 "recipes": "Поиск рецептов...",
                 "checkpoints": "Поиск checkpoints...",
-                "embeddings": "Поиск embeddings..."
+                "embeddings": "Поиск embeddings...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "Опции поиска",
             "searchIn": "Искать в:",
@@ -188,17 +201,30 @@
                 "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": "Продажа разрешена",
+            "noTags": "Без тегов",
             "clearAll": "Очистить все фильтры"
         },
         "theme": {
@@ -221,7 +247,9 @@
             "label": "Открыть папку настроек",
             "tooltip": "Открыть папку, содержащую settings.json",
             "success": "Папка settings.json открыта",
-            "failed": "Не удалось открыть папку settings.json"
+            "failed": "Не удалось открыть папку settings.json",
+            "copied": "Путь настроек скопирован в буфер обмена: {{path}}",
+            "clipboardFallback": "Путь настроек: {{path}}"
         },
         "sections": {
             "contentFiltering": "Фильтрация контента",
@@ -305,6 +333,8 @@
             "defaultLoraRootHelp": "Установить корневую папку LoRA по умолчанию для загрузок, импорта и перемещений",
             "defaultCheckpointRoot": "Корневая папка Checkpoint по умолчанию",
             "defaultCheckpointRootHelp": "Установить корневую папку checkpoint по умолчанию для загрузок, импорта и перемещений",
+            "defaultUnetRoot": "Корневая папка Diffusion Model по умолчанию",
+            "defaultUnetRootHelp": "Установить корневую папку Diffusion Model (UNET) по умолчанию для загрузок, импорта и перемещений",
             "defaultEmbeddingRoot": "Корневая папка Embedding по умолчанию",
             "defaultEmbeddingRootHelp": "Установить корневую папку embedding по умолчанию для загрузок, импорта и перемещений",
             "noDefault": "Не задано"
@@ -443,7 +473,10 @@
                 "dateAsc": "Старейшим",
                 "size": "Размеру файла",
                 "sizeDesc": "Наибольшим",
-                "sizeAsc": "Наименьшим"
+                "sizeAsc": "Наименьшим",
+                "usage": "Число использований",
+                "usageDesc": "Больше",
+                "usageAsc": "Меньше"
             },
             "refresh": {
                 "title": "Обновить список моделей",
@@ -518,6 +551,7 @@
             "replacePreview": "Заменить превью",
             "setContentRating": "Установить рейтинг контента",
             "moveToFolder": "Переместить в папку",
+            "repairMetadata": "Восстановить метаданные",
             "excludeModel": "Исключить модель",
             "deleteModel": "Удалить модель",
             "shareRecipe": "Поделиться рецептом",
@@ -588,10 +622,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,15 +667,39 @@
                 "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"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "Корень",
         "collapseAll": "Свернуть все папки",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "Рекурсивный поиск доступен только в режиме дерева",
         "collapseAllDisabled": "Недоступно в виде списка",
         "dragDrop": {
-            "unableToResolveRoot": "Не удалось определить путь назначения для перемещения."
+            "unableToResolveRoot": "Не удалось определить путь назначения для перемещения.",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "Расположение файла успешно открыто",
-                "failed": "Не удалось открыть расположение файла"
+                "failed": "Не удалось открыть расположение файла",
+                "copied": "Путь скопирован в буфер обмена: {{path}}",
+                "clipboardFallback": "Путь: {{path}}"
             },
             "metadata": {
                 "version": "Версия",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "Добавить предустановленный параметр...",
                 "strengthMin": "Мин. сила",
                 "strengthMax": "Макс. сила",
+                "strengthRange": "Диапазон силы",
                 "strength": "Сила",
                 "clipStrength": "Сила клипа",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "Значение",
-                "add": "Добавить"
+                "add": "Добавить",
+                "invalidRange": "Неверный формат диапазона. Используйте x.x-y.y"
             },
             "triggerWords": {
                 "label": "Триггерные слова",
@@ -914,6 +993,13 @@
                 "recipes": "Рецепты",
                 "versions": "Версии"
             },
+            "navigation": {
+                "label": "Навигация по моделям",
+                "previousWithShortcut": "Предыдущая модель (←)",
+                "nextWithShortcut": "Следующая модель (→)",
+                "noPrevious": "Предыдущая модель отсутствует",
+                "noNext": "Следующая модель отсутствует"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "Инициализация статистики",
             "message": "Обработка данных моделей для статистики. Это может занять несколько минут..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "Советы и хитрости",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "Рецепт добавлен в workflow",
             "recipeReplaced": "Рецепт заменён в workflow",
             "recipeFailedToSend": "Не удалось отправить рецепт в workflow",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "В текущем workflow нет совместимых узлов",
             "noTargetNodeSelected": "Целевой узел не выбран"
         },
         "nodeSelector": {
             "recipe": "Рецепт",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "Заменить",
             "append": "Добавить",
             "selectTargetNode": "Выберите целевой узел",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "Папка с примерами изображений открыта",
             "openingFolder": "Открытие папки с примерами изображений",
-            "failedToOpen": "Не удалось открыть папку с примерами изображений"
+            "failedToOpen": "Не удалось открыть папку с примерами изображений",
+            "setupRequired": "Хранилище примеров изображений",
+            "setupDescription": "Чтобы добавить собственные примеры изображений, сначала нужно установить место загрузки.",
+            "setupUsage": "Этот путь используется как для загруженных, так и для пользовательских примеров изображений.",
+            "openSettings": "Открыть настройки"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "Проверка обновлений...",
         "checkingMessage": "Пожалуйста, подождите, пока мы проверяем последнюю версию.",
         "showNotifications": "Показывать уведомления об обновлениях",
+        "latestBadge": "Последний",
         "updateProgress": {
             "preparing": "Подготовка обновления...",
             "installing": "Установка обновления...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "Проверка завершена. Все файлы подтверждены как дубликаты.",
             "verificationFailed": "Не удалось проверить хеши: {message}",
             "noTagsToAdd": "Нет тегов для добавления",
+            "bulkTagsUpdating": "Обновление тегов для {count} модел(ей)...",
             "tagsAddedSuccessfully": "Успешно добавлено {tagCount} тег(ов) к {count} {type}(ам)",
             "tagsReplacedSuccessfully": "Успешно заменены теги для {count} {type}(ов) на {tagCount} тег(ов)",
             "tagsAddFailed": "Не удалось добавить теги к {count} модель(ям)",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "Не удалось загрузить корни LoRA: {message}",
             "checkpointRootsFailed": "Не удалось загрузить корни checkpoint: {message}",
+            "unetRootsFailed": "Не удалось загрузить корни Diffusion Model: {message}",
             "embeddingRootsFailed": "Не удалось загрузить корни embedding: {message}",
             "mappingsUpdated": "Сопоставления путей базовых моделей обновлены ({count} сопоставлени{plural})",
             "mappingsCleared": "Сопоставления путей базовых моделей очищены",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "Метаданные успешно обновлены",
             "metadataRefreshFailed": "Не удалось обновить метаданные: {message}",
             "metadataUpdateComplete": "Обновление метаданных завершено",
+            "operationCancelled": "Операция отменена пользователем",
+            "operationCancelledPartial": "Операция отменена. Обработано {success} элементов.",
             "metadataFetchFailed": "Не удалось получить метаданные: {message}",
             "bulkMetadataCompleteAll": "Успешно обновлены все {count} {type}s",
             "bulkMetadataCompletePartial": "Обновлено {success} из {total} {type}s",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "Неудачные перемещения:\n{failures}",
             "bulkMoveSuccess": "Успешно перемещено {successCount} {type}s",
             "exampleImagesDownloadSuccess": "Примеры изображений успешно загружены!",
-            "exampleImagesDownloadFailed": "Не удалось загрузить примеры изображений: {message}"
+            "exampleImagesDownloadFailed": "Не удалось загрузить примеры изображений: {message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "配方",
             "checkpoints": "Checkpoint",
             "embeddings": "Embedding",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "统计"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "搜索 LoRA...",
                 "recipes": "搜索配方...",
                 "checkpoints": "搜索 Checkpoint...",
-                "embeddings": "搜索 Embedding..."
+                "embeddings": "搜索 Embedding...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "搜索选项",
             "searchIn": "搜索范围：",
@@ -188,17 +201,30 @@
                 "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": "允许销售",
+            "noTags": "无标签",
             "clearAll": "清除所有筛选"
         },
         "theme": {
@@ -221,7 +247,9 @@
             "label": "打开设置文件夹",
             "tooltip": "打开包含 settings.json 的文件夹",
             "success": "已打开 settings.json 文件夹",
-            "failed": "无法打开 settings.json 文件夹"
+            "failed": "无法打开 settings.json 文件夹",
+            "copied": "设置路径已复制到剪贴板：{{path}}",
+            "clipboardFallback": "设置路径：{{path}}"
         },
         "sections": {
             "contentFiltering": "内容过滤",
@@ -305,6 +333,8 @@
             "defaultLoraRootHelp": "设置下载、导入和移动时的默认 LoRA 根目录",
             "defaultCheckpointRoot": "默认 Checkpoint 根目录",
             "defaultCheckpointRootHelp": "设置下载、导入和移动时的默认 Checkpoint 根目录",
+            "defaultUnetRoot": "默认 Diffusion Model 根目录",
+            "defaultUnetRootHelp": "设置下载、导入和移动时的默认 Diffusion Model (UNET) 根目录",
             "defaultEmbeddingRoot": "默认 Embedding 根目录",
             "defaultEmbeddingRootHelp": "设置下载、导入和移动时的默认 Embedding 根目录",
             "noDefault": "无默认"
@@ -443,7 +473,10 @@
                 "dateAsc": "最旧",
                 "size": "文件大小",
                 "sizeDesc": "最大",
-                "sizeAsc": "最小"
+                "sizeAsc": "最小",
+                "usage": "使用次数",
+                "usageDesc": "最多",
+                "usageAsc": "最少"
             },
             "refresh": {
                 "title": "刷新模型列表",
@@ -518,6 +551,7 @@
             "replacePreview": "替换预览",
             "setContentRating": "设置内容评级",
             "moveToFolder": "移动到文件夹",
+            "repairMetadata": "修复元数据",
             "excludeModel": "排除模型",
             "deleteModel": "删除模型",
             "shareRecipe": "分享配方",
@@ -588,10 +622,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,15 +667,39 @@
                 "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 模型"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "根目录",
         "collapseAll": "折叠所有文件夹",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "仅在树形视图中可使用递归搜索",
         "collapseAllDisabled": "列表视图下不可用",
         "dragDrop": {
-            "unableToResolveRoot": "无法确定移动的目标路径。"
+            "unableToResolveRoot": "无法确定移动的目标路径。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "文件位置已成功打开",
-                "failed": "打开文件位置失败"
+                "failed": "打开文件位置失败",
+                "copied": "路径已复制到剪贴板：{{path}}",
+                "clipboardFallback": "路径：{{path}}"
             },
             "metadata": {
                 "version": "版本",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "添加预设参数...",
                 "strengthMin": "最小强度",
                 "strengthMax": "最大强度",
+                "strengthRange": "强度范围",
                 "strength": "强度",
                 "clipStrength": "Clip 强度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "数值",
-                "add": "添加"
+                "add": "添加",
+                "invalidRange": "无效的范围格式。请使用 x.x-y.y"
             },
             "triggerWords": {
                 "label": "触发词",
@@ -914,6 +993,13 @@
                 "recipes": "配方",
                 "versions": "版本"
             },
+            "navigation": {
+                "label": "模型导航",
+                "previousWithShortcut": "上一个模型（←）",
+                "nextWithShortcut": "下一个模型（→）",
+                "noPrevious": "没有上一个模型",
+                "noNext": "没有下一个模型"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "初始化统计",
             "message": "正在处理模型数据以生成统计信息。这可能需要几分钟..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "技巧与提示",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "配方已追加到工作流",
             "recipeReplaced": "配方已替换到工作流",
             "recipeFailedToSend": "发送配方到工作流失败",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "当前工作流中没有兼容的节点",
             "noTargetNodeSelected": "未选择目标节点"
         },
         "nodeSelector": {
             "recipe": "配方",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "替换",
             "append": "追加",
             "selectTargetNode": "选择目标节点",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "示例图片文件夹已打开",
             "openingFolder": "正在打开示例图片文件夹",
-            "failedToOpen": "打开示例图片文件夹失败"
+            "failedToOpen": "打开示例图片文件夹失败",
+            "setupRequired": "示例图片存储",
+            "setupDescription": "要添加自定义示例图片，您需要先设置下载位置。",
+            "setupUsage": "此路径用于存储下载的示例图片和自定义图片。",
+            "openSettings": "打开设置"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "正在检查更新...",
         "checkingMessage": "请稍候，正在检查最新版本。",
         "showNotifications": "显示更新通知",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "正在准备更新...",
             "installing": "正在安装更新...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "验证完成。所有文件均为重复项。",
             "verificationFailed": "验证哈希失败：{message}",
             "noTagsToAdd": "没有可添加的标签",
+            "bulkTagsUpdating": "正在更新 {count} 个模型的标签...",
             "tagsAddedSuccessfully": "已成功为 {count} 个 {type} 添加 {tagCount} 个标签",
             "tagsReplacedSuccessfully": "已成功为 {count} 个 {type} 替换为 {tagCount} 个标签",
             "tagsAddFailed": "为 {count} 个模型添加标签失败",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "加载 LoRA 根目录失败：{message}",
             "checkpointRootsFailed": "加载 Checkpoint 根目录失败：{message}",
+            "unetRootsFailed": "加载 Diffusion Model 根目录失败：{message}",
             "embeddingRootsFailed": "加载 Embedding 根目录失败：{message}",
             "mappingsUpdated": "基础模型路径映射已更新（{count} 条映射{plural}）",
             "mappingsCleared": "基础模型路径映射已清除",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "元数据刷新成功",
             "metadataRefreshFailed": "刷新元数据失败：{message}",
             "metadataUpdateComplete": "元数据更新完成",
+            "operationCancelled": "操作已由用户取消",
+            "operationCancelledPartial": "操作已取消。已处理 {success} 个项目。",
             "metadataFetchFailed": "获取元数据失败：{message}",
             "bulkMetadataCompleteAll": "全部 {count} 个 {type} 元数据刷新成功",
             "bulkMetadataCompletePartial": "已刷新 {success}/{total} 个 {type} 元数据",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "移动失败：\n{failures}",
             "bulkMoveSuccess": "成功移动 {successCount} 个 {type}",
             "exampleImagesDownloadSuccess": "示例图片下载成功！",
-            "exampleImagesDownloadFailed": "示例图片下载失败：{message}"
+            "exampleImagesDownloadFailed": "示例图片下载失败：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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": {
@@ -168,6 +179,7 @@
             "recipes": "配方",
             "checkpoints": "Checkpoint",
             "embeddings": "Embedding",
+            "misc": "[TODO: Translate] Misc",
             "statistics": "統計"
         },
         "search": {
@@ -176,7 +188,8 @@
                 "loras": "搜尋 LoRA...",
                 "recipes": "搜尋配方...",
                 "checkpoints": "搜尋 checkpoint...",
-                "embeddings": "搜尋 embedding..."
+                "embeddings": "搜尋 embedding...",
+                "misc": "[TODO: Translate] Search VAE/Upscaler models..."
             },
             "options": "搜尋選項",
             "searchIn": "搜尋範圍：",
@@ -188,17 +201,30 @@
                 "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": "允許銷售",
+            "noTags": "無標籤",
             "clearAll": "清除所有篩選"
         },
         "theme": {
@@ -221,7 +247,9 @@
             "label": "開啟設定資料夾",
             "tooltip": "開啟包含 settings.json 的資料夾",
             "success": "已開啟 settings.json 資料夾",
-            "failed": "無法開啟 settings.json 資料夾"
+            "failed": "無法開啟 settings.json 資料夾",
+            "copied": "設定路徑已複製到剪貼簿：{{path}}",
+            "clipboardFallback": "設定路徑：{{path}}"
         },
         "sections": {
             "contentFiltering": "內容過濾",
@@ -305,6 +333,8 @@
             "defaultLoraRootHelp": "設定下載、匯入和移動時的預設 LoRA 根目錄",
             "defaultCheckpointRoot": "預設 Checkpoint 根目錄",
             "defaultCheckpointRootHelp": "設定下載、匯入和移動時的預設 Checkpoint 根目錄",
+            "defaultUnetRoot": "預設 Diffusion Model 根目錄",
+            "defaultUnetRootHelp": "設定下載、匯入和移動時的預設 Diffusion Model (UNET) 根目錄",
             "defaultEmbeddingRoot": "預設 Embedding 根目錄",
             "defaultEmbeddingRootHelp": "設定下載、匯入和移動時的預設 Embedding 根目錄",
             "noDefault": "未設定預設"
@@ -443,7 +473,10 @@
                 "dateAsc": "最舊",
                 "size": "檔案大小",
                 "sizeDesc": "最大",
-                "sizeAsc": "最小"
+                "sizeAsc": "最小",
+                "usage": "使用次數",
+                "usageDesc": "最多",
+                "usageAsc": "最少"
             },
             "refresh": {
                 "title": "重新整理模型列表",
@@ -518,6 +551,7 @@
             "replacePreview": "更換預覽圖",
             "setContentRating": "設定內容分級",
             "moveToFolder": "移動到資料夾",
+            "repairMetadata": "修復元數據",
             "excludeModel": "排除模型",
             "deleteModel": "刪除模型",
             "shareRecipe": "分享配方",
@@ -588,10 +622,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,15 +667,39 @@
                 "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 模型"
     },
+    "misc": {
+        "title": "[TODO: Translate] VAE & Upscaler Models",
+        "modelTypes": {
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler"
+        },
+        "contextMenu": {
+            "moveToOtherTypeFolder": "[TODO: Translate] Move to {otherType} Folder"
+        }
+    },
     "sidebar": {
         "modelRoot": "根目錄",
         "collapseAll": "全部摺疊資料夾",
@@ -638,7 +712,8 @@
         "recursiveUnavailable": "遞迴搜尋僅能在樹狀檢視中使用",
         "collapseAllDisabled": "列表檢視下不可用",
         "dragDrop": {
-            "unableToResolveRoot": "無法確定移動的目標路徑。"
+            "unableToResolveRoot": "無法確定移動的目標路徑。",
+            "moveUnsupported": "Move is not supported for this item."
         }
     },
     "statistics": {
@@ -848,7 +923,9 @@
             },
             "openFileLocation": {
                 "success": "檔案位置已成功開啟",
-                "failed": "開啟檔案位置失敗"
+                "failed": "開啟檔案位置失敗",
+                "copied": "路徑已複製到剪貼簿：{{path}}",
+                "clipboardFallback": "路徑：{{path}}"
             },
             "metadata": {
                 "version": "版本",
@@ -871,11 +948,13 @@
                 "addPresetParameter": "新增預設參數...",
                 "strengthMin": "最小強度",
                 "strengthMax": "最大強度",
+                "strengthRange": "強度範圍",
                 "strength": "強度",
                 "clipStrength": "Clip 強度",
                 "clipSkip": "Clip Skip",
                 "valuePlaceholder": "數值",
-                "add": "新增"
+                "add": "新增",
+                "invalidRange": "無效的範圍格式。請使用 x.x-y.y"
             },
             "triggerWords": {
                 "label": "觸發詞",
@@ -914,6 +993,13 @@
                 "recipes": "配方",
                 "versions": "版本"
             },
+            "navigation": {
+                "label": "模型導覽",
+                "previousWithShortcut": "上一個模型（←）",
+                "nextWithShortcut": "下一個模型（→）",
+                "noPrevious": "沒有上一個模型",
+                "noNext": "沒有下一個模型"
+            },
             "license": {
                 "noImageSell": "No selling generated content",
                 "noRentCivit": "No Civitai generation",
@@ -1030,6 +1116,10 @@
             "title": "初始化統計",
             "message": "正在處理模型資料以產生統計，可能需要幾分鐘..."
         },
+        "misc": {
+            "title": "[TODO: Translate] Initializing Misc Model Manager",
+            "message": "[TODO: Translate] Scanning VAE and Upscaler models..."
+        },
         "tips": {
             "title": "小技巧",
             "civitai": {
@@ -1089,12 +1179,18 @@
             "recipeAdded": "配方已附加到工作流",
             "recipeReplaced": "配方已取代於工作流",
             "recipeFailedToSend": "傳送配方到工作流失敗",
+            "vaeUpdated": "[TODO: Translate] VAE updated in workflow",
+            "vaeFailed": "[TODO: Translate] Failed to update VAE in workflow",
+            "upscalerUpdated": "[TODO: Translate] Upscaler updated in workflow",
+            "upscalerFailed": "[TODO: Translate] Failed to update upscaler in workflow",
             "noMatchingNodes": "目前工作流程中沒有相容的節點",
             "noTargetNodeSelected": "未選擇目標節點"
         },
         "nodeSelector": {
             "recipe": "配方",
             "lora": "LoRA",
+            "vae": "[TODO: Translate] VAE",
+            "upscaler": "[TODO: Translate] Upscaler",
             "replace": "取代",
             "append": "附加",
             "selectTargetNode": "選擇目標節點",
@@ -1103,7 +1199,11 @@
         "exampleImages": {
             "opened": "範例圖片資料夾已開啟",
             "openingFolder": "正在開啟範例圖片資料夾",
-            "failedToOpen": "開啟範例圖片資料夾失敗"
+            "failedToOpen": "開啟範例圖片資料夾失敗",
+            "setupRequired": "範例圖片儲存",
+            "setupDescription": "要新增自訂範例圖片，您需要先設定下載位置。",
+            "setupUsage": "此路徑用於儲存下載的範例圖片和自訂圖片。",
+            "openSettings": "開啟設定"
         }
     },
     "help": {
@@ -1152,6 +1252,7 @@
         "checkingUpdates": "正在檢查更新...",
         "checkingMessage": "請稍候，正在檢查最新版本。",
         "showNotifications": "顯示更新通知",
+        "latestBadge": "最新",
         "updateProgress": {
             "preparing": "正在準備更新...",
             "installing": "正在安裝更新...",
@@ -1317,6 +1418,7 @@
             "verificationCompleteSuccess": "驗證完成。所有檔案均確認為重複項。",
             "verificationFailed": "驗證雜湊失敗：{message}",
             "noTagsToAdd": "沒有可新增的標籤",
+            "bulkTagsUpdating": "正在更新 {count} 個模型的標籤...",
             "tagsAddedSuccessfully": "已成功將 {tagCount} 個標籤新增到 {count} 個 {type}",
             "tagsReplacedSuccessfully": "已成功以 {tagCount} 個標籤取代 {count} 個 {type} 的標籤",
             "tagsAddFailed": "新增標籤到 {count} 個模型失敗",
@@ -1330,6 +1432,7 @@
         "settings": {
             "loraRootsFailed": "載入 LoRA 根目錄失敗：{message}",
             "checkpointRootsFailed": "載入 checkpoint 根目錄失敗：{message}",
+            "unetRootsFailed": "載入 Diffusion Model 根目錄失敗：{message}",
             "embeddingRootsFailed": "載入 embedding 根目錄失敗：{message}",
             "mappingsUpdated": "基礎模型路徑對應已更新（{count} 個對應）",
             "mappingsCleared": "基礎模型路徑對應已清除",
@@ -1350,7 +1453,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 +1559,8 @@
             "metadataRefreshed": "metadata 已成功刷新",
             "metadataRefreshFailed": "刷新 metadata 失敗：{message}",
             "metadataUpdateComplete": "metadata 更新完成",
+            "operationCancelled": "操作已由用戶取消",
+            "operationCancelledPartial": "操作已取消。已處理 {success} 個項目。",
             "metadataFetchFailed": "取得 metadata 失敗：{message}",
             "bulkMetadataCompleteAll": "已成功刷新全部 {count} 個 {type}",
             "bulkMetadataCompletePartial": "已刷新 {success} / {total} 個 {type}",
@@ -1453,7 +1577,8 @@
             "bulkMoveFailures": "移動失敗：\n{failures}",
             "bulkMoveSuccess": "已成功移動 {successCount} 個 {type}",
             "exampleImagesDownloadSuccess": "範例圖片下載成功！",
-            "exampleImagesDownloadFailed": "下載範例圖片失敗：{message}"
+            "exampleImagesDownloadFailed": "下載範例圖片失敗：{message}",
+            "moveFailed": "Failed to move item: {message}"
         }
     },
     "banners": {

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,15 +83,19 @@ 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
         self.embeddings_roots = None
+        self.vae_roots = None
+        self.upscaler_roots = None
         self.base_models_roots = self._init_checkpoint_paths()
         self.embeddings_roots = self._init_embedding_paths()
+        self.misc_roots = self._init_misc_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
@@ -147,6 +154,8 @@ class Config:
                 'checkpoints': list(self.checkpoints_roots or []),
                 'unet': list(self.unet_roots or []),
                 'embeddings': list(self.embeddings_roots or []),
+                'vae': list(self.vae_roots or []),
+                'upscale_models': list(self.upscaler_roots or []),
             }
 
             normalized_target_paths = _normalize_folder_paths_for_comparison(target_folder_paths)
@@ -220,45 +229,332 @@ 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 [])
+        roots.extend(self.misc_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)
+        start = time.perf_counter()
         
-        for root in self.base_models_roots:
-            self._scan_directory_links(root)
-            
-        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()
+        visited_dirs: Set[str] = set()
+        for root in self._symlink_roots():
+            self._scan_directory_links(root, visited_dirs)
+        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_directory_links(self, root: str, visited_dirs: Set[str]):
+        """Iteratively scan directory symlinks to avoid deep recursion."""
         try:
-            with os.scandir(root) as it:
-                for entry in it:
-                    if self._is_link(entry.path):
-                        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)
-        except Exception as e:
-            logger.error(f"Error scanning links in {root}: {e}")
+            # Note: We only use realpath for the initial root if it's not already resolved
+            # to ensure we have a valid entry point.
+            root_real = self._normalize_path(os.path.realpath(root))
+        except OSError:
+            root_real = self._normalize_path(root)
+
+        if root_real in visited_dirs:
+            return
+
+        visited_dirs.add(root_real)
+        # Stack entries: (display_path, real_resolved_path)
+        stack: List[Tuple[str, str]] = [(root, root_real)]
+
+        while stack:
+            current_display, current_real = stack.pop()
+            try:
+                with os.scandir(current_display) as it:
+                    for entry in it:
+                        try:
+                            # 1. Detect symlinks including Windows junctions
+                            is_link = self._entry_is_symlink(entry)
+
+                            if is_link:
+                                # Only resolve realpath when we actually find a link
+                                target_path = os.path.realpath(entry.path)
+                                if not os.path.isdir(target_path):
+                                    continue
+
+                                normalized_target = self._normalize_path(target_path)
+                                self.add_path_mapping(entry.path, target_path)
+                                
+                                if normalized_target in visited_dirs:
+                                    continue
+                                    
+                                visited_dirs.add(normalized_target)
+                                stack.append((target_path, normalized_target))
+                                continue
+
+                            # 2. Process normal directories
+                            if not entry.is_dir(follow_symlinks=False):
+                                continue
+
+                            # For normal directories, we avoid realpath() call by 
+                            # incrementally building the real path relative to current_real.
+                            # This is safe because 'entry' is NOT a symlink.
+                            entry_real = self._normalize_path(os.path.join(current_real, entry.name))
+                            
+                            if entry_real in visited_dirs:
+                                continue
+                            
+                            visited_dirs.add(entry_real)
+                            stack.append((entry.path, entry_real))
+                        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 {current_display}: {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."""
 
@@ -309,34 +605,53 @@ class Config:
             preview_roots.update(self._expand_preview_root(root))
         for root in self.embeddings_roots or []:
             preview_roots.update(self._expand_preview_root(root))
+        for root in self.misc_roots or []:
+            preview_roots.update(self._expand_preview_root(root))
 
         for target, link in self._path_mappings.items():
             preview_roots.update(self._expand_preview_root(target))
             preview_roots.update(self._expand_preview_root(link))
 
         self._preview_root_paths = {path for path in preview_roots if path.is_absolute()}
+        logger.debug(
+            "Preview roots rebuilt: %d paths from %d lora roots, %d checkpoint roots, %d embedding roots, %d misc 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.misc_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] = {}
@@ -411,8 +726,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"""
@@ -464,6 +778,49 @@ class Config:
             logger.warning(f"Error initializing embedding paths: {e}")
             return []
 
+    def _init_misc_paths(self) -> List[str]:
+        """Initialize and validate misc (VAE and upscaler) paths from ComfyUI settings"""
+        try:
+            raw_vae_paths = folder_paths.get_folder_paths("vae")
+            raw_upscaler_paths = folder_paths.get_folder_paths("upscale_models")
+            unique_paths = self._prepare_misc_paths(raw_vae_paths, raw_upscaler_paths)
+
+            logger.info("Found misc roots:" + ("\n - " + "\n - ".join(unique_paths) if unique_paths else "[]"))
+
+            if not unique_paths:
+                logger.warning("No valid VAE or upscaler folders found in ComfyUI configuration")
+                return []
+
+            return unique_paths
+        except Exception as e:
+            logger.warning(f"Error initializing misc paths: {e}")
+            return []
+
+    def _prepare_misc_paths(
+        self, vae_paths: Iterable[str], upscaler_paths: Iterable[str]
+    ) -> List[str]:
+        vae_map = self._dedupe_existing_paths(vae_paths)
+        upscaler_map = self._dedupe_existing_paths(upscaler_paths)
+
+        merged_map: Dict[str, str] = {}
+        for real_path, original in {**vae_map, **upscaler_map}.items():
+            if real_path not in merged_map:
+                merged_map[real_path] = original
+
+        unique_paths = sorted(merged_map.values(), key=lambda p: p.lower())
+
+        vae_values = set(vae_map.values())
+        upscaler_values = set(upscaler_map.values())
+        self.vae_roots = [p for p in unique_paths if p in vae_values]
+        self.upscaler_roots = [p for p in unique_paths if p in upscaler_values]
+
+        for original_path in unique_paths:
+            real_path = os.path.normpath(os.path.realpath(original_path)).replace(os.sep, '/')
+            if real_path != original_path:
+                self.add_path_mapping(original_path, real_path)
+
+        return unique_paths
+
     def get_preview_static_url(self, preview_path: str) -> str:
         if not preview_path:
             return ""
@@ -483,12 +840,29 @@ class Config:
         except Exception:
             return False
 
+        # Use os.path.normcase for case-insensitive comparison on Windows.
+        # On Windows, Path.relative_to() is case-sensitive for drive letters,
+        # causing paths like 'a:/folder' to not match 'A:/folder'.
+        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))
+            # Check if candidate is equal to or under the root directory
+            if candidate_str == root_str or candidate_str.startswith(root_str + os.sep):
                 return True
-            except ValueError:
-                continue
+
+        if self._preview_root_paths:
+            logger.debug(
+                "Preview path rejected: %s (candidate=%s, num_roots=%d, first_root=%s)",
+                preview_path,
+                candidate_str,
+                len(self._preview_root_paths),
+                os.path.normcase(str(next(iter(self._preview_root_paths)))),
+            )
+        else:
+            logger.debug(
+                "Preview path rejected (no roots configured): %s",
+                preview_path,
+            )
 
         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"""
@@ -162,15 +184,17 @@ class LoraManager:
             lora_scanner = await ServiceRegistry.get_lora_scanner()
             checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
             embedding_scanner = await ServiceRegistry.get_embedding_scanner()
-            
+            misc_scanner = await ServiceRegistry.get_misc_scanner()
+
             # Initialize recipe scanner if needed
             recipe_scanner = await ServiceRegistry.get_recipe_scanner()
-            
+
             # Create low-priority initialization tasks
             init_tasks = [
                 asyncio.create_task(lora_scanner.initialize_in_background(), name='lora_cache_init'),
                 asyncio.create_task(checkpoint_scanner.initialize_in_background(), name='checkpoint_cache_init'),
                 asyncio.create_task(embedding_scanner.initialize_in_background(), name='embedding_cache_init'),
+                asyncio.create_task(misc_scanner.initialize_in_background(), name='misc_cache_init'),
                 asyncio.create_task(recipe_scanner.initialize_in_background(), name='recipe_cache_init')
             ]
 
@@ -230,8 +254,9 @@ class LoraManager:
             # Collect all model roots
             all_roots = set()
             all_roots.update(config.loras_roots)
-            all_roots.update(config.base_models_roots) 
+            all_roots.update(config.base_models_roots)
             all_roots.update(config.embeddings_roots)
+            all_roots.update(config.misc_roots or [])
             
             total_deleted = 0
             total_size_freed = 0

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"""
-        if not metadata.get(MODELS):
+    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
             
-        # In most workflows, there's only one checkpoint, so we can just take the first one
+        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
+        
+        # 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/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,15 +1,15 @@
 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"
     OUTPUT_NODE = True
-    
+
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -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)
-            
-            # Send metadata to frontend for display
-            PromptServer.instance.send_sync("metadata_update", {
-                "id": id,
-                "metadata": metadata_json
-            })
-            
+
+            # Use the MetadataProcessor to convert it to dict
+            metadata_dict = MetadataProcessor.to_dict(metadata, id)
+
+            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,136 @@
+"""
+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.get("model_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

@@ -9,7 +9,7 @@ from ..metadata_collector import get_metadata
 from PIL import Image, PngImagePlugin
 import piexif
 
-class SaveImage:
+class SaveImageLM:
     NAME = "Save Image (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = "Save images with embedded generation metadata in compatible format"

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,27 +6,36 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-class TriggerWordToggle:
+class TriggerWordToggleLM:
     NAME = "TriggerWord Toggle (LoraManager)"
     CATEGORY = "Lora Manager/utils"
     DESCRIPTION = "Toggle trigger words on/off"
-    
+
     @classmethod
     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,15 +47,15 @@ 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
@@ -60,115 +69,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 trigger_words_override != 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
@@ -148,8 +149,9 @@ class RecipeMetadataParser(ABC):
             logger.error(f"Error populating lora from Civitai info: {e}")
             
         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/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/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,7 @@ 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"),
 )
 
 

py/routes/handlers/example_images_handlers.py

@@ -113,6 +113,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()
 
@@ -160,6 +163,7 @@ class ExampleImagesHandlerSet:
             "force_download_example_images": self.download.force_download_example_images,
             "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

@@ -42,7 +42,6 @@ class PreviewHandler:
 
         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():

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()
@@ -410,6 +486,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 +495,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 +514,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,17 +523,101 @@ 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()
             recipe_scanner = self._recipe_scanner_getter()
             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 +626,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 +721,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 +771,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 +910,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 +941,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 +950,7 @@ class RecipeManagementHandler:
             "name": name,
             "tags": tags,
             "metadata": metadata,
+            "extension": extension,
         }
 
     def _parse_tags(self, tag_text: Optional[str]) -> list[str]:
@@ -729,7 +1021,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]:
         civitai_client = self._civitai_client_getter()
         downloader = await self._downloader_factory()
         temp_path = None
@@ -744,15 +1036,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 +1074,7 @@ class RecipeManagementHandler:
                 except FileNotFoundError:
                     pass
 
+
     def _safe_int(self, value: Any) -> int:
         try:
             return int(value)

py/routes/lora_routes.py

@@ -12,14 +12,15 @@ from ..utils.utils import get_lora_info
 
 logger = logging.getLogger(__name__)
 
+
 class LoraRoutes(BaseModelRoutes):
     """LoRA-specific route controller"""
-    
+
     def __init__(self):
         """Initialize LoRA routes with LoRA service"""
         super().__init__()
         self.template_name = "loras.html"
-    
+
     async def initialize_services(self):
         """Initialize services from ServiceRegistry"""
         lora_scanner = await ServiceRegistry.get_lora_scanner()
@@ -29,207 +30,304 @@ class LoraRoutes(BaseModelRoutes):
 
         # Attach service dependencies
         self.attach_service(self.service)
-    
+
     def setup_routes(self, app: web.Application):
         """Setup LoRA routes"""
         # Schedule service initialization on app startup
         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:
         """Get expected model types string for error messages"""
         return "LORA, LoCon, or DORA"
-    
+
     # LoRA-specific route handlers
     async def get_letter_counts(self, request: web.Request) -> web.Response:
         """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)
-            
-            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 ''
-            })
-            
+                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 ""})
+
         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"""
         try:
             json_data = await request.json()
             lora_names = json_data.get("lora_names", [])
             node_ids = json_data.get("node_ids", [])
-            
+
             all_trigger_words = []
             for lora_name in lora_names:
                 _, trigger_words = get_lora_info(lora_name)
                 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:
                 node_identifier = entry
@@ -243,21 +341,15 @@ 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)
 
                 PromptServer.instance.send_sync("trigger_word_update", payload)
-            
+
             return web.json_response({"success": True})
 
         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_model_routes.py

@@ -0,0 +1,112 @@
+import logging
+from typing import Dict
+from aiohttp import web
+
+from .base_model_routes import BaseModelRoutes
+from .model_route_registrar import ModelRouteRegistrar
+from ..services.misc_service import MiscService
+from ..services.service_registry import ServiceRegistry
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+class MiscModelRoutes(BaseModelRoutes):
+    """Misc-specific route controller (VAE, Upscaler)"""
+
+    def __init__(self):
+        """Initialize Misc routes with Misc service"""
+        super().__init__()
+        self.template_name = "misc.html"
+
+    async def initialize_services(self):
+        """Initialize services from ServiceRegistry"""
+        misc_scanner = await ServiceRegistry.get_misc_scanner()
+        update_service = await ServiceRegistry.get_model_update_service()
+        self.service = MiscService(misc_scanner, update_service=update_service)
+        self.set_model_update_service(update_service)
+
+        # Attach service dependencies
+        self.attach_service(self.service)
+
+    def setup_routes(self, app: web.Application):
+        """Setup Misc routes"""
+        # Schedule service initialization on app startup
+        app.on_startup.append(lambda _: self.initialize_services())
+
+        # Setup common routes with 'misc' prefix (includes page route)
+        super().setup_routes(app, 'misc')
+
+    def setup_specific_routes(self, registrar: ModelRouteRegistrar, prefix: str):
+        """Setup Misc-specific routes"""
+        # Misc info by name
+        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/info/{name}', prefix, self.get_misc_info)
+
+        # VAE roots and Upscaler roots
+        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/vae_roots', prefix, self.get_vae_roots)
+        registrar.add_prefixed_route('GET', '/api/lm/{prefix}/upscaler_roots', prefix, self.get_upscaler_roots)
+
+    def _validate_civitai_model_type(self, model_type: str) -> bool:
+        """Validate CivitAI model type for Misc (VAE or Upscaler)"""
+        return model_type.lower() in ['vae', 'upscaler']
+
+    def _get_expected_model_types(self) -> str:
+        """Get expected model types string for error messages"""
+        return "VAE or Upscaler"
+
+    def _parse_specific_params(self, request: web.Request) -> Dict:
+        """Parse Misc-specific parameters"""
+        params: Dict = {}
+
+        if 'misc_hash' in request.query:
+            params['hash_filters'] = {'single_hash': request.query['misc_hash'].lower()}
+        elif 'misc_hashes' in request.query:
+            params['hash_filters'] = {
+                'multiple_hashes': [h.lower() for h in request.query['misc_hashes'].split(',')]
+            }
+
+        return params
+
+    async def get_misc_info(self, request: web.Request) -> web.Response:
+        """Get detailed information for a specific misc model by name"""
+        try:
+            name = request.match_info.get('name', '')
+            misc_info = await self.service.get_model_info_by_name(name)
+
+            if misc_info:
+                return web.json_response(misc_info)
+            else:
+                return web.json_response({"error": "Misc model not found"}, status=404)
+
+        except Exception as e:
+            logger.error(f"Error in get_misc_info: {e}", exc_info=True)
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def get_vae_roots(self, request: web.Request) -> web.Response:
+        """Return the list of VAE roots from config"""
+        try:
+            roots = config.vae_roots
+            return web.json_response({
+                "success": True,
+                "roots": roots
+            })
+        except Exception as e:
+            logger.error(f"Error getting VAE roots: {e}", exc_info=True)
+            return web.json_response({
+                "success": False,
+                "error": str(e)
+            }, status=500)
+
+    async def get_upscaler_roots(self, request: web.Request) -> web.Response:
+        """Return the list of upscaler roots from config"""
+        try:
+            roots = config.upscaler_roots
+            return web.json_response({
+                "success": True,
+                "roots": roots
+            })
+        except Exception as e:
+            logger.error(f"Error getting upscaler roots: {e}", exc_info=True)
+            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 = release.get('body', '')
+                changelog = UpdateRoutes._parse_changelog(body)
+                
+                releases.append({
+                    'version': version,
+                    'changelog': changelog,
+                    'published_at': release.get('published_at', ''),
+                    'is_latest': i == 0
+                })
             
-            # Extract changelog from release notes
-            body = data.get('body', '')
-            changelog = UpdateRoutes._parse_changelog(body)
+            # 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 version, changelog
+            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,9 +25,10 @@ logger = logging.getLogger(__name__)
 if TYPE_CHECKING:
     from .model_update_service import ModelUpdateService
 
+
 class BaseModelService(ABC):
     """Base service class for all model types"""
-    
+
     def __init__(
         self,
         model_type: str,
@@ -58,13 +61,15 @@ class BaseModelService(ABC):
         self.filter_set = filter_set or ModelFilterSet(self.settings)
         self.search_strategy = search_strategy or SearchStrategy()
         self.update_service = update_service
-    
+
     async def get_paginated_data(
         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,
@@ -79,16 +84,26 @@ class BaseModelService(ABC):
         **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,
@@ -108,57 +123,119 @@ 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 _apply_hash_filters(self, data: List[Dict], hash_filters: Dict) -> List[Dict]:
+    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 []
+
+        # 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
-    
+
     async def _apply_common_filters(
         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,
@@ -169,6 +246,8 @@ class BaseModelService(ABC):
         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,
@@ -176,7 +255,7 @@ class BaseModelService(ABC):
             search_options=normalized_options,
         )
         return self.filter_set.apply(data, criteria)
-    
+
     async def _apply_search_filters(
         self,
         data: List[Dict],
@@ -186,28 +265,34 @@ 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:
             data: List of model data items
-            credit_required: 
+            credit_required:
                 - True: Return items where credit is required (allowNoCredit=False)
                 - False: Return items where credit is not required (allowNoCredit=True)
         """
         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))
-            
+
             # If credit_required is True, we want items where allowNoCredit is False (credit required)
             # If credit_required is False, we want items where allowNoCredit is True (no credit required)
             if credit_required:
@@ -216,26 +301,30 @@ class BaseModelService(ABC):
             else:
                 if allow_no_credit:  # Credit is not required
                     filtered_data.append(item)
-        
+
         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:
             data: List of model data items
-            allow_selling: 
+            allow_selling:
                 - True: Return items where selling generated content is allowed (allowCommercialUse contains Image)
                 - False: Return items where selling generated content is not allowed (allowCommercialUse does not contain Image)
         """
         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)
             has_image_permission = bool(license_flags & (1 << 1))
-            
+
             # If allow_selling is True, we want items where Image permission is granted
             # If allow_selling is False, we want items where Image permission is not granted
             if allow_selling:
@@ -244,7 +333,7 @@ class BaseModelService(ABC):
             else:
                 if not has_image_permission:  # Selling generated content is not allowed
                     filtered_data.append(item)
-        
+
         return filtered_data
 
     async def _annotate_update_flags(
@@ -262,7 +351,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 +359,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 +435,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 +456,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 +475,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 +488,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 +525,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)
@@ -447,91 +544,119 @@ class BaseModelService(ABC):
         total_items = len(data)
         start_idx = (page - 1) * page_size
         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
     async def format_response(self, model_data: Dict) -> Dict:
         """Format model data for API response - must be implemented by subclasses"""
         pass
-    
+
     # Common service methods that delegate to scanner
     async def get_top_tags(self, limit: int = 20) -> List[Dict]:
         """Get top tags sorted by frequency"""
         return await self.scanner.get_top_tags(limit)
-    
+
     async def get_base_models(self, limit: int = 20) -> List[Dict]:
         """Get base models sorted by frequency"""
         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,
         )
 
         return sorted_types[:limit]
-    
+
     def has_hash(self, sha256: str) -> bool:
         """Check if a model with given hash exists"""
         return self.scanner.has_hash(sha256)
-    
+
     def get_path_by_hash(self, sha256: str) -> Optional[str]:
         """Get file path for a model by its hash"""
         return self.scanner.get_path_by_hash(sha256)
-    
+
     def get_hash_by_path(self, file_path: str) -> Optional[str]:
         """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"""
         return await self.scanner.get_model_info_by_name(name)
-    
+
     def get_model_roots(self) -> List[str]:
         """Get model root directories"""
         return self.scanner.get_model_roots()
-    
+
     def filter_civitai_data(self, data: Dict, minimal: bool = False) -> Dict:
         """Filter relevant fields from CivitAI data"""
         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:
         """Get hierarchical folder tree for a specific model root"""
         cache = await self.scanner.get_cached_data()
-        
+
         # Build tree structure from folders
         tree = {}
-        
+
         for folder in cache.folders:
             # Check if this folder belongs to the specified model root
             folder_belongs_to_root = False
@@ -539,95 +664,96 @@ class BaseModelService(ABC):
                 if root == model_root:
                     folder_belongs_to_root = True
                     break
-            
+
             if not folder_belongs_to_root:
                 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:
                 if part not in current_level:
                     current_level[part] = {}
                 current_level = current_level[part]
-        
+
         return tree
-    
+
     async def get_unified_folder_tree(self) -> Dict:
         """Get unified folder tree across all model roots"""
         cache = await self.scanner.get_cached_data()
-        
+
         # Build unified tree structure by analyzing all relative paths
         unified_tree = {}
-        
+
         # Get all model roots for path normalization
         model_roots = self.scanner.get_model_roots()
-        
+
         for folder in cache.folders:
             if not folder:  # Skip empty folders
                 continue
-            
+
             # Find which root this folder belongs to by checking the actual file paths
             # This is a simplified approach - we'll use the folder as-is since it should already be relative
             relative_path = folder
-            
+
             # Split folder path into components
-            parts = relative_path.split('/')
+            parts = relative_path.split("/")
             current_level = unified_tree
-            
+
             for part in parts:
                 if part not in current_level:
                     current_level[part] = {}
                 current_level = current_level[part]
-        
+
         return unified_tree
 
     async def get_model_notes(self, model_name: str) -> Optional[str]:
         """Get notes for a specific model file"""
         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
-    
+
     async def get_model_preview_url(self, model_name: str) -> Optional[str]:
         """Get the static preview URL for a model file"""
         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}"
                     if version_id:
                         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 +761,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,53 +813,64 @@ 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)
-        
+
         matching_paths = []
-        
+
         # Get model roots for path calculation
         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
-                
+
             # Calculate relative path from model root
             relative_path = None
             for root in model_roots:
                 # Normalize paths for comparison
                 normalized_root = os.path.normpath(root)
                 normalized_file = os.path.normpath(file_path)
-                
+
                 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
                     break
-        
+
         # Sort by relevance (prefix and earliest hits first, then by length and alphabetically)
         matching_paths.sort(
             key=lambda relative: self._relative_path_sort_key(relative, include_terms)
         )
-        
+
         return matching_paths[:limit]

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_service.py

@@ -3,29 +3,37 @@ 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"""
-    
+
     def __init__(self, scanner, update_service=None):
         """Initialize LoRA service
-        
+
         Args:
             scanner: LoRA scanner instance
             update_service: Optional service for remote update tracking.
         """
         super().__init__("lora", scanner, LoraMetadata, update_service=update_service)
-    
+
     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,149 +43,491 @@ 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)
-        
+
         return data
-    
+
     def _filter_by_first_letter(self, data: List[Dict], letter: str) -> List[Dict]:
         """Filter data by first letter of model name
-        
+
         Special handling:
         - '#': Numbers (0-9)
         - '@': Special characters (not alphanumeric)
         - '漢': CJK characters
         """
         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:
                 # Regular alphabet matching
                 filtered_data.append(lora)
-                
+
         return filtered_data
-    
+
     def _is_cjk_character(self, char: str) -> bool:
         """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)
         return any(start <= code_point <= end for start, end in cjk_ranges)
-    
+
     # LoRA-specific methods
     async def get_letter_counts(self) -> Dict[str, int]:
         """Get count of LoRAs for each letter of the alphabet"""
         cache = await self.scanner.get_cached_data()
         data = cache.raw_data
-        
+
         # 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
-    
+
     async def get_lora_trigger_words(self, lora_name: str) -> List[str]:
         """Get trigger words for a specific LoRA file"""
         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
-    
+
     def find_duplicate_hashes(self) -> Dict:
         """Find LoRAs with duplicate SHA256 hashes"""
         return self.scanner._hash_index.get_duplicate_hashes()
-    
+
     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_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", ""),
             )

py/services/misc_scanner.py

@@ -0,0 +1,55 @@
+import logging
+from typing import Any, Dict, List, Optional
+
+from ..utils.models import MiscMetadata
+from ..config import config
+from .model_scanner import ModelScanner
+from .model_hash_index import ModelHashIndex
+
+logger = logging.getLogger(__name__)
+
+class MiscScanner(ModelScanner):
+    """Service for scanning and managing misc files (VAE, Upscaler)"""
+
+    def __init__(self):
+        # Define supported file extensions (combined from VAE and upscaler)
+        file_extensions = {'.safetensors', '.pt', '.bin', '.ckpt', '.pth'}
+        super().__init__(
+            model_type="misc",
+            model_class=MiscMetadata,
+            file_extensions=file_extensions,
+            hash_index=ModelHashIndex()
+        )
+
+    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
+
+        if config.vae_roots and root_path in config.vae_roots:
+            return "vae"
+
+        if config.upscaler_roots and root_path in config.upscaler_roots:
+            return "upscaler"
+
+        return None
+
+    def adjust_metadata(self, metadata, file_path, root_path):
+        """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]:
+        """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 sub_type:
+            entry["sub_type"] = sub_type
+        return entry
+
+    def get_model_roots(self) -> List[str]:
+        """Get misc root directories (VAE and upscaler)"""
+        return config.misc_roots

py/services/misc_service.py

@@ -0,0 +1,55 @@
+import os
+import logging
+from typing import Dict
+
+from .base_model_service import BaseModelService
+from ..utils.models import MiscMetadata
+from ..config import config
+
+logger = logging.getLogger(__name__)
+
+class MiscService(BaseModelService):
+    """Misc-specific service implementation (VAE, Upscaler)"""
+
+    def __init__(self, scanner, update_service=None):
+        """Initialize Misc service
+
+        Args:
+            scanner: Misc scanner instance
+            update_service: Optional service for remote update tracking.
+        """
+        super().__init__("misc", scanner, MiscMetadata, update_service=update_service)
+
+    async def format_response(self, misc_data: Dict) -> Dict:
+        """Format Misc data for API response"""
+        # Get sub_type from cache entry (new canonical field)
+        sub_type = misc_data.get("sub_type", "vae")
+
+        return {
+            "model_name": misc_data["model_name"],
+            "file_name": misc_data["file_name"],
+            "preview_url": config.get_preview_static_url(misc_data.get("preview_url", "")),
+            "preview_nsfw_level": misc_data.get("preview_nsfw_level", 0),
+            "base_model": misc_data.get("base_model", ""),
+            "folder": misc_data["folder"],
+            "sha256": misc_data.get("sha256", ""),
+            "file_path": misc_data["file_path"].replace(os.sep, "/"),
+            "file_size": misc_data.get("size", 0),
+            "modified": misc_data.get("modified", ""),
+            "tags": misc_data.get("tags", []),
+            "from_civitai": misc_data.get("from_civitai", True),
+            "usage_count": misc_data.get("usage_count", 0),
+            "notes": misc_data.get("notes", ""),
+            "sub_type": sub_type,
+            "favorite": misc_data.get("favorite", False),
+            "update_available": bool(misc_data.get("update_available", False)),
+            "civitai": self.filter_civitai_data(misc_data.get("civitai", {}), minimal=True)
+        }
+
+    def find_duplicate_hashes(self) -> Dict:
+        """Find Misc models with duplicate SHA256 hashes"""
+        return self.scanner._hash_index.get_duplicate_hashes()
+
+    def find_duplicate_filenames(self) -> Dict:
+        """Find Misc models with conflicting filenames"""
+        return self.scanner._hash_index.get_duplicate_filenames()

py/services/model_cache.py

@@ -1,4 +1,8 @@
 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
@@ -13,7 +17,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 +219,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(
+            result = sorted(
                 data,
                 key=itemgetter('modified'),
                 reverse=reverse
             )
         elif sort_key == 'size':
             # Sort by file size
-            return sorted(
+            result = sorted(
                 data,
                 key=itemgetter('size'),
                 reverse=reverse
             )
+        elif sort_key == 'usage':
+            # Sort by usage count, fallback to 0, then name for stability
+            return sorted(
+                data,
+                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()
@@ -186,6 +190,21 @@ class ModelFileService:
                 progress_callback,
                 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:
@@ -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_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,6 +92,8 @@ 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
@@ -109,82 +139,222 @@ 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:
 
-        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
+                    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 +369,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 +410,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 +423,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

@@ -84,6 +84,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 +275,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
 
@@ -653,6 +655,11 @@ class ModelScanner:
         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()
@@ -678,6 +685,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 +745,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
@@ -784,6 +795,10 @@ class ModelScanner:
                                 logger.error(f"Could not determine root path for {path}")
                         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
@@ -838,6 +853,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 +955,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 +1058,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
 
@@ -1073,6 +1103,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 +1112,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 +1251,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 +1288,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 +1325,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 +1348,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 +1483,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 +1527,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)
     
@@ -122,21 +118,24 @@ class ModelServiceFactory:
 
 
 def register_default_model_types():
-    """Register the default model types (LoRA, Checkpoint, and Embedding)"""
+    """Register the default model types (LoRA, Checkpoint, Embedding, and Misc)"""
     from ..services.lora_service import LoraService
     from ..services.checkpoint_service import CheckpointService
     from ..services.embedding_service import EmbeddingService
+    from ..services.misc_service import MiscService
     from ..routes.lora_routes import LoraRoutes
     from ..routes.checkpoint_routes import CheckpointRoutes
     from ..routes.embedding_routes import EmbeddingRoutes
-    
+    from ..routes.misc_model_routes import MiscModelRoutes
+
     # Register LoRA model type
     ModelServiceFactory.register_model_type('lora', LoraService, LoraRoutes)
-    
+
     # Register Checkpoint model type
     ModelServiceFactory.register_model_type('checkpoint', CheckpointService, CheckpointRoutes)
-    
+
     # Register Embedding model type
     ModelServiceFactory.register_model_type('embedding', EmbeddingService, EmbeddingRoutes)
-    
-    logger.info("Registered default model types: lora, checkpoint, embedding")
+
+    # Register Misc model type (VAE, Upscaler)
+    ModelServiceFactory.register_model_type('misc', MiscService, MiscModelRoutes)

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

py/services/persistent_model_cache.py

@@ -1,13 +1,12 @@
 import json
 import logging
 import os
-import re
 import sqlite3
 import threading
 from dataclasses import dataclass
 from typing import Dict, List, Mapping, Optional, Sequence, Tuple
 
-from ..utils.settings_paths import get_project_root, get_settings_dir
+from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
 
 logger = logging.getLogger(__name__)
 
@@ -404,20 +403,12 @@ class PersistentModelCache:
     # Internal helpers -------------------------------------------------
 
     def _resolve_default_path(self, library_name: str) -> str:
-        override = os.environ.get("LORA_MANAGER_CACHE_DB")
-        if override:
-            return override
-        try:
-            settings_dir = get_settings_dir(create=True)
-        except Exception as exc:  # pragma: no cover - defensive guard
-            logger.warning("Falling back to project directory for cache: %s", exc)
-            settings_dir = get_project_root()
-        safe_name = re.sub(r"[^A-Za-z0-9_.-]", "_", library_name or "default")
-        if safe_name.lower() in ("default", ""):
-            legacy_path = os.path.join(settings_dir, self._DEFAULT_FILENAME)
-            if os.path.exists(legacy_path):
-                return legacy_path
-        return os.path.join(settings_dir, "model_cache", f"{safe_name}.sqlite")
+        env_override = os.environ.get("LORA_MANAGER_CACHE_DB")
+        return resolve_cache_path_with_migration(
+            CacheType.MODEL,
+            library_name=library_name,
+            env_override=env_override,
+        )
 
     def _initialize_schema(self) -> None:
         with self._db_lock:

py/services/persistent_recipe_cache.py

@@ -0,0 +1,484 @@
+"""SQLite-based persistent cache for recipe metadata.
+
+This module provides fast recipe cache persistence using SQLite, enabling
+quick startup by loading from cache instead of walking directories and
+parsing JSON files.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sqlite3
+import threading
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Set, Tuple
+
+from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PersistedRecipeData:
+    """Lightweight structure returned by the persistent recipe cache."""
+
+    raw_data: List[Dict]
+    file_stats: Dict[str, Tuple[float, int]]  # json_path -> (mtime, size)
+
+
+class PersistentRecipeCache:
+    """Persist recipe metadata in SQLite for fast startup."""
+
+    _DEFAULT_FILENAME = "recipe_cache.sqlite"
+    _RECIPE_COLUMNS: Tuple[str, ...] = (
+        "recipe_id",
+        "file_path",
+        "json_path",
+        "title",
+        "folder",
+        "base_model",
+        "fingerprint",
+        "created_date",
+        "modified",
+        "file_mtime",
+        "file_size",
+        "favorite",
+        "repair_version",
+        "preview_nsfw_level",
+        "loras_json",
+        "checkpoint_json",
+        "gen_params_json",
+        "tags_json",
+    )
+    _instances: Dict[str, "PersistentRecipeCache"] = {}
+    _instance_lock = threading.Lock()
+
+    def __init__(self, library_name: str = "default", db_path: Optional[str] = None) -> None:
+        self._library_name = library_name or "default"
+        self._db_path = db_path or self._resolve_default_path(self._library_name)
+        self._db_lock = threading.Lock()
+        self._schema_initialized = False
+        try:
+            directory = os.path.dirname(self._db_path)
+            if directory:
+                os.makedirs(directory, exist_ok=True)
+        except Exception as exc:
+            logger.warning("Could not create recipe cache directory %s: %s", directory, exc)
+        if self.is_enabled():
+            self._initialize_schema()
+
+    @classmethod
+    def get_default(cls, library_name: Optional[str] = None) -> "PersistentRecipeCache":
+        name = library_name or "default"
+        with cls._instance_lock:
+            if name not in cls._instances:
+                cls._instances[name] = cls(name)
+            return cls._instances[name]
+
+    @classmethod
+    def clear_instances(cls) -> None:
+        """Clear all cached instances (useful for library switching)."""
+        with cls._instance_lock:
+            cls._instances.clear()
+
+    def is_enabled(self) -> bool:
+        return os.environ.get("LORA_MANAGER_DISABLE_PERSISTENT_CACHE", "0") != "1"
+
+    def get_database_path(self) -> str:
+        """Expose the resolved SQLite database path."""
+        return self._db_path
+
+    def load_cache(self) -> Optional[PersistedRecipeData]:
+        """Load all cached recipes from SQLite.
+
+        Returns:
+            PersistedRecipeData with raw_data and file_stats if cache exists,
+            None if cache is empty or unavailable.
+        """
+        if not self.is_enabled():
+            return None
+        if not self._schema_initialized:
+            self._initialize_schema()
+        if not self._schema_initialized:
+            return None
+
+        try:
+            with self._db_lock:
+                conn = self._connect(readonly=True)
+                try:
+                    # Load all recipes
+                    columns_sql = ", ".join(self._RECIPE_COLUMNS)
+                    rows = conn.execute(f"SELECT {columns_sql} FROM recipes").fetchall()
+
+                    if not rows:
+                        return None
+
+                finally:
+                    conn.close()
+        except FileNotFoundError:
+            return None
+        except Exception as exc:
+            logger.warning("Failed to load persisted recipe cache: %s", exc)
+            return None
+
+        raw_data: List[Dict] = []
+        file_stats: Dict[str, Tuple[float, int]] = {}
+
+        for row in rows:
+            recipe = self._row_to_recipe(row)
+            raw_data.append(recipe)
+
+            json_path = row["json_path"]
+            if json_path:
+                file_stats[json_path] = (
+                    row["file_mtime"] or 0.0,
+                    row["file_size"] or 0,
+                )
+
+        return PersistedRecipeData(raw_data=raw_data, file_stats=file_stats)
+
+    def save_cache(self, recipes: List[Dict], json_paths: Optional[Dict[str, str]] = None) -> None:
+        """Save all recipes to SQLite cache.
+
+        Args:
+            recipes: List of recipe dictionaries to persist.
+            json_paths: Optional mapping of recipe_id -> json_path for file stats.
+        """
+        if not self.is_enabled():
+            return
+        if not self._schema_initialized:
+            self._initialize_schema()
+        if not self._schema_initialized:
+            return
+
+        try:
+            with self._db_lock:
+                conn = self._connect()
+                try:
+                    conn.execute("PRAGMA foreign_keys = ON")
+                    conn.execute("BEGIN")
+
+                    # Clear existing data
+                    conn.execute("DELETE FROM recipes")
+
+                    # Prepare and insert all rows
+                    recipe_rows = []
+                    for recipe in recipes:
+                        recipe_id = str(recipe.get("id", ""))
+                        if not recipe_id:
+                            continue
+
+                        json_path = ""
+                        if json_paths:
+                            json_path = json_paths.get(recipe_id, "")
+
+                        row = self._prepare_recipe_row(recipe, json_path)
+                        recipe_rows.append(row)
+
+                    if recipe_rows:
+                        placeholders = ", ".join(["?"] * len(self._RECIPE_COLUMNS))
+                        columns = ", ".join(self._RECIPE_COLUMNS)
+                        conn.executemany(
+                            f"INSERT INTO recipes ({columns}) VALUES ({placeholders})",
+                            recipe_rows,
+                        )
+
+                    conn.commit()
+                    logger.debug("Persisted %d recipes to cache", len(recipe_rows))
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.warning("Failed to persist recipe cache: %s", exc)
+
+    def get_file_stats(self) -> Dict[str, Tuple[float, int]]:
+        """Return stored file stats for all cached recipes.
+
+        Returns:
+            Dictionary mapping json_path -> (mtime, size).
+        """
+        if not self.is_enabled() or not self._schema_initialized:
+            return {}
+
+        try:
+            with self._db_lock:
+                conn = self._connect(readonly=True)
+                try:
+                    rows = conn.execute(
+                        "SELECT json_path, file_mtime, file_size FROM recipes WHERE json_path IS NOT NULL"
+                    ).fetchall()
+                    return {
+                        row["json_path"]: (row["file_mtime"] or 0.0, row["file_size"] or 0)
+                        for row in rows
+                        if row["json_path"]
+                    }
+                finally:
+                    conn.close()
+        except Exception:
+            return {}
+
+    def update_recipe(self, recipe: Dict, json_path: Optional[str] = None) -> None:
+        """Update or insert a single recipe in the cache.
+
+        Args:
+            recipe: The recipe dictionary to persist.
+            json_path: Optional path to the recipe JSON file.
+        """
+        if not self.is_enabled() or not self._schema_initialized:
+            return
+
+        recipe_id = str(recipe.get("id", ""))
+        if not recipe_id:
+            return
+
+        try:
+            with self._db_lock:
+                conn = self._connect()
+                try:
+                    row = self._prepare_recipe_row(recipe, json_path or "")
+                    placeholders = ", ".join(["?"] * len(self._RECIPE_COLUMNS))
+                    columns = ", ".join(self._RECIPE_COLUMNS)
+                    conn.execute(
+                        f"INSERT OR REPLACE INTO recipes ({columns}) VALUES ({placeholders})",
+                        row,
+                    )
+                    conn.commit()
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Failed to update recipe %s in cache: %s", recipe_id, exc)
+
+    def remove_recipe(self, recipe_id: str) -> None:
+        """Remove a recipe from the cache by ID.
+
+        Args:
+            recipe_id: The ID of the recipe to remove.
+        """
+        if not self.is_enabled() or not self._schema_initialized:
+            return
+
+        if not recipe_id:
+            return
+
+        try:
+            with self._db_lock:
+                conn = self._connect()
+                try:
+                    conn.execute("DELETE FROM recipes WHERE recipe_id = ?", (str(recipe_id),))
+                    conn.commit()
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Failed to remove recipe %s from cache: %s", recipe_id, exc)
+
+    def get_indexed_recipe_ids(self) -> Set[str]:
+        """Return all recipe IDs in the cache.
+
+        Returns:
+            Set of recipe ID strings.
+        """
+        if not self.is_enabled() or not self._schema_initialized:
+            return set()
+
+        try:
+            with self._db_lock:
+                conn = self._connect(readonly=True)
+                try:
+                    rows = conn.execute("SELECT recipe_id FROM recipes").fetchall()
+                    return {row["recipe_id"] for row in rows if row["recipe_id"]}
+                finally:
+                    conn.close()
+        except Exception:
+            return set()
+
+    def get_recipe_count(self) -> int:
+        """Return the number of recipes in the cache."""
+        if not self.is_enabled() or not self._schema_initialized:
+            return 0
+
+        try:
+            with self._db_lock:
+                conn = self._connect(readonly=True)
+                try:
+                    result = conn.execute("SELECT COUNT(*) FROM recipes").fetchone()
+                    return result[0] if result else 0
+                finally:
+                    conn.close()
+        except Exception:
+            return 0
+
+    # Internal helpers
+
+    def _resolve_default_path(self, library_name: str) -> str:
+        env_override = os.environ.get("LORA_MANAGER_RECIPE_CACHE_DB")
+        return resolve_cache_path_with_migration(
+            CacheType.RECIPE,
+            library_name=library_name,
+            env_override=env_override,
+        )
+
+    def _initialize_schema(self) -> None:
+        with self._db_lock:
+            if self._schema_initialized:
+                return
+            try:
+                with self._connect() as conn:
+                    conn.execute("PRAGMA journal_mode=WAL")
+                    conn.execute("PRAGMA foreign_keys = ON")
+                    conn.executescript(
+                        """
+                        CREATE TABLE IF NOT EXISTS recipes (
+                            recipe_id TEXT PRIMARY KEY,
+                            file_path TEXT,
+                            json_path TEXT,
+                            title TEXT,
+                            folder TEXT,
+                            base_model TEXT,
+                            fingerprint TEXT,
+                            created_date REAL,
+                            modified REAL,
+                            file_mtime REAL,
+                            file_size INTEGER,
+                            favorite INTEGER DEFAULT 0,
+                            repair_version INTEGER DEFAULT 0,
+                            preview_nsfw_level INTEGER DEFAULT 0,
+                            loras_json TEXT,
+                            checkpoint_json TEXT,
+                            gen_params_json TEXT,
+                            tags_json TEXT
+                        );
+
+                        CREATE INDEX IF NOT EXISTS idx_recipes_json_path ON recipes(json_path);
+                        CREATE INDEX IF NOT EXISTS idx_recipes_fingerprint ON recipes(fingerprint);
+
+                        CREATE TABLE IF NOT EXISTS cache_metadata (
+                            key TEXT PRIMARY KEY,
+                            value TEXT
+                        );
+                        """
+                    )
+                    conn.commit()
+                self._schema_initialized = True
+            except Exception as exc:
+                logger.warning("Failed to initialize persistent recipe cache schema: %s", exc)
+
+    def _connect(self, readonly: bool = False) -> sqlite3.Connection:
+        uri = False
+        path = self._db_path
+        if readonly:
+            if not os.path.exists(path):
+                raise FileNotFoundError(path)
+            path = f"file:{path}?mode=ro"
+            uri = True
+        conn = sqlite3.connect(path, check_same_thread=False, uri=uri, detect_types=sqlite3.PARSE_DECLTYPES)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _prepare_recipe_row(self, recipe: Dict, json_path: str) -> Tuple:
+        """Convert a recipe dict to a row tuple for SQLite insertion."""
+        loras = recipe.get("loras")
+        loras_json = json.dumps(loras) if loras else None
+
+        checkpoint = recipe.get("checkpoint")
+        checkpoint_json = json.dumps(checkpoint) if checkpoint else None
+
+        gen_params = recipe.get("gen_params")
+        gen_params_json = json.dumps(gen_params) if gen_params else None
+
+        tags = recipe.get("tags")
+        tags_json = json.dumps(tags) if tags else None
+
+        # Get file stats if json_path exists
+        file_mtime = 0.0
+        file_size = 0
+        if json_path and os.path.exists(json_path):
+            try:
+                stat = os.stat(json_path)
+                file_mtime = stat.st_mtime
+                file_size = stat.st_size
+            except OSError:
+                pass
+
+        return (
+            str(recipe.get("id", "")),
+            recipe.get("file_path"),
+            json_path,
+            recipe.get("title"),
+            recipe.get("folder"),
+            recipe.get("base_model"),
+            recipe.get("fingerprint"),
+            float(recipe.get("created_date") or 0.0),
+            float(recipe.get("modified") or 0.0),
+            file_mtime,
+            file_size,
+            1 if recipe.get("favorite") else 0,
+            int(recipe.get("repair_version") or 0),
+            int(recipe.get("preview_nsfw_level") or 0),
+            loras_json,
+            checkpoint_json,
+            gen_params_json,
+            tags_json,
+        )
+
+    def _row_to_recipe(self, row: sqlite3.Row) -> Dict:
+        """Convert a SQLite row to a recipe dictionary."""
+        loras = []
+        if row["loras_json"]:
+            try:
+                loras = json.loads(row["loras_json"])
+            except json.JSONDecodeError:
+                pass
+
+        checkpoint = None
+        if row["checkpoint_json"]:
+            try:
+                checkpoint = json.loads(row["checkpoint_json"])
+            except json.JSONDecodeError:
+                pass
+
+        gen_params = {}
+        if row["gen_params_json"]:
+            try:
+                gen_params = json.loads(row["gen_params_json"])
+            except json.JSONDecodeError:
+                pass
+
+        tags = []
+        if row["tags_json"]:
+            try:
+                tags = json.loads(row["tags_json"])
+            except json.JSONDecodeError:
+                pass
+
+        recipe = {
+            "id": row["recipe_id"],
+            "file_path": row["file_path"] or "",
+            "title": row["title"] or "",
+            "folder": row["folder"] or "",
+            "base_model": row["base_model"] or "",
+            "fingerprint": row["fingerprint"] or "",
+            "created_date": row["created_date"] or 0.0,
+            "modified": row["modified"] or 0.0,
+            "favorite": bool(row["favorite"]),
+            "repair_version": row["repair_version"] or 0,
+            "preview_nsfw_level": row["preview_nsfw_level"] or 0,
+            "loras": loras,
+            "gen_params": gen_params,
+        }
+
+        if tags:
+            recipe["tags"] = tags
+
+        if checkpoint:
+            recipe["checkpoint"] = checkpoint
+
+        return recipe
+
+
+def get_persistent_recipe_cache() -> PersistentRecipeCache:
+    """Get the default persistent recipe cache instance for the active library."""
+    from .settings_manager import get_settings_manager
+
+    library_name = get_settings_manager().get_active_library_name()
+    return PersistentRecipeCache.get_default(library_name)

py/services/recipe_cache.py

@@ -7,12 +7,18 @@ from natsort import natsorted
 @dataclass
 class RecipeCache:
     """Cache structure for Recipe data"""
+
     raw_data: List[Dict]
     sorted_by_name: List[Dict]
     sorted_by_date: List[Dict]
+    folders: List[str] | None = None
+    folder_tree: Dict | None = None
 
     def __post_init__(self):
         self._lock = asyncio.Lock()
+        # Normalize optional metadata containers
+        self.folders = self.folders or []
+        self.folder_tree = self.folder_tree or {}
 
     async def resort(self, name_only: bool = False):
         """Resort all cached data views"""

py/services/recipe_fts_index.py

@@ -0,0 +1,612 @@
+"""SQLite FTS5-based full-text search index for recipes.
+
+This module provides fast recipe search using SQLite's FTS5 extension,
+enabling sub-100ms search times even with 20k+ recipes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+import sqlite3
+import threading
+import time
+from typing import Any, Dict, List, Optional, Set
+
+from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
+
+logger = logging.getLogger(__name__)
+
+
+class RecipeFTSIndex:
+    """SQLite FTS5-based full-text search index for recipes.
+
+    Provides fast prefix-based search across multiple recipe fields:
+    - title
+    - tags
+    - lora_names (file names)
+    - lora_models (model names)
+    - prompt
+    - negative_prompt
+    """
+
+    _DEFAULT_FILENAME = "recipe_fts.sqlite"
+
+    # Map of search option keys to FTS column names
+    FIELD_MAP = {
+        'title': ['title'],
+        'tags': ['tags'],
+        'lora_name': ['lora_names'],
+        'lora_model': ['lora_models'],
+        'prompt': ['prompt', 'negative_prompt'],
+    }
+
+    def __init__(self, db_path: Optional[str] = None) -> None:
+        """Initialize the FTS index.
+
+        Args:
+            db_path: Optional path to the SQLite database file.
+                     If not provided, uses the default location in settings directory.
+        """
+        self._db_path = db_path or self._resolve_default_path()
+        self._lock = threading.Lock()
+        self._ready = threading.Event()
+        self._indexing_in_progress = False
+        self._schema_initialized = False
+        self._warned_not_ready = False
+
+        # Ensure directory exists
+        try:
+            directory = os.path.dirname(self._db_path)
+            if directory:
+                os.makedirs(directory, exist_ok=True)
+        except Exception as exc:
+            logger.warning("Could not create FTS index directory %s: %s", directory, exc)
+
+    def _resolve_default_path(self) -> str:
+        """Resolve the default database path."""
+        env_override = os.environ.get("LORA_MANAGER_RECIPE_FTS_DB")
+        return resolve_cache_path_with_migration(
+            CacheType.RECIPE_FTS,
+            env_override=env_override,
+        )
+
+    def get_database_path(self) -> str:
+        """Return the resolved database path."""
+        return self._db_path
+
+    def is_ready(self) -> bool:
+        """Check if the FTS index is ready for queries."""
+        return self._ready.is_set()
+
+    def is_indexing(self) -> bool:
+        """Check if indexing is currently in progress."""
+        return self._indexing_in_progress
+
+    def initialize(self) -> None:
+        """Initialize the database schema."""
+        if self._schema_initialized:
+            return
+
+        with self._lock:
+            if self._schema_initialized:
+                return
+
+            try:
+                conn = self._connect()
+                try:
+                    conn.execute("PRAGMA journal_mode=WAL")
+                    conn.executescript("""
+                        -- FTS5 virtual table for full-text search
+                        -- Note: We use a regular FTS5 table (not contentless) so we can retrieve recipe_id
+                        CREATE VIRTUAL TABLE IF NOT EXISTS recipe_fts USING fts5(
+                            recipe_id,
+                            title,
+                            tags,
+                            lora_names,
+                            lora_models,
+                            prompt,
+                            negative_prompt,
+                            tokenize='unicode61 remove_diacritics 2'
+                        );
+
+                        -- Recipe ID to rowid mapping for fast lookups and deletions
+                        CREATE TABLE IF NOT EXISTS recipe_rowid (
+                            recipe_id TEXT PRIMARY KEY,
+                            fts_rowid INTEGER UNIQUE
+                        );
+
+                        -- Index version tracking
+                        CREATE TABLE IF NOT EXISTS fts_metadata (
+                            key TEXT PRIMARY KEY,
+                            value TEXT
+                        );
+                    """)
+                    conn.commit()
+                    self._schema_initialized = True
+                    logger.debug("FTS index schema initialized at %s", self._db_path)
+                finally:
+                    conn.close()
+            except Exception as exc:
+                logger.error("Failed to initialize FTS schema: %s", exc)
+
+    def build_index(self, recipes: List[Dict[str, Any]]) -> None:
+        """Build or rebuild the entire FTS index from recipe data.
+
+        Args:
+            recipes: List of recipe dictionaries to index.
+        """
+        if self._indexing_in_progress:
+            logger.warning("FTS indexing already in progress, skipping")
+            return
+
+        self._indexing_in_progress = True
+        self._ready.clear()
+        start_time = time.time()
+
+        try:
+            self.initialize()
+            if not self._schema_initialized:
+                logger.error("Cannot build FTS index: schema not initialized")
+                return
+
+            with self._lock:
+                conn = self._connect()
+                try:
+                    conn.execute("BEGIN")
+
+                    # Clear existing data
+                    conn.execute("DELETE FROM recipe_fts")
+                    conn.execute("DELETE FROM recipe_rowid")
+
+                    # Batch insert for performance
+                    batch_size = 500
+                    total = len(recipes)
+                    inserted = 0
+
+                    for i in range(0, total, batch_size):
+                        batch = recipes[i:i + batch_size]
+                        rows = []
+                        rowid_mappings = []
+
+                        for recipe in batch:
+                            recipe_id = str(recipe.get('id', ''))
+                            if not recipe_id:
+                                continue
+
+                            row = self._prepare_fts_row(recipe)
+                            rows.append(row)
+                            inserted += 1
+
+                        if rows:
+                            # Insert into FTS table
+                            conn.executemany(
+                                """INSERT INTO recipe_fts (recipe_id, title, tags, lora_names,
+                                   lora_models, prompt, negative_prompt)
+                                   VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                                rows
+                            )
+
+                            # Build rowid mappings
+                            for row in rows:
+                                recipe_id = row[0]
+                                cursor = conn.execute(
+                                    "SELECT rowid FROM recipe_fts WHERE recipe_id = ?",
+                                    (recipe_id,)
+                                )
+                                result = cursor.fetchone()
+                                if result:
+                                    rowid_mappings.append((recipe_id, result[0]))
+
+                            if rowid_mappings:
+                                conn.executemany(
+                                    "INSERT OR REPLACE INTO recipe_rowid (recipe_id, fts_rowid) VALUES (?, ?)",
+                                    rowid_mappings
+                                )
+
+                    # Update metadata
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ('last_build_time', str(time.time()))
+                    )
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ('recipe_count', str(inserted))
+                    )
+
+                    conn.commit()
+                    elapsed = time.time() - start_time
+                    logger.info("FTS index built: %d recipes indexed in %.2fs", inserted, elapsed)
+                finally:
+                    conn.close()
+
+            self._ready.set()
+
+        except Exception as exc:
+            logger.error("Failed to build FTS index: %s", exc, exc_info=True)
+        finally:
+            self._indexing_in_progress = False
+
+    def search(self, query: str, fields: Optional[Set[str]] = None) -> Set[str]:
+        """Search recipes using FTS5 with prefix matching.
+
+        Args:
+            query: The search query string.
+            fields: Optional set of field names to search. If None, searches all fields.
+                    Valid fields: 'title', 'tags', 'lora_name', 'lora_model', 'prompt'
+
+        Returns:
+            Set of matching recipe IDs.
+        """
+        if not self.is_ready():
+            if not self._warned_not_ready:
+                logger.debug("FTS index not ready, returning empty results")
+                self._warned_not_ready = True
+            return set()
+
+        if not query or not query.strip():
+            return set()
+
+        fts_query = self._build_fts_query(query, fields)
+        if not fts_query:
+            return set()
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    cursor = conn.execute(
+                        "SELECT recipe_id FROM recipe_fts WHERE recipe_fts MATCH ?",
+                        (fts_query,)
+                    )
+                    return {row[0] for row in cursor.fetchall()}
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("FTS search error for query '%s': %s", query, exc)
+            return set()
+
+    def add_recipe(self, recipe: Dict[str, Any]) -> bool:
+        """Add a single recipe to the FTS index.
+
+        Args:
+            recipe: The recipe dictionary to add.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        if not self.is_ready():
+            return False
+
+        recipe_id = str(recipe.get('id', ''))
+        if not recipe_id:
+            return False
+
+        try:
+            with self._lock:
+                conn = self._connect()
+                try:
+                    # Remove existing entry if present
+                    self._remove_recipe_locked(conn, recipe_id)
+
+                    # Insert new entry
+                    row = self._prepare_fts_row(recipe)
+                    conn.execute(
+                        """INSERT INTO recipe_fts (recipe_id, title, tags, lora_names,
+                           lora_models, prompt, negative_prompt)
+                           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+                        row
+                    )
+
+                    # Update rowid mapping
+                    cursor = conn.execute(
+                        "SELECT rowid FROM recipe_fts WHERE recipe_id = ?",
+                        (recipe_id,)
+                    )
+                    result = cursor.fetchone()
+                    if result:
+                        conn.execute(
+                            "INSERT OR REPLACE INTO recipe_rowid (recipe_id, fts_rowid) VALUES (?, ?)",
+                            (recipe_id, result[0])
+                        )
+
+                    conn.commit()
+                    return True
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Failed to add recipe %s to FTS index: %s", recipe_id, exc)
+            return False
+
+    def remove_recipe(self, recipe_id: str) -> bool:
+        """Remove a recipe from the FTS index.
+
+        Args:
+            recipe_id: The ID of the recipe to remove.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        if not self.is_ready():
+            return False
+
+        if not recipe_id:
+            return False
+
+        try:
+            with self._lock:
+                conn = self._connect()
+                try:
+                    self._remove_recipe_locked(conn, recipe_id)
+                    conn.commit()
+                    return True
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Failed to remove recipe %s from FTS index: %s", recipe_id, exc)
+            return False
+
+    def update_recipe(self, recipe: Dict[str, Any]) -> bool:
+        """Update a recipe in the FTS index.
+
+        Args:
+            recipe: The updated recipe dictionary.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        return self.add_recipe(recipe)  # add_recipe handles removal and re-insertion
+
+    def clear(self) -> bool:
+        """Clear all data from the FTS index.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        try:
+            with self._lock:
+                conn = self._connect()
+                try:
+                    conn.execute("DELETE FROM recipe_fts")
+                    conn.execute("DELETE FROM recipe_rowid")
+                    conn.commit()
+                    self._ready.clear()
+                    return True
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.error("Failed to clear FTS index: %s", exc)
+            return False
+
+    def get_indexed_count(self) -> int:
+        """Return the number of recipes currently indexed."""
+        if not self._schema_initialized:
+            return 0
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    cursor = conn.execute("SELECT COUNT(*) FROM recipe_fts")
+                    result = cursor.fetchone()
+                    return result[0] if result else 0
+                finally:
+                    conn.close()
+        except Exception:
+            return 0
+
+    def get_indexed_recipe_ids(self) -> Set[str]:
+        """Return all recipe IDs currently in the index.
+
+        Returns:
+            Set of recipe ID strings.
+        """
+        if not self._schema_initialized:
+            self.initialize()
+
+        if not self._schema_initialized:
+            return set()
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    cursor = conn.execute("SELECT recipe_id FROM recipe_fts")
+                    return {row[0] for row in cursor.fetchall() if row[0]}
+                finally:
+                    conn.close()
+        except FileNotFoundError:
+            return set()
+        except Exception as exc:
+            logger.debug("Failed to get indexed recipe IDs: %s", exc)
+            return set()
+
+    def validate_index(self, recipe_count: int, recipe_ids: Set[str]) -> bool:
+        """Check if the FTS index matches the expected recipes.
+
+        This method validates whether the existing FTS index can be reused
+        without a full rebuild. It checks:
+        1. The index has been initialized
+        2. The count matches
+        3. The recipe IDs match
+
+        Args:
+            recipe_count: Expected number of recipes.
+            recipe_ids: Expected set of recipe IDs.
+
+        Returns:
+            True if the index is valid and can be reused, False otherwise.
+        """
+        if not self._schema_initialized:
+            self.initialize()
+
+        if not self._schema_initialized:
+            return False
+
+        try:
+            indexed_count = self.get_indexed_count()
+            if indexed_count != recipe_count:
+                logger.debug(
+                    "FTS index count mismatch: indexed=%d, expected=%d",
+                    indexed_count, recipe_count
+                )
+                return False
+
+            indexed_ids = self.get_indexed_recipe_ids()
+            if indexed_ids != recipe_ids:
+                missing = recipe_ids - indexed_ids
+                extra = indexed_ids - recipe_ids
+                if missing:
+                    logger.debug("FTS index missing %d recipe IDs", len(missing))
+                if extra:
+                    logger.debug("FTS index has %d extra recipe IDs", len(extra))
+                return False
+
+            return True
+        except Exception as exc:
+            logger.debug("FTS index validation failed: %s", exc)
+            return False
+
+    # Internal helpers
+
+    def _connect(self, readonly: bool = False) -> sqlite3.Connection:
+        """Create a database connection."""
+        uri = False
+        path = self._db_path
+        if readonly:
+            if not os.path.exists(path):
+                raise FileNotFoundError(path)
+            path = f"file:{path}?mode=ro"
+            uri = True
+        conn = sqlite3.connect(path, check_same_thread=False, uri=uri)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _remove_recipe_locked(self, conn: sqlite3.Connection, recipe_id: str) -> None:
+        """Remove a recipe entry. Caller must hold the lock."""
+        # Get the rowid for deletion
+        cursor = conn.execute(
+            "SELECT fts_rowid FROM recipe_rowid WHERE recipe_id = ?",
+            (recipe_id,)
+        )
+        result = cursor.fetchone()
+        if result:
+            fts_rowid = result[0]
+            # Delete from FTS using rowid
+            conn.execute(
+                "DELETE FROM recipe_fts WHERE rowid = ?",
+                (fts_rowid,)
+            )
+        # Also try direct delete by recipe_id (handles edge cases)
+        conn.execute(
+            "DELETE FROM recipe_fts WHERE recipe_id = ?",
+            (recipe_id,)
+        )
+        conn.execute(
+            "DELETE FROM recipe_rowid WHERE recipe_id = ?",
+            (recipe_id,)
+        )
+
+    def _prepare_fts_row(self, recipe: Dict[str, Any]) -> tuple:
+        """Prepare a row tuple for FTS insertion."""
+        recipe_id = str(recipe.get('id', ''))
+        title = str(recipe.get('title', ''))
+
+        # Extract tags as space-separated string
+        tags_list = recipe.get('tags', [])
+        tags = ' '.join(str(t) for t in tags_list if t) if tags_list else ''
+
+        # Extract LoRA file names and model names
+        loras = recipe.get('loras', [])
+        lora_names = []
+        lora_models = []
+        for lora in loras:
+            if isinstance(lora, dict):
+                file_name = lora.get('file_name', '')
+                if file_name:
+                    lora_names.append(str(file_name))
+                model_name = lora.get('modelName', '')
+                if model_name:
+                    lora_models.append(str(model_name))
+
+        lora_names_str = ' '.join(lora_names)
+        lora_models_str = ' '.join(lora_models)
+
+        # Extract prompts from gen_params
+        gen_params = recipe.get('gen_params', {})
+        prompt = str(gen_params.get('prompt', '')) if gen_params else ''
+        negative_prompt = str(gen_params.get('negative_prompt', '')) if gen_params else ''
+
+        return (recipe_id, title, tags, lora_names_str, lora_models_str, prompt, negative_prompt)
+
+    def _build_fts_query(self, query: str, fields: Optional[Set[str]] = None) -> str:
+        """Build an FTS5 query string with prefix matching and field restrictions.
+
+        Args:
+            query: The user's search query.
+            fields: Optional set of field names to restrict search to.
+
+        Returns:
+            FTS5 query string.
+        """
+        # Split query into words and clean them
+        words = query.lower().split()
+        if not words:
+            return ''
+
+        # Escape and add prefix wildcard to each word
+        prefix_terms = []
+        for word in words:
+            escaped = self._escape_fts_query(word)
+            if escaped:
+                # Add prefix wildcard for substring-like matching
+                # FTS5 prefix queries: word* matches words starting with "word"
+                prefix_terms.append(f'{escaped}*')
+
+        if not prefix_terms:
+            return ''
+
+        # Combine terms with implicit AND (all words must match)
+        term_expr = ' '.join(prefix_terms)
+
+        # If no field restriction, search all indexed fields (not recipe_id)
+        if not fields:
+            return term_expr
+
+        # Build field-restricted query where ALL words must match within at least one field
+        field_clauses = []
+        for field in fields:
+            if field in self.FIELD_MAP:
+                cols = self.FIELD_MAP[field]
+                for col in cols:
+                    # Create clause where ALL terms must match in this column (implicit AND)
+                    col_terms = [f'{col}:{term}' for term in prefix_terms]
+                    field_clauses.append('(' + ' '.join(col_terms) + ')')
+
+        if not field_clauses:
+            return term_expr
+
+        # Any field matching all terms is acceptable (OR between field clauses)
+        return ' OR '.join(field_clauses)
+
+    def _escape_fts_query(self, text: str) -> str:
+        """Escape special FTS5 characters.
+
+        FTS5 special characters: " ( ) * : ^ -
+        We keep * for prefix matching but escape others.
+        """
+        if not text:
+            return ''
+
+        # Replace FTS5 special characters with space
+        # Keep alphanumeric, CJK characters, and common punctuation
+        special = ['"', '(', ')', '*', ':', '^', '-', '{', '}', '[', ']']
+        result = text
+        for char in special:
+            result = result.replace(char, ' ')
+
+        # Collapse multiple spaces and strip
+        result = re.sub(r'\s+', ' ', result).strip()
+        return result

py/services/recipes/analysis_service.py

@@ -13,6 +13,7 @@ import numpy as np
 from PIL import Image
 
 from ...utils.utils import calculate_recipe_fingerprint
+from ...utils.civitai_utils import rewrite_preview_url
 from .errors import (
     RecipeDownloadError,
     RecipeNotFoundError,
@@ -94,18 +95,39 @@ class RecipeAnalysisService:
         if civitai_client is None:
             raise RecipeServiceError("Civitai client unavailable")
 
-        temp_path = self._create_temp_path()
+        temp_path = None
         metadata: Optional[dict[str, Any]] = None
+        is_video = False
+        extension = ".jpg"  # Default
+
         try:
             civitai_match = re.match(r"https://civitai\.com/images/(\d+)", url)
             if civitai_match:
                 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")
+                
                 image_url = image_info.get("url")
                 if not image_url:
                     raise RecipeDownloadError("No image URL found in Civitai response")
+                
+                is_video = image_info.get("type") == "video"
+                
+                # Use optimized preview URLs if possible
+                rewritten_url, _ = rewrite_preview_url(image_url, media_type=image_info.get("type"))
+                if rewritten_url:
+                    image_url = rewritten_url
+
+                if is_video:
+                    # Extract extension from URL
+                    url_path = image_url.split('?')[0].split('#')[0]
+                    extension = os.path.splitext(url_path)[1].lower() or ".mp4"
+                else:
+                    extension = ".jpg"
+
+                temp_path = self._create_temp_path(suffix=extension)
                 await self._download_image(image_url, temp_path)
+                
                 metadata = image_info.get("meta") if "meta" in image_info else None
                 if (
                     isinstance(metadata, dict)
@@ -114,22 +136,31 @@ class RecipeAnalysisService:
                 ):
                     metadata = metadata["meta"]
             else:
+                # Basic extension detection for non-Civitai URLs
+                url_path = url.split('?')[0].split('#')[0]
+                extension = os.path.splitext(url_path)[1].lower()
+                if extension in [".mp4", ".webm"]:
+                    is_video = True
+                else:
+                    extension = ".jpg"
+                
+                temp_path = self._create_temp_path(suffix=extension)
                 await self._download_image(url, temp_path)
 
-            if metadata is None:
+            if metadata is None and not is_video:
                 metadata = self._exif_utils.extract_image_metadata(temp_path)
 
-            if not metadata:
-                return self._metadata_not_found_response(temp_path)
-
             return await self._parse_metadata(
-                metadata,
+                metadata or {},
                 recipe_scanner=recipe_scanner,
                 image_path=temp_path,
                 include_image_base64=True,
+                is_video=is_video,
+                extension=extension,
             )
         finally:
-            self._safe_cleanup(temp_path)
+            if temp_path:
+                self._safe_cleanup(temp_path)
 
     async def analyze_local_image(
         self,
@@ -198,12 +229,16 @@ class RecipeAnalysisService:
         recipe_scanner,
         image_path: Optional[str],
         include_image_base64: bool,
+        is_video: bool = False,
+        extension: str = ".jpg",
     ) -> AnalysisResult:
         parser = self._recipe_parser_factory.create_parser(metadata)
         if parser is None:
             payload = {"error": "No parser found for this image", "loras": []}
             if include_image_base64 and image_path:
                 payload["image_base64"] = self._encode_file(image_path)
+            payload["is_video"] = is_video
+            payload["extension"] = extension
             return AnalysisResult(payload)
 
         result = await parser.parse_metadata(metadata, recipe_scanner=recipe_scanner)
@@ -211,6 +246,9 @@ class RecipeAnalysisService:
         if include_image_base64 and image_path:
             result["image_base64"] = self._encode_file(image_path)
 
+        result["is_video"] = is_video
+        result["extension"] = extension
+
         if "error" in result and not result.get("loras"):
             return AnalysisResult(result)
 
@@ -241,8 +279,8 @@ class RecipeAnalysisService:
             temp_file.write(data)
             return temp_file.name
 
-    def _create_temp_path(self) -> str:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
+    def _create_temp_path(self, suffix: str = ".jpg") -> str:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
             return temp_file.name
 
     def _safe_cleanup(self, path: Optional[str]) -> None:

py/services/recipes/persistence_service.py

@@ -5,6 +5,7 @@ import base64
 import json
 import os
 import re
+import shutil
 import time
 import uuid
 from dataclasses import dataclass
@@ -46,6 +47,7 @@ class RecipePersistenceService:
         name: str | None,
         tags: Iterable[str],
         metadata: Optional[dict[str, Any]],
+        extension: str | None = None,
     ) -> PersistenceResult:
         """Persist a user uploaded recipe."""
 
@@ -64,13 +66,21 @@ class RecipePersistenceService:
         os.makedirs(recipes_dir, exist_ok=True)
 
         recipe_id = str(uuid.uuid4())
-        optimized_image, extension = self._exif_utils.optimize_image(
-            image_data=resolved_image_bytes,
-            target_width=self._card_preview_width,
-            format="webp",
-            quality=85,
-            preserve_metadata=True,
-        )
+        
+        # Handle video formats by bypassing optimization and metadata embedding
+        is_video = extension in [".mp4", ".webm"]
+        if is_video:
+            optimized_image = resolved_image_bytes
+            # extension is already set
+        else:
+            optimized_image, extension = self._exif_utils.optimize_image(
+                image_data=resolved_image_bytes,
+                target_width=self._card_preview_width,
+                format="webp",
+                quality=85,
+                preserve_metadata=True,
+            )
+            
         image_filename = f"{recipe_id}{extension}"
         image_path = os.path.join(recipes_dir, image_filename)
         normalized_image_path = os.path.normpath(image_path)
@@ -126,7 +136,8 @@ class RecipePersistenceService:
         with open(json_path, "w", encoding="utf-8") as file_obj:
             json.dump(recipe_data, file_obj, indent=4, ensure_ascii=False)
 
-        self._exif_utils.append_recipe_metadata(normalized_image_path, recipe_data)
+        if not is_video:
+            self._exif_utils.append_recipe_metadata(normalized_image_path, recipe_data)
 
         matching_recipes = await self._find_matching_recipes(recipe_scanner, fingerprint, exclude_id=recipe_id)
         await recipe_scanner.add_recipe(recipe_data)
@@ -144,12 +155,8 @@ class RecipePersistenceService:
     async def delete_recipe(self, *, recipe_scanner, recipe_id: str) -> PersistenceResult:
         """Delete an existing recipe."""
 
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir or not os.path.exists(recipes_dir):
-            raise RecipeNotFoundError("Recipes directory not found")
-
-        recipe_json_path = os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-        if not os.path.exists(recipe_json_path):
+        recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
             raise RecipeNotFoundError("Recipe not found")
 
         with open(recipe_json_path, "r", encoding="utf-8") as file_obj:
@@ -166,9 +173,9 @@ class RecipePersistenceService:
     async def update_recipe(self, *, recipe_scanner, recipe_id: str, updates: dict[str, Any]) -> PersistenceResult:
         """Update persisted metadata for a recipe."""
 
-        if not any(key in updates for key in ("title", "tags", "source_path", "preview_nsfw_level")):
+        if not any(key in updates for key in ("title", "tags", "source_path", "preview_nsfw_level", "favorite")):
             raise RecipeValidationError(
-                "At least one field to update must be provided (title or tags or source_path or preview_nsfw_level)"
+                "At least one field to update must be provided (title or tags or source_path or preview_nsfw_level or favorite)"
             )
 
         success = await recipe_scanner.update_recipe_metadata(recipe_id, updates)
@@ -177,6 +184,163 @@ class RecipePersistenceService:
 
         return PersistenceResult({"success": True, "recipe_id": recipe_id, "updates": updates})
 
+    def _normalize_target_path(self, recipe_scanner, target_path: str) -> tuple[str, str]:
+        """Normalize and validate the target path for recipe moves."""
+
+        if not target_path:
+            raise RecipeValidationError("Target path is required")
+
+        recipes_root = recipe_scanner.recipes_dir
+        if not recipes_root:
+            raise RecipeNotFoundError("Recipes directory not found")
+
+        normalized_target = os.path.normpath(target_path)
+        recipes_root = os.path.normpath(recipes_root)
+        if not os.path.isabs(normalized_target):
+            normalized_target = os.path.normpath(os.path.join(recipes_root, normalized_target))
+
+        try:
+            common_root = os.path.commonpath([normalized_target, recipes_root])
+        except ValueError as exc:
+            raise RecipeValidationError("Invalid target path") from exc
+
+        if common_root != recipes_root:
+            raise RecipeValidationError("Target path must be inside the recipes directory")
+
+        return normalized_target, recipes_root
+
+    async def _move_recipe_files(
+        self,
+        *,
+        recipe_scanner,
+        recipe_id: str,
+        normalized_target: str,
+        recipes_root: str,
+    ) -> dict[str, Any]:
+        """Move the recipe's JSON and preview image into the normalized target."""
+
+        recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
+            raise RecipeNotFoundError("Recipe not found")
+
+        recipe_data = await recipe_scanner.get_recipe_by_id(recipe_id)
+        if not recipe_data:
+            raise RecipeNotFoundError("Recipe not found")
+
+        current_json_dir = os.path.dirname(recipe_json_path)
+        normalized_image_path = os.path.normpath(recipe_data.get("file_path") or "") if recipe_data.get("file_path") else None
+
+        os.makedirs(normalized_target, exist_ok=True)
+
+        if os.path.normpath(current_json_dir) == normalized_target:
+            return {
+                "success": True,
+                "message": "Recipe is already in the target folder",
+                "recipe_id": recipe_id,
+                "original_file_path": recipe_data.get("file_path"),
+                "new_file_path": recipe_data.get("file_path"),
+            }
+
+        new_json_path = os.path.normpath(os.path.join(normalized_target, os.path.basename(recipe_json_path)))
+        shutil.move(recipe_json_path, new_json_path)
+
+        new_image_path = normalized_image_path
+        if normalized_image_path:
+            target_image_path = os.path.normpath(os.path.join(normalized_target, os.path.basename(normalized_image_path)))
+            if os.path.exists(normalized_image_path) and normalized_image_path != target_image_path:
+                shutil.move(normalized_image_path, target_image_path)
+            new_image_path = target_image_path
+
+        relative_folder = os.path.relpath(normalized_target, recipes_root)
+        if relative_folder in (".", ""):
+            relative_folder = ""
+        updates = {"file_path": new_image_path or recipe_data.get("file_path"), "folder": relative_folder.replace(os.path.sep, "/")}
+
+        updated = await recipe_scanner.update_recipe_metadata(recipe_id, updates)
+        if not updated:
+            raise RecipeNotFoundError("Recipe not found after move")
+
+        return {
+            "success": True,
+            "recipe_id": recipe_id,
+            "original_file_path": recipe_data.get("file_path"),
+            "new_file_path": updates["file_path"],
+            "json_path": new_json_path,
+            "folder": updates["folder"],
+        }
+
+    async def move_recipe(self, *, recipe_scanner, recipe_id: str, target_path: str) -> PersistenceResult:
+        """Move a recipe's assets into a new folder under the recipes root."""
+
+        normalized_target, recipes_root = self._normalize_target_path(recipe_scanner, target_path)
+        result = await self._move_recipe_files(
+            recipe_scanner=recipe_scanner,
+            recipe_id=recipe_id,
+            normalized_target=normalized_target,
+            recipes_root=recipes_root,
+        )
+        return PersistenceResult(result)
+
+    async def move_recipes_bulk(
+        self,
+        *,
+        recipe_scanner,
+        recipe_ids: Iterable[str],
+        target_path: str,
+    ) -> PersistenceResult:
+        """Move multiple recipes to a new folder."""
+
+        recipe_ids = list(recipe_ids)
+        if not recipe_ids:
+            raise RecipeValidationError("No recipe IDs provided")
+
+        normalized_target, recipes_root = self._normalize_target_path(recipe_scanner, target_path)
+
+        results: list[dict[str, Any]] = []
+        success_count = 0
+        failure_count = 0
+
+        for recipe_id in recipe_ids:
+            try:
+                move_result = await self._move_recipe_files(
+                    recipe_scanner=recipe_scanner,
+                    recipe_id=str(recipe_id),
+                    normalized_target=normalized_target,
+                    recipes_root=recipes_root,
+                )
+                results.append(
+                    {
+                        "recipe_id": recipe_id,
+                        "original_file_path": move_result.get("original_file_path"),
+                        "new_file_path": move_result.get("new_file_path"),
+                        "success": True,
+                        "message": move_result.get("message", ""),
+                        "folder": move_result.get("folder", ""),
+                    }
+                )
+                success_count += 1
+            except Exception as exc:  # pragma: no cover - per-item error handling
+                results.append(
+                    {
+                        "recipe_id": recipe_id,
+                        "original_file_path": None,
+                        "new_file_path": None,
+                        "success": False,
+                        "message": str(exc),
+                    }
+                )
+                failure_count += 1
+
+        return PersistenceResult(
+            {
+                "success": True,
+                "message": f"Moved {success_count} of {len(recipe_ids)} recipes",
+                "results": results,
+                "success_count": success_count,
+                "failure_count": failure_count,
+            }
+        )
+
     async def reconnect_lora(
         self,
         *,
@@ -187,8 +351,8 @@ class RecipePersistenceService:
     ) -> PersistenceResult:
         """Reconnect a LoRA entry within an existing recipe."""
 
-        recipe_path = os.path.join(recipe_scanner.recipes_dir, f"{recipe_id}.recipe.json")
-        if not os.path.exists(recipe_path):
+        recipe_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_path or not os.path.exists(recipe_path):
             raise RecipeNotFoundError("Recipe not found")
 
         target_lora = await recipe_scanner.get_local_lora(target_name)
@@ -233,16 +397,12 @@ class RecipePersistenceService:
         if not recipe_ids:
             raise RecipeValidationError("No recipe IDs provided")
 
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir or not os.path.exists(recipes_dir):
-            raise RecipeNotFoundError("Recipes directory not found")
-
         deleted_recipes: list[str] = []
         failed_recipes: list[dict[str, Any]] = []
 
         for recipe_id in recipe_ids:
-            recipe_json_path = os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-            if not os.path.exists(recipe_json_path):
+            recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+            if not recipe_json_path or not os.path.exists(recipe_json_path):
                 failed_recipes.append({"id": recipe_id, "reason": "Recipe not found"})
                 continue
 

py/services/service_registry.py

@@ -233,23 +233,44 @@ class ServiceRegistry:
     async def get_embedding_scanner(cls):
         """Get or create Embedding scanner instance"""
         service_name = "embedding_scanner"
-        
+
         if service_name in cls._services:
             return cls._services[service_name]
-        
+
         async with cls._get_lock(service_name):
             # Double-check after acquiring lock
             if service_name in cls._services:
                 return cls._services[service_name]
-            
+
             # Import here to avoid circular imports
             from .embedding_scanner import EmbeddingScanner
-            
+
             scanner = await EmbeddingScanner.get_instance()
             cls._services[service_name] = scanner
             logger.debug(f"Created and registered {service_name}")
             return scanner
-    
+
+    @classmethod
+    async def get_misc_scanner(cls):
+        """Get or create Misc scanner instance (VAE, Upscaler)"""
+        service_name = "misc_scanner"
+
+        if service_name in cls._services:
+            return cls._services[service_name]
+
+        async with cls._get_lock(service_name):
+            # Double-check after acquiring lock
+            if service_name in cls._services:
+                return cls._services[service_name]
+
+            # Import here to avoid circular imports
+            from .misc_scanner import MiscScanner
+
+            scanner = await MiscScanner.get_instance()
+            cls._services[service_name] = scanner
+            logger.debug(f"Created and registered {service_name}")
+            return scanner
+
     @classmethod
     def clear_services(cls):
         """Clear all registered services - mainly for testing"""

py/services/settings_manager.py

@@ -35,6 +35,8 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "hash_chunk_size_mb": DEFAULT_HASH_CHUNK_SIZE_MB,
     "language": "en",
     "show_only_sfw": False,
+    "onboarding_completed": False,
+    "dismissed_banners": [],
     "enable_metadata_archive_db": False,
     "proxy_enabled": False,
     "proxy_host": "",
@@ -44,6 +46,7 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "proxy_type": "http",
     "default_lora_root": "",
     "default_checkpoint_root": "",
+    "default_unet_root": "",
     "default_embedding_root": "",
     "base_model_path_mappings": {},
     "download_path_templates": {},
@@ -215,6 +218,7 @@ class SettingsManager:
                 folder_paths=merged.get("folder_paths", {}),
                 default_lora_root=merged.get("default_lora_root"),
                 default_checkpoint_root=merged.get("default_checkpoint_root"),
+                default_unet_root=merged.get("default_unet_root"),
                 default_embedding_root=merged.get("default_embedding_root"),
             )
         }
@@ -300,6 +304,7 @@ class SettingsManager:
                 folder_paths=normalized_top_level_paths,
                 default_lora_root=self.settings.get("default_lora_root", ""),
                 default_checkpoint_root=self.settings.get("default_checkpoint_root", ""),
+                default_unet_root=self.settings.get("default_unet_root", ""),
                 default_embedding_root=self.settings.get("default_embedding_root", ""),
             )
             libraries = {library_name: library_payload}
@@ -342,6 +347,7 @@ class SettingsManager:
                 folder_paths=candidate_folder_paths,
                 default_lora_root=data.get("default_lora_root"),
                 default_checkpoint_root=data.get("default_checkpoint_root"),
+                default_unet_root=data.get("default_unet_root"),
                 default_embedding_root=data.get("default_embedding_root"),
                 metadata=data.get("metadata"),
                 base=data,
@@ -380,6 +386,7 @@ class SettingsManager:
         self.settings["folder_paths"] = folder_paths
         self.settings["default_lora_root"] = active_library.get("default_lora_root", "")
         self.settings["default_checkpoint_root"] = active_library.get("default_checkpoint_root", "")
+        self.settings["default_unet_root"] = active_library.get("default_unet_root", "")
         self.settings["default_embedding_root"] = active_library.get("default_embedding_root", "")
 
         if save:
@@ -394,6 +401,7 @@ class SettingsManager:
         folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
         default_lora_root: Optional[str] = None,
         default_checkpoint_root: Optional[str] = None,
+        default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
         metadata: Optional[Mapping[str, Any]] = None,
         base: Optional[Mapping[str, Any]] = None,
@@ -416,6 +424,11 @@ class SettingsManager:
         else:
             payload.setdefault("default_checkpoint_root", "")
 
+        if default_unet_root is not None:
+            payload["default_unet_root"] = default_unet_root
+        else:
+            payload.setdefault("default_unet_root", "")
+
         if default_embedding_root is not None:
             payload["default_embedding_root"] = default_embedding_root
         else:
@@ -517,6 +530,7 @@ class SettingsManager:
         folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
         default_lora_root: Optional[str] = None,
         default_checkpoint_root: Optional[str] = None,
+        default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
     ) -> bool:
         libraries = self.settings.get("libraries", {})
@@ -541,6 +555,10 @@ class SettingsManager:
             library["default_checkpoint_root"] = default_checkpoint_root
             changed = True
 
+        if default_unet_root is not None and library.get("default_unet_root") != default_unet_root:
+            library["default_unet_root"] = default_unet_root
+            changed = True
+
         if default_embedding_root is not None and library.get("default_embedding_root") != default_embedding_root:
             library["default_embedding_root"] = default_embedding_root
             changed = True
@@ -596,7 +614,11 @@ class SettingsManager:
             logger.info("Migration completed")
 
     def _auto_set_default_roots(self):
-        """Auto set default root paths when only one folder is present and the current default is unset or not among the options."""
+        """Auto set default root paths when the current default is unset or not among the options.
+
+        For single-path cases, always use that path.
+        For multi-path cases, only set if current default is empty or invalid.
+        """
         folder_paths = self.settings.get('folder_paths', {})
         updated = False
         # loras
@@ -613,6 +635,14 @@ class SettingsManager:
             if current_checkpoint_root not in checkpoints:
                 self.settings['default_checkpoint_root'] = checkpoints[0]
                 updated = True
+        # unet (diffusion models) - auto-set if empty or invalid
+        unet_paths = folder_paths.get('unet', [])
+        if isinstance(unet_paths, list) and len(unet_paths) >= 1:
+            current_unet_root = self.settings.get('default_unet_root')
+            # Set to first path if current is empty or not in the valid paths
+            if not current_unet_root or current_unet_root not in unet_paths:
+                self.settings['default_unet_root'] = unet_paths[0]
+                updated = True
         # embeddings
         embeddings = folder_paths.get('embeddings', [])
         if isinstance(embeddings, list) and len(embeddings) == 1:
@@ -624,6 +654,7 @@ class SettingsManager:
             self._update_active_library_entry(
                 default_lora_root=self.settings.get('default_lora_root'),
                 default_checkpoint_root=self.settings.get('default_checkpoint_root'),
+                default_unet_root=self.settings.get('default_unet_root'),
                 default_embedding_root=self.settings.get('default_embedding_root'),
             )
             if self._bootstrap_reason == "missing":
@@ -851,6 +882,8 @@ class SettingsManager:
             self._update_active_library_entry(default_lora_root=str(value))
         elif key == 'default_checkpoint_root':
             self._update_active_library_entry(default_checkpoint_root=str(value))
+        elif key == 'default_unet_root':
+            self._update_active_library_entry(default_unet_root=str(value))
         elif key == 'default_embedding_root':
             self._update_active_library_entry(default_embedding_root=str(value))
         elif key == 'model_name_display':
@@ -883,6 +916,7 @@ class SettingsManager:
 
         if os.path.abspath(previous_path) != os.path.abspath(target_path):
             self._copy_model_cache_directory(previous_dir, target_dir)
+            logger.info("Switching settings file to: %s", target_path)
 
         self._pending_portable_switch = {"other_path": other_path}
         self.settings_file = target_path
@@ -929,7 +963,12 @@ class SettingsManager:
             and os.path.abspath(source_cache_dir) != os.path.abspath(target_cache_dir)
         ):
             try:
-                shutil.copytree(source_cache_dir, target_cache_dir, dirs_exist_ok=True)
+                shutil.copytree(
+                    source_cache_dir,
+                    target_cache_dir,
+                    dirs_exist_ok=True,
+                    ignore=shutil.ignore_patterns("*.sqlite-shm", "*.sqlite-wal"),
+                )
             except Exception as exc:
                 logger.warning(
                     "Failed to copy model_cache directory from %s to %s: %s",
@@ -1125,6 +1164,7 @@ class SettingsManager:
         folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
         default_lora_root: Optional[str] = None,
         default_checkpoint_root: Optional[str] = None,
+        default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
         metadata: Optional[Mapping[str, Any]] = None,
         activate: bool = False,
@@ -1149,6 +1189,11 @@ class SettingsManager:
                 if default_checkpoint_root is not None
                 else existing.get("default_checkpoint_root")
             ),
+            default_unet_root=(
+                default_unet_root
+                if default_unet_root is not None
+                else existing.get("default_unet_root")
+            ),
             default_embedding_root=(
                 default_embedding_root
                 if default_embedding_root is not None
@@ -1178,6 +1223,7 @@ class SettingsManager:
         folder_paths: Mapping[str, Iterable[str]],
         default_lora_root: str = "",
         default_checkpoint_root: str = "",
+        default_unet_root: str = "",
         default_embedding_root: str = "",
         metadata: Optional[Mapping[str, Any]] = None,
         activate: bool = False,
@@ -1193,6 +1239,7 @@ class SettingsManager:
             folder_paths=folder_paths,
             default_lora_root=default_lora_root,
             default_checkpoint_root=default_checkpoint_root,
+            default_unet_root=default_unet_root,
             default_embedding_root=default_embedding_root,
             metadata=metadata,
             activate=activate,
@@ -1250,6 +1297,7 @@ class SettingsManager:
         *,
         default_lora_root: Optional[str] = None,
         default_checkpoint_root: Optional[str] = None,
+        default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
     ) -> None:
         """Update folder paths for the active library."""
@@ -1260,6 +1308,7 @@ class SettingsManager:
             folder_paths=folder_paths,
             default_lora_root=default_lora_root,
             default_checkpoint_root=default_checkpoint_root,
+            default_unet_root=default_unet_root,
             default_embedding_root=default_embedding_root,
             activate=True,
         )

py/services/tag_fts_index.py

@@ -0,0 +1,680 @@
+"""SQLite FTS5-based full-text search index for tags.
+
+This module provides fast tag search using SQLite's FTS5 extension,
+enabling sub-100ms search times for 221k+ Danbooru/e621 tags.
+
+Supports alias search: when a user searches for an alias (e.g., "miku"),
+the system returns the canonical tag (e.g., "hatsune_miku") and indicates
+which alias was matched.
+"""
+
+from __future__ import annotations
+
+import csv
+import logging
+import os
+import re
+import sqlite3
+import threading
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
+
+logger = logging.getLogger(__name__)
+
+# Schema version for tracking migrations
+SCHEMA_VERSION = 2  # Version 2: Added aliases support
+
+
+# Category definitions for Danbooru and e621
+CATEGORY_NAMES = {
+    # Danbooru categories
+    0: "general",
+    1: "artist",
+    3: "copyright",
+    4: "character",
+    5: "meta",
+    # e621 categories
+    7: "general",
+    8: "artist",
+    10: "copyright",
+    11: "character",
+    12: "species",
+    14: "meta",
+    15: "lore",
+}
+
+# Map category names to their IDs (for filtering)
+CATEGORY_NAME_TO_IDS = {
+    "general": [0, 7],
+    "artist": [1, 8],
+    "copyright": [3, 10],
+    "character": [4, 11],
+    "meta": [5, 14],
+    "species": [12],
+    "lore": [15],
+}
+
+
+class TagFTSIndex:
+    """SQLite FTS5-based full-text search index for tags.
+
+    Provides fast prefix-based search across the Danbooru/e621 tag database.
+    Supports category-based filtering and returns enriched results with
+    post counts and category information.
+    """
+
+    _DEFAULT_FILENAME = "tag_fts.sqlite"
+    _CSV_FILENAME = "danbooru_e621_merged.csv"
+
+    def __init__(self, db_path: Optional[str] = None, csv_path: Optional[str] = None) -> None:
+        """Initialize the FTS index.
+
+        Args:
+            db_path: Optional path to the SQLite database file.
+                     If not provided, uses the default location in settings directory.
+            csv_path: Optional path to the CSV file containing tag data.
+                      If not provided, looks in the refs/ directory.
+        """
+        self._db_path = db_path or self._resolve_default_db_path()
+        self._csv_path = csv_path or self._resolve_default_csv_path()
+        self._lock = threading.Lock()
+        self._ready = threading.Event()
+        self._indexing_in_progress = False
+        self._schema_initialized = False
+        self._warned_not_ready = False
+
+        # Ensure directory exists
+        try:
+            directory = os.path.dirname(self._db_path)
+            if directory:
+                os.makedirs(directory, exist_ok=True)
+        except Exception as exc:
+            logger.warning("Could not create FTS index directory %s: %s", directory, exc)
+
+    def _resolve_default_db_path(self) -> str:
+        """Resolve the default database path."""
+        env_override = os.environ.get("LORA_MANAGER_TAG_FTS_DB")
+        return resolve_cache_path_with_migration(
+            CacheType.TAG_FTS,
+            env_override=env_override,
+        )
+
+    def _resolve_default_csv_path(self) -> str:
+        """Resolve the default CSV file path."""
+        # Look for the CSV in the refs/ directory relative to the package
+        package_dir = Path(__file__).parent.parent.parent
+        csv_path = package_dir / "refs" / self._CSV_FILENAME
+        return str(csv_path)
+
+    def get_database_path(self) -> str:
+        """Return the resolved database path."""
+        return self._db_path
+
+    def get_csv_path(self) -> str:
+        """Return the resolved CSV path."""
+        return self._csv_path
+
+    def is_ready(self) -> bool:
+        """Check if the FTS index is ready for queries."""
+        return self._ready.is_set()
+
+    def is_indexing(self) -> bool:
+        """Check if indexing is currently in progress."""
+        return self._indexing_in_progress
+
+    def initialize(self) -> None:
+        """Initialize the database schema."""
+        if self._schema_initialized:
+            return
+
+        with self._lock:
+            if self._schema_initialized:
+                return
+
+            try:
+                conn = self._connect()
+                try:
+                    conn.execute("PRAGMA journal_mode=WAL")
+
+                    # Check if we need to migrate from old schema
+                    needs_rebuild = self._check_and_migrate_schema(conn)
+
+                    conn.executescript("""
+                        -- FTS5 virtual table for full-text search
+                        -- searchable_text contains "tag_name alias1 alias2 ..." for alias matching
+                        CREATE VIRTUAL TABLE IF NOT EXISTS tag_fts USING fts5(
+                            searchable_text,
+                            tokenize='unicode61 remove_diacritics 2'
+                        );
+
+                        -- Tags table with metadata and aliases
+                        CREATE TABLE IF NOT EXISTS tags (
+                            rowid INTEGER PRIMARY KEY,
+                            tag_name TEXT UNIQUE NOT NULL,
+                            category INTEGER NOT NULL DEFAULT 0,
+                            post_count INTEGER NOT NULL DEFAULT 0,
+                            aliases TEXT DEFAULT ''
+                        );
+
+                        -- Indexes for efficient filtering
+                        CREATE INDEX IF NOT EXISTS idx_tags_category ON tags(category);
+                        CREATE INDEX IF NOT EXISTS idx_tags_post_count ON tags(post_count DESC);
+
+                        -- Index version tracking
+                        CREATE TABLE IF NOT EXISTS fts_metadata (
+                            key TEXT PRIMARY KEY,
+                            value TEXT
+                        );
+                    """)
+
+                    # Set schema version
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ("schema_version", str(SCHEMA_VERSION))
+                    )
+                    conn.commit()
+
+                    self._schema_initialized = True
+                    self._needs_rebuild = needs_rebuild
+                    logger.debug("Tag FTS index schema initialized at %s", self._db_path)
+                finally:
+                    conn.close()
+            except Exception as exc:
+                logger.error("Failed to initialize tag FTS schema: %s", exc)
+
+    def _check_and_migrate_schema(self, conn: sqlite3.Connection) -> bool:
+        """Check schema version and migrate if necessary.
+
+        Returns:
+            True if the index needs to be rebuilt, False otherwise.
+        """
+        try:
+            # Check if fts_metadata table exists
+            cursor = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='fts_metadata'"
+            )
+            if not cursor.fetchone():
+                return False  # Fresh database, no migration needed
+
+            # Check schema version
+            cursor = conn.execute(
+                "SELECT value FROM fts_metadata WHERE key='schema_version'"
+            )
+            row = cursor.fetchone()
+            if not row:
+                # Old schema without version, needs rebuild
+                logger.info("Migrating tag FTS index to schema version %d (adding alias support)", SCHEMA_VERSION)
+                self._drop_old_tables(conn)
+                return True
+
+            current_version = int(row[0])
+            if current_version < SCHEMA_VERSION:
+                logger.info("Migrating tag FTS index from version %d to %d", current_version, SCHEMA_VERSION)
+                self._drop_old_tables(conn)
+                return True
+
+            return False
+        except Exception as exc:
+            logger.warning("Error checking schema version: %s", exc)
+            return False
+
+    def _drop_old_tables(self, conn: sqlite3.Connection) -> None:
+        """Drop old tables for schema migration."""
+        try:
+            conn.executescript("""
+                DROP TABLE IF EXISTS tag_fts;
+                DROP TABLE IF EXISTS tags;
+            """)
+            conn.commit()
+        except Exception as exc:
+            logger.warning("Error dropping old tables: %s", exc)
+
+    def build_index(self) -> None:
+        """Build the FTS index from the CSV file.
+
+        This method parses the danbooru_e621_merged.csv file and creates
+        the FTS index for fast searching. The CSV format is:
+        tag_name,category,post_count,aliases
+
+        Where aliases is a comma-separated string (e.g., "miku,vocaloid_miku,39").
+        """
+        if self._indexing_in_progress:
+            logger.warning("Tag FTS indexing already in progress, skipping")
+            return
+
+        if not os.path.exists(self._csv_path):
+            logger.warning("CSV file not found at %s, cannot build tag index", self._csv_path)
+            return
+
+        self._indexing_in_progress = True
+        self._ready.clear()
+        start_time = time.time()
+
+        try:
+            self.initialize()
+            if not self._schema_initialized:
+                logger.error("Cannot build tag FTS index: schema not initialized")
+                return
+
+            with self._lock:
+                conn = self._connect()
+                try:
+                    conn.execute("BEGIN")
+
+                    # Clear existing data
+                    conn.execute("DELETE FROM tag_fts")
+                    conn.execute("DELETE FROM tags")
+
+                    # Parse CSV and insert in batches
+                    batch_size = 500
+                    rows = []
+                    total_inserted = 0
+                    tags_with_aliases = 0
+
+                    with open(self._csv_path, "r", encoding="utf-8") as f:
+                        reader = csv.reader(f)
+                        for row in reader:
+                            if len(row) < 3:
+                                continue
+
+                            tag_name = row[0].strip()
+                            if not tag_name:
+                                continue
+
+                            try:
+                                category = int(row[1])
+                            except (ValueError, IndexError):
+                                category = 0
+
+                            try:
+                                post_count = int(row[2])
+                            except (ValueError, IndexError):
+                                post_count = 0
+
+                            # Parse aliases from column 4 (if present)
+                            aliases = row[3].strip() if len(row) >= 4 else ""
+                            if aliases:
+                                tags_with_aliases += 1
+
+                            rows.append((tag_name, category, post_count, aliases))
+
+                            if len(rows) >= batch_size:
+                                self._insert_batch(conn, rows)
+                                total_inserted += len(rows)
+                                rows = []
+
+                    # Insert remaining rows
+                    if rows:
+                        self._insert_batch(conn, rows)
+                        total_inserted += len(rows)
+
+                    # Update metadata
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ("last_build_time", str(time.time()))
+                    )
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ("tag_count", str(total_inserted))
+                    )
+                    conn.execute(
+                        "INSERT OR REPLACE INTO fts_metadata (key, value) VALUES (?, ?)",
+                        ("schema_version", str(SCHEMA_VERSION))
+                    )
+
+                    conn.commit()
+                    elapsed = time.time() - start_time
+                    logger.info(
+                        "Tag FTS index built: %d tags indexed (%d with aliases) in %.2fs",
+                        total_inserted, tags_with_aliases, elapsed
+                    )
+                finally:
+                    conn.close()
+
+            self._ready.set()
+
+        except Exception as exc:
+            logger.error("Failed to build tag FTS index: %s", exc, exc_info=True)
+        finally:
+            self._indexing_in_progress = False
+
+    def _insert_batch(self, conn: sqlite3.Connection, rows: List[tuple]) -> None:
+        """Insert a batch of rows into the database.
+
+        Each row is a tuple of (tag_name, category, post_count, aliases).
+        The FTS searchable_text is built as "tag_name alias1 alias2 ..." for alias matching.
+        """
+        # Insert into tags table (with aliases)
+        conn.executemany(
+            "INSERT OR IGNORE INTO tags (tag_name, category, post_count, aliases) VALUES (?, ?, ?, ?)",
+            rows
+        )
+
+        # Build a map of tag_name -> aliases for FTS insertion
+        aliases_map = {row[0]: row[3] for row in rows}
+
+        # Get rowids and insert into FTS table with explicit rowid
+        # to ensure tags.rowid matches tag_fts.rowid for JOINs
+        tag_names = [row[0] for row in rows]
+        placeholders = ",".join("?" * len(tag_names))
+        cursor = conn.execute(
+            f"SELECT rowid, tag_name FROM tags WHERE tag_name IN ({placeholders})",
+            tag_names
+        )
+
+        # Build FTS rows with (rowid, searchable_text) = (tags.rowid, "tag_name alias1 alias2 ...")
+        fts_rows = []
+        for rowid, tag_name in cursor.fetchall():
+            aliases = aliases_map.get(tag_name, "")
+            if aliases:
+                # Replace commas with spaces to create searchable text
+                # Strip "/" prefix from aliases as it's an FTS5 special character
+                alias_parts = []
+                for alias in aliases.split(","):
+                    alias = alias.strip()
+                    if alias.startswith("/"):
+                        alias = alias[1:]  # Remove leading slash
+                    if alias:
+                        alias_parts.append(alias)
+                searchable_text = f"{tag_name} {' '.join(alias_parts)}" if alias_parts else tag_name
+            else:
+                searchable_text = tag_name
+            fts_rows.append((rowid, searchable_text))
+
+        if fts_rows:
+            conn.executemany("INSERT INTO tag_fts (rowid, searchable_text) VALUES (?, ?)", fts_rows)
+
+    def ensure_ready(self) -> bool:
+        """Ensure the index is ready, building if necessary.
+
+        Returns:
+            True if the index is ready, False otherwise.
+        """
+        if self.is_ready():
+            return True
+
+        # Check if index already exists and has data
+        self.initialize()
+        if self._schema_initialized:
+            # Check if schema migration requires rebuild
+            if getattr(self, "_needs_rebuild", False):
+                logger.info("Schema migration requires index rebuild")
+                self._needs_rebuild = False
+                self.build_index()
+                return self.is_ready()
+
+            count = self.get_indexed_count()
+            if count > 0:
+                self._ready.set()
+                logger.debug("Tag FTS index already populated with %d tags", count)
+                return True
+
+        # Build the index
+        self.build_index()
+        return self.is_ready()
+
+    def search(
+        self,
+        query: str,
+        categories: Optional[List[int]] = None,
+        limit: int = 20
+    ) -> List[Dict]:
+        """Search tags using FTS5 with prefix matching.
+
+        Supports alias search: if the query matches an alias rather than
+        the tag_name, the result will include a "matched_alias" field.
+
+        Args:
+            query: The search query string.
+            categories: Optional list of category IDs to filter by.
+            limit: Maximum number of results to return.
+
+        Returns:
+            List of dictionaries with tag_name, category, post_count,
+            and optionally matched_alias.
+        """
+        # Ensure index is ready (lazy initialization)
+        if not self.ensure_ready():
+            if not self._warned_not_ready:
+                logger.debug("Tag FTS index not ready, returning empty results")
+                self._warned_not_ready = True
+            return []
+
+        if not query or not query.strip():
+            return []
+
+        fts_query = self._build_fts_query(query)
+        if not fts_query:
+            return []
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    # Build the SQL query - now also fetch aliases for matched_alias detection
+                    # Use subquery for category filter to ensure FTS is evaluated first
+                    if categories:
+                        placeholders = ",".join("?" * len(categories))
+                        sql = f"""
+                            SELECT t.tag_name, t.category, t.post_count, t.aliases
+                            FROM tags t
+                            WHERE t.rowid IN (
+                                SELECT rowid FROM tag_fts WHERE searchable_text MATCH ?
+                            )
+                            AND t.category IN ({placeholders})
+                            ORDER BY t.post_count DESC
+                            LIMIT ?
+                        """
+                        params = [fts_query] + categories + [limit]
+                    else:
+                        sql = """
+                            SELECT t.tag_name, t.category, t.post_count, t.aliases
+                            FROM tag_fts f
+                            JOIN tags t ON f.rowid = t.rowid
+                            WHERE f.searchable_text MATCH ?
+                            ORDER BY t.post_count DESC
+                            LIMIT ?
+                        """
+                        params = [fts_query, limit]
+
+                    cursor = conn.execute(sql, params)
+                    results = []
+                    for row in cursor.fetchall():
+                        result = {
+                            "tag_name": row[0],
+                            "category": row[1],
+                            "post_count": row[2],
+                        }
+
+                        # Check if search matched an alias rather than the tag_name
+                        matched_alias = self._find_matched_alias(query, row[0], row[3])
+                        if matched_alias:
+                            result["matched_alias"] = matched_alias
+
+                        results.append(result)
+                    return results
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Tag FTS search error for query '%s': %s", query, exc)
+            return []
+
+    def _find_matched_alias(self, query: str, tag_name: str, aliases_str: str) -> Optional[str]:
+        """Find which alias matched the query, if any.
+
+        Args:
+            query: The original search query.
+            tag_name: The canonical tag name.
+            aliases_str: Comma-separated string of aliases.
+
+        Returns:
+            The matched alias string, or None if the query matched the tag_name directly.
+        """
+        query_lower = query.lower().strip()
+        if not query_lower:
+            return None
+
+        # Strip leading "/" from query if present (FTS index strips these)
+        query_normalized = query_lower.lstrip("/")
+
+        # Check if query matches tag_name prefix (direct match, no alias needed)
+        if tag_name.lower().startswith(query_normalized):
+            return None
+
+        # Check aliases first - if query matches an alias or a word within an alias, return it
+        if aliases_str:
+            for alias in aliases_str.split(","):
+                alias = alias.strip()
+                if not alias:
+                    continue
+                # Normalize alias for comparison (strip leading slash)
+                alias_normalized = alias.lower().lstrip("/")
+
+                # Check if alias starts with query
+                if alias_normalized.startswith(query_normalized):
+                    return alias  # Return original alias (with "/" if present)
+
+                # Check if any word within the alias starts with query
+                # (mirrors FTS5 tokenization which splits on underscores)
+                alias_words = alias_normalized.replace("_", " ").split()
+                for word in alias_words:
+                    if word.startswith(query_normalized):
+                        return alias
+
+        # If no alias matched, check if query matches a word in tag_name
+        # (handles cases like "long_hair" matching "long" - no alias indicator needed)
+        tag_words = tag_name.lower().replace("_", " ").split()
+        for word in tag_words:
+            if word.startswith(query_normalized):
+                return None
+
+        # Query matched via FTS but not tag_name words or aliases
+        # This shouldn't normally happen, but return None for safety
+        return None
+
+    def get_indexed_count(self) -> int:
+        """Return the number of tags currently indexed."""
+        if not self._schema_initialized:
+            return 0
+
+        try:
+            with self._lock:
+                conn = self._connect(readonly=True)
+                try:
+                    cursor = conn.execute("SELECT COUNT(*) FROM tags")
+                    result = cursor.fetchone()
+                    return result[0] if result else 0
+                finally:
+                    conn.close()
+        except Exception:
+            return 0
+
+    def clear(self) -> bool:
+        """Clear all data from the FTS index.
+
+        Returns:
+            True if successful, False otherwise.
+        """
+        try:
+            with self._lock:
+                conn = self._connect()
+                try:
+                    conn.execute("DELETE FROM tag_fts")
+                    conn.execute("DELETE FROM tags")
+                    conn.commit()
+                    self._ready.clear()
+                    return True
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.error("Failed to clear tag FTS index: %s", exc)
+            return False
+
+    # Internal helpers
+
+    def _connect(self, readonly: bool = False) -> sqlite3.Connection:
+        """Create a database connection."""
+        uri = False
+        path = self._db_path
+        if readonly:
+            if not os.path.exists(path):
+                raise FileNotFoundError(path)
+            path = f"file:{path}?mode=ro"
+            uri = True
+        conn = sqlite3.connect(path, check_same_thread=False, uri=uri)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _build_fts_query(self, query: str) -> str:
+        """Build an FTS5 query string with prefix matching.
+
+        Args:
+            query: The user's search query.
+
+        Returns:
+            FTS5 query string.
+        """
+        # Split query into words and clean them
+        words = query.lower().split()
+        if not words:
+            return ""
+
+        # Escape and add prefix wildcard to each word
+        prefix_terms = []
+        for word in words:
+            escaped = self._escape_fts_query(word)
+            if escaped:
+                # Add prefix wildcard for substring-like matching
+                prefix_terms.append(f"{escaped}*")
+
+        if not prefix_terms:
+            return ""
+
+        # Combine terms with implicit AND (all words must match)
+        return " ".join(prefix_terms)
+
+    def _escape_fts_query(self, text: str) -> str:
+        """Escape special FTS5 characters.
+
+        FTS5 special characters: " ( ) * : ^ - /
+        We keep * for prefix matching but escape others.
+        """
+        if not text:
+            return ""
+
+        # Replace FTS5 special characters with space
+        # Note: "/" is special in FTS5 (column filter syntax), so we strip it
+        special = ['"', "(", ")", "*", ":", "^", "-", "{", "}", "[", "]", "/"]
+        result = text
+        for char in special:
+            result = result.replace(char, " ")
+
+        # Collapse multiple spaces and strip
+        result = re.sub(r"\s+", " ", result).strip()
+        return result
+
+
+# Singleton instance
+_tag_fts_index: Optional[TagFTSIndex] = None
+_tag_fts_lock = threading.Lock()
+
+
+def get_tag_fts_index() -> TagFTSIndex:
+    """Get the singleton TagFTSIndex instance."""
+    global _tag_fts_index
+    if _tag_fts_index is None:
+        with _tag_fts_lock:
+            if _tag_fts_index is None:
+                _tag_fts_index = TagFTSIndex()
+    return _tag_fts_index
+
+
+__all__ = [
+    "TagFTSIndex",
+    "get_tag_fts_index",
+    "CATEGORY_NAMES",
+    "CATEGORY_NAME_TO_IDS",
+]

py/services/use_cases/bulk_metadata_refresh_use_case.py

@@ -59,6 +59,8 @@ class BulkMetadataRefreshUseCase:
         success = 0
         needs_resort = False
 
+        self._service.scanner.reset_cancellation()
+
         async def emit(status: str, **extra: Any) -> None:
             if progress_callback is None:
                 return
@@ -69,6 +71,10 @@ class BulkMetadataRefreshUseCase:
         await emit("started")
 
         for model in to_process:
+            if self._service.scanner.is_cancelled():
+                self._logger.info("Bulk metadata refresh cancelled by user")
+                await emit("cancelled", processed=processed, success=success)
+                return {"success": False, "message": "Operation cancelled", "processed": processed, "updated": success, "total": total_models}
             try:
                 original_name = model.get("model_name")
                 await MetadataManager.hydrate_model_data(model)

py/services/websocket_manager.py

@@ -20,6 +20,8 @@ class WebSocketManager:
         self._last_init_progress: Dict[str, Dict] = {}
         # Add auto-organize progress tracking
         self._auto_organize_progress: Optional[Dict] = None
+        # Add recipe repair progress tracking
+        self._recipe_repair_progress: Optional[Dict] = None
         self._auto_organize_lock = asyncio.Lock()
         
     async def handle_connection(self, request: web.Request) -> web.WebSocketResponse:
@@ -189,6 +191,14 @@ class WebSocketManager:
         # Broadcast via WebSocket
         await self.broadcast(data)
     
+    async def broadcast_recipe_repair_progress(self, data: Dict):
+        """Broadcast recipe repair progress to connected clients"""
+        # Store progress data in memory
+        self._recipe_repair_progress = data
+        
+        # Broadcast via WebSocket
+        await self.broadcast(data)
+    
     def get_auto_organize_progress(self) -> Optional[Dict]:
         """Get current auto-organize progress"""
         return self._auto_organize_progress
@@ -197,6 +207,22 @@ class WebSocketManager:
         """Clear auto-organize progress data"""
         self._auto_organize_progress = None
     
+    def get_recipe_repair_progress(self) -> Optional[Dict]:
+        """Get current recipe repair progress"""
+        return self._recipe_repair_progress
+    
+    def cleanup_recipe_repair_progress(self):
+        """Clear recipe repair progress data if it is in a finished state"""
+        if self._recipe_repair_progress and self._recipe_repair_progress.get('status') in ['completed', 'cancelled', 'error']:
+            self._recipe_repair_progress = None
+    
+    def is_recipe_repair_running(self) -> bool:
+        """Check if recipe repair is currently running"""
+        if not self._recipe_repair_progress:
+            return False
+        status = self._recipe_repair_progress.get('status')
+        return status in ['started', 'processing']
+    
     def is_auto_organize_running(self) -> bool:
         """Check if auto-organize is currently running"""
         if not self._auto_organize_progress:

py/utils/cache_paths.py

@@ -0,0 +1,421 @@
+"""Centralized cache path resolution with automatic migration support.
+
+This module provides a unified interface for resolving cache file paths,
+with automatic migration from legacy locations to the new organized
+cache directory structure.
+
+Target structure:
+    {settings_dir}/
+    └── cache/
+        ├── symlink/
+        │   └── symlink_map.json
+        ├── model/
+        │   └── {library_name}.sqlite
+        ├── recipe/
+        │   └── {library_name}.sqlite
+        └── fts/
+            ├── recipe_fts.sqlite
+            └── tag_fts.sqlite
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shutil
+from enum import Enum
+from typing import List, Optional
+
+from .settings_paths import get_project_root, get_settings_dir
+
+logger = logging.getLogger(__name__)
+
+
+class CacheType(Enum):
+    """Types of cache files managed by the cache path resolver."""
+
+    MODEL = "model"
+    RECIPE = "recipe"
+    RECIPE_FTS = "recipe_fts"
+    TAG_FTS = "tag_fts"
+    SYMLINK = "symlink"
+
+
+# Subdirectory structure for each cache type
+_CACHE_SUBDIRS = {
+    CacheType.MODEL: "model",
+    CacheType.RECIPE: "recipe",
+    CacheType.RECIPE_FTS: "fts",
+    CacheType.TAG_FTS: "fts",
+    CacheType.SYMLINK: "symlink",
+}
+
+# Filename patterns for each cache type
+_CACHE_FILENAMES = {
+    CacheType.MODEL: "{library_name}.sqlite",
+    CacheType.RECIPE: "{library_name}.sqlite",
+    CacheType.RECIPE_FTS: "recipe_fts.sqlite",
+    CacheType.TAG_FTS: "tag_fts.sqlite",
+    CacheType.SYMLINK: "symlink_map.json",
+}
+
+
+def get_cache_base_dir(create: bool = True) -> str:
+    """Return the base cache directory path.
+
+    Args:
+        create: Whether to create the directory if it does not exist.
+
+    Returns:
+        The absolute path to the cache base directory ({settings_dir}/cache/).
+    """
+    settings_dir = get_settings_dir(create=create)
+    cache_dir = os.path.join(settings_dir, "cache")
+    if create:
+        os.makedirs(cache_dir, exist_ok=True)
+    return cache_dir
+
+
+def _sanitize_library_name(library_name: Optional[str]) -> str:
+    """Sanitize a library name for use in filenames.
+
+    Args:
+        library_name: The library name to sanitize.
+
+    Returns:
+        A sanitized version safe for use in filenames.
+    """
+    name = library_name or "default"
+    return re.sub(r"[^A-Za-z0-9_.-]", "_", name)
+
+
+def get_cache_file_path(
+    cache_type: CacheType,
+    library_name: Optional[str] = None,
+    create_dir: bool = True,
+) -> str:
+    """Get the canonical path for a cache file.
+
+    Args:
+        cache_type: The type of cache file.
+        library_name: The library name (only used for MODEL and RECIPE types).
+        create_dir: Whether to create the parent directory if it does not exist.
+
+    Returns:
+        The absolute path to the cache file in its canonical location.
+    """
+    cache_base = get_cache_base_dir(create=create_dir)
+    subdir = _CACHE_SUBDIRS[cache_type]
+    cache_dir = os.path.join(cache_base, subdir)
+
+    if create_dir:
+        os.makedirs(cache_dir, exist_ok=True)
+
+    filename_template = _CACHE_FILENAMES[cache_type]
+    safe_name = _sanitize_library_name(library_name)
+    filename = filename_template.format(library_name=safe_name)
+
+    return os.path.join(cache_dir, filename)
+
+
+def get_legacy_cache_paths(
+    cache_type: CacheType,
+    library_name: Optional[str] = None,
+) -> List[str]:
+    """Get a list of legacy cache file paths to check for migration.
+
+    The paths are returned in order of priority (most recent first).
+
+    Args:
+        cache_type: The type of cache file.
+        library_name: The library name (only used for MODEL and RECIPE types).
+
+    Returns:
+        A list of potential legacy paths to check, in order of preference.
+    """
+    try:
+        settings_dir = get_settings_dir(create=False)
+    except Exception:
+        settings_dir = get_project_root()
+
+    safe_name = _sanitize_library_name(library_name)
+    legacy_paths: List[str] = []
+
+    if cache_type == CacheType.MODEL:
+        # Legacy per-library path: {settings_dir}/model_cache/{library}.sqlite
+        legacy_paths.append(
+            os.path.join(settings_dir, "model_cache", f"{safe_name}.sqlite")
+        )
+        # Legacy root-level single cache (for "default" library only)
+        if safe_name.lower() in ("default", ""):
+            legacy_paths.append(os.path.join(settings_dir, "model_cache.sqlite"))
+
+    elif cache_type == CacheType.RECIPE:
+        # Legacy per-library path: {settings_dir}/recipe_cache/{library}.sqlite
+        legacy_paths.append(
+            os.path.join(settings_dir, "recipe_cache", f"{safe_name}.sqlite")
+        )
+        # Legacy root-level single cache (for "default" library only)
+        if safe_name.lower() in ("default", ""):
+            legacy_paths.append(os.path.join(settings_dir, "recipe_cache.sqlite"))
+
+    elif cache_type == CacheType.RECIPE_FTS:
+        # Legacy root-level path
+        legacy_paths.append(os.path.join(settings_dir, "recipe_fts.sqlite"))
+
+    elif cache_type == CacheType.TAG_FTS:
+        # Legacy root-level path
+        legacy_paths.append(os.path.join(settings_dir, "tag_fts.sqlite"))
+
+    elif cache_type == CacheType.SYMLINK:
+        # Current location in cache/ but without subdirectory
+        legacy_paths.append(
+            os.path.join(settings_dir, "cache", "symlink_map.json")
+        )
+
+    return legacy_paths
+
+
+def _cleanup_legacy_file_after_migration(
+    legacy_path: str,
+    canonical_path: str,
+) -> bool:
+    """Safely remove a legacy file after successful migration.
+
+    Args:
+        legacy_path: The legacy file path to remove.
+        canonical_path: The canonical path where the file was copied to.
+
+    Returns:
+        True if cleanup succeeded, False otherwise.
+    """
+    try:
+        if not os.path.exists(canonical_path):
+            logger.warning(
+                "Skipping cleanup of %s: canonical file not found at %s",
+                legacy_path,
+                canonical_path,
+            )
+            return False
+
+        legacy_size = os.path.getsize(legacy_path)
+        canonical_size = os.path.getsize(canonical_path)
+        if legacy_size != canonical_size:
+            logger.warning(
+                "Skipping cleanup of %s: file size mismatch (legacy=%d, canonical=%d)",
+                legacy_path,
+                legacy_size,
+                canonical_size,
+            )
+            return False
+
+        os.remove(legacy_path)
+        logger.info("Cleaned up legacy cache file: %s", legacy_path)
+
+        _cleanup_empty_legacy_directories(legacy_path)
+
+        return True
+
+    except Exception as exc:
+        logger.warning(
+            "Failed to cleanup legacy cache file %s: %s",
+            legacy_path,
+            exc,
+        )
+        return False
+
+
+def _cleanup_empty_legacy_directories(legacy_path: str) -> None:
+    """Remove empty parent directories of a legacy file.
+
+    This function only removes directories if they are empty,
+    using os.rmdir() which fails on non-empty directories.
+
+    Args:
+        legacy_path: The legacy file path whose parent directories should be cleaned.
+    """
+    try:
+        parent_dir = os.path.dirname(legacy_path)
+
+        legacy_dir_names = ("model_cache", "recipe_cache")
+
+        current = parent_dir
+        while current:
+            base_name = os.path.basename(current)
+
+            if base_name in legacy_dir_names:
+                if os.path.isdir(current) and not os.listdir(current):
+                    try:
+                        os.rmdir(current)
+                        logger.info("Removed empty legacy directory: %s", current)
+                    except Exception:
+                        pass
+
+            parent = os.path.dirname(current)
+            if parent == current:
+                break
+            current = parent
+
+    except Exception as exc:
+        logger.debug("Failed to cleanup empty legacy directories: %s", exc)
+
+
+def resolve_cache_path_with_migration(
+    cache_type: CacheType,
+    library_name: Optional[str] = None,
+    env_override: Optional[str] = None,
+) -> str:
+    """Resolve the cache file path, migrating from legacy locations if needed.
+
+    This function performs lazy migration: on first access, it checks if the
+    file exists at the canonical location. If not, it looks for legacy files
+    and copies them to the new location. After successful migration, the
+    legacy file is automatically removed.
+
+    Args:
+        cache_type: The type of cache file.
+        library_name: The library name (only used for MODEL and RECIPE types).
+        env_override: Optional environment variable value that overrides all
+            path resolution. When set, returns this path directly without
+            any migration.
+
+    Returns:
+        The resolved path to use for the cache file.
+    """
+    # Environment override bypasses all migration logic
+    if env_override:
+        return env_override
+
+    canonical_path = get_cache_file_path(cache_type, library_name, create_dir=True)
+
+    # If file already exists at canonical location, use it
+    if os.path.exists(canonical_path):
+        return canonical_path
+
+    # Check legacy paths for migration
+    legacy_paths = get_legacy_cache_paths(cache_type, library_name)
+
+    for legacy_path in legacy_paths:
+        if os.path.exists(legacy_path):
+            try:
+                shutil.copy2(legacy_path, canonical_path)
+                logger.info(
+                    "Migrated %s cache from %s to %s",
+                    cache_type.value,
+                    legacy_path,
+                    canonical_path,
+                )
+
+                _cleanup_legacy_file_after_migration(legacy_path, canonical_path)
+
+                return canonical_path
+            except Exception as exc:
+                logger.warning(
+                    "Failed to migrate %s cache from %s: %s",
+                    cache_type.value,
+                    legacy_path,
+                    exc,
+                )
+
+    # No legacy file found; return canonical path (will be created fresh)
+    return canonical_path
+
+
+def get_legacy_cache_files_for_cleanup() -> List[str]:
+    """Get a list of legacy cache files that can be removed after migration.
+
+    This function returns files that exist in legacy locations and have
+    corresponding files in the new canonical locations.
+
+    Returns:
+        A list of legacy file paths that are safe to remove.
+    """
+    files_to_remove: List[str] = []
+
+    try:
+        settings_dir = get_settings_dir(create=False)
+    except Exception:
+        return files_to_remove
+
+    # Check each cache type for migrated legacy files
+    for cache_type in CacheType:
+        # For MODEL and RECIPE, we need to check each library
+        if cache_type in (CacheType.MODEL, CacheType.RECIPE):
+            # Check default library
+            _check_legacy_for_cleanup(cache_type, "default", files_to_remove)
+            # Check for any per-library caches in legacy directories
+            legacy_dir_name = "model_cache" if cache_type == CacheType.MODEL else "recipe_cache"
+            legacy_dir = os.path.join(settings_dir, legacy_dir_name)
+            if os.path.isdir(legacy_dir):
+                try:
+                    for filename in os.listdir(legacy_dir):
+                        if filename.endswith(".sqlite"):
+                            library_name = filename[:-7]  # Remove .sqlite
+                            _check_legacy_for_cleanup(cache_type, library_name, files_to_remove)
+                except Exception:
+                    pass
+        else:
+            _check_legacy_for_cleanup(cache_type, None, files_to_remove)
+
+    return files_to_remove
+
+
+def _check_legacy_for_cleanup(
+    cache_type: CacheType,
+    library_name: Optional[str],
+    files_to_remove: List[str],
+) -> None:
+    """Check if a legacy cache file can be removed after migration.
+
+    Args:
+        cache_type: The type of cache file.
+        library_name: The library name (only used for MODEL and RECIPE types).
+        files_to_remove: List to append removable files to.
+    """
+    canonical_path = get_cache_file_path(cache_type, library_name, create_dir=False)
+    if not os.path.exists(canonical_path):
+        return
+
+    legacy_paths = get_legacy_cache_paths(cache_type, library_name)
+    for legacy_path in legacy_paths:
+        if os.path.exists(legacy_path) and legacy_path not in files_to_remove:
+            files_to_remove.append(legacy_path)
+
+
+def cleanup_legacy_cache_files(dry_run: bool = True) -> List[str]:
+    """Remove legacy cache files that have been migrated.
+
+    Args:
+        dry_run: If True, only return the list of files that would be removed
+            without actually removing them.
+
+    Returns:
+        A list of files that were (or would be) removed.
+    """
+    files = get_legacy_cache_files_for_cleanup()
+
+    if dry_run or not files:
+        return files
+
+    removed: List[str] = []
+    for file_path in files:
+        try:
+            os.remove(file_path)
+            removed.append(file_path)
+            logger.info("Removed legacy cache file: %s", file_path)
+        except Exception as exc:
+            logger.warning("Failed to remove legacy cache file %s: %s", file_path, exc)
+
+    # Try to remove empty legacy directories
+    try:
+        settings_dir = get_settings_dir(create=False)
+        for legacy_dir_name in ("model_cache", "recipe_cache"):
+            legacy_dir = os.path.join(settings_dir, legacy_dir_name)
+            if os.path.isdir(legacy_dir) and not os.listdir(legacy_dir):
+                os.rmdir(legacy_dir)
+                logger.info("Removed empty legacy directory: %s", legacy_dir)
+    except Exception:
+        pass
+
+    return removed

py/utils/civitai_utils.py

@@ -20,11 +20,25 @@ _COMMERCIAL_SHIFT = 1
 def _normalize_commercial_values(value: Any) -> Sequence[str]:
     """Return a normalized list of commercial permissions preserving source values."""
 
+    def _split_aggregate(value_str: str) -> list[str]:
+        stripped = value_str.strip()
+        looks_aggregate = "," in stripped or (stripped.startswith("{") and stripped.endswith("}"))
+        if not looks_aggregate:
+            return [value_str]
+
+        trimmed = stripped
+        if trimmed.startswith("{") and trimmed.endswith("}"):
+            trimmed = trimmed[1:-1]
+
+        parts = [part.strip() for part in trimmed.split(",")]
+        result = [part for part in parts if part]
+        return result or [value_str]
+
     if value is None:
         return list(_DEFAULT_ALLOW_COMMERCIAL_USE)
 
     if isinstance(value, str):
-        return [value]
+        return _split_aggregate(value)
 
     if isinstance(value, Iterable):
         result = []
@@ -32,7 +46,7 @@ def _normalize_commercial_values(value: Any) -> Sequence[str]:
             if item is None:
                 continue
             if isinstance(item, str):
-                result.append(item)
+                result.extend(_split_aggregate(item))
                 continue
             result.append(str(item))
         if result:

py/utils/constants.py

@@ -4,14 +4,14 @@ NSFW_LEVELS = {
     "R": 4,
     "X": 8,
     "XXX": 16,
-    "Blocked": 32, # Probably not actually visible through the API without being logged in on model owner account?
+    "Blocked": 32,  # Probably not actually visible through the API without being logged in on model owner account?
 }
 
 # Node type constants
 NODE_TYPES = {
     "Lora Loader (LoraManager)": 1,
     "Lora Stacker (LoraManager)": 2,
-    "WanVideo Lora Select (LoraManager)": 3
+    "WanVideo Lora Select (LoraManager)": 3,
 }
 
 # Default ComfyUI node color when bgcolor is null
@@ -19,18 +19,18 @@ DEFAULT_NODE_COLOR = "#353535"
 
 # preview extensions
 PREVIEW_EXTENSIONS = [
-    '.webp',
-    '.preview.webp',
-    '.preview.png',
-    '.preview.jpeg',
-    '.preview.jpg',
-    '.preview.mp4',
-    '.png',
-    '.jpeg',
-    '.jpg',
-    '.mp4',
-    '.gif',
-    '.webm'
+    ".webp",
+    ".preview.webp",
+    ".preview.png",
+    ".preview.jpeg",
+    ".preview.jpg",
+    ".preview.mp4",
+    ".png",
+    ".jpeg",
+    ".jpg",
+    ".mp4",
+    ".gif",
+    ".webm",
 ]
 
 # Card preview image width
@@ -41,37 +41,77 @@ EXAMPLE_IMAGE_WIDTH = 832
 
 # Supported media extensions for example downloads
 SUPPORTED_MEDIA_EXTENSIONS = {
-    'images': ['.jpg', '.jpeg', '.png', '.webp', '.gif'],
-    'videos': ['.mp4', '.webm']
+    "images": [".jpg", ".jpeg", ".png", ".webp", ".gif"],
+    "videos": [".mp4", ".webm"],
 }
 
-# Valid Lora types
-VALID_LORA_TYPES = ['lora', 'locon', 'dora']
+# Valid sub-types for each scanner type
+VALID_LORA_SUB_TYPES = ["lora", "locon", "dora"]
+VALID_CHECKPOINT_SUB_TYPES = ["checkpoint", "diffusion_model"]
+VALID_EMBEDDING_SUB_TYPES = ["embedding"]
+VALID_MISC_SUB_TYPES = ["vae", "upscaler"]
+
+# Backward compatibility alias
+VALID_LORA_TYPES = VALID_LORA_SUB_TYPES
 
 # Supported Civitai model types for user model queries (case-insensitive)
 CIVITAI_USER_MODEL_TYPES = [
     *VALID_LORA_TYPES,
-    'textualinversion',
-    'checkpoint',
+    "textualinversion",
+    "checkpoint",
 ]
 
 # Default chunk size in megabytes used for hashing large files.
 DEFAULT_HASH_CHUNK_SIZE_MB = 4
 
 # Auto-organize settings
-AUTO_ORGANIZE_BATCH_SIZE = 50  # Process models in batches to avoid overwhelming the system
+AUTO_ORGANIZE_BATCH_SIZE = (
+    50  # Process models in batches to avoid overwhelming the system
+)
 
 # Civitai model tags in priority order for subfolder organization
 CIVITAI_MODEL_TAGS = [
-    'character', 'concept', 'clothing',
-    'realistic', 'anime', 'toon', 'furry', 'style',
-    'poses', 'background', 'tool', 'vehicle', 'buildings',
-    'objects', 'assets', 'animal', 'action'
+    "character",
+    "concept",
+    "clothing",
+    "realistic",
+    "anime",
+    "toon",
+    "furry",
+    "style",
+    "poses",
+    "background",
+    "tool",
+    "vehicle",
+    "buildings",
+    "objects",
+    "assets",
+    "animal",
+    "action",
 ]
 
 # Default priority tag configuration strings for each model type
 DEFAULT_PRIORITY_TAG_CONFIG = {
-    'lora': ', '.join(CIVITAI_MODEL_TAGS),
-    'checkpoint': ', '.join(CIVITAI_MODEL_TAGS),
-    'embedding': ', '.join(CIVITAI_MODEL_TAGS),
+    "lora": ", ".join(CIVITAI_MODEL_TAGS),
+    "checkpoint": ", ".join(CIVITAI_MODEL_TAGS),
+    "embedding": ", ".join(CIVITAI_MODEL_TAGS),
+    "misc": ", ".join(CIVITAI_MODEL_TAGS),
 }
+
+# baseModel values from CivitAI that should be treated as diffusion models (unet)
+# These model types are incorrectly labeled as "checkpoint" by CivitAI but are actually diffusion models
+DIFFUSION_MODEL_BASE_MODELS = frozenset(
+    [
+        "ZImageTurbo",
+        "Wan Video 1.3B t2v",
+        "Wan Video 14B t2v",
+        "Wan Video 14B i2v 480p",
+        "Wan Video 14B i2v 720p",
+        "Wan Video 2.2 TI2V-5B",
+        "Wan Video 2.2 I2V-A14B",
+        "Wan Video 2.2 T2V-A14B",
+        "Wan Video 2.5 T2V",
+        "Wan Video 2.5 I2V",
+        "Qwen",
+    ]
+)

py/utils/example_images_processor.py

@@ -593,5 +593,114 @@ class ExampleImagesProcessor:
                 'error': str(e)
             }, status=500)
 
+    @staticmethod
+    async def set_example_image_nsfw_level(request: web.Request) -> web.StreamResponse:
+        """
+        Update the NSFW level for a single example image (regular or custom).
+        """
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({'success': False, 'error': 'Invalid JSON body'}, status=400)
+
+        model_hash = data.get('model_hash')
+        raw_level = data.get('nsfw_level')
+        source = (data.get('source') or 'civitai').lower()
+        index = data.get('index')
+        image_id = data.get('id')
+
+        if model_hash is None or raw_level is None:
+            return web.json_response(
+                {'success': False, 'error': 'Missing required parameters: model_hash and nsfw_level'},
+                status=400,
+            )
+
+        try:
+            nsfw_level = int(raw_level)
+        except (TypeError, ValueError):
+            return web.json_response(
+                {'success': False, 'error': 'nsfw_level must be an integer'}, status=400
+            )
+
+        if source == 'custom':
+            if not image_id:
+                return web.json_response(
+                    {'success': False, 'error': 'Custom images require an id field'}, status=400
+                )
+        else:
+            try:
+                index = int(index)
+            except (TypeError, ValueError):
+                return web.json_response(
+                    {'success': False, 'error': 'Regular images require a numeric index'}, status=400
+                )
+
+        try:
+            lora_scanner = await ServiceRegistry.get_lora_scanner()
+            checkpoint_scanner = await ServiceRegistry.get_checkpoint_scanner()
+            embedding_scanner = await ServiceRegistry.get_embedding_scanner()
+
+            model_data = None
+            scanner = None
+
+            for scan_obj in [lora_scanner, checkpoint_scanner, embedding_scanner]:
+                if scan_obj.has_hash(model_hash):
+                    cache = await scan_obj.get_cached_data()
+                    for item in cache.raw_data:
+                        if item.get('sha256') == model_hash:
+                            model_data = item
+                            scanner = scan_obj
+                            break
+                if model_data:
+                    break
+
+            if not model_data:
+                return web.json_response(
+                    {'success': False, 'error': f"Model with hash {model_hash} not found in cache"},
+                    status=404,
+                )
+
+            await MetadataManager.hydrate_model_data(model_data)
+            civitai_data = model_data.setdefault('civitai', {})
+            regular_images = civitai_data.get('images') or []
+            custom_images = civitai_data.get('customImages') or []
+
+            target_image = None
+            if source == 'custom':
+                for image in custom_images:
+                    if image.get('id') == image_id:
+                        target_image = image
+                        break
+            else:
+                if 0 <= index < len(regular_images):
+                    target_image = regular_images[index]
+
+            if target_image is None:
+                return web.json_response(
+                    {'success': False, 'error': 'Target image not found'}, status=404
+                )
+
+            target_image['nsfwLevel'] = nsfw_level
+            civitai_data['images'] = regular_images
+            civitai_data['customImages'] = custom_images
+
+            file_path = model_data.get('file_path')
+            if file_path:
+                model_copy = model_data.copy()
+                model_copy.pop('folder', None)
+                await MetadataManager.save_metadata(file_path, model_copy)
+                await scanner.update_single_model_cache(file_path, file_path, model_data)
+
+            return web.json_response({
+                'success': True,
+                'regular_images': regular_images,
+                'custom_images': custom_images,
+                'model_file_path': model_data.get('file_path', ''),
+                'nsfw_level': nsfw_level
+            })
+        except Exception as exc:
+            logger.error("Failed to update example image NSFW level: %s", exc, exc_info=True)
+            return web.json_response({'success': False, 'error': str(exc)}, status=500)
+
 
     

py/utils/exif_utils.py

@@ -22,6 +22,12 @@ class ExifUtils:
             Optional[str]: Extracted metadata or None if not found
         """
         try:
+            # Skip for video files
+            if image_path:
+                ext = os.path.splitext(image_path)[1].lower()
+                if ext in ['.mp4', '.webm']:
+                    return None
+
             # First try to open the image
             with Image.open(image_path) as img:
                 # Method 1: Check for parameters in image info
@@ -80,6 +86,12 @@ class ExifUtils:
             str: Path to the updated image
         """
         try:
+            # Skip for video files
+            if image_path:
+                ext = os.path.splitext(image_path)[1].lower()
+                if ext in ['.mp4', '.webm']:
+                    return image_path
+
             # Load the image and check its format
             with Image.open(image_path) as img:
                 img_format = img.format
@@ -133,6 +145,12 @@ class ExifUtils:
     def append_recipe_metadata(image_path, recipe_data) -> str:
         """Append recipe metadata to an image's EXIF data"""
         try:
+            # Skip for video files
+            if image_path:
+                ext = os.path.splitext(image_path)[1].lower()
+                if ext in ['.mp4', '.webm']:
+                    return image_path
+
             # First, extract existing metadata
             metadata = ExifUtils.extract_image_metadata(image_path)
             
@@ -242,6 +260,16 @@ class ExifUtils:
             Tuple of (optimized_image_data, extension)
         """
         try:
+            # Skip for video files early if it's a file path
+            if isinstance(image_data, str) and os.path.exists(image_data):
+                ext = os.path.splitext(image_data)[1].lower()
+                if ext in ['.mp4', '.webm']:
+                    try:
+                        with open(image_data, 'rb') as f:
+                            return f.read(), ext
+                    except Exception:
+                        return image_data, ext
+
             # First validate the image data is usable
             img = None
             if isinstance(image_data, str) and os.path.exists(image_data):