Standard Ebooks
+Discover meticulously produced public-domain ebooks with consistent typography, metadata, and clean EPUB sources.
++ + Visit standardebooks.org + +
+Opens in a new tab so you can grab EPUB downloads and drag them into abogen.
+
+Abogen offers **two interfaces** to suit different workflows:
-## Demo
+| Command | Interface | Best for |
+|---------|-----------|----------|
+| `abogen` | PyQt6 Desktop GUI | Local desktop use on Windows/macOS/Linux |
+| `abogen-web` | Flask Web UI | Docker, headless servers, remote access |
-https://github.com/user-attachments/assets/094ba3df-7d66-494a-bc31-0e4b41d0b865
+Both interfaces share the same core processing engine and produce identical output.
-> This demo was generated in just 5 seconds, producing ∼1 minute of audio with perfectly synced subtitles. To create a similar video, see [the demo guide](https://github.com/denizsafak/abogen/tree/main/demo).
-
-## `How to install?` 
-
-### `Windows`
-Go to [espeak-ng latest release](https://github.com/espeak-ng/espeak-ng/releases/latest) download and run the *.msi file.
-
-#### OPTION 1: Install using script
-1. [Download](https://github.com/denizsafak/abogen/archive/refs/heads/main.zip) the repository
-2. Extract the ZIP file
-3. Run `WINDOWS_INSTALL.bat` by double-clicking it
-
-This method handles everything automatically - installing all dependencies including CUDA in a self-contained environment without requiring a separate Python installation. (You still need to install [espeak-ng](https://github.com/espeak-ng/espeak-ng/releases/latest).)
-
-> [!NOTE]
-> You don't need to install Python separately. The script will install Python automatically.
-
-#### OPTION 2: Install using uv
-First, [install uv](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already.
+## Quick start
+Abogen supports Python 3.10–3.12.
+### Install with pip
```bash
-# For NVIDIA GPUs (CUDA 12.8) - Recommended
-uv tool install --python 3.12 abogen[cuda] --extra-index-url https://download.pytorch.org/whl/cu128 --index-strategy unsafe-best-match
-
-# For NVIDIA GPUs (CUDA 12.6) - Older drivers
-uv tool install --python 3.12 abogen[cuda126] --extra-index-url https://download.pytorch.org/whl/cu126 --index-strategy unsafe-best-match
-
-# For NVIDIA GPUs (CUDA 13.0) - Newer drivers
-uv tool install --python 3.12 abogen[cuda130] --extra-index-url https://download.pytorch.org/whl/cu130 --index-strategy unsafe-best-match
-
-# For AMD GPUs or without GPU - If you have AMD GPU, you need to use Linux for GPU acceleration, because ROCm is not available on Windows.
-uv tool install --python 3.12 abogen
-```
-
-
-
-Here’s Abogen in action: in this demo, it processes ∼3,000 characters of text in just 11 seconds and turns it into 3 minutes and 28 seconds of audio, and I have a low-end **RTX 2060 Mobile laptop GPU**. Your results may vary depending on your hardware.
-
-## `Configuration`
-
-| Options | Description |
-|---------|-------------|
-| **Input Box** | Drag and drop `ePub`, `PDF`, `.TXT`, `.MD`, `.SRT`, `.ASS` or `.VTT` files (or use built-in text editor) |
-| **Queue options** | Add multiple files to a queue and process them in batch, with individual settings for each file. See [Queue mode](#queue-mode) for more details. |
-| **Speed** | Adjust speech rate from `0.1x` to `2.0x` |
-| **Select Voice** | First letter of the language code (e.g., `a` for American English, `b` for British English, etc.), second letter is for `m` for male and `f` for female. |
-| **Voice mixer** | Create custom voices by mixing different voice models with a profile system. See [Voice Mixer](#voice-mixer) for more details. |
-| **Voice preview** | Listen to the selected voice before processing. |
-| **Generate subtitles** | `Disabled`, `Line`, `Sentence`, `Sentence + Comma`, `Sentence + Highlighting`, `1 word`, `2 words`, `3 words`, etc. (Represents the number of words in each subtitle entry) |
-| **Output voice format** | `.WAV`, `.FLAC`, `.MP3`, `.OPUS (best compression)` and `M4B (with chapters)` |
-| **Output subtitle format** | Configures the subtitle format as `SRT (standard)`, `ASS (wide)`, `ASS (narrow)`, `ASS (centered wide)`, or `ASS (centered narrow)`. |
-| **Replace single newlines with spaces** | Replaces single newlines with spaces in the text. This is useful for texts that have imaginary line breaks. |
-| **Save location** | `Save next to input file`, `Save to desktop`, or `Choose output folder` |
-
-> Special thanks to [@brianxiadong](https://github.com/brianxiadong) for adding markdown support in PR [#75](https://github.com/denizsafak/abogen/pull/75)
-
-> Special thanks to [@jborza](https://github.com/jborza) for chapter support in PR [#10](https://github.com/denizsafak/abogen/pull/10)
-
-> Special thanks to [@mleg](https://github.com/mleg) for adding `Line` option in subtitle generation in PR [#94](https://github.com/denizsafak/abogen/pull/94)
-
-| Book handler options | Description |
-|---------|-------------|
-| **Chapter Control** | Select specific `chapters` from ePUBs or markdown files or `chapters + pages` from PDFs. |
-| **Save each chapter separately** | Save each chapter in e-books as a separate audio file. |
-| **Create a merged version** | Create a single audio file that combines all chapters. (If `Save each chapter separately` is disabled, this option will be the default behavior.) |
-| **Save in a project folder with metadata** | Save the converted items in a project folder with available metadata files. |
-
-| Menu options | Description |
-|---------|-------------|
-| **Theme** | Change the application's theme using `System`, `Light`, or `Dark` options. |
-| **Configure max words per subtitle** | Configures the maximum number of words per subtitle entry. |
-| **Configure silence between chapters** | Configures the duration of silence between chapters (in seconds). |
-| **Configure max lines in log window** | Configures the maximum number of lines to display in the log window. |
-| **Separate chapters audio format** | Configures the audio format for separate chapters as `wav`, `flac`, `mp3`, or `opus`. |
-| **Create desktop shortcut** | Creates a shortcut on your desktop for easy access. |
-| **Open config directory** | Opens the directory where the configuration file is stored. |
-| **Open cache directory** | Opens the cache directory where converted text files are stored. |
-| **Clear cache files** | Deletes cache files created during the conversion or preview. |
-| **Use silent gaps between subtitles** | Prevents unnecessary audio speed-up by letting speech continue into the silent gaps between subtitle etries. In short, it ignores the end times in subtitle entries and uses the silent space until the beginning of the next subtitle entry. When disabled, it speeds up the audio to fit the exact time interval specified in the subtitle. (for subtitle files). |
-| **Subtitle speed adjustment method** | Choose how to speed up audio when needed: `TTS Regeneration (better quality)` re-generates the audio at a faster speed, while `FFmpeg Time-stretch (better speed)` quickly speeds up the generated audio. (for subtitle files). |
-| **Use spaCy for sentence segmentation** | When this option is enabled, Abogen uses [spaCy](https://spacy.io/) to detect sentence boundaries more accurately, instead of using punctuation marks (like periods, question marks, etc.) to split sentences, which could incorrectly cut off phrases like "Mr." or "Dr.". With spaCy, sentences are divided more accurately. For non-English text, spaCy runs **before** audio generation to create sentence chunks. For English text, spaCy runs **during** subtitle generation to improve timing and readability. spaCy is only used when subtitle mode is `Sentence` or `Sentence + Comma`. If you prefer the old punctuation splitting method, you can turn this option off. |
-| **Pre-download models and voices for offline use** | Opens a window that displays the available models and voices. Click `Download all` button to download all required models and voices, allowing you to use Abogen completely offline without any internet connection. |
-| **Disable Kokoro's internet access** | Prevents Kokoro from downloading models or voices from HuggingFace Hub, useful for offline use. |
-| **Check for updates at startup** | Automatically checks for updates when the program starts. |
-| **Reset to default settings** | Resets all settings to their default values. |
-
-> Special thanks to [@robmckinnon](https://github.com/robmckinnon) for adding Sentence + Highlighting feature in PR [#65](https://github.com/denizsafak/abogen/pull/65)
-
-## `Voice Mixer`
-
-
-With voice mixer, you can create custom voices by mixing different voice models. You can adjust the weight of each voice and save your custom voice as a profile for future use. The voice mixer allows you to create unique and personalized voices.
-
-> Special thanks to [@jborza](https://github.com/jborza) for making this possible through his contributions in [#5](https://github.com/denizsafak/abogen/pull/5)
-
-## `Queue Mode`
-
-
-Abogen supports **queue mode**, allowing you to add multiple files to a processing queue. This is useful if you want to convert several files in one batch.
-
-- You can add text files (`.txt`) and subtitle files (`.srt`, `.ass`, `.vtt`) directly using the **Add files** button in the Queue Manager or by dragging and dropping them into the queue list. To add PDF, EPUB, or markdown files, use the input box in the main window and click the **Add to Queue** button.
-- Each file in the queue keeps the configuration settings that were active when it was added. Changing the main window configuration afterward does **not** affect files already in the queue.
-- You can enable the **Override item settings with current selection** option to force all items in the queue to use the configuration currently selected in the main window, overriding their saved settings.
-- You can view each file's configuration by hovering over them.
-
-Abogen will process each item in the queue automatically, saving outputs as configured.
-
-> Special thanks to [@jborza](https://github.com/jborza) for adding queue mode in PR [#35](https://github.com/denizsafak/abogen/pull/35)
-
-## `About Chapter Markers`
-When you process ePUB, PDF or markdown files, Abogen converts them into text files stored in your cache directory. When you click "Edit," you're actually modifying these converted text files. In these text files, you'll notice tags that look like this:
-
-```
-<Each paragraph begins with a stable debug code marker.
", + ] + + for sample in DEBUG_TTS_SAMPLES: + safe_label = sample.label.replace("&", "and") + chapter_lines.append(f"" + marker_for(sample.code) + " " + sample.text + "
" + ) + + chapter_lines += ["", ""] + chapter_xhtml = "\n".join(chapter_lines) + + container_xml = """ +\n"
+ f"{safe_original}\n"
+ " "
+ )
+
+ return (
+ "\n"
+ "\n"
+ " \n"
+ " {inline_html}
" + + +def _format_smil_time(value: Optional[float]) -> str: + if value is None or value < 0: + value = 0.0 + total_ms = int(round(value * 1000)) + hours, remainder = divmod(total_ms, 3600_000) + minutes, remainder = divmod(remainder, 60_000) + seconds, milliseconds = divmod(remainder, 1000) + return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{milliseconds:03d}" + + +def _safe_int(value: Any, default: int = 0) -> int: + try: + return int(value) + except (TypeError, ValueError): + return default + + +def _safe_float(value: Any) -> Optional[float]: + if value is None: + return None + try: + return float(value) + except (TypeError, ValueError): + return None + + +def _restore_original_chunk_text(chapter_text: str, overlays: List[ChunkOverlay]) -> None: + if not chapter_text or not overlays: + return + + cursor = 0 + for chunk in overlays: + if chunk.original_text is not None: + prepared = _prepare_display_text(chunk.original_text) + chunk.text = prepared + continue + candidate = chunk.text or "" + if not candidate: + continue + match = _search_original_span(chapter_text, candidate, cursor) + if match is None and cursor: + match = _search_original_span(chapter_text, candidate, 0) + if match is None: + if chunk.original_text is None: + chunk.original_text = chunk.text + chunk.text = _prepare_display_text(chunk.text or "") + continue + start, end = match + segment = chapter_text[start:end] + chunk.original_text = segment + chunk.text = _prepare_display_text(segment) + cursor = end + + +def _prepare_display_text(value: str) -> str: + if not value: + return "" + cleaned = re.sub(r"(?:[ \t]*\r?\n)+\Z", "", value) + return cleaned if cleaned else "" + + +def _search_original_span(source: str, normalized: str, start: int) -> Optional[Tuple[int, int]]: + if not normalized: + return None + pattern = _build_chunk_pattern(normalized) + match = pattern.search(source, start) + if not match: + return None + return match.start(1), match.end(1) + + +_CHUNK_REGEX_CACHE: Dict[str, Pattern[str]] = {} + + +def _build_chunk_pattern(text: str) -> Pattern[str]: + cached = _CHUNK_REGEX_CACHE.get(text) + if cached is not None: + return cached + escaped = re.escape(text) + escaped = escaped.replace(r"\ ", r"\s+") + pattern = re.compile(r"(\s*" + escaped + r"\s*)", re.DOTALL) + _CHUNK_REGEX_CACHE[text] = pattern + return pattern + + +def _render_metadata_xml( + title: str, + authors: Sequence[str], + language: str, + book_id: str, + *, + duration: Optional[float], + publisher: Optional[str], + description: Optional[str], + speaker_mode: Optional[str], + modified: Optional[str], +) -> List[str]: + elements = [ + f"
{PROGRAM_DESCRIPTION}
" - "Visit the GitHub repository for updates, documentation, and to report issues.
" - ) - desc_label.setTextFormat(Qt.TextFormat.RichText) - desc_label.setWordWrap(True) - layout.addWidget(desc_label) - - # GitHub link - github_btn = QPushButton("Visit GitHub Repository") - github_btn.setIcon(QIcon(get_resource_path("abogen.assets", "github.png"))) - github_btn.clicked.connect(lambda: QDesktopServices.openUrl(QUrl(GITHUB_URL))) - github_btn.setFixedHeight(32) - layout.addWidget(github_btn) - - # Check for updates button - update_btn = QPushButton("Check for updates") - update_btn.clicked.connect(self.manual_check_for_updates) - update_btn.setFixedHeight(32) - layout.addWidget(update_btn) - - # Close button - close_btn = QPushButton("Close") - close_btn.clicked.connect(dialog.accept) - close_btn.setFixedHeight(32) - layout.addWidget(close_btn) - - dialog.exec() - - def manual_check_for_updates(self): - """Manually check for updates and always show result""" - # Set a flag to always show the result message - self._show_update_check_result = True - self.check_for_updates_startup() - - def check_for_updates_startup(self): - import urllib.request - - def show_update_message(remote_version, local_version): - msg_box = QMessageBox(self) - msg_box.setIcon(QMessageBox.Icon.Information) - msg_box.setWindowTitle("Update Available") - msg_box.setText( - f"A new version of {PROGRAM_NAME} is available! ({local_version} > {remote_version})" - ) - msg_box.setInformativeText( - f"If you installed via pip, update by running:\n" - f"pip install --upgrade {PROGRAM_NAME}\n\n" - f"If you're using the Windows portable version, run 'WINDOWS_INSTALL.bat' again.\n\n" - "Alternatively, visit the GitHub repository for more information. " - "Would you like to view the changelog?" - ) - msg_box.setStandardButtons( - QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No - ) - msg_box.setDefaultButton(QMessageBox.StandardButton.Yes) - if msg_box.exec() == QMessageBox.StandardButton.Yes: - try: - QDesktopServices.openUrl(QUrl(GITHUB_URL + "/releases/latest")) - except Exception: - pass - - # Reset flag to track if we should show "no updates" message - show_result = ( - hasattr(self, "_show_update_check_result") - and self._show_update_check_result - ) - self._show_update_check_result = False - - try: - update_url = "https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/abogen/VERSION" - with urllib.request.urlopen(update_url) as response: - remote_raw = response.read().decode().strip() - local_raw = VERSION - - # Parse version numbers - remote_version = remote_raw - local_version = local_raw - - try: - remote_num = int("".join(remote_version.split("."))) - local_num = int("".join(local_version.split("."))) - except ValueError as ve: - return - - if remote_num > local_num: - # Use QTimer to ensure UI is ready, then show update message. - QTimer.singleShot( - 1000, lambda: show_update_message(remote_version, local_version) - ) - elif show_result: - # Show "no updates" message if manually checking - QMessageBox.information( - self, - "Up to Date", - f"You are running the latest version of {PROGRAM_NAME} ({local_version}).", - ) - except Exception as e: - if show_result: - QMessageBox.warning( - self, - "Update Check Failed", - f"Could not check for updates:\n{str(e)}", - ) - pass - - def clear_cache_files(self): - """Clear cache files created by the program.""" - import glob - - try: - # Get the abogen cache directory - cache_dir = get_user_cache_path() - - # Find all .txt files and cover images in the abogen cache directory - cache_files = glob.glob(os.path.join(cache_dir, "*.txt")) - cache_files.extend(glob.glob(os.path.join(cache_dir, "cover_*.jpg"))) - - # Count the files - file_count = len(cache_files) - - # Check for preview cache files - preview_cache_dir = os.path.join(cache_dir, "preview_cache") - preview_files = [] - if os.path.exists(preview_cache_dir): - preview_pattern = os.path.join(preview_cache_dir, "*.wav") - preview_files = glob.glob(preview_pattern) - - preview_count = len(preview_files) - - if file_count == 0 and preview_count == 0: - QMessageBox.information( - self, "No Cache Files", "No cache files were found." - ) - return - - # Create a custom message box with checkbox - msg_box = QMessageBox(self) - msg_box.setIcon(QMessageBox.Icon.Question) - msg_box.setWindowTitle("Clear Cache Files") - - msg_text = f"Found {file_count} cache file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} cache folder." - if preview_count > 0: - msg_text += f"\nAlso found {preview_count} preview cache file{'s' if preview_count != 1 else ''}." - - msg_box.setText(msg_text + "\nDo you want to delete them?") - - # Add checkbox for preview cache - preview_cache_checkbox = QCheckBox("Also clean preview cache", msg_box) - preview_cache_checkbox.setChecked(False) - # Only enable checkbox if preview files exist - preview_cache_checkbox.setEnabled(preview_count > 0) - - # Add the checkbox to the layout - msg_box.setCheckBox(preview_cache_checkbox) - - # Add buttons - msg_box.setStandardButtons( - QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No - ) - msg_box.setDefaultButton(QMessageBox.StandardButton.Yes) - - if msg_box.exec() != QMessageBox.StandardButton.Yes: - return - - # Delete the text files - deleted_count = 0 - for file_path in cache_files: - try: - os.remove(file_path) - deleted_count += 1 - except Exception as e: - print(f"Error deleting {file_path}: {e}") - - # Delete preview cache files if checkbox is checked - deleted_preview_count = 0 - if preview_cache_checkbox.isChecked() and preview_count > 0: - for file_path in preview_files: - try: - os.remove(file_path) - deleted_preview_count += 1 - except Exception as e: - print(f"Error deleting preview cache {file_path}: {e}") - - # Build result message - result_msg = f"Successfully deleted {deleted_count} temporary file{'s' if deleted_count != 1 else ''}." - if preview_cache_checkbox.isChecked() and deleted_preview_count > 0: - result_msg += f"\nAlso deleted {deleted_preview_count} preview cache file{'s' if deleted_preview_count != 1 else ''}." - - # Show results - QMessageBox.information(self, "Cache Files Cleared", result_msg) - - # If currently selected file is in the cache directory, clear the UI - if ( - self.selected_file - and os.path.dirname(self.selected_file) == cache_dir - and self.selected_file.endswith(".txt") - ): - self.input_box.clear_input() - - except Exception as e: - QMessageBox.critical( - self, "Error", f"An error occurred while clearing temporary files:\n{e}" - ) - - def set_max_log_lines(self): - """Open a dialog to set the maximum lines in the log window.""" - from PyQt6.QtWidgets import QInputDialog - - value, ok = QInputDialog.getInt( - self, - "Max Lines in Log Window", - "Enter the maximum number of lines to display in the log window:", - self.log_window_max_lines, - 10, # min value - 999999999, # max value - 1, # step - ) - if ok: - self.log_window_max_lines = value - self.config["log_window_max_lines"] = value - save_config(self.config) - QMessageBox.information( - self, - "Setting Saved", - f"Maximum lines in log window set to {value}.", - ) - - def set_max_subtitle_words(self): - """Open a dialog to set the maximum words per subtitle""" - from PyQt6.QtWidgets import QInputDialog - - current_value = self.config.get("max_subtitle_words", 50) - - value, ok = QInputDialog.getInt( - self, - "Max Words Per Subtitle", - "Enter the maximum number of words per\nsubtitle (before splitting the subtitle):", - current_value, - 1, # min value - 200, # max value - 1, # step - ) - - if ok: - # Save the new value - self.max_subtitle_words = value - self.config["max_subtitle_words"] = value - save_config(self.config) - - # Show confirmation - QMessageBox.information( - self, - "Setting Saved", - f"Maximum words per subtitle set to {value}.", - ) - - def set_silence_between_chapters(self): - """Open a dialog to set the silence duration between chapters""" - - current_value = self.config.get("silence_duration", 2.0) - - dlg = QInputDialog(self) - dlg.setWindowTitle("Silence Duration (seconds)") - dlg.setLabelText( - "Enter the duration of silence\nbetween chapters (in seconds):" - ) - dlg.setInputMode(QInputDialog.InputMode.DoubleInput) - dlg.setDoubleDecimals(1) - dlg.setDoubleMinimum(0.0) - dlg.setDoubleMaximum(60.0) - dlg.setDoubleValue(current_value) - dlg.setDoubleStep(0.1) # <-- set step to 0.1 - - if dlg.exec() == QDialog.DialogCode.Accepted: - value = dlg.doubleValue() - # Round to one decimal to avoid floating-point representation noise - value = round(value, 1) - - # Save the new value - self.silence_duration = value - self.config["silence_duration"] = value - save_config(self.config) - - # Show confirmation (format with one decimal) - QMessageBox.information( - self, - "Setting Saved", - f"Silence duration between chapters set to {value:.1f} seconds.", - ) - - def set_separate_chapters_format(self, fmt): - """Set the format for separate chapters audio files.""" - self.separate_chapters_format = fmt - self.config["separate_chapters_format"] = fmt - save_config(self.config) - - def set_subtitle_format(self, fmt): - """Set the subtitle format.""" - self.config["subtitle_format"] = fmt - save_config(self.config) - - def show_model_download_warning(self, title, message): - QMessageBox.information(self, title, message) +__all__ = ["abogen"] diff --git a/abogen/heteronym_overrides.py b/abogen/heteronym_overrides.py new file mode 100644 index 0000000..dbb5384 --- /dev/null +++ b/abogen/heteronym_overrides.py @@ -0,0 +1,298 @@ +from __future__ import annotations + +import hashlib +import re +from dataclasses import dataclass +from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple + +try: # pragma: no cover - optional dependency + import spacy # type: ignore +except Exception: # pragma: no cover - spaCy may be unavailable in minimal environments + spacy = None + + +@dataclass(frozen=True) +class HeteronymVariant: + key: str + label: str + replacement_token: str + example_sentence: str + + +@dataclass(frozen=True) +class HeteronymSpec: + token: str + variants: Tuple[HeteronymVariant, HeteronymVariant] + + def default_choice_for_token(self, spacy_token: Any) -> str: + """Return the most likely variant key for this token.""" + pos = (getattr(spacy_token, "pos_", "") or "").upper() + tag = (getattr(spacy_token, "tag_", "") or "").upper() + + token_lower = self.token.casefold() + if token_lower == "wind": + # VERB => /waɪnd/, NOUN => /wɪnd/ + return "verb" if pos == "VERB" else "noun" + if token_lower == "read": + # VBD/VBN => /rɛd/ + return "past" if tag in {"VBD", "VBN"} else "present" + if token_lower == "tear": + return "verb" if pos == "VERB" else "noun" + if token_lower == "close": + return "verb" if pos == "VERB" else "adj" + if token_lower == "lead": + # Default to verb unless POS suggests noun. + return "metal" if pos == "NOUN" else "verb" + return self.variants[0].key + + +# Minimal, high-confidence starter set. +# NOTE: These replacements intentionally prioritize speech output. +# Some replacements may not be appropriate for subtitles/text exports. +_HETERONYM_SPECS: Dict[str, HeteronymSpec] = { + "wind": HeteronymSpec( + token="wind", + variants=( + HeteronymVariant( + key="noun", + label="Noun (the wind)", + replacement_token="wind", + example_sentence="Listen to the wind.", + ), + HeteronymVariant( + key="verb", + label="Verb (to wind)", + replacement_token="wynd", + example_sentence="I need to wind the watch.", + ), + ), + ), + "read": HeteronymSpec( + token="read", + variants=( + HeteronymVariant( + key="present", + label="Present (I read every day)", + replacement_token="read", + example_sentence="I read every day.", + ), + HeteronymVariant( + key="past", + label="Past (I read it yesterday)", + replacement_token="red", + example_sentence="I read it yesterday.", + ), + ), + ), + "tear": HeteronymSpec( + token="tear", + variants=( + HeteronymVariant( + key="noun", + label="Noun (a tear /crying/)", + replacement_token="tier", + example_sentence="A tear rolled down her cheek.", + ), + HeteronymVariant( + key="verb", + label="Verb (to tear /rip/)", + replacement_token="tear", + example_sentence="Please don't tear the page.", + ), + ), + ), + "close": HeteronymSpec( + token="close", + variants=( + HeteronymVariant( + key="adj", + label="Adjective (close /near/)", + replacement_token="close", + example_sentence="We are close to the station.", + ), + HeteronymVariant( + key="verb", + label="Verb (close /klohz/)", + replacement_token="cloze", + example_sentence="Please close the door.", + ), + ), + ), + "lead": HeteronymSpec( + token="lead", + variants=( + HeteronymVariant( + key="verb", + label="Verb (to lead)", + replacement_token="lead", + example_sentence="They will lead the way.", + ), + HeteronymVariant( + key="metal", + label="Noun (lead /metal/)", + replacement_token="led", + example_sentence="The pipe was made of lead.", + ), + ), + ), +} + + +def _hash_id(*parts: str) -> str: + digest = hashlib.sha1("\n".join(parts).encode("utf-8")).hexdigest() + return digest[:12] + + +_WORD_BOUNDARY_CACHE: Dict[str, re.Pattern[str]] = {} + + +def _word_boundary_pattern(token: str) -> re.Pattern[str]: + key = token.casefold() + cached = _WORD_BOUNDARY_CACHE.get(key) + if cached is not None: + return cached + escaped = re.escape(token) + pattern = re.compile(rf"(?i)(?'s|\u2019s|\u2019)?(?!\w)") + _WORD_BOUNDARY_CACHE[key] = pattern + return pattern + + +def _preserve_case(replacement: str, original: str) -> str: + if not replacement: + return replacement + if original.isupper(): + return replacement.upper() + if original[:1].isupper(): + return replacement[:1].upper() + replacement[1:] + return replacement + + +def _build_replacement_sentence(sentence: str, token: str, replacement_token: str) -> str: + pattern = _word_boundary_pattern(token) + + def _repl(match: re.Match[str]) -> str: + matched = match.group(0) or "" + suffix = match.group("possessive") or "" + base = matched[: len(matched) - len(suffix)] if suffix else matched + return _preserve_case(replacement_token, base) + suffix + + return pattern.sub(_repl, sentence) + + +def _load_spacy(language: str) -> Any: + if spacy is None: + return None + + # English only for now. + # Use installed small model; keep it simple. + lang = (language or "en").lower() + if lang.startswith("en"): + try: + return spacy.load("en_core_web_sm") + except Exception: + return spacy.blank("en") + return spacy.blank("xx") + + +def extract_heteronym_overrides( + chapters: Sequence[Mapping[str, Any]], + *, + language: str, + existing: Optional[Iterable[Mapping[str, Any]]] = None, +) -> List[Dict[str, Any]]: + """Extract distinct heteronym-containing sentences from chapters. + + Returns entries shaped for persistence + UI. + + Each entry contains: + - id + - token + - sentence + - options: [{key,label,replacement_token,replacement_sentence,example_sentence}] + - default_choice + - choice + """ + + lang = (language or "en").lower() + if not lang.startswith("en"): + return [] + + if spacy is None: + return [] + + nlp = _load_spacy(lang) + if nlp is None: + return [] + + previous_choices: Dict[str, str] = {} + if existing: + for item in existing: + if not isinstance(item, Mapping): + continue + entry_id = str(item.get("id") or "").strip() + choice = str(item.get("choice") or "").strip() + if entry_id and choice: + previous_choices[entry_id] = choice + + results: List[Dict[str, Any]] = [] + seen: set[tuple[str, str]] = set() + + for chapter in chapters: + if not isinstance(chapter, Mapping): + continue + text = str(chapter.get("text") or "") + if not text.strip(): + continue + + doc = nlp(text) + for sent in getattr(doc, "sents", []): + sentence = str(getattr(sent, "text", "") or "").strip() + if not sentence: + continue + + for token in sent: + token_text = str(getattr(token, "text", "") or "") + if not token_text: + continue + token_key = token_text.casefold() + spec = _HETERONYM_SPECS.get(token_key) + if not spec: + continue + + dedupe_key = (token_key, sentence) + if dedupe_key in seen: + continue + seen.add(dedupe_key) + + entry_id = _hash_id(token_key, sentence) + default_choice = spec.default_choice_for_token(token) + choice = previous_choices.get(entry_id, default_choice) + + options: List[Dict[str, Any]] = [] + for variant in spec.variants: + replacement_sentence = _build_replacement_sentence( + sentence, token=spec.token, replacement_token=variant.replacement_token + ) + options.append( + { + "key": variant.key, + "label": variant.label, + "replacement_token": variant.replacement_token, + "replacement_sentence": replacement_sentence, + "example_sentence": variant.example_sentence, + } + ) + + results.append( + { + "id": entry_id, + "token": token_text, + "token_lower": token_key, + "sentence": sentence, + "options": options, + "default_choice": default_choice, + "choice": choice, + } + ) + + return results diff --git a/abogen/integrations/__init__.py b/abogen/integrations/__init__.py new file mode 100644 index 0000000..06e8198 --- /dev/null +++ b/abogen/integrations/__init__.py @@ -0,0 +1 @@ +"""Integration clients for external services.""" diff --git a/abogen/integrations/audiobookshelf.py b/abogen/integrations/audiobookshelf.py new file mode 100644 index 0000000..0538cce --- /dev/null +++ b/abogen/integrations/audiobookshelf.py @@ -0,0 +1,680 @@ +from __future__ import annotations + +import json +import logging +import math +import mimetypes +import re +from contextlib import ExitStack +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple + +import httpx + +logger = logging.getLogger(__name__) + + +class AudiobookshelfUploadError(RuntimeError): + """Raised when an upload to Audiobookshelf fails.""" + + +@dataclass(frozen=True) +class AudiobookshelfConfig: + base_url: str + api_token: str + library_id: Optional[str] = None + collection_id: Optional[str] = None + folder_id: Optional[str] = None + verify_ssl: bool = True + send_cover: bool = True + send_chapters: bool = True + send_subtitles: bool = True + timeout: float = 3600.0 + + def normalized_base_url(self) -> str: + base = (self.base_url or "").strip() + if not base: + raise ValueError("Audiobookshelf base URL is required") + normalized = base.rstrip("/") + # The web UI historically suggested including '/api' in the base URL; trim + # it here so we can safely append `/api/...` endpoints below. + if normalized.lower().endswith("/api"): + normalized = normalized[:-4] + return normalized or base + + +class AudiobookshelfClient: + """Client for the legacy Audiobookshelf multipart upload endpoint.""" + + def __init__(self, config: AudiobookshelfConfig) -> None: + if not config.api_token: + raise ValueError("Audiobookshelf API token is required") + # library_id is now optional for discovery + self._config = config + normalized = config.normalized_base_url() or "" + self._base_url = normalized.rstrip("/") or normalized + self._client_base_url = f"{self._base_url}/" + self._folder_cache: Optional[Tuple[str, str, str]] = None + + def get_libraries(self) -> List[Dict[str, Any]]: + """Fetch all libraries from the Audiobookshelf server.""" + route = self._api_path("libraries") + try: + with self._open_client() as client: + response = client.get(route) + response.raise_for_status() + data = response.json() + # data['libraries'] is a list of library objects + return data.get("libraries", []) + except httpx.HTTPError as exc: + raise AudiobookshelfUploadError(f"Failed to fetch libraries: {exc}") from exc + + def _api_path(self, suffix: str = "") -> str: + """Join the API prefix with the provided suffix without losing proxies.""" + clean_suffix = suffix.lstrip("/") + return f"api/{clean_suffix}" if clean_suffix else "api" + + def upload_audiobook( + self, + audio_path: Path, + *, + metadata: Dict[str, Any], + cover_path: Optional[Path] = None, + chapters: Optional[Iterable[Dict[str, Any]]] = None, + subtitles: Optional[Iterable[Path]] = None, + ) -> Dict[str, Any]: + if not audio_path.exists(): + raise AudiobookshelfUploadError(f"Audio path does not exist: {audio_path}") + + form_fields = self._build_upload_fields(audio_path, metadata, chapters) + file_entries = self._build_file_entries(audio_path, cover_path, subtitles) + + route = self._api_path("upload") + try: + with self._open_client() as client, ExitStack() as stack: + files_payload = self._open_file_handles(file_entries, stack) + response = client.post(route, data=form_fields, files=files_payload) + response.raise_for_status() + except httpx.HTTPStatusError as exc: + status = exc.response.status_code + detail = (exc.response.text or "").strip() + if detail: + detail = detail[:200] + message = f"Audiobookshelf upload failed with status {status}: {detail}" + else: + message = f"Audiobookshelf upload failed with status {status}" + raise AudiobookshelfUploadError( + message + ) from exc + except httpx.HTTPError as exc: + raise AudiobookshelfUploadError(f"Audiobookshelf upload failed: {exc}") from exc + + return {} + + def _open_client(self) -> httpx.Client: + headers = { + "Authorization": f"Bearer {self._config.api_token}", + "Accept": "application/json", + } + return httpx.Client( + base_url=self._client_base_url, + headers=headers, + timeout=self._config.timeout, + verify=self._config.verify_ssl, + ) + + def _build_upload_fields( + self, + audio_path: Path, + metadata: Dict[str, Any], + chapters: Optional[Iterable[Dict[str, Any]]], + ) -> Dict[str, str]: + folder_id, _, _ = self._ensure_folder() + title = self._extract_title(metadata, audio_path) + author = self._extract_author(metadata) + series = self._extract_series(metadata) + series_sequence = self._extract_series_sequence(metadata) + + fields: Dict[str, str] = { + "library": self._config.library_id, + "folder": folder_id, + "title": title, + } + if author: + fields["author"] = author + if series: + fields["series"] = series + if series_sequence: + fields["seriesSequence"] = series_sequence + if self._config.collection_id: + fields["collectionId"] = self._config.collection_id + + metadata_payload: Dict[str, Any] = metadata or {} + if chapters and self._config.send_chapters: + metadata_payload = dict(metadata_payload) + metadata_payload["chapters"] = list(chapters) + + if metadata_payload: + # Ensure authors is a list of strings in the JSON payload if it exists + if "authors" in metadata_payload: + authors_val = metadata_payload["authors"] + if isinstance(authors_val, str): + metadata_payload["authors"] = [a.strip() for a in authors_val.split(",") if a.strip()] + elif isinstance(authors_val, list): + metadata_payload["authors"] = [str(a).strip() for a in authors_val if str(a).strip()] + + try: + fields["metadata"] = json.dumps(metadata_payload, ensure_ascii=False) + except (TypeError, ValueError): + logger.debug("Failed to serialize Audiobookshelf metadata payload") + + return fields + + def _build_file_entries( + self, + audio_path: Path, + cover_path: Optional[Path], + subtitles: Optional[Iterable[Path]], + ) -> List[Tuple[str, Path]]: + entries: List[Tuple[str, Path]] = [("file0", audio_path)] + index = 1 + + if cover_path and self._config.send_cover and cover_path.exists(): + entries.append((f"file{index}", cover_path)) + index += 1 + + if subtitles and self._config.send_subtitles: + for subtitle in subtitles: + if subtitle.exists(): + entries.append((f"file{index}", subtitle)) + index += 1 + + return entries + + def _open_file_handles( + self, + entries: Sequence[Tuple[str, Path]], + stack: ExitStack, + ) -> List[Tuple[str, Tuple[str, Any, str]]]: + files: List[Tuple[str, Tuple[str, Any, str]]] = [] + for field_name, path in entries: + mime_type, _ = mimetypes.guess_type(path.name) + mime_type = mime_type or "application/octet-stream" + handle = stack.enter_context(path.open("rb")) + files.append((field_name, (path.name, handle, mime_type))) + return files + + def find_existing_items( + self, + title: str, + *, + folder_id: Optional[str] = None, + ) -> List[Mapping[str, Any]]: + normalized_title = self._normalize_title_value(title) + if not normalized_title: + return [] + + folder_hint = folder_id or self._config.folder_id + target_folders = set() + if folder_hint: + folder_token = str(folder_hint).strip().lower() + if folder_token: + target_folders.add(folder_token) + + requests = self._candidate_search_requests(title, folder_hint) + if not requests: + return [] + + matches: List[Mapping[str, Any]] = [] + + try: + with self._open_client() as client: + for route, params in requests: + try: + response = client.get(route, params=params) + except httpx.HTTPError as exc: + logger.debug("Audiobookshelf lookup failed for %s: %s", route, exc) + continue + + if response.status_code == 404: + continue + + try: + response.raise_for_status() + except httpx.HTTPStatusError as exc: + status = exc.response.status_code + if status in {401, 403}: + raise AudiobookshelfUploadError( + "Audiobookshelf authentication failed while checking for existing items." + ) from exc + logger.debug("Audiobookshelf lookup error %s for %s", status, route) + continue + + try: + payload = response.json() + except ValueError: + continue + + candidates = self._extract_candidate_items(payload) + for item in candidates: + item_title = self._normalize_item_title(item) + if not item_title or item_title != normalized_title: + continue + if target_folders: + item_folder = self._normalize_folder_id(item) + if item_folder and item_folder not in target_folders: + continue + matches.append(item) + if matches: + break + except AudiobookshelfUploadError: + raise + except Exception: + logger.debug( + "Unexpected error while checking Audiobookshelf for existing items", + exc_info=True, + ) + + return matches + + def delete_items(self, items: Iterable[Mapping[str, Any] | str]) -> None: + to_delete: List[str] = [] + for entry in items: + if isinstance(entry, Mapping): + item_id = self._extract_item_id(entry) + else: + item_id = str(entry).strip() + if item_id: + to_delete.append(item_id) + + if not to_delete: + return + + with self._open_client() as client: + for item_id in to_delete: + self._delete_single_item(client, item_id) + + def _candidate_search_requests( + self, + title: str, + folder_id: Optional[str], + ) -> List[Tuple[str, Dict[str, Any]]]: + query = (title or "").strip() + if not query: + return [] + + library_id = self._config.library_id + folder_token = (folder_id or self._config.folder_id or "").strip() + + requests: List[Tuple[str, Dict[str, Any]]] = [] + seen_routes: set[str] = set() + + def _append(route: str, params: Dict[str, Any]) -> None: + if route in seen_routes: + return + seen_routes.add(route) + requests.append((route, params)) + + if folder_token: + _append( + self._api_path(f"folders/{folder_token}/items"), + {"library": library_id, "search": query}, + ) + + _append(self._api_path(f"libraries/{library_id}/items"), {"search": query}) + _append(self._api_path("items"), {"library": library_id, "search": query}) + _append( + self._api_path("search"), + {"query": query, "library": library_id, "media": "audiobook"}, + ) + + return requests + + def _delete_single_item(self, client: httpx.Client, item_id: str) -> None: + routes = [ + self._api_path(f"items/{item_id}"), + self._api_path(f"libraries/{self._config.library_id}/items/{item_id}"), + ] + + for route in routes: + try: + response = client.delete(route) + except httpx.HTTPError as exc: + logger.debug("Audiobookshelf delete failed for %s: %s", route, exc) + continue + + if response.status_code in (200, 202, 204): + return + if response.status_code == 404: + continue + + try: + response.raise_for_status() + except httpx.HTTPStatusError as exc: + raise AudiobookshelfUploadError( + f"Failed to delete Audiobookshelf item '{item_id}': {exc}" + ) from exc + + logger.debug("Audiobookshelf item %s could not be confirmed deleted", item_id) + + def resolve_folder(self) -> Tuple[str, str, str]: + """Return the resolved folder (id, name, library name).""" + return self._ensure_folder() + + def list_folders(self) -> List[Dict[str, str]]: + """Return all folders for the configured library.""" + library_name, folders = self._load_library_metadata() + results: List[Dict[str, str]] = [] + for folder in folders: + folder_id = str(folder.get("id") or "").strip() + if not folder_id: + continue + name = self._folder_display_name(folder) + path = self._select_folder_path(folder) + results.append( + { + "id": folder_id, + "name": name, + "path": path, + "library": library_name, + } + ) + results.sort(key=lambda entry: (entry.get("path") or entry.get("name") or entry.get("id") or "").lower()) + return results + + def _ensure_folder(self) -> Tuple[str, str, str]: + if self._folder_cache: + return self._folder_cache + + identifier = (self._config.folder_id or "").strip() + if not identifier: + raise AudiobookshelfUploadError( + "Audiobookshelf folder is required; enter the folder name or ID in Settings." + ) + + identifier_norm = self._normalize_identifier(identifier) + library_name, folders = self._load_library_metadata() + + # direct ID match + for folder in folders: + folder_id = str(folder.get("id") or "").strip() + if folder_id and folder_id == identifier: + folder_name = self._folder_display_name(folder) or folder_id + self._folder_cache = (folder_id, folder_name, library_name) + return self._folder_cache + + has_path_component = "/" in identifier_norm + + for folder in folders: + folder_id = str(folder.get("id") or "").strip() + if not folder_id: + continue + folder_name = self._folder_display_name(folder) + name_norm = self._normalize_identifier(folder_name) + if name_norm and name_norm == identifier_norm: + self._folder_cache = (folder_id, folder_name or folder_id, library_name) + return self._folder_cache + + for candidate in self._folder_path_candidates(folder): + candidate_norm = self._normalize_identifier(candidate) + if not candidate_norm: + continue + if candidate_norm == identifier_norm: + self._folder_cache = (folder_id, folder_name or folder_id, library_name) + return self._folder_cache + if has_path_component and candidate_norm.endswith(identifier_norm): + self._folder_cache = (folder_id, folder_name or folder_id, library_name) + return self._folder_cache + if not has_path_component: + tail = candidate_norm.split("/")[-1] + if tail and tail == identifier_norm: + self._folder_cache = (folder_id, folder_name or folder_id, library_name) + return self._folder_cache + + raise AudiobookshelfUploadError( + f"Folder '{identifier}' was not found in library '{library_name}'. " + "Enter the folder name exactly as it appears in Audiobookshelf, a trailing path segment, or paste the folder ID." + ) + + def _load_library_metadata(self) -> Tuple[str, List[Mapping[str, Any]]]: + try: + with self._open_client() as client: + response = client.get(self._api_path(f"libraries/{self._config.library_id}")) + response.raise_for_status() + payload = response.json() + except httpx.HTTPStatusError as exc: + status = exc.response.status_code + if status == 404: + message = f"Audiobookshelf library '{self._config.library_id}' not found." + else: + detail = (exc.response.text or "").strip() + if detail: + detail = detail[:200] + message = ( + f"Failed to load Audiobookshelf library '{self._config.library_id}' " + f"(status {status}): {detail}" + ) + else: + message = ( + f"Failed to load Audiobookshelf library '{self._config.library_id}' " + f"(status {status})." + ) + raise AudiobookshelfUploadError(message) from exc + except httpx.HTTPError as exc: + raise AudiobookshelfUploadError( + f"Failed to reach Audiobookshelf library '{self._config.library_id}': {exc}" + ) from exc + + if not isinstance(payload, Mapping): + return self._config.library_id, [] + + library_name = str(payload.get("name") or payload.get("label") or self._config.library_id) + raw_folders = payload.get("libraryFolders") or payload.get("folders") or [] + folders = [entry for entry in raw_folders if isinstance(entry, Mapping)] + return library_name, folders + + @staticmethod + def _folder_path_candidates(folder: Mapping[str, Any]) -> List[str]: + candidates: List[str] = [] + for key in ("fullPath", "fullpath", "path", "folderPath", "virtualPath"): + value = folder.get(key) + if isinstance(value, str) and value.strip(): + candidates.append(value) + return candidates + + @staticmethod + def _folder_display_name(folder: Mapping[str, Any]) -> str: + name = str(folder.get("name") or folder.get("label") or "").strip() + if name: + return name + path = AudiobookshelfClient._select_folder_path(folder) + if path: + tail = path.strip("/ ") + tail = tail.split("/")[-1] if tail else "" + if tail: + return tail + return str(folder.get("id") or "").strip() + + @staticmethod + def _select_folder_path(folder: Mapping[str, Any]) -> str: + for candidate in AudiobookshelfClient._folder_path_candidates(folder): + normalized = candidate.replace("\\", "/").strip() + if normalized: + return normalized + return "" + + @staticmethod + def _normalize_identifier(value: str) -> str: + token = (value or "").strip() + token = token.replace("\\", "/") + if len(token) > 1 and token[1] == ":": + token = token[2:] + token = token.strip("/ ") + return token.lower() + + @staticmethod + def _normalize_title_value(value: Optional[str]) -> str: + if not isinstance(value, str): + return "" + normalized = re.sub(r"\s+", " ", value).strip() + return normalized.casefold() if normalized else "" + + @staticmethod + def _normalize_item_title(item: Mapping[str, Any]) -> str: + if not isinstance(item, Mapping): + return "" + for key in ("title", "name", "label"): + candidate = item.get(key) + if isinstance(candidate, str) and candidate.strip(): + return AudiobookshelfClient._normalize_title_value(candidate) + library_item = item.get("libraryItem") + if isinstance(library_item, Mapping): + return AudiobookshelfClient._normalize_item_title(library_item) + return "" + + @staticmethod + def _normalize_folder_id(item: Mapping[str, Any]) -> Optional[str]: + if not isinstance(item, Mapping): + return None + for key in ("folderId", "libraryFolderId", "folder_id", "folder"): + value = item.get(key) + if isinstance(value, str) and value.strip(): + return value.strip().lower() + if isinstance(value, (int, float)): + return str(value).strip().lower() + library_item = item.get("libraryItem") + if isinstance(library_item, Mapping): + return AudiobookshelfClient._normalize_folder_id(library_item) + return None + + @staticmethod + def _extract_item_id(item: Mapping[str, Any]) -> Optional[str]: + if not isinstance(item, Mapping): + return None + for key in ("id", "libraryItemId", "itemId"): + value = item.get(key) + if isinstance(value, str) and value.strip(): + return value.strip() + if isinstance(value, (int, float)): + return str(value).strip() + library_item = item.get("libraryItem") + if isinstance(library_item, Mapping): + return AudiobookshelfClient._extract_item_id(library_item) + return None + + @staticmethod + def _extract_candidate_items(payload: Any) -> List[Mapping[str, Any]]: + items: List[Mapping[str, Any]] = [] + seen_ids: set[str] = set() + visited: set[int] = set() + + def _visit(obj: Any) -> None: + if isinstance(obj, Mapping): + obj_id = id(obj) + if obj_id in visited: + return + visited.add(obj_id) + + title = AudiobookshelfClient._normalize_item_title(obj) + item_id = AudiobookshelfClient._extract_item_id(obj) + if title and item_id: + key = item_id.strip().lower() + if key not in seen_ids: + seen_ids.add(key) + items.append(obj) + + for value in obj.values(): + _visit(value) + + elif isinstance(obj, list): + for entry in obj: + _visit(entry) + + _visit(payload) + return items + + @staticmethod + def _extract_title(metadata: Mapping[str, Any], audio_path: Path) -> str: + title = metadata.get("title") if isinstance(metadata, Mapping) else None + candidate = str(title).strip() if isinstance(title, str) else "" + if candidate: + return candidate + return audio_path.stem or audio_path.name + + @staticmethod + def _extract_author(metadata: Mapping[str, Any]) -> str: + authors = metadata.get("authors") if isinstance(metadata, Mapping) else None + if isinstance(authors, str): + candidate = authors.strip() + return candidate + if isinstance(authors, Iterable) and not isinstance(authors, (str, Mapping)): + names = [str(entry).strip() for entry in authors if isinstance(entry, str) and entry.strip()] + if names: + # ABS expects a comma-separated string for multiple authors. + return ", ".join(names) + return "" + + @staticmethod + def _extract_series(metadata: Mapping[str, Any]) -> str: + series_name = metadata.get("seriesName") if isinstance(metadata, Mapping) else None + if isinstance(series_name, str) and series_name.strip(): + return series_name.strip() + return "" + + @staticmethod + def _extract_series_sequence(metadata: Mapping[str, Any]) -> str: + if not isinstance(metadata, Mapping): + return "" + + preferred_keys = ( + "seriesSequence", + "series_sequence", + "seriesIndex", + "series_index", + "seriesNumber", + "series_number", + "bookNumber", + "book_number", + ) + + for key in preferred_keys: + if key not in metadata: + continue + normalized = AudiobookshelfClient._normalize_series_sequence(metadata.get(key)) + if normalized: + return normalized + return "" + + @staticmethod + def _normalize_series_sequence(raw: Any) -> str: + if raw is None: + return "" + + if isinstance(raw, (int, float)): + if isinstance(raw, float) and (math.isnan(raw) or math.isinf(raw)): + return "" + text = str(raw) + else: + text = str(raw).strip() + + if not text: + return "" + + candidate = text.replace(",", ".") + match = re.search(r"\d+(?:\.\d+)?", candidate) + if not match: + return "" + + normalized = match.group(0) + if "." in normalized: + normalized = normalized.rstrip("0").rstrip(".") + if not normalized: + normalized = "0" + return normalized + + try: + return str(int(normalized)) + except ValueError: + cleaned = normalized.lstrip("0") + return cleaned or "0" diff --git a/abogen/integrations/calibre_opds.py b/abogen/integrations/calibre_opds.py new file mode 100644 index 0000000..128e2ba --- /dev/null +++ b/abogen/integrations/calibre_opds.py @@ -0,0 +1,1460 @@ +from __future__ import annotations + +import dataclasses +import html +import re +import unicodedata +import xml.etree.ElementTree as ET +from collections import deque +from dataclasses import dataclass, field +from pathlib import PurePosixPath +from typing import Any, Deque, Dict, Iterable, Iterator, List, Mapping, Optional, Set, Tuple, Union +from urllib.parse import quote, urljoin, urlparse + +import httpx + + +ATOM_NS = "http://www.w3.org/2005/Atom" +OPDS_NS = "http://opds-spec.org/2010/catalog" +DC_NS = "http://purl.org/dc/terms/" +CALIBRE_CATALOG_NS = "http://calibre.kovidgoyal.net/2009/catalog" +CALIBRE_METADATA_NS = "http://calibre.kovidgoyal.net/2009/metadata" +NS = { + "atom": ATOM_NS, + "opds": OPDS_NS, + "dc": DC_NS, + "calibre": CALIBRE_CATALOG_NS, + "calibre_md": CALIBRE_METADATA_NS, +} + + +_TAG_STRIP_RE = re.compile(r"<[^>]+>") +_SERIES_PREFIX_RE = re.compile(r"^\s*(series|books?)\s*[:\-]\s*", re.IGNORECASE) +_SERIES_NUMBER_BRACKET_RE = re.compile(r"[\[(]\s*(?:book\s*)?(\d+(?:\.\d+)?)\s*[\])]", re.IGNORECASE) +_SERIES_NUMBER_HASH_RE = re.compile(r"#\s*(\d+(?:\.\d+)?)") +_SERIES_NUMBER_BOOK_RE = re.compile(r"\bbook\s+(\d+(?:\.\d+)?)\b", re.IGNORECASE) +_SERIES_LINE_TEXT_RE = re.compile(r"^\s*series\s*[:\-]\s*(.+)$", re.IGNORECASE) +_SUMMARY_METADATA_LINE_RE = re.compile(r"^([A-Z][A-Z0-9&/\- +'\u2019]{1,40})\s*[:\-]\s*(.+)$") +_EPUB_MIME_TYPES = { + "application/epub+zip", + "application/zip", + "application/x-zip", + "application/x-zip-compressed", +} +_SUPPORTED_DOWNLOAD_MIME_TYPES = set(_EPUB_MIME_TYPES) | {"application/pdf"} +_SUPPORTED_DOWNLOAD_EXTENSIONS = {".epub", ".pdf"} +_STOP_WORDS = { + "a", "an", "the", "and", "or", "but", "if", "then", "else", "when", + "at", "by", "for", "from", "in", "into", "of", "off", "on", "onto", + "to", "with", "is", "are", "was", "were", "be", "been", "being", + "that", "this", "these", "those", "it", "its" +} + + +class CalibreOPDSError(RuntimeError): + """Raised when the Calibre OPDS client encounters an unrecoverable error.""" + + +@dataclass +class OPDSLink: + href: str + rel: Optional[str] = None + type: Optional[str] = None + title: Optional[str] = None + + def to_dict(self) -> Dict[str, Optional[str]]: + return { + "href": self.href, + "rel": self.rel, + "type": self.type, + "title": self.title, + } + + +@dataclass +class OPDSEntry: + id: str + title: str + position: Optional[int] = None + authors: List[str] = field(default_factory=list) + subtitle: Optional[str] = None + updated: Optional[str] = None + published: Optional[str] = None + summary: Optional[str] = None + download: Optional[OPDSLink] = None + alternate: Optional[OPDSLink] = None + thumbnail: Optional[OPDSLink] = None + links: List[OPDSLink] = field(default_factory=list) + series: Optional[str] = None + series_index: Optional[float] = None + tags: List[str] = field(default_factory=list) + rating: Optional[float] = None + rating_max: Optional[float] = None + + def to_dict(self) -> Dict[str, Any]: + return { + "id": self.id, + "title": self.title, + "position": self.position, + "authors": list(self.authors), + "subtitle": self.subtitle, + "updated": self.updated, + "published": self.published, + "summary": self.summary, + "download": self.download.to_dict() if self.download else None, + "alternate": self.alternate.to_dict() if self.alternate else None, + "thumbnail": self.thumbnail.to_dict() if self.thumbnail else None, + "links": [link.to_dict() for link in self.links], + "series": self.series, + "series_index": self.series_index, + "tags": list(self.tags), + "rating": self.rating, + "rating_max": self.rating_max, + } + + +@dataclass +class OPDSFeed: + id: Optional[str] + title: Optional[str] + entries: List[OPDSEntry] + links: Dict[str, OPDSLink] = field(default_factory=dict) + + def to_dict(self) -> Dict[str, Any]: + return { + "id": self.id, + "title": self.title, + "entries": [entry.to_dict() for entry in self.entries], + "links": {key: link.to_dict() for key, link in self.links.items()}, + } + + +def feed_to_dict(feed: OPDSFeed) -> Dict[str, Any]: + return feed.to_dict() + + +@dataclass +class DownloadedResource: + filename: str + mime_type: str + content: bytes + + +class CalibreOPDSClient: + """Client for interacting with a Calibre-Web OPDS catalog.""" + + def __init__( + self, + base_url: str, + *, + username: Optional[str] = None, + password: Optional[str] = None, + timeout: float = 15.0, + verify: bool = True, + ) -> None: + if not base_url: + raise ValueError("Calibre OPDS base URL is required") + normalized = base_url.strip() + if not normalized: + raise ValueError("Calibre OPDS base URL is required") + # Store the original URL without forcing a trailing slash. + # Some servers (e.g., Booklore) return 404 for URLs with trailing slashes. + self._base_url = normalized.rstrip("/") + self._auth = None + if username: + self._auth = httpx.BasicAuth(username, password or "") + self._timeout = timeout + self._verify = verify + self._headers = { + "User-Agent": "abogen-calibre-opds/1.0", + "Accept": "application/atom+xml,application/xml;q=0.9,*/*;q=0.8", + } + + @staticmethod + def _strip_html(value: Optional[str]) -> Optional[str]: + if not value: + return None + cleaned = _TAG_STRIP_RE.sub("", value) + return html.unescape(cleaned).strip() or None + + def _make_url(self, href: Optional[str]) -> str: + if not href: + return self._base_url + href = href.strip() + if href.startswith("http://") or href.startswith("https://"): + return href + if href.startswith("/"): + # Absolute path - join with origin only + parsed = urlparse(self._base_url) + return f"{parsed.scheme}://{parsed.netloc}{href}" + if href.startswith("?") or href.startswith("#"): + return f"{self._base_url}{href}" + if href.startswith("./") or href.startswith("../"): + # For relative paths, we need a trailing slash for urljoin to work correctly + base_with_slash = self._base_url if self._base_url.endswith("/") else f"{self._base_url}/" + return urljoin(base_with_slash, href) + # Relative path like "search" or "catalog?page=1" - treat as sibling + base_with_slash = self._base_url if self._base_url.endswith("/") else f"{self._base_url}/" + return urljoin(base_with_slash, href) + + def _open_client(self) -> httpx.Client: + return httpx.Client( + auth=self._auth, + headers=dict(self._headers), + timeout=self._timeout, + verify=self._verify, + ) + + def fetch_feed(self, href: Optional[str] = None, *, params: Optional[Mapping[str, Any]] = None) -> OPDSFeed: + target = self._make_url(href) + try: + with self._open_client() as client: + response = client.get(target, params=params, follow_redirects=True) + response.raise_for_status() + except httpx.HTTPStatusError as exc: # pragma: no cover - thin wrapper + raise CalibreOPDSError(f"Calibre OPDS request failed: {exc.response.status_code}") from exc + except httpx.HTTPError as exc: # pragma: no cover - thin wrapper + raise CalibreOPDSError(f"Calibre OPDS request failed: {exc}") from exc + + return self._parse_feed(response.text, base_url=target) + + def _fetch_opensearch_template(self, href: str) -> Optional[str]: + target = self._make_url(href) + try: + with self._open_client() as client: + response = client.get(target, follow_redirects=True) + response.raise_for_status() + + # Simple XML parsing to find the Url template + # We avoid full namespace handling for robustness + root = ET.fromstring(response.text) + for node in root.iter(): + if node.tag.endswith("Url"): + template = node.attrib.get("template") + if template and "{searchTerms}" in template: + mime = node.attrib.get("type", "") + # Prefer atom/xml feeds + if "atom" in mime or "xml" in mime: + return template + return None + except Exception: + return None + + def _find_best_seed_feed(self, root_feed: OPDSFeed) -> OPDSFeed: + # If the root feed already has books, use it + for entry in root_feed.entries: + if any("acquisition" in (link.rel or "") for link in entry.links): + return root_feed + + # Otherwise, look for a "By Title" or "All" navigation entry + candidates = ["title", "all", "books", "catalog"] + best_href = None + + for entry in root_feed.entries: + title_lower = (entry.title or "").lower() + if any(c in title_lower for c in candidates): + # Check if it has a navigation link + for link in entry.links: + if self._is_navigation_link(link): + best_href = link.href + # Prefer "By Title" explicitly + if "title" in title_lower: + break + if best_href and "title" in title_lower: + break + + if best_href: + try: + return self.fetch_feed(best_href) + except CalibreOPDSError: + pass + + return root_feed + + def search(self, query: str, start_href: Optional[str] = None) -> OPDSFeed: + cleaned = (query or "").strip() + if not cleaned: + return self.fetch_feed(start_href) if start_href else self.fetch_feed() + + base_feed: Optional[OPDSFeed] = None + try: + base_feed = self.fetch_feed() + except CalibreOPDSError: + pass + + # 1. Try explicit search link from feed + if base_feed: + # Check for OpenSearch description first + search_link = self._resolve_link(base_feed.links, "search") + if search_link and search_link.type == "application/opensearchdescription+xml": + template = self._fetch_opensearch_template(search_link.href) + if template: + search_url = template.replace("{searchTerms}", quote(cleaned)) + try: + feed = self.fetch_feed(search_url) + if feed.entries: + filtered = self._filter_feed_entries(feed, cleaned) + if filtered.entries: + return filtered + except CalibreOPDSError: + pass + + # Check for direct template + search_url = self._resolve_search_url(base_feed, cleaned) + if search_url: + try: + feed = self.fetch_feed(search_url) + if feed.entries: + filtered = self._filter_feed_entries(feed, cleaned) + if filtered.entries: + return filtered + except CalibreOPDSError: + pass + + # 2. Try common guesses if explicit link failed + candidates: List[Tuple[Optional[str], Optional[Mapping[str, Any]]]] = [ + ("search", {"query": cleaned}), + ("search", {"q": cleaned}), + (None, {"search": cleaned}), + ] + + last_error: Optional[Exception] = None + + for path, params in candidates: + try: + feed = self.fetch_feed(path, params=params) + if feed.entries: + # Check if the server ignored the query and returned the default feed + if base_feed and feed.title == base_feed.title: + # Compare first entry ID to see if it's the same feed + if feed.entries[0].id == base_feed.entries[0].id: + continue + + filtered = self._filter_feed_entries(feed, cleaned) + if filtered.entries: + return filtered + except CalibreOPDSError as exc: + last_error = exc + continue + + # 3. Fallback to local search (crawling) + seed_feed: Optional[OPDSFeed] = None + if start_href: + try: + seed_feed = self.fetch_feed(start_href) + except CalibreOPDSError: + pass + + if not seed_feed and base_feed: + # If we are falling back to base_feed (Root), try to find a better seed + seed_feed = self._find_best_seed_feed(base_feed) + + if not seed_feed: + try: + seed_feed = self.fetch_feed() + except CalibreOPDSError as exc: + if last_error: + raise last_error + raise exc + + # Heuristic: If the seed feed has acquisition links, use linear scan. + # Otherwise, use BFS to find content. + has_books = False + if seed_feed and seed_feed.entries: + for entry in seed_feed.entries[:5]: + for link in entry.links: + if "acquisition" in (link.rel or ""): + has_books = True + break + if has_books: + break + + if has_books: + return self._collect_search_results(seed_feed, cleaned) + else: + return self._local_search(cleaned, seed_feed=seed_feed) + + def _collect_search_results( + self, + seed_feed: OPDSFeed, + query: str, + *, + max_pages: int = 40, + ) -> OPDSFeed: + normalized = (query or "").strip() + if not normalized: + return seed_feed + seen_ids: Set[str] = set() + collected: List[OPDSEntry] = [] + for page in self._iter_paginated_feeds(seed_feed, max_pages=max_pages): + filtered = self._filter_feed_entries(page, normalized) + for entry in filtered.entries: + entry_id = (entry.id or "").strip() + if entry_id: + if entry_id in seen_ids: + continue + seen_ids.add(entry_id) + collected.append(entry) + return dataclasses.replace(seed_feed, entries=collected) + + def _iter_paginated_feeds(self, seed_feed: OPDSFeed, *, max_pages: int = 40) -> Iterator[OPDSFeed]: + yield seed_feed + next_link = self._resolve_link(seed_feed.links, "next") + visited: Set[str] = set() + pages_examined = 0 + while next_link and pages_examined < max_pages: + href = (next_link.href or "").strip() + if not href: + break + absolute = self._make_url(href) + if absolute in visited: + break + visited.add(absolute) + pages_examined += 1 + try: + page = self.fetch_feed(absolute) + except CalibreOPDSError: + break + yield page + next_link = self._resolve_link(page.links, "next") + + @staticmethod + def _merge_feed_entries(primary: OPDSFeed, secondary: OPDSFeed) -> OPDSFeed: + if primary is secondary or not secondary.entries: + return primary + seen_ids: Set[str] = set() + combined: List[OPDSEntry] = list(primary.entries) + for entry in primary.entries: + entry_id = (entry.id or "").strip() + if entry_id: + seen_ids.add(entry_id) + for entry in secondary.entries: + entry_id = (entry.id or "").strip() + if entry_id and entry_id in seen_ids: + continue + if entry_id: + seen_ids.add(entry_id) + combined.append(entry) + return dataclasses.replace(primary, entries=combined) + + def _local_search( + self, + query: str, + *, + seed_feed: Optional[OPDSFeed] = None, + max_pages: int = 40, + ) -> OPDSFeed: + normalized = (query or "").strip() + if not normalized: + return seed_feed or self.fetch_feed() + tokens = [token for token in re.split(r"\s+", normalized.lower()) if token] + if not tokens: + return seed_feed or self.fetch_feed() + + start_feed = seed_feed or self.fetch_feed() + collected: List[OPDSEntry] = [] + seen_match_ids: Set[str] = set() + + def add_matches(feed: OPDSFeed) -> None: + filtered = self._filter_feed_entries(feed, normalized) + for entry in filtered.entries: + entry_id = (entry.id or "").strip() + if entry_id: + if entry_id in seen_match_ids: + continue + seen_match_ids.add(entry_id) + collected.append(entry) + + add_matches(start_feed) + + queue: Deque[str] = deque() + queued: Set[str] = set() + visited: Set[str] = set() + + def is_navigation_link(rel_hint: Optional[str], link: OPDSLink) -> bool: + rel_candidates: List[str] = [] + if rel_hint: + rel_candidates.append(rel_hint) + if link.rel and link.rel not in rel_candidates: + rel_candidates.append(link.rel) + rel_candidates = [(rel or "").strip().lower() for rel in rel_candidates if rel] + link_type = (link.type or "").strip().lower() + if link_type and "opds-catalog" in link_type: + return True + for rel_value in rel_candidates: + if not rel_value: + continue + if "acquisition" in rel_value: + return False + if rel_value == "self": + continue + if rel_value == "next": + return True + if rel_value in {"start", "up", "down"}: + return True + if rel_value.endswith("navigation") or rel_value.endswith("collection"): + return True + if rel_value.startswith("http://opds-spec.org/"): + if rel_value.startswith("http://opds-spec.org/group") or rel_value.startswith( + "http://opds-spec.org/sort" + ): + return True + if rel_value.endswith("navigation") or rel_value.endswith("collection"): + return True + return False + + def enqueue_link(link: OPDSLink, rel_hint: Optional[str] = None) -> None: + if not is_navigation_link(rel_hint, link): + return + href = (link.href or "").strip() + if not href: + return + absolute = self._make_url(href) + if absolute in queued or absolute in visited: + return + queued.add(absolute) + queue.append(absolute) + + for rel_key, link in (start_feed.links or {}).items(): + enqueue_link(link, rel_key) + for entry in start_feed.entries: + for link in entry.links: + enqueue_link(link, link.rel) + + pages_examined = 0 + while queue and pages_examined < max_pages: + href = queue.popleft() + if href in visited: + continue + visited.add(href) + pages_examined += 1 + try: + feed = self.fetch_feed(href) + except CalibreOPDSError: + continue + add_matches(feed) + for rel_key, link in (feed.links or {}).items(): + enqueue_link(link, rel_key) + for entry in feed.entries: + for link in entry.links: + enqueue_link(link, link.rel) + if collected: + return dataclasses.replace(start_feed, entries=collected) + return dataclasses.replace(start_feed, entries=[]) + + def download(self, href: str) -> DownloadedResource: + if not href: + raise ValueError("Download link missing") + target = self._make_url(href) + try: + with self._open_client() as client: + response = client.get(target, follow_redirects=True) + response.raise_for_status() + except httpx.HTTPStatusError as exc: # pragma: no cover - thin wrapper + raise CalibreOPDSError( + f"Download failed with status {exc.response.status_code}" + ) from exc + except httpx.HTTPError as exc: # pragma: no cover - thin wrapper + raise CalibreOPDSError(f"Download failed: {exc}") from exc + + mime_type = response.headers.get("Content-Type", "application/octet-stream").split(";")[0].strip() + filename = self._deduce_filename(response, target, mime_type) + return DownloadedResource(filename=filename, mime_type=mime_type, content=response.content) + + def _deduce_filename(self, response: httpx.Response, url: str, mime_type: str) -> str: + header = response.headers.get("Content-Disposition", "") + match = re.search(r'filename="?([^";]+)"?', header) + if match: + candidate = match.group(1).strip() + if candidate: + return candidate + parsed = urlparse(url) + stem = (parsed.path or "").strip("/").split("/")[-1] + if not stem: + stem = "download" + if "." not in stem: + extension = self._extension_for_mime(mime_type) + if extension: + stem = f"{stem}{extension}" + return stem + + @staticmethod + def _extension_for_mime(mime_type: str) -> str: + normalized = mime_type.lower() + if normalized in _EPUB_MIME_TYPES: + return ".epub" + if normalized == "application/pdf": + return ".pdf" + if normalized in {"text/plain", "text/html"}: + return ".txt" + return "" + + def _parse_feed(self, xml_payload: str, *, base_url: str) -> OPDSFeed: + try: + root = ET.fromstring(xml_payload) + except ET.ParseError as exc: + raise CalibreOPDSError(f"Unable to parse OPDS feed: {exc}") from exc + + feed_id = root.findtext("atom:id", default=None, namespaces=NS) + feed_title = root.findtext("atom:title", default=None, namespaces=NS) + links_list = self._extract_links(root.findall("atom:link", NS), base_url) + links = self._links_to_dict(links_list) + parsed_entries = [self._parse_entry(node, base_url) for node in root.findall("atom:entry", NS)] + entries: List[OPDSEntry] = [] + for entry in parsed_entries: + if entry.download and self._is_supported_download(entry.download): + entries.append(entry) + continue + if self._has_navigation_link(entry): + entries.append(entry) + return OPDSFeed(id=feed_id, title=feed_title, entries=entries, links=links) + + def _parse_entry(self, node: ET.Element, base_url: str) -> OPDSEntry: + entry_id = node.findtext("atom:id", default="", namespaces=NS).strip() + title = node.findtext("atom:title", default="Untitled", namespaces=NS).strip() or "Untitled" + + subtitle = ( + node.findtext("calibre_md:subtitle", default=None, namespaces=NS) + or node.findtext("calibre:subtitle", default=None, namespaces=NS) + or node.findtext("atom:subtitle", default=None, namespaces=NS) + ) + subtitle = self._strip_html(subtitle.strip()) if subtitle else None + + position_value = self._extract_position(node) + updated = node.findtext("atom:updated", default=None, namespaces=NS) + published = ( + node.findtext("dc:date", default=None, namespaces=NS) + or node.findtext("atom:published", default=None, namespaces=NS) + ) + if published: + published = published.strip() or None + + summary_text = ( + self._extract_text(node.find("atom:summary", NS)) + or self._extract_text(node.find("atom:content", NS)) + or self._extract_text(node.find("dc:description", NS)) + ) + summary_metadata: Dict[str, str] = {} + summary_body: Optional[str] = None + if summary_text: + summary_metadata, summary_body = self._split_summary_metadata(summary_text) + cleaned_summary = self._strip_html(summary_body or summary_text) + + authors: List[str] = [] + for author_node in node.findall("atom:author", NS): + name = author_node.findtext("atom:name", default="", namespaces=NS).strip() + if name: + authors.append(name) + if not authors: + creators = node.findall("dc:creator", NS) + for creator in creators: + value = (creator.text or "").strip() + if value: + authors.append(value) + + links = node.findall("atom:link", NS) + all_links = self._extract_links(links, base_url) + link_dict = self._links_to_dict(all_links) + download_link = self._select_download_link(all_links) + alternate_link = link_dict.get("alternate") + thumb_link = link_dict.get("http://opds-spec.org/image/thumbnail") or link_dict.get( + "thumbnail" + ) + + series_name = ( + node.findtext("calibre:series", default=None, namespaces=NS) + or node.findtext("calibre_md:series", default=None, namespaces=NS) + ) + if series_name: + series_name = series_name.strip() or None + + series_index_raw = ( + node.findtext("calibre:series_index", default=None, namespaces=NS) + or node.findtext("calibre_md:series_index", default=None, namespaces=NS) + ) + series_index: Optional[float] = None + if series_index_raw is not None: + text = str(series_index_raw).strip() + if text: + try: + series_index = float(text) + except ValueError: + match = re.search(r"\d+(?:\.\d+)?", text.replace(",", ".")) + if match: + try: + series_index = float(match.group(0)) + except ValueError: + series_index = None + + if series_name is None or series_index is None: + category_series_name, category_series_index = self._extract_series_from_categories( + node.findall("atom:category", NS), + authors=authors, + ) + if series_name is None and category_series_name: + series_name = category_series_name + if series_index is None and category_series_index is not None: + series_index = category_series_index + + if (series_name is None or series_index is None) and summary_text: + text_series_name, text_series_index = self._extract_series_from_text(summary_text) + if series_name is None and text_series_name: + series_name = text_series_name + if series_index is None and text_series_index is not None: + series_index = text_series_index + + tags_value = summary_metadata.get("TAGS") + tags = self._parse_tags(tags_value) if tags_value else [] + rating_value = summary_metadata.get("RATING") + rating, rating_max = self._parse_rating(rating_value) if rating_value else (None, None) + + return OPDSEntry( + id=entry_id or title, + title=title, + position=position_value, + authors=authors, + subtitle=subtitle, + updated=updated, + published=published, + summary=cleaned_summary, + download=download_link, + alternate=alternate_link, + thumbnail=thumb_link, + links=all_links, + series=series_name, + series_index=series_index, + tags=tags, + rating=rating, + rating_max=rating_max, + ) + + def _extract_series_from_categories( + self, + category_nodes: List[ET.Element], + *, + authors: Optional[List[str]] = None, + ) -> tuple[Optional[str], Optional[float]]: + name: Optional[str] = None + index: Optional[float] = None + author_set = {str(author).strip().casefold() for author in (authors or []) if str(author).strip()} + for category in category_nodes: + scheme = (category.attrib.get("scheme") or "").strip().lower() + label = (category.attrib.get("label") or "").strip() + term = (category.attrib.get("term") or "").strip() + values: List[str] = [] + if label: + values.append(label) + if term and term not in values: + values.append(term) + + # Be conservative: category schemes are often URLs and can contain unrelated substrings. + # Also, some catalog feeds incorrectly include author names in series-like categories. + is_series_hint = self._is_series_scheme(scheme) or any("series" in value.lower() for value in values if value) + if not is_series_hint: + continue + + for value in values: + if not value: + continue + candidate_name, candidate_index = self._parse_series_value(value) + if candidate_name and candidate_name.casefold() in author_set: + # Guardrail: avoid mapping the author name into series. + continue + if candidate_name and not name: + name = candidate_name + if candidate_index is not None and index is None: + index = candidate_index + if name and index is not None: + return name, index + return name, index + + @staticmethod + def _is_series_scheme(scheme: str) -> bool: + cleaned = (scheme or "").strip().lower() + if not cleaned: + return False + if "author" in cleaned: + return False + return bool(re.search(r"(^|[/#:\-])series([/#:\-]|$)", cleaned)) + + def _parse_series_value(self, value: str) -> tuple[Optional[str], Optional[float]]: + cleaned = re.sub(r"\s+", " ", value or "").strip() + if not cleaned: + return None, None + cleaned = _SERIES_PREFIX_RE.sub("", cleaned) + working = cleaned + number: Optional[float] = None + + bracket_match = _SERIES_NUMBER_BRACKET_RE.search(working) + if bracket_match: + number = self._coerce_series_index(bracket_match.group(1)) + start, end = bracket_match.span() + working = (working[:start] + working[end:]).strip() + + if number is None: + hash_match = _SERIES_NUMBER_HASH_RE.search(working) + if hash_match: + number = self._coerce_series_index(hash_match.group(1)) + start, end = hash_match.span() + working = (working[:start] + working[end:]).strip() + + if number is None: + book_match = _SERIES_NUMBER_BOOK_RE.search(working) + if book_match: + number = self._coerce_series_index(book_match.group(1)) + start, end = book_match.span() + working = (working[:start] + working[end:]).strip() + + name = working.strip(" -–—,:") + name = re.sub(r"\s+", " ", name).strip() + if not name: + name = None + return name, number + + @staticmethod + def _extract_text(node: Optional[ET.Element]) -> Optional[str]: + if node is None: + return None + # Prefer itertext to capture nested XHTML content + parts = list(node.itertext()) + if not parts: + return (node.text or "").strip() or None + combined = "".join(parts).strip() + return combined or None + + def _extract_series_from_text(self, text: str) -> tuple[Optional[str], Optional[float]]: + for line in text.splitlines(): + match = _SERIES_LINE_TEXT_RE.match(line) + if not match: + continue + candidate = match.group(1).strip() + if not candidate: + continue + name, number = self._parse_series_value(candidate) + if name or number is not None: + return name, number + return None, None + + def _split_summary_metadata(self, text: Optional[str]) -> tuple[Dict[str, str], Optional[str]]: + metadata: Dict[str, str] = {} + if text is None: + return metadata, None + lines = text.splitlines() + index = 0 + total = len(lines) + while index < total and not lines[index].strip(): + index += 1 + while index < total: + stripped = lines[index].strip() + if not stripped: + break + match = _SUMMARY_METADATA_LINE_RE.match(stripped) + if not match: + break + key = match.group(1).strip().upper() + value = match.group(2).strip() + if key and value: + metadata[key] = value + index += 1 + remainder = "\n".join(lines[index:]).strip() + return metadata, (remainder or None) + + @staticmethod + def _parse_tags(value: str) -> List[str]: + if not value: + return [] + tokens = re.split(r"[;,\n]\s*", value) + cleaned: List[str] = [] + seen: set[str] = set() + for token in tokens: + entry = token.strip() + if not entry: + continue + key = entry.casefold() + if key in seen: + continue + seen.add(key) + cleaned.append(entry) + return cleaned + + @staticmethod + def _parse_rating(value: str) -> tuple[Optional[float], Optional[float]]: + if not value: + return None, None + text = value.strip() + if not text: + return None, None + stars = text.count("★") + half = 0.5 if "½" in text else 0.0 + if stars or half: + rating = stars + half + return (rating if rating > 0 else None, 5.0) + match = re.search(r"\d+(?:\.\d+)?", text.replace(",", ".")) + if match: + try: + rating_value = float(match.group(0)) + except ValueError: + return None, None + return rating_value, 5.0 + return None, None + + @staticmethod + def _coerce_series_index(value: str) -> Optional[float]: + text = value.strip().replace(",", ".") + if not text: + return None + try: + return float(text) + except ValueError: + return None + + def _extract_position(self, node: ET.Element) -> Optional[int]: + candidates = [ + node.findtext("opds:position", default=None, namespaces=NS), + node.findtext("opds:groupPosition", default=None, namespaces=NS), + node.findtext("opds:order", default=None, namespaces=NS), + node.findtext("dc:identifier", default=None, namespaces=NS), + ] + for value in candidates: + if value is None: + continue + text = str(value).strip() + if not text: + continue + try: + return int(float(text)) + except (TypeError, ValueError): + continue + return None + + def _extract_links(self, link_nodes: List[ET.Element], base_url: str) -> List[OPDSLink]: + links: List[OPDSLink] = [] + for link in link_nodes: + href = link.attrib.get("href") + if not href: + continue + rel = link.attrib.get("rel") + link_type = link.attrib.get("type") + title = link.attrib.get("title") + base_for_join = base_url or self._base_url + absolute_href = urljoin(base_for_join, href) + links.append(OPDSLink(href=absolute_href, rel=rel, type=link_type, title=title)) + return links + + def _links_to_dict(self, links: List[OPDSLink]) -> Dict[str, OPDSLink]: + results: Dict[str, OPDSLink] = {} + for entry in links: + key = entry.rel or entry.href + if not key: + continue + + # Prioritize search links with template parameters + if key == "search" and key in results: + existing = results[key] + if "{searchTerms}" in (existing.href or ""): + continue + if "{searchTerms}" in (entry.href or ""): + results[key] = entry + continue + + results[key] = entry + return results + + @staticmethod + def _is_supported_download(link: OPDSLink) -> bool: + mime = (link.type or "").split(";")[0].strip().lower() + if mime in _SUPPORTED_DOWNLOAD_MIME_TYPES: + return True + href = (link.href or "").strip() + if not href: + return False + parsed_path = urlparse(href).path or "" + extension = PurePosixPath(parsed_path).suffix.lower() + return extension in _SUPPORTED_DOWNLOAD_EXTENSIONS + + @staticmethod + def _select_download_link(links: Mapping[str, OPDSLink] | Iterable[OPDSLink]) -> Optional[OPDSLink]: + if isinstance(links, Mapping): + iterable: List[OPDSLink] = list(links.values()) + else: + iterable = list(links) + supported = [link for link in iterable if CalibreOPDSClient._is_supported_download(link)] + best: Optional[OPDSLink] = None + for link in supported: + rel = (link.rel or "").lower() + if "acquisition" not in rel: + continue + mime = (link.type or "").lower() + if mime in _EPUB_MIME_TYPES: + return link + if best is None: + best = link + if best: + return best + if supported: + return supported[0] + # No valid acquisition-style link exposed + return None + + @staticmethod + def _resolve_link(links: Optional[Mapping[str, OPDSLink]], rel: str) -> Optional[OPDSLink]: + if not links: + return None + if rel in links: + return links[rel] + rel_lower = rel.lower() + for key, link in links.items(): + key_lower = (key or "").strip().lower() + if key_lower == rel_lower or key_lower.endswith(rel_lower): + return link + return None + + @staticmethod + def _is_navigation_link(link: OPDSLink) -> bool: + href = (link.href or "").strip() + if not href: + return False + rel = (link.rel or "").strip().lower() + link_type = (link.type or "").strip().lower() + if "acquisition" in rel: + return False + if rel == "self": + return False + if "opds-catalog" in link_type: + return True + if rel.endswith("navigation") or rel.endswith("collection"): + return True + if rel.startswith("http://opds-spec.org/sort") or rel.startswith("http://opds-spec.org/group"): + return True + return False + + @staticmethod + def _has_navigation_link(entry: OPDSEntry) -> bool: + return any(CalibreOPDSClient._is_navigation_link(link) for link in entry.links) + + @staticmethod + def _browse_mode_for_title(title: Optional[str]) -> str: + if not title: + return "generic" + lowered = title.lower() + if "author" in lowered: + return "author" + if "series" in lowered: + return "series" + if "title" in lowered or "book" in lowered: + return "title" + return "generic" + + @staticmethod + def _strip_leading_article(text: str) -> str: + working = text.strip() + lowered = working.lower() + for article in ("the ", "a ", "an "): + if lowered.startswith(article): + return working[len(article):].strip() + return working + + @staticmethod + def _alphabet_source(entry: OPDSEntry, mode: str) -> str: + if mode == "author" and entry.authors: + candidate = entry.authors[0] or "" + if "," in candidate: + return candidate.split(",", 1)[0].strip() + parts = candidate.split() + if len(parts) > 1: + return parts[-1].strip() + return candidate.strip() + if mode == "series" and entry.series: + return entry.series.strip() + if entry.title: + return entry.title.strip() + if entry.series: + return entry.series.strip() + for link in entry.links: + if link.title: + return link.title.strip() + return "" + + @staticmethod + def _normalize_text(text: str) -> str: + if not text: + return "" + # Normalize unicode characters to their base form (e.g. é -> e) + normalized = unicodedata.normalize('NFKD', text).encode('ASCII', 'ignore').decode('utf-8') + return normalized.lower().strip() + + @staticmethod + def _alphabet_letter_for_entry(entry: OPDSEntry, mode: str) -> Optional[str]: + source = CalibreOPDSClient._alphabet_source(entry, mode) + if not source: + return None + if mode == "title": + source = CalibreOPDSClient._strip_leading_article(source) + + # Normalize to handle accents (É -> E) + normalized_source = unicodedata.normalize('NFKD', source).encode('ASCII', 'ignore').decode('utf-8') + + cleaned = re.sub(r"^[^0-9A-Za-z]+", "", normalized_source) + if not cleaned: + return "#" + initial = cleaned[0] + if initial.isalpha(): + return initial.upper() + if initial.isdigit(): + return "#" + return "#" + + @staticmethod + def _entry_matches_query(entry: OPDSEntry, tokens: List[str]) -> bool: + if not tokens: + return True + search_fragments: List[str] = [] + + if entry.title: + search_fragments.append(CalibreOPDSClient._normalize_text(entry.title)) + if entry.series: + search_fragments.append(CalibreOPDSClient._normalize_text(entry.series)) + + for author in entry.authors: + cleaned = (author or "").strip() + if not cleaned: + continue + normalized_author = CalibreOPDSClient._normalize_text(cleaned) + search_fragments.append(normalized_author) + for part in re.split(r"[\s,]+", normalized_author): + part = part.strip() + if part: + search_fragments.append(part) + + if not search_fragments: + return False + + # Check if all tokens match at least one fragment + # Tokens are already normalized in _filter_feed_entries + return all(any(token in fragment for fragment in search_fragments) for token in tokens) + + def _filter_feed_entries(self, feed: OPDSFeed, query: str) -> OPDSFeed: + normalized_query = CalibreOPDSClient._normalize_text(query) + if not normalized_query: + return feed + tokens = [token for token in re.split(r"\s+", normalized_query) if token] + if not tokens: + return feed + + scored_entries = [] + for entry in feed.entries: + if not self._entry_matches_query(entry, tokens): + continue + score = self._calculate_match_score(entry, tokens) + # Require a minimum score to avoid weak matches (e.g. single word in summary) + if score >= 10: + scored_entries.append((score, entry)) + + # Sort by score descending + scored_entries.sort(key=lambda x: x[0], reverse=True) + + filtered = [e for s, e in scored_entries] + return dataclasses.replace(feed, entries=filtered) + + def _estimate_letter_position(self, letter: str) -> float: + """Estimate the relative position (0.0-1.0) of a letter in an alphabetical list.""" + if letter == "#": + return 0.0 + if not letter or not letter.isalpha(): + return 0.0 + + # Approximate cumulative distribution of starting letters in English book titles + # This is a heuristic to jump closer to the target + weights = { + 'A': 0.00, 'B': 0.08, 'C': 0.15, 'D': 0.22, 'E': 0.28, + 'F': 0.33, 'G': 0.38, 'H': 0.43, 'I': 0.49, 'J': 0.53, + 'K': 0.55, 'L': 0.58, 'M': 0.63, 'N': 0.68, 'O': 0.71, + 'P': 0.75, 'Q': 0.80, 'R': 0.81, 'S': 0.85, 'T': 0.92, + 'U': 0.97, 'V': 0.98, 'W': 0.99, 'X': 0.995, 'Y': 0.997, 'Z': 0.999 + } + return weights.get(letter.upper(), 0.0) + + def _attempt_smart_jump(self, feed: OPDSFeed, letter: str) -> Optional[OPDSFeed]: + """ + Attempt to jump to a page closer to the target letter by analyzing pagination links. + Returns a new OPDSFeed if a jump was successful, or None. + """ + first_link = self._resolve_link(feed.links, "first") + last_link = self._resolve_link(feed.links, "last") + next_link = self._resolve_link(feed.links, "next") + + if not (first_link and last_link and next_link): + return None + + # Try to extract offsets from URLs to determine page size and total items + # Common Calibre pattern: .../offset/0, .../offset/50 + def extract_offset(href: str) -> Optional[int]: + match = re.search(r"/(\d+)/?$", href) + if match: + return int(match.group(1)) + # Try query param + parsed = urlparse(href) + qs = dict(pair.split('=') for pair in parsed.query.split('&') if '=' in pair) + if 'offset' in qs: + try: + return int(qs['offset']) + except ValueError: + pass + return None + + start_offset = extract_offset(first_link.href) + next_offset = extract_offset(next_link.href) + last_offset = extract_offset(last_link.href) + + if start_offset is None or next_offset is None or last_offset is None: + return None + + page_size = next_offset - start_offset + if page_size <= 0: + return None + + # Estimate total items (last_offset is the start of the last page) + # We assume the last page is roughly half full for estimation + total_items = last_offset + (page_size // 2) + + target_ratio = self._estimate_letter_position(letter) + # Aim slightly early (subtract 1-2 pages worth) to ensure we don't miss the start + target_offset = int(total_items * target_ratio) + target_offset = max(0, target_offset - (page_size * 2)) + + # Round to nearest page boundary + target_offset = (target_offset // page_size) * page_size + + # If the jump is too small (e.g. we are already near the start), don't bother + if target_offset < (page_size * 3): + return None + + # Construct the new URL + # We assume the URL structure is consistent and we can just replace the offset + # This is risky but works for standard Calibre OPDS + base_href = first_link.href + if str(start_offset) in base_href: + # Path based replacement + # Replace the last occurrence of the offset + parts = base_href.rsplit(str(start_offset), 1) + if len(parts) == 2: + new_href = f"{parts[0]}{target_offset}{parts[1]}" + try: + return self.fetch_feed(new_href) + except Exception: + return None + + return None + + def browse_letter( + self, + letter: str, + *, + start_href: Optional[str] = None, + max_pages: int = 40, + ) -> OPDSFeed: + normalized = (letter or "").strip() + if not normalized: + return self.fetch_feed(start_href) + key = normalized.upper() + if key in {"ALL", "*"}: + return self.fetch_feed(start_href) + if key in {"0-9", "NUMERIC"}: + key = "#" + if len(key) > 1: + key = key[0] + if key != "#" and not key.isalpha(): + key = "#" + base_feed = self.fetch_feed(start_href) + + # Ensure we start from the beginning of the feed if possible + first_link = self._resolve_link(base_feed.links, "first") or self._resolve_link(base_feed.links, "start") + if first_link and first_link.href: + try: + # Only switch if the href is different to avoid redundant fetch + if not start_href or first_link.href != start_href: + base_feed = self.fetch_feed(first_link.href) + except CalibreOPDSError: + pass + + mode = self._browse_mode_for_title(base_feed.title) + + def letter_matches(entry: OPDSEntry, active_mode: str) -> bool: + letter_value = self._alphabet_letter_for_entry(entry, active_mode) + if not letter_value: + return False + if key == "#": + return letter_value == "#" + return letter_value == key + + collected: List[OPDSEntry] = [] + seen_ids: Set[str] = set() + letter_href: Optional[str] = None + + def add_entry(entry: OPDSEntry) -> None: + entry_id = (entry.id or "").strip() + if entry_id: + if entry_id in seen_ids: + return + seen_ids.add(entry_id) + collected.append(entry) + + # Check the first page for navigation links before attempting any jumps + # This handles the case where "By Title" has "A", "B", "C" folders + has_nav_links = False + for entry in base_feed.entries: + if self._has_navigation_link(entry): + has_nav_links = True + if letter_matches(entry, mode): + for link in entry.links: + if self._is_navigation_link(link): + href = (link.href or "").strip() + if href: + letter_href = href + break + if letter_href: + break + + # If we didn't find a direct link, and it looks like a flat list (no nav links matching criteria), + # try to jump closer to the target letter if we are in a sorted mode + if not letter_href and mode in {"title", "author", "series"}: + jump_feed = self._attempt_smart_jump(base_feed, key) + if jump_feed: + base_feed = jump_feed + + for page in self._iter_paginated_feeds(base_feed, max_pages=max_pages): + for entry in page.entries: + if not letter_matches(entry, mode): + continue + if self._has_navigation_link(entry): + if letter_href is None: + for link in entry.links: + if self._is_navigation_link(link): + href = (link.href or "").strip() + if href: + letter_href = href + break + else: + add_entry(entry) + + letter_feed: Optional[OPDSFeed] = None + if letter_href: + try: + letter_feed = self.fetch_feed(letter_href) + except CalibreOPDSError: + letter_feed = None + else: + letter_mode = self._browse_mode_for_title(letter_feed.title) + for page in self._iter_paginated_feeds(letter_feed, max_pages=max_pages): + for entry in page.entries: + if not letter_matches(entry, letter_mode): + continue + if self._has_navigation_link(entry): + continue + add_entry(entry) + + template = letter_feed or base_feed + if collected: + return dataclasses.replace(template, entries=collected) + return dataclasses.replace(template, entries=[]) + + def _resolve_search_url(self, feed: OPDSFeed, query: str) -> Optional[str]: + link = self._resolve_link(feed.links, "search") + if not link: + link = self._resolve_link(feed.links, "http://opds-spec.org/search") + + if not link or not link.href: + return None + + href = link.href.strip() + if "{searchTerms}" in href: + return href.replace("{searchTerms}", quote(query)) + + return href + + def _calculate_match_score(self, entry: OPDSEntry, tokens: List[str]) -> int: + if not tokens: + return 0 + + score = 0 + + # Prepare normalized text + title = self._normalize_text(entry.title) + authors = [self._normalize_text(a) for a in entry.authors] + series = self._normalize_text(entry.series) if entry.series else "" + summary = self._normalize_text(entry.summary) if entry.summary else "" + tags = [self._normalize_text(t) for t in entry.tags] + + # 1. Exact/Phrase matches + query_phrase = " ".join(tokens) + if query_phrase == title: + score += 1000 + elif query_phrase in title: + score += 500 + + for author in authors: + if query_phrase in author: + score += 300 + + if query_phrase in series: + score += 200 + + for tag in tags: + if query_phrase == tag: + score += 100 + elif query_phrase in tag: + score += 50 + + # 2. Token matches + # Filter out stop words unless the query is only stop words + significant_tokens = [t for t in tokens if t not in _STOP_WORDS] + if not significant_tokens: + significant_tokens = tokens + + for token in significant_tokens: + token_score = 0 + # Use regex for word boundary matching + # Escape token to handle special chars + token_regex = r"\b" + re.escape(token) + r"\b" + + # Title: High weight + if re.search(token_regex, title): + token_score = max(token_score, 50) + elif token in title: + token_score = max(token_score, 5) + + # Author: Medium-High weight + for author in authors: + if re.search(token_regex, author): + token_score = max(token_score, 40) + elif token in author: + token_score = max(token_score, 5) + + # Series: Medium weight + if token in series: + if re.search(token_regex, series): + token_score = max(token_score, 30) + else: + token_score = max(token_score, 5) + + # Tags: Medium weight + for tag in tags: + if re.search(token_regex, tag): + token_score = max(token_score, 30) + elif token in tag: + token_score = max(token_score, 5) + + # Summary: Low weight + if token in summary: + if re.search(token_regex, summary): + # Only add if not found elsewhere? Or just add small amount? + if token_score == 0: + token_score = 15 + else: + token_score += 5 # Small boost if also in description + elif token_score == 0: + token_score = 2 # Very low for substring in summary + + score += token_score + + return score diff --git a/abogen/kokoro_text_normalization.py b/abogen/kokoro_text_normalization.py new file mode 100644 index 0000000..563e63d --- /dev/null +++ b/abogen/kokoro_text_normalization.py @@ -0,0 +1,2240 @@ +from __future__ import annotations + +import json +import re +import unicodedata +import os +import locale +from fractions import Fraction +from dataclasses import dataclass, field +from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple +import logging + +logger = logging.getLogger(__name__) + +try: # pragma: no cover - optional dependency guard + from num2words import num2words +except ImportError: + num2words = None + logger.warning("num2words library not found. Number normalization will be disabled.") +except Exception as e: # pragma: no cover - graceful degradation + num2words = None + logger.error(f"Failed to import num2words: {e}") + +HAS_NUM2WORDS = num2words is not None + +if TYPE_CHECKING: # pragma: no cover - type checking only + from abogen.llm_client import LLMCompletion + +from abogen.spacy_contraction_resolver import resolve_ambiguous_contractions + +# ---------- Contraction Category Defaults ---------- + +CONTRACTION_CATEGORY_DEFAULTS: Dict[str, bool] = { + "contraction_aux_be": True, + "contraction_aux_have": True, + "contraction_modal_will": True, + "contraction_modal_would": True, + "contraction_negation_not": True, + "contraction_let_us": True, +} + +# ---------- Configuration Dataclass ---------- + +@dataclass +class ApostropheConfig: + contraction_mode: str = "expand" # expand|collapse|keep + possessive_mode: str = "keep" # keep|collapse + plural_possessive_mode: str = "collapse" # keep|collapse + irregular_possessive_mode: str = "keep" # keep|expand (expand just means keep or add hints; modify if needed) + sibilant_possessive_mode: str = "mark" # keep|mark|approx + fantasy_mode: str = "keep" # keep|mark|collapse_internal + acronym_possessive_mode: str = "keep" # keep|collapse_add_s + decades_mode: str = "expand" # keep|expand + leading_elision_mode: str = "expand" # keep|expand + ambiguous_past_modal_mode: str = "contextual" # keep|expand_prefer_would|expand_prefer_had|contextual + add_phoneme_hints: bool = True # Whether to emit markers like ‹IZ› + fantasy_marker: str = "‹FAP›" # Marker inserted if fantasy_mode == mark + sibilant_iz_marker: str = "‹IZ›" # Marker for /ɪz/ insertion + joiner: str = "" # Replacement used when collapsing internal apostrophes + lowercase_for_matching: bool = True # Normalize to lower for rule matching (not output) + protect_cultural_names: bool = True # Always keep O'Brien, D'Angelo, etc. + convert_numbers: bool = True # Convert grouped numbers such as 12,500 to words + convert_currency: bool = True # Convert currency symbols to words + remove_footnotes: bool = True # Remove footnote indicators + number_lang: str = "en" # num2words language code + year_pronunciation_mode: str = "american" # off|american (extend if needed) + contraction_categories: Dict[str, bool] = field(default_factory=lambda: dict(CONTRACTION_CATEGORY_DEFAULTS)) + + def is_contraction_enabled(self, category: str) -> bool: + return self.contraction_categories.get(category, True) + +# ---------- Dictionaries / Patterns ---------- + +# Common contraction expansions (type + expansion words) +CONTRACTION_LEXICON: Dict[str, Tuple[str, Tuple[str, ...]]] = { + "let's": ("contraction_let_us", ("let", "us")), + "can't": ("contraction_negation_not", ("can", "not")), + "won't": ("contraction_negation_not", ("will", "not")), + "don't": ("contraction_negation_not", ("do", "not")), + "doesn't": ("contraction_negation_not", ("does", "not")), + "didn't": ("contraction_negation_not", ("did", "not")), + "isn't": ("contraction_negation_not", ("is", "not")), + "aren't": ("contraction_negation_not", ("are", "not")), + "wasn't": ("contraction_negation_not", ("was", "not")), + "weren't": ("contraction_negation_not", ("were", "not")), + "haven't": ("contraction_negation_not", ("have", "not")), + "hasn't": ("contraction_negation_not", ("has", "not")), + "hadn't": ("contraction_negation_not", ("had", "not")), + "couldn't": ("contraction_negation_not", ("could", "not")), + "shouldn't": ("contraction_negation_not", ("should", "not")), + "wouldn't": ("contraction_negation_not", ("would", "not")), + "mustn't": ("contraction_negation_not", ("must", "not")), + "mightn't": ("contraction_negation_not", ("might", "not")), + "shan't": ("contraction_negation_not", ("shall", "not")), +} + +SUFFIX_CONTRACTION_RULES: Tuple[Tuple[str, str, str], ...] = ( + ("'ll", "will", "contraction_modal_will"), + ("'re", "are", "contraction_aux_be"), + ("'ve", "have", "contraction_aux_have"), +) + +SUFFIX_CONTRACTION_BASES: Dict[str, Tuple[str, ...]] = { + "'m": ("i",), +} + +# For ambiguous 'd and 's we handle separately +_NUMBER_WITH_GROUP_RE = re.compile(r"(?{_NUMBER_CORE_PATTERN})(?PBy {authors_text}
" + + publisher = self.book_metadata.get("publisher") + pub_year = self.book_metadata.get("publication_year") + + if publisher or pub_year: + pub_info = [] + if publisher: + pub_info.append(f"Published by {publisher}") + if pub_year: + pub_info.append(f"Year: {pub_year}") + html_content += f"{' | '.join(pub_info)}
" + + html_content += "{desc}
" + + if self.parser.file_type == "pdf": + # Access pdf_doc from parser if available + pdf_doc = getattr(self.parser, "pdf_doc", None) + page_count = len(pdf_doc) if pdf_doc else 0 + html_content += f"File type: PDF
Page count: {page_count}
{PROGRAM_DESCRIPTION}
" + "Visit the GitHub repository for updates, documentation, and to report issues.
" + ) + desc_label.setTextFormat(Qt.TextFormat.RichText) + desc_label.setWordWrap(True) + layout.addWidget(desc_label) + + # GitHub link + github_btn = QPushButton("Visit GitHub Repository") + github_btn.setIcon(QIcon(get_resource_path("abogen.assets", "github.png"))) + github_btn.clicked.connect(lambda: QDesktopServices.openUrl(QUrl(GITHUB_URL))) + github_btn.setFixedHeight(32) + layout.addWidget(github_btn) + + # Check for updates button + update_btn = QPushButton("Check for updates") + update_btn.clicked.connect(self.manual_check_for_updates) + update_btn.setFixedHeight(32) + layout.addWidget(update_btn) + + # Close button + close_btn = QPushButton("Close") + close_btn.clicked.connect(dialog.accept) + close_btn.setFixedHeight(32) + layout.addWidget(close_btn) + + dialog.exec() + + def manual_check_for_updates(self): + """Manually check for updates and always show result""" + # Set a flag to always show the result message + self._show_update_check_result = True + self.check_for_updates_startup() + + def check_for_updates_startup(self): + import urllib.request + + def show_update_message(remote_version, local_version): + msg_box = QMessageBox(self) + msg_box.setIcon(QMessageBox.Icon.Information) + msg_box.setWindowTitle("Update Available") + msg_box.setText( + f"A new version of {PROGRAM_NAME} is available! ({local_version} > {remote_version})" + ) + msg_box.setInformativeText( + f"If you installed via pip, update by running:\n" + f"pip install --upgrade {PROGRAM_NAME}\n\n" + f"If you're using the Windows portable version, run 'WINDOWS_INSTALL.bat' again.\n\n" + "Alternatively, visit the GitHub repository for more information. " + "Would you like to view the changelog?" + ) + msg_box.setStandardButtons( + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No + ) + msg_box.setDefaultButton(QMessageBox.StandardButton.Yes) + if msg_box.exec() == QMessageBox.StandardButton.Yes: + try: + QDesktopServices.openUrl(QUrl(GITHUB_URL + "/releases/latest")) + except Exception: + pass + + # Reset flag to track if we should show "no updates" message + show_result = ( + hasattr(self, "_show_update_check_result") + and self._show_update_check_result + ) + self._show_update_check_result = False + + try: + update_url = "https://raw.githubusercontent.com/denizsafak/abogen/refs/heads/main/abogen/VERSION" + with urllib.request.urlopen(update_url) as response: + remote_raw = response.read().decode().strip() + local_raw = VERSION + + # Parse version numbers + remote_version = remote_raw + local_version = local_raw + + try: + remote_num = int("".join(remote_version.split("."))) + local_num = int("".join(local_version.split("."))) + except ValueError as ve: + return + + if remote_num > local_num: + # Use QTimer to ensure UI is ready, then show update message. + QTimer.singleShot( + 1000, lambda: show_update_message(remote_version, local_version) + ) + elif show_result: + # Show "no updates" message if manually checking + QMessageBox.information( + self, + "Up to Date", + f"You are running the latest version of {PROGRAM_NAME} ({local_version}).", + ) + except Exception as e: + if show_result: + QMessageBox.warning( + self, + "Update Check Failed", + f"Could not check for updates:\n{str(e)}", + ) + pass + + def clear_cache_files(self): + """Clear cache files created by the program.""" + import glob + + try: + # Get the abogen cache directory + cache_dir = get_user_cache_path() + + # Find all .txt files and cover images in the abogen cache directory + cache_files = glob.glob(os.path.join(cache_dir, "*.txt")) + cache_files.extend(glob.glob(os.path.join(cache_dir, "cover_*.jpg"))) + + # Count the files + file_count = len(cache_files) + + # Check for preview cache files + preview_cache_dir = os.path.join(cache_dir, "preview_cache") + preview_files = [] + if os.path.exists(preview_cache_dir): + preview_pattern = os.path.join(preview_cache_dir, "*.wav") + preview_files = glob.glob(preview_pattern) + + preview_count = len(preview_files) + + if file_count == 0 and preview_count == 0: + QMessageBox.information( + self, "No Cache Files", "No cache files were found." + ) + return + + # Create a custom message box with checkbox + msg_box = QMessageBox(self) + msg_box.setIcon(QMessageBox.Icon.Question) + msg_box.setWindowTitle("Clear Cache Files") + + msg_text = f"Found {file_count} cache file{'s' if file_count != 1 else ''} in the {PROGRAM_NAME} cache folder." + if preview_count > 0: + msg_text += f"\nAlso found {preview_count} preview cache file{'s' if preview_count != 1 else ''}." + + msg_box.setText(msg_text + "\nDo you want to delete them?") + + # Add checkbox for preview cache + preview_cache_checkbox = QCheckBox("Also clean preview cache", msg_box) + preview_cache_checkbox.setChecked(False) + # Only enable checkbox if preview files exist + preview_cache_checkbox.setEnabled(preview_count > 0) + + # Add the checkbox to the layout + msg_box.setCheckBox(preview_cache_checkbox) + + # Add buttons + msg_box.setStandardButtons( + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No + ) + msg_box.setDefaultButton(QMessageBox.StandardButton.Yes) + + if msg_box.exec() != QMessageBox.StandardButton.Yes: + return + + # Delete the text files + deleted_count = 0 + for file_path in cache_files: + try: + os.remove(file_path) + deleted_count += 1 + except Exception as e: + print(f"Error deleting {file_path}: {e}") + + # Delete preview cache files if checkbox is checked + deleted_preview_count = 0 + if preview_cache_checkbox.isChecked() and preview_count > 0: + for file_path in preview_files: + try: + os.remove(file_path) + deleted_preview_count += 1 + except Exception as e: + print(f"Error deleting preview cache {file_path}: {e}") + + # Build result message + result_msg = f"Successfully deleted {deleted_count} temporary file{'s' if deleted_count != 1 else ''}." + if preview_cache_checkbox.isChecked() and deleted_preview_count > 0: + result_msg += f"\nAlso deleted {deleted_preview_count} preview cache file{'s' if deleted_preview_count != 1 else ''}." + + # Show results + QMessageBox.information(self, "Cache Files Cleared", result_msg) + + # If currently selected file is in the cache directory, clear the UI + if ( + self.selected_file + and os.path.dirname(self.selected_file) == cache_dir + and self.selected_file.endswith(".txt") + ): + self.input_box.clear_input() + + except Exception as e: + QMessageBox.critical( + self, "Error", f"An error occurred while clearing temporary files:\n{e}" + ) + + def set_max_log_lines(self): + """Open a dialog to set the maximum lines in the log window.""" + from PyQt6.QtWidgets import QInputDialog + + value, ok = QInputDialog.getInt( + self, + "Max Lines in Log Window", + "Enter the maximum number of lines to display in the log window:", + self.log_window_max_lines, + 10, # min value + 999999999, # max value + 1, # step + ) + if ok: + self.log_window_max_lines = value + self.config["log_window_max_lines"] = value + save_config(self.config) + QMessageBox.information( + self, + "Setting Saved", + f"Maximum lines in log window set to {value}.", + ) + + def set_max_subtitle_words(self): + """Open a dialog to set the maximum words per subtitle""" + from PyQt6.QtWidgets import QInputDialog + + current_value = self.config.get("max_subtitle_words", 50) + + value, ok = QInputDialog.getInt( + self, + "Max Words Per Subtitle", + "Enter the maximum number of words per\nsubtitle (before splitting the subtitle):", + current_value, + 1, # min value + 200, # max value + 1, # step + ) + + if ok: + # Save the new value + self.max_subtitle_words = value + self.config["max_subtitle_words"] = value + save_config(self.config) + + # Show confirmation + QMessageBox.information( + self, + "Setting Saved", + f"Maximum words per subtitle set to {value}.", + ) + + def set_silence_between_chapters(self): + """Open a dialog to set the silence duration between chapters""" + + current_value = self.config.get("silence_duration", 2.0) + + dlg = QInputDialog(self) + dlg.setWindowTitle("Silence Duration (seconds)") + dlg.setLabelText( + "Enter the duration of silence\nbetween chapters (in seconds):" + ) + dlg.setInputMode(QInputDialog.InputMode.DoubleInput) + dlg.setDoubleDecimals(1) + dlg.setDoubleMinimum(0.0) + dlg.setDoubleMaximum(60.0) + dlg.setDoubleValue(current_value) + dlg.setDoubleStep(0.1) # <-- set step to 0.1 + + if dlg.exec() == QDialog.DialogCode.Accepted: + value = dlg.doubleValue() + # Round to one decimal to avoid floating-point representation noise + value = round(value, 1) + + # Save the new value + self.silence_duration = value + self.config["silence_duration"] = value + save_config(self.config) + + # Show confirmation (format with one decimal) + QMessageBox.information( + self, + "Setting Saved", + f"Silence duration between chapters set to {value:.1f} seconds.", + ) + + def set_separate_chapters_format(self, fmt): + """Set the format for separate chapters audio files.""" + self.separate_chapters_format = fmt + self.config["separate_chapters_format"] = fmt + save_config(self.config) + + def set_subtitle_format(self, fmt): + """Set the subtitle format.""" + self.config["subtitle_format"] = fmt + save_config(self.config) + + def show_model_download_warning(self, title, message): + QMessageBox.information(self, title, message) diff --git a/abogen/pyqt/main.py b/abogen/pyqt/main.py new file mode 100644 index 0000000..f788e15 --- /dev/null +++ b/abogen/pyqt/main.py @@ -0,0 +1,187 @@ +import os +import sys +import platform +import atexit +import signal +from abogen.utils import get_resource_path, load_config, prevent_sleep_end + + +# Fix PyTorch DLL loading issue ([WinError 1114]) on Windows before importing PyQt6 +if platform.system() == "Windows": + import ctypes + from importlib.util import find_spec + + try: + if ( + (spec := find_spec("torch")) + and spec.origin + and os.path.exists( + dll_path := os.path.join(os.path.dirname(spec.origin), "lib", "c10.dll") + ) + ): + ctypes.CDLL(os.path.normpath(dll_path)) + except Exception: + pass + + +# Qt platform plugin detection (fixes #59) +try: + from PyQt6.QtCore import QLibraryInfo + + # Get the path to the plugins directory + plugins = QLibraryInfo.path(QLibraryInfo.LibraryPath.PluginsPath) + + # Normalize path to use the OS-native separators and absolute path + platform_dir = os.path.normpath(os.path.join(plugins, "platforms")) + + # Ensure we work with an absolute path for clarity + platform_dir = os.path.abspath(platform_dir) + + if os.path.isdir(platform_dir): + os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = platform_dir + print("QT_QPA_PLATFORM_PLUGIN_PATH set to:", platform_dir) + else: + print("PyQt6 platform plugins not found at", platform_dir) +except ImportError: + print("PyQt6 not installed.") + + +# Pre-load "libxcb-cursor" on Linux (fixes #101) +if platform.system() == "Linux": + arch = platform.machine().lower() + lib_filename = {"x86_64": "libxcb-cursor-amd64.so.0", "amd64": "libxcb-cursor-amd64.so.0", "aarch64": "libxcb-cursor-arm64.so.0", "arm64": "libxcb-cursor-arm64.so.0"}.get(arch) + if lib_filename: + import ctypes + try: + # Try to load the system libxcb-cursor.so.0 first + ctypes.CDLL('libxcb-cursor.so.0', mode=ctypes.RTLD_GLOBAL) + except OSError: + # System lib not available, load the bundled version + lib_path = get_resource_path('abogen.libs', lib_filename) + if lib_path: + try: + ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL) + except OSError: + # If it fails (e.g. wrong glibc version on very old systems), + # we simply ignore it and hope the system has the library. + pass + + +# Set application ID for Windows taskbar icon +if platform.system() == "Windows": + try: + from abogen.constants import PROGRAM_NAME, VERSION + import ctypes + + app_id = f"{PROGRAM_NAME}.{VERSION}" + ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id) + except Exception as e: + print("Warning: failed to set AppUserModelID:", e) + +from PyQt6.QtWidgets import QApplication +from PyQt6.QtGui import QIcon +from PyQt6.QtCore import ( + QLibraryInfo, + qInstallMessageHandler, + QtMsgType, +) + +# Add the directory to Python path +sys.path.insert(0, os.path.join(os.path.dirname(__file__))) + +# Set Hugging Face Hub environment variables +os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1" # Disable Hugging Face telemetry +os.environ["HF_HUB_ETAG_TIMEOUT"] = "10" # Metadata request timeout (seconds) +os.environ["HF_HUB_DOWNLOAD_TIMEOUT"] = "10" # File download timeout (seconds) +os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1" # Disable symlinks warning +if load_config().get("disable_kokoro_internet", False): + print("INFO: Kokoro's internet access is disabled.") + os.environ["HF_HUB_OFFLINE"] = "1" # Disable Hugging Face Hub internet access + +from abogen.pyqt.gui import abogen +from abogen.constants import PROGRAM_NAME, VERSION + +# Set environment variables for AMD ROCm +os.environ["MIOPEN_FIND_MODE"] = "FAST" +os.environ["MIOPEN_CONV_PRECISE_ROCM_TUNING"] = "0" + +# Reset sleep states +atexit.register(prevent_sleep_end) + + +# Also handle signals (Ctrl+C, kill, etc.) +def _cleanup_sleep(signum, frame): + prevent_sleep_end() + sys.exit(0) + + +signal.signal(signal.SIGINT, _cleanup_sleep) +signal.signal(signal.SIGTERM, _cleanup_sleep) + +# Ensure sys.stdout and sys.stderr are valid in GUI mode +if sys.stdout is None: + sys.stdout = open(os.devnull, "w") +if sys.stderr is None: + sys.stderr = open(os.devnull, "w") + +# Enable MPS GPU acceleration on Mac Apple Silicon +if platform.system() == "Darwin" and platform.processor() == "arm": + os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" + + +# Custom message handler to filter out specific Qt warnings +def qt_message_handler(mode, context, message): + # In PyQt6, the mode is an enum, so we compare with the enum members + if "Wayland does not support QWindow::requestActivate()" in message: + return # Suppress this specific message + if "setGrabPopup called with a parent, QtWaylandClient" in message: + return + + if mode == QtMsgType.QtWarningMsg: + print(f"Qt Warning: {message}") + elif mode == QtMsgType.QtCriticalMsg: + print(f"Qt Critical: {message}") + elif mode == QtMsgType.QtFatalMsg: + print(f"Qt Fatal: {message}") + elif mode == QtMsgType.QtInfoMsg: + print(f"Qt Info: {message}") + + +# Install the custom message handler +qInstallMessageHandler(qt_message_handler) + +# Handle Wayland on Linux GNOME +if platform.system() == "Linux": + xdg_session = os.environ.get("XDG_SESSION_TYPE", "").lower() + desktop = os.environ.get("XDG_CURRENT_DESKTOP", "").lower() + if ( + "gnome" in desktop + and xdg_session == "wayland" + and "QT_QPA_PLATFORM" not in os.environ + ): + os.environ["QT_QPA_PLATFORM"] = "wayland" + + +def main(): + """Main entry point for console usage.""" + app = QApplication(sys.argv) + + # Set application icon using get_resource_path from utils + icon_path = get_resource_path("abogen.assets", "icon.ico") + if icon_path: + app.setWindowIcon(QIcon(icon_path)) + + # Set the .desktop name on Linux + if platform.system() == "Linux": + try: + app.setDesktopFileName("abogen") + except AttributeError: + pass + + ex = abogen() + ex.show() + sys.exit(app.exec()) + + +if __name__ == "__main__": + main() diff --git a/abogen/pyqt/predownload_gui.py b/abogen/pyqt/predownload_gui.py new file mode 100644 index 0000000..47138f1 --- /dev/null +++ b/abogen/pyqt/predownload_gui.py @@ -0,0 +1,590 @@ +""" +Pre-download dialog and worker for Abogen + +This module consolidates pre-download logic for Kokoro voices and model +and spaCy language models. The code favors clarity, avoids duplication, +and handles optional dependencies gracefully. +""" + +from typing import List, Optional, Tuple +import importlib +import importlib.util + +from PyQt6.QtWidgets import ( + QDialog, + QVBoxLayout, + QHBoxLayout, + QLabel, + QPushButton, + QSpacerItem, + QSizePolicy, +) +from PyQt6.QtCore import QThread, pyqtSignal + +from abogen.constants import COLORS, VOICES_INTERNAL +from abogen.spacy_utils import SPACY_MODELS +import abogen.hf_tracker + + +# Helpers +def _unique_sorted_models() -> List[str]: + """Return a sorted list of unique spaCy model package names.""" + return sorted(set(SPACY_MODELS.values())) + + +def _is_package_installed(pkg_name: str) -> bool: + """Return True if a package with the given name can be imported (site-packages).""" + try: + return importlib.util.find_spec(pkg_name) is not None + except Exception: + return False + + +# NOTE: explicit HF cache helper removed; we use try_to_load_from_cache in-scope where needed + + +class PreDownloadWorker(QThread): + """Worker thread to download required models/voices. + + Emits human-readable messages via `progress`. Uses `category_done` to indicate + a category (voices/model/spacy) finished successfully. Emits `error` on exception + and `finished` after all work completes. + """ + + # Emit (category, status, message) + progress = pyqtSignal(str, str, str) + category_done = pyqtSignal(str) + finished = pyqtSignal() + error = pyqtSignal(str) + + def __init__(self, parent=None): + super().__init__(parent) + self._cancelled = False + # repo and filenames used for Kokoro model + self._repo_id = "hexgrad/Kokoro-82M" + self._model_files = ["kokoro-v1_0.pth", "config.json"] + # Track download success per category + self._voices_success = False + self._model_success = False + self._spacy_success = False + # Suppress HF tracker warnings during downloads + self._original_emitter = abogen.hf_tracker.show_warning_signal_emitter + + def cancel(self) -> None: + self._cancelled = True + + def run(self) -> None: + # Suppress HF tracker warnings during downloads + abogen.hf_tracker.show_warning_signal_emitter = None + try: + self._download_kokoro_voices() + if self._cancelled: + return + if self._voices_success: + self.category_done.emit("voices") + + self._download_kokoro_model() + if self._cancelled: + return + if self._model_success: + self.category_done.emit("model") + + self._download_spacy_models() + if self._cancelled: + return + if self._spacy_success: + self.category_done.emit("spacy") + + self.finished.emit() + except Exception as exc: # pragma: no cover - best-effort reporting + self.error.emit(str(exc)) + finally: + # Restore original emitter + abogen.hf_tracker.show_warning_signal_emitter = self._original_emitter + + # Kokoro voices + def _download_kokoro_voices(self) -> None: + self._voices_success = True + try: + from huggingface_hub import hf_hub_download, try_to_load_from_cache + except Exception: + self.progress.emit( + "voice", "warning", "huggingface_hub not installed, skipping voices..." + ) + self._voices_success = False + return + + voice_list = VOICES_INTERNAL + for idx, voice in enumerate(voice_list, start=1): + if self._cancelled: + self._voices_success = False + return + filename = f"voices/{voice}.pt" + if try_to_load_from_cache(repo_id=self._repo_id, filename=filename): + self.progress.emit( + "voice", + "installed", + f"{idx}/{len(voice_list)}: {voice} already present", + ) + continue + self.progress.emit( + "voice", "downloading", f"{idx}/{len(voice_list)}: {voice}..." + ) + try: + hf_hub_download(repo_id=self._repo_id, filename=filename) + self.progress.emit("voice", "downloaded", f"{voice} downloaded") + except Exception as exc: + self.progress.emit( + "voice", "warning", f"could not download {voice}: {exc}" + ) + self._voices_success = False + + # Kokoro model + def _download_kokoro_model(self) -> None: + self._model_success = True + try: + from huggingface_hub import hf_hub_download, try_to_load_from_cache + except Exception: + self.progress.emit( + "model", "warning", "huggingface_hub not installed, skipping model..." + ) + self._model_success = False + return + for fname in self._model_files: + if self._cancelled: + self._model_success = False + return + category = "config" if fname == "config.json" else "model" + if try_to_load_from_cache(repo_id=self._repo_id, filename=fname): + self.progress.emit( + category, "installed", f"file {fname} already present" + ) + continue + self.progress.emit(category, "downloading", f"file {fname}...") + try: + hf_hub_download(repo_id=self._repo_id, filename=fname) + self.progress.emit(category, "downloaded", f"file {fname} downloaded") + except Exception as exc: + self.progress.emit( + category, "warning", f"could not download file {fname}: {exc}" + ) + self._model_success = False + + # spaCy models + def _download_spacy_models(self) -> None: + """Download spaCy models. Prefer missing models provided by parent. + + Parent dialog will populate _spacy_models_missing during checking. + """ + self._spacy_success = True + # Determine which models to process: prefer parent-provided missing list to avoid + # re-checking everything; otherwise use the full unique list. + parent = self.parent() + models_to_process: List[str] = _unique_sorted_models() + try: + if ( + parent is not None + and hasattr(parent, "_spacy_models_missing") + and parent._spacy_models_missing + ): + models_to_process = list(dict.fromkeys(parent._spacy_models_missing)) + except Exception: + pass + + # If spaCy is not available to run the CLI, skip gracefully + try: + import spacy.cli as _spacy_cli + except Exception: + self.progress.emit( + "spacy", "warning", "spaCy not available, skipping spaCy models..." + ) + self._spacy_success = False + return + + for idx, model_name in enumerate(models_to_process, start=1): + if self._cancelled: + self._spacy_success = False + return + if _is_package_installed(model_name): + self.progress.emit( + "spacy", + "installed", + f"{idx}/{len(models_to_process)}: {model_name} already installed", + ) + continue + self.progress.emit( + "spacy", + "downloading", + f"{idx}/{len(models_to_process)}: {model_name}...", + ) + try: + _spacy_cli.download(model_name) + self.progress.emit("spacy", "downloaded", f"{model_name} downloaded") + except Exception as exc: + self.progress.emit( + "spacy", "warning", f"could not download {model_name}: {exc}" + ) + self._spacy_success = False + + +class PreDownloadDialog(QDialog): + """Dialog to show and control pre-download process.""" + + VOICE_PREFIX = "Kokoro voices: " + MODEL_PREFIX = "Kokoro model: " + CONFIG_PREFIX = "Kokoro config: " + SPACY_PREFIX = "spaCy models: " + + def __init__(self, parent=None): + super().__init__(parent) + self.setWindowTitle("Pre-download Models and Voices") + self.setMinimumWidth(500) + self.worker: Optional[PreDownloadWorker] = None + self.has_missing = False + self._spacy_models_checked: List[tuple] = [] + self._spacy_models_missing: List[str] = [] + self._status_worker = None + + # Map keywords to (label, prefix) - labels filled after UI creation + self.status_map = { + "voice": (None, self.VOICE_PREFIX), + "spacy": (None, self.SPACY_PREFIX), + "model": (None, self.MODEL_PREFIX), + "config": (None, self.CONFIG_PREFIX), + } + + self.category_map = { + "voices": ["voice"], + "model": ["model", "config"], + "spacy": ["spacy"], + } + + self._setup_ui() + self._start_status_check() + + def _setup_ui(self) -> None: + layout = QVBoxLayout(self) + layout.setSpacing(0) + layout.setContentsMargins(15, 0, 15, 15) + + desc = QLabel( + "You can pre-download all required models and voices for offline use.\n" + "This includes Kokoro voices, Kokoro model (and config), and spaCy models." + ) + desc.setWordWrap(True) + layout.addWidget(desc) + + # Status rows + status_layout = QVBoxLayout() + status_title = QLabel("Current Status:") + status_layout.addWidget(status_title) + + self.voices_status = QLabel(self.VOICE_PREFIX + "⏳ Checking...") + row = QHBoxLayout() + row.addWidget(self.voices_status) + row.addStretch() + status_layout.addLayout(row) + + self.model_status = QLabel(self.MODEL_PREFIX + "⏳ Checking...") + row = QHBoxLayout() + row.addWidget(self.model_status) + row.addStretch() + status_layout.addLayout(row) + + self.config_status = QLabel(self.CONFIG_PREFIX + "⏳ Checking...") + row = QHBoxLayout() + row.addWidget(self.config_status) + row.addStretch() + status_layout.addLayout(row) + + self.spacy_status = QLabel(self.SPACY_PREFIX + "⏳ Checking...") + row = QHBoxLayout() + row.addWidget(self.spacy_status) + row.addStretch() + status_layout.addLayout(row) + + # register labels + self.status_map["voice"] = (self.voices_status, self.VOICE_PREFIX) + self.status_map["model"] = (self.model_status, self.MODEL_PREFIX) + self.status_map["config"] = (self.config_status, self.CONFIG_PREFIX) + self.status_map["spacy"] = (self.spacy_status, self.SPACY_PREFIX) + + layout.addLayout(status_layout) + + layout.addItem( + QSpacerItem(0, 20, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed) + ) + + # Buttons + button_row = QHBoxLayout() + button_row.setSpacing(10) + self.download_btn = QPushButton("Download all") + self.download_btn.setMinimumWidth(100) + self.download_btn.setMinimumHeight(35) + self.download_btn.setEnabled(False) + self.download_btn.clicked.connect(self._start_download) + button_row.addWidget(self.download_btn) + + self.close_btn = QPushButton("Close") + self.close_btn.setMinimumWidth(100) + self.close_btn.setMinimumHeight(35) + self.close_btn.clicked.connect(self._handle_close) + button_row.addWidget(self.close_btn) + + layout.addLayout(button_row) + self.adjustSize() + + # Status checking worker + class StatusCheckWorker(QThread): + voices_checked = pyqtSignal(bool, list) + model_checked = pyqtSignal(bool) + config_checked = pyqtSignal(bool) + spacy_model_checking = pyqtSignal(str) + spacy_model_result = pyqtSignal(str, bool) + spacy_checked = pyqtSignal(bool, list) + + def run(self): + parent = self.parent() + if parent is None: + return + + voices_ok, missing_voices = parent._check_kokoro_voices() + self.voices_checked.emit(voices_ok, missing_voices) + + model_ok = parent._check_kokoro_model() + self.model_checked.emit(model_ok) + + config_ok = parent._check_kokoro_config() + self.config_checked.emit(config_ok) + + # Check spaCy models by package name to detect site-package installs + unique = _unique_sorted_models() + missing: List[str] = [] + for name in unique: + self.spacy_model_checking.emit(name) + ok = _is_package_installed(name) + self.spacy_model_result.emit(name, ok) + if not ok: + missing.append(name) + parent._spacy_models_missing = missing + self.spacy_checked.emit(len(missing) == 0, missing) + + def _start_status_check(self) -> None: + self._status_worker = self.StatusCheckWorker(self) + self._status_worker.voices_checked.connect(self._update_voices_status) + self._status_worker.model_checked.connect(self._update_model_status) + self._status_worker.config_checked.connect(self._update_config_status) + self._status_worker.spacy_model_checking.connect(self._spacy_model_checking) + self._status_worker.spacy_model_result.connect(self._spacy_model_result) + self._status_worker.spacy_checked.connect(self._update_spacy_status) + + # These are initialized in __init__ to keep consistent object state + + # Set checking visual state + for lbl in ( + self.voices_status, + self.model_status, + self.config_status, + self.spacy_status, + ): + lbl.setStyleSheet(f"color: {COLORS['ORANGE']};") + + self.spacy_status.setText(self.SPACY_PREFIX + "⏳ Checking...") + self._status_worker.start() + + # UI update callbacks + def _spacy_model_checking(self, name: str) -> None: + self.spacy_status.setText(f"{self.SPACY_PREFIX}Checking {name}...") + + def _spacy_model_result(self, name: str, ok: bool) -> None: + self._spacy_models_checked.append((name, ok)) + if not ok and name not in self._spacy_models_missing: + self._spacy_models_missing.append(name) + checked = len(self._spacy_models_checked) + missing_count = len(self._spacy_models_missing) + if missing_count: + self.spacy_status.setText( + f"{self.SPACY_PREFIX}{checked} checked, {missing_count} missing..." + ) + else: + self.spacy_status.setText(f"{self.SPACY_PREFIX}{checked} checked...") + + def _update_voices_status(self, ok: bool, missing: List[str]) -> None: + if ok: + self._set_status("voice", "✓ Downloaded", COLORS["GREEN"]) + else: + self.has_missing = True + if missing: + self._set_status( + "voice", f"✗ Missing {len(missing)} voices", COLORS["RED"] + ) + else: + self._set_status("voice", "✗ Not downloaded", COLORS["RED"]) + + def _update_model_status(self, ok: bool) -> None: + if ok: + self._set_status("model", "✓ Downloaded", COLORS["GREEN"]) + else: + self.has_missing = True + self._set_status("model", "✗ Not downloaded", COLORS["RED"]) + + def _update_config_status(self, ok: bool) -> None: + if ok: + self._set_status("config", "✓ Downloaded", COLORS["GREEN"]) + else: + self.has_missing = True + self._set_status("config", "✗ Not downloaded", COLORS["RED"]) + + def _update_spacy_status(self, ok: bool, missing: List[str]) -> None: + if ok: + self._set_status("spacy", "✓ Downloaded", COLORS["GREEN"]) + else: + self.has_missing = True + if missing: + self._set_status( + "spacy", f"✗ Missing {len(missing)} model(s)", COLORS["RED"] + ) + else: + self._set_status("spacy", "✗ Not downloaded", COLORS["RED"]) + self.download_btn.setEnabled(self.has_missing) + + def _set_status(self, key: str, text: str, color: str) -> None: + lbl, prefix = self.status_map.get(key, (None, "")) + if not lbl: + return + lbl.setText(prefix + text) + lbl.setStyleSheet(f"color: {color};") + + # Helper checks + def _check_kokoro_voices(self) -> Tuple[bool, List[str]]: + """Return (ok, missing_list) for Kokoro voices check.""" + missing = [] + try: + from huggingface_hub import try_to_load_from_cache + + for voice in VOICES_INTERNAL: + if not try_to_load_from_cache( + repo_id="hexgrad/Kokoro-82M", filename=f"voices/{voice}.pt" + ): + missing.append(voice) + except Exception: + # If HF missing, report all as missing + return False, list(VOICES_INTERNAL) + return (len(missing) == 0), missing + + def _check_kokoro_model(self) -> bool: + try: + from huggingface_hub import try_to_load_from_cache + + return ( + try_to_load_from_cache( + repo_id="hexgrad/Kokoro-82M", filename="kokoro-v1_0.pth" + ) + is not None + ) + except Exception: + return False + + def _check_kokoro_config(self) -> bool: + try: + from huggingface_hub import try_to_load_from_cache + + return ( + try_to_load_from_cache( + repo_id="hexgrad/Kokoro-82M", filename="config.json" + ) + is not None + ) + except Exception: + return False + + def _check_spacy_models(self) -> bool: + unique = _unique_sorted_models() + missing = [m for m in unique if not _is_package_installed(m)] + self._spacy_models_missing = missing + return len(missing) == 0 + + # Download control + def _start_download(self) -> None: + self.download_btn.setEnabled(False) + self.download_btn.setText("Downloading...") + # mark the start of downloads; this triggers the labels + self._on_progress("system", "starting", "Processing, please wait...") + self.worker = PreDownloadWorker(self) + self.worker.progress.connect(self._on_progress) + self.worker.category_done.connect(self._on_category_done) + self.worker.finished.connect(self._on_download_finished) + self.worker.error.connect(self._on_download_error) + self.worker.start() + + def _on_progress(self, category: str, status: str, message: str) -> None: + """Map worker (category, status, message) to UI label updates. + + Status is one of: 'downloading', 'installed', 'downloaded', 'warning', 'starting'. + Category is one of: 'voice', 'model', 'spacy', 'config', or 'system'. + """ + try: + # If the category targets a specific label, update directly + if category in self.status_map: + lbl, prefix = self.status_map[category] + if not lbl: + return + # Compose message and set color based on status token + full_text = prefix + message + if len(full_text) > 60: + display_text = full_text[:57] + "..." + lbl.setText(display_text) + lbl.setToolTip(full_text) + else: + lbl.setText(full_text) + lbl.setToolTip("") # Clear tooltip if not needed + if status == "downloading": + lbl.setStyleSheet(f"color: {COLORS['ORANGE']};") + elif status in ("installed", "downloaded"): + lbl.setStyleSheet(f"color: {COLORS['GREEN']};") + elif status == "warning": + lbl.setStyleSheet(f"color: {COLORS['RED']};") + elif status == "error": + lbl.setStyleSheet(f"color: {COLORS['RED']};") + return + + # System-level messages + if category == "system": + if status == "starting": + for k in self.status_map: + lbl, prefix = self.status_map[k] + if lbl: + lbl.setText(prefix + "Processing, please wait...") + lbl.setStyleSheet(f"color: {COLORS['ORANGE']};") + # other system statuses don't require action + return + except Exception: + # Do not let UI thread crash on unexpected worker message + pass + + def _on_category_done(self, category: str) -> None: + for key in self.category_map.get(category, []): + self._set_status(key, "✓ Downloaded", COLORS["GREEN"]) + + def _on_download_finished(self) -> None: + self.has_missing = False + self.download_btn.setText("Download all") + self.download_btn.setEnabled(False) + + def _on_download_error(self, error_msg: str) -> None: + self.download_btn.setText("Download all") + self.download_btn.setEnabled(True) + for key in self.status_map: + self._set_status(key, f"✗ Error - {error_msg}", COLORS["RED"]) + + def _handle_close(self) -> None: + if self.worker and self.worker.isRunning(): + self.worker.cancel() + self.worker.wait(2000) + self.accept() + + def closeEvent(self, event) -> None: + if self.worker and self.worker.isRunning(): + self.worker.cancel() + self.worker.wait(2000) + super().closeEvent(event) diff --git a/abogen/pyqt/queue_manager_gui.py b/abogen/pyqt/queue_manager_gui.py new file mode 100644 index 0000000..384be79 --- /dev/null +++ b/abogen/pyqt/queue_manager_gui.py @@ -0,0 +1,860 @@ +# a simple window with a list of items in the queue, no checkboxes +# button to remove an item from the queue +# button to clear the queue + +from PyQt6.QtWidgets import ( + QDialog, + QVBoxLayout, + QHBoxLayout, + QDialogButtonBox, + QPushButton, + QListWidget, + QListWidgetItem, + QFileIconProvider, + QLabel, + QWidget, + QSizePolicy, + QAbstractItemView, + QCheckBox, +) +from PyQt6.QtCore import QFileInfo, Qt +from abogen.constants import COLORS +from copy import deepcopy +from PyQt6.QtGui import QFontMetrics +from abogen.utils import load_config, save_config + +# Define attributes that are safe to override with global settings +OVERRIDE_FIELDS = [ + "lang_code", + "speed", + "voice", + "save_option", + "output_folder", + "subtitle_mode", + "output_format", + "replace_single_newlines", + "use_silent_gaps", + "subtitle_speed_method", +] + + +class ElidedLabel(QLabel): + def __init__(self, text): + super().__init__(text) + self._full_text = text + self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Preferred) + self.setTextFormat(Qt.TextFormat.PlainText) + + def setText(self, text): + self._full_text = text + super().setText(text) + self.update() + + def resizeEvent(self, event): + metrics = QFontMetrics(self.font()) + elided = metrics.elidedText( + self._full_text, Qt.TextElideMode.ElideRight, self.width() + ) + super().setText(elided) + super().resizeEvent(event) + + def fullText(self): + return self._full_text + + +class QueueListItemWidget(QWidget): + def __init__(self, file_name, char_count): + super().__init__() + layout = QHBoxLayout() + layout.setContentsMargins(12, 0, 6, 0) + layout.setSpacing(0) + import os + + name_label = ElidedLabel(os.path.basename(file_name)) + char_label = QLabel(f"Chars: {char_count}") + char_label.setStyleSheet(f"color: {COLORS['LIGHT_DISABLED']};") + char_label.setAlignment( + Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter + ) + char_label.setSizePolicy( + QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Preferred + ) + layout.addWidget(name_label, 1) + layout.addWidget(char_label, 0) + self.setLayout(layout) + + +class DroppableQueueListWidget(QListWidget): + def __init__(self, parent_dialog): + super().__init__() + self.parent_dialog = parent_dialog + self.setAcceptDrops(True) + # Overlay for drag hover + self.drag_overlay = QLabel("", self) + self.drag_overlay.setAlignment(Qt.AlignmentFlag.AlignCenter) + self.drag_overlay.setStyleSheet( + f"border:2px dashed {COLORS['BLUE_BORDER_HOVER']}; border-radius:5px; padding:20px; background:{COLORS['BLUE_BG_HOVER']};" + ) + self.drag_overlay.setVisible(False) + self.drag_overlay.setAttribute( + Qt.WidgetAttribute.WA_TransparentForMouseEvents, True + ) + + def dragEnterEvent(self, event): + if event.mimeData().hasUrls(): + for url in event.mimeData().urls(): + file_path = url.toLocalFile().lower() + if url.isLocalFile() and ( + file_path.endswith(".txt") + or file_path.endswith((".srt", ".ass", ".vtt")) + ): + self.drag_overlay.resize(self.size()) + self.drag_overlay.setVisible(True) + event.acceptProposedAction() + return + self.drag_overlay.setVisible(False) + event.ignore() + + def dragMoveEvent(self, event): + if event.mimeData().hasUrls(): + for url in event.mimeData().urls(): + file_path = url.toLocalFile().lower() + if url.isLocalFile() and ( + file_path.endswith(".txt") + or file_path.endswith((".srt", ".ass", ".vtt")) + ): + event.acceptProposedAction() + return + event.ignore() + + def dragLeaveEvent(self, event): + self.drag_overlay.setVisible(False) + event.accept() + + def dropEvent(self, event): + self.drag_overlay.setVisible(False) + if event.mimeData().hasUrls(): + file_paths = [ + url.toLocalFile() + for url in event.mimeData().urls() + if url.isLocalFile() + and ( + url.toLocalFile().lower().endswith(".txt") + or url.toLocalFile().lower().endswith((".srt", ".ass", ".vtt")) + ) + ] + if file_paths: + self.parent_dialog.add_files_from_paths(file_paths) + event.acceptProposedAction() + else: + event.ignore() + else: + event.ignore() + + def resizeEvent(self, event): + super().resizeEvent(event) + if hasattr(self, "drag_overlay"): + self.drag_overlay.resize(self.size()) + + +class QueueManager(QDialog): + def __init__(self, parent, queue: list, title="Queue Manager", size=(600, 700)): + super().__init__() + self.queue = queue + self._original_queue = deepcopy( + queue + ) # Store a deep copy of the original queue + self.parent = parent + self.config = load_config() # Load config for persistence + + layout = QVBoxLayout() + layout.setContentsMargins(15, 15, 15, 15) # set main layout margins + layout.setSpacing(12) # set spacing between widgets in main layout + # list of queued items + self.listwidget = DroppableQueueListWidget(self) + self.listwidget.setSelectionMode( + QAbstractItemView.SelectionMode.ExtendedSelection + ) + self.listwidget.setAlternatingRowColors(True) + self.listwidget.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) + self.listwidget.customContextMenuRequested.connect(self.show_context_menu) + # Add informative instructions at the top + instructions = QLabel( + "[A-Z0-9_]+)" + re.escape(MARKER_SUFFIX))
+
+
+@dataclass(frozen=True)
+class DebugWavArtifact:
+ label: str
+ filename: str
+ code: Optional[str] = None
+ text: Optional[str] = None
+
+
+def _resolve_voice_setting(value: str) -> tuple[str, Optional[str], Optional[str]]:
+ """Resolve settings voice strings into a pipeline-ready voice spec.
+
+ Supports "profile:" by converting it into a concrete voice formula.
+ Returns (resolved_voice_spec, profile_name, profile_language).
+ """
+
+ from abogen.webui.routes.utils.voice import resolve_voice_setting
+
+ return resolve_voice_setting(value)
+
+
+def _load_pipeline(language: str, use_gpu: bool) -> Any:
+ device = "cpu"
+ if use_gpu:
+ device = _select_device()
+ _np, KPipeline = load_numpy_kpipeline()
+ return KPipeline(lang_code=language, repo_id="hexgrad/Kokoro-82M", device=device)
+
+
+def _extract_cases_from_text(text: str) -> List[Tuple[str, str]]:
+ raw = str(text or "")
+ matches = list(_MARKER_RE.finditer(raw))
+ cases: List[Tuple[str, str]] = []
+ if not matches:
+ return cases
+ for idx, match in enumerate(matches):
+ code = match.group("code")
+ start = match.end()
+ end = matches[idx + 1].start() if idx + 1 < len(matches) else len(raw)
+ snippet = raw[start:end]
+ # Keep it small and predictable: collapse whitespace.
+ snippet = " ".join(snippet.strip().split())
+ cases.append((code, snippet))
+ return cases
+
+
+def _spoken_id(code: str) -> str:
+ # Make IDs pronounceable and stable (avoid reading as a word).
+ out: List[str] = []
+ for ch in str(code or ""):
+ if ch == "_":
+ out.append(" ")
+ elif ch.isalnum():
+ out.append(ch)
+ else:
+ out.append(" ")
+ # Add spaces between alnum to encourage letter-by-letter reading.
+ spaced = " ".join("".join(out).split())
+ return spaced
+
+
+def run_debug_tts_wavs(
+ *,
+ output_root: Path,
+ settings: Mapping[str, Any],
+ epub_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+ """Generate WAV artifacts for the debug EPUB samples.
+
+ Writes:
+ - overall.wav: concatenation of all samples
+ - case_.wav: each sample rendered separately
+ - manifest.json: metadata + file list
+ """
+
+ output_root = Path(output_root)
+ output_root.mkdir(parents=True, exist_ok=True)
+
+ run_id = uuid.uuid4().hex
+ run_dir = output_root / "debug" / run_id
+ run_dir.mkdir(parents=True, exist_ok=True)
+
+ if epub_path is None:
+ epub_path = run_dir / "abogen_debug_samples.epub"
+ build_debug_epub(epub_path)
+ else:
+ epub_path = Path(epub_path)
+
+ extraction = extract_from_path(epub_path)
+ combined_text = extraction.combined_text or "\n\n".join((c.text or "") for c in extraction.chapters)
+ cases = _extract_cases_from_text(combined_text)
+
+ # Prefer the canonical sample catalog for text (EPUB extraction may include headings).
+ try:
+ from abogen.debug_tts_samples import DEBUG_TTS_SAMPLES
+
+ sample_text_by_code = {sample.code: sample.text for sample in DEBUG_TTS_SAMPLES}
+ except Exception:
+ sample_text_by_code = {}
+
+ expected = list(iter_expected_codes())
+ found_codes = {code for code, _ in cases}
+ missing = [code for code in expected if code not in found_codes]
+ if missing:
+ raise RuntimeError(f"Debug EPUB missing expected codes: {', '.join(missing)}")
+
+ language = str(settings.get("language") or "a").strip() or "a"
+ # Kokoro's KPipeline expects short language codes like "a" (American English),
+ # but older settings may store ISO-like values such as "en".
+ language_aliases = {
+ "en": "a",
+ "en-us": "a",
+ "en_us": "a",
+ "en-gb": "b",
+ "en_gb": "b",
+ "es": "e",
+ "es-es": "e",
+ "fr": "f",
+ "fr-fr": "f",
+ "hi": "h",
+ "it": "i",
+ "pt": "p",
+ "pt-br": "p",
+ "ja": "j",
+ "jp": "j",
+ "zh": "z",
+ "zh-cn": "z",
+ }
+ language = language_aliases.get(language.lower(), language)
+ voice_spec = str(settings.get("default_voice") or "").strip()
+ use_gpu = bool(settings.get("use_gpu", False))
+ speed = float(settings.get("default_speed", 1.0) or 1.0)
+
+ # Settings may store "profile:" which is not a Kokoro voice ID.
+ # Resolve it to a concrete voice formula (e.g. "af_heart*0.5+...") so Kokoro
+ # doesn't attempt to download a non-existent "voices/profile:.pt".
+ try:
+ resolved_voice, _profile_name, profile_language = _resolve_voice_setting(voice_spec)
+ if resolved_voice:
+ voice_spec = resolved_voice
+ if profile_language:
+ language = str(profile_language).strip() or language
+ except Exception:
+ # Voice profile resolution is best-effort; fall back to raw voice_spec.
+ pass
+
+ # Best-effort voice caching (only for known Kokoro internal voices).
+ voice_ids = _spec_to_voice_ids(voice_spec)
+ if voice_ids:
+ try:
+ ensure_voice_assets(voice_ids)
+ except Exception:
+ # Network / optional dependency variance; debug runner can still proceed.
+ pass
+
+ pipeline = _load_pipeline(language, use_gpu)
+ voice_choice = _resolve_voice(pipeline, voice_spec, use_gpu)
+
+ apostrophe_config = build_apostrophe_config(settings=settings)
+ normalization_settings = dict(settings)
+
+ artifacts: List[DebugWavArtifact] = []
+
+ overall_path = run_dir / "overall.wav"
+ overall_audio: List[np.ndarray] = []
+
+ def synth(text: str, *, apply_normalization: bool = True) -> np.ndarray:
+ normalized = (
+ normalize_for_pipeline(
+ text,
+ config=apostrophe_config,
+ settings=normalization_settings,
+ )
+ if apply_normalization
+ else str(text or "")
+ )
+ parts: List[np.ndarray] = []
+ for segment in pipeline(
+ normalized,
+ voice=voice_choice,
+ speed=speed,
+ split_pattern=SPLIT_PATTERN,
+ ):
+ audio = _to_float32(getattr(segment, "audio", None))
+ if audio.size:
+ parts.append(audio)
+ if not parts:
+ return np.zeros(0, dtype="float32")
+ return np.concatenate(parts).astype("float32", copy=False)
+
+ pause_1s = np.zeros(int(1.0 * SAMPLE_RATE), dtype="float32")
+ between_cases = np.zeros(int(0.35 * SAMPLE_RATE), dtype="float32")
+
+ # Per sample
+ for code, snippet in cases:
+ snippet = sample_text_by_code.get(code, snippet)
+ if not snippet:
+ continue
+ id_audio = synth(_spoken_id(code), apply_normalization=False)
+ text_audio = synth(snippet, apply_normalization=True)
+ audio = np.concatenate([id_audio, pause_1s, text_audio]).astype("float32", copy=False)
+ filename = f"case_{code}.wav"
+ path = run_dir / filename
+ # Write float32 PCM WAV.
+ import soundfile as sf
+
+ sf.write(path, audio, SAMPLE_RATE, subtype="FLOAT")
+ artifacts.append(DebugWavArtifact(label=f"{code}", filename=filename, code=code, text=snippet))
+ overall_audio.append(audio)
+ overall_audio.append(between_cases)
+
+ # Overall
+ if overall_audio:
+ combined = np.concatenate(overall_audio).astype("float32", copy=False)
+ else:
+ combined = np.zeros(0, dtype="float32")
+ import soundfile as sf
+
+ sf.write(overall_path, combined, SAMPLE_RATE, subtype="FLOAT")
+ artifacts.insert(0, DebugWavArtifact(label="Overall", filename="overall.wav", code=None, text=None))
+
+ manifest = {
+ "run_id": run_id,
+ "epub": str(epub_path),
+ "artifacts": [artifact.__dict__ for artifact in artifacts],
+ "sample_rate": SAMPLE_RATE,
+ }
+ (run_dir / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+ return manifest
diff --git a/abogen/webui/entrypoint.sh b/abogen/webui/entrypoint.sh
new file mode 100755
index 0000000..b11305f
--- /dev/null
+++ b/abogen/webui/entrypoint.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+# Entrypoint script for abogen container
+# Performs CUDA diagnostics and starts the web server
+
+set -e
+
+echo "=== Abogen Container Starting ==="
+
+# Check CUDA availability
+if command -v nvidia-smi &> /dev/null; then
+ echo "NVIDIA Driver detected:"
+ nvidia-smi --query-gpu=name,driver_version,memory.total,memory.free --format=csv,noheader 2>/dev/null || echo " (nvidia-smi query failed)"
+
+ # Check PyTorch CUDA support
+ python3 -c "
+import torch
+print(f'PyTorch version: {torch.__version__}')
+print(f'CUDA available: {torch.cuda.is_available()}')
+if torch.cuda.is_available():
+ print(f'CUDA version (PyTorch): {torch.version.cuda}')
+ print(f'GPU count: {torch.cuda.device_count()}')
+ for i in range(torch.cuda.device_count()):
+ props = torch.cuda.get_device_properties(i)
+ print(f' GPU {i}: {props.name} ({props.total_memory // 1024**2} MB)')
+else:
+ print('WARNING: PyTorch cannot access CUDA. Running on CPU.')
+" 2>&1 || echo "PyTorch CUDA check failed"
+else
+ echo "No NVIDIA driver detected. Running on CPU."
+fi
+
+echo "================================="
+echo ""
+
+# Start the application
+exec "$@"
diff --git a/abogen/webui/routes/__init__.py b/abogen/webui/routes/__init__.py
new file mode 100644
index 0000000..6cf27f0
--- /dev/null
+++ b/abogen/webui/routes/__init__.py
@@ -0,0 +1,18 @@
+from abogen.webui.routes.main import main_bp
+from abogen.webui.routes.jobs import jobs_bp
+from abogen.webui.routes.settings import settings_bp
+from abogen.webui.routes.voices import voices_bp
+from abogen.webui.routes.entities import entities_bp
+from abogen.webui.routes.books import books_bp
+from abogen.webui.routes.api import api_bp
+
+__all__ = [
+ "main_bp",
+ "jobs_bp",
+ "settings_bp",
+ "voices_bp",
+ "entities_bp",
+ "books_bp",
+ "api_bp",
+]
+
diff --git a/abogen/webui/routes/api.py b/abogen/webui/routes/api.py
new file mode 100644
index 0000000..f02ab9d
--- /dev/null
+++ b/abogen/webui/routes/api.py
@@ -0,0 +1,680 @@
+from typing import Any, Dict, Mapping, List, Optional
+import base64
+import uuid
+from pathlib import Path
+
+from flask import Blueprint, request, jsonify, send_file, url_for, current_app
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.routes.utils.settings import (
+ load_settings,
+ load_integration_settings,
+ coerce_float,
+ coerce_bool,
+ audiobookshelf_settings_from_payload,
+ calibre_settings_from_payload,
+)
+from abogen.voice_profiles import (
+ load_profiles,
+ save_profiles,
+ delete_profile,
+ duplicate_profile,
+ serialize_profiles,
+ import_profiles_data,
+ export_profiles_payload,
+ normalize_profile_entry,
+)
+from abogen.webui.routes.utils.common import split_profile_spec
+from abogen.webui.routes.utils.preview import synthesize_preview, generate_preview_audio
+from abogen.webui.routes.utils.voice import formula_from_profile
+from abogen.normalization_settings import (
+ build_llm_configuration,
+ build_apostrophe_config,
+ apply_overrides,
+)
+from abogen.llm_client import list_models, LLMClientError
+from abogen.kokoro_text_normalization import normalize_for_pipeline
+from abogen.integrations.audiobookshelf import AudiobookshelfClient, AudiobookshelfConfig
+from abogen.integrations.calibre_opds import (
+ CalibreOPDSClient,
+ CalibreOPDSError,
+)
+from abogen.webui.routes.utils.service import get_service
+from abogen.webui.routes.utils.form import build_pending_job_from_extraction
+from abogen.text_extractor import extract_from_path
+from werkzeug.utils import secure_filename
+
+api_bp = Blueprint("api", __name__)
+
+# --- Voice Profile Routes ---
+
+@api_bp.get("/voice-profiles")
+def api_get_voice_profiles() -> ResponseReturnValue:
+ profiles = load_profiles()
+ return jsonify(profiles)
+
+@api_bp.post("/voice-profiles")
+def api_save_voice_profile() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ name = str(payload.get("name") or "").strip()
+ original_name = str(payload.get("originalName") or "").strip() or None
+
+ profile = payload.get("profile")
+ if profile is None:
+ # Speaker Studio payload format
+ provider = str(payload.get("provider") or "kokoro").strip().lower()
+ if provider not in {"kokoro", "supertonic"}:
+ provider = "kokoro"
+ if provider == "supertonic":
+ profile = {
+ "provider": "supertonic",
+ "language": str(payload.get("language") or "a").strip().lower() or "a",
+ "voice": payload.get("voice"),
+ "total_steps": payload.get("total_steps") or payload.get("supertonic_total_steps"),
+ "speed": payload.get("speed") or payload.get("supertonic_speed"),
+ }
+ else:
+ profile = {
+ "provider": "kokoro",
+ "language": str(payload.get("language") or "a").strip().lower() or "a",
+ "voices": payload.get("voices") or [],
+ }
+
+ if not name or not profile:
+ return jsonify({"error": "Name and profile are required"}), 400
+
+ profiles = load_profiles()
+
+ normalized = normalize_profile_entry(profile)
+ if not normalized:
+ return jsonify({"error": "Invalid profile payload"}), 400
+
+ if original_name and original_name in profiles and original_name != name:
+ del profiles[original_name]
+
+ profiles[name] = normalized
+ save_profiles(profiles)
+
+ return jsonify({"success": True, "profile": name, "profiles": serialize_profiles()})
+
+@api_bp.delete("/voice-profiles/")
+def api_delete_voice_profile(name: str) -> ResponseReturnValue:
+ delete_profile(name)
+ return jsonify({"success": True, "profiles": serialize_profiles()})
+
+
+@api_bp.post("/voice-profiles//duplicate")
+def api_duplicate_voice_profile(name: str) -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ new_name = str(payload.get("name") or "").strip()
+ if not new_name:
+ return jsonify({"error": "Name is required"}), 400
+ duplicate_profile(name, new_name)
+ return jsonify({"success": True, "profile": new_name, "profiles": serialize_profiles()})
+
+
+@api_bp.post("/voice-profiles/import")
+def api_import_voice_profiles() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ data = payload.get("data")
+ replace_existing = bool(payload.get("replace_existing"))
+ if not isinstance(data, dict):
+ return jsonify({"error": "Invalid profile payload"}), 400
+ try:
+ imported = import_profiles_data(data, replace_existing=replace_existing)
+ except Exception as exc:
+ return jsonify({"error": str(exc)}), 400
+ return jsonify({"success": True, "imported": imported, "profiles": serialize_profiles()})
+
+
+@api_bp.get("/voice-profiles/export")
+def api_export_voice_profiles() -> ResponseReturnValue:
+ names_param = request.args.get("names")
+ names = None
+ if names_param:
+ names = [item.strip() for item in names_param.split(",") if item.strip()]
+ payload = export_profiles_payload(names)
+ import io
+ import json
+
+ data = json.dumps(payload, indent=2).encode("utf-8")
+ filename = "voice_profiles.json" if not names else "voice_profiles_export.json"
+ return send_file(
+ io.BytesIO(data),
+ mimetype="application/json",
+ as_attachment=True,
+ download_name=filename,
+ )
+
+
+@api_bp.post("/voice-profiles/preview")
+def api_voice_profiles_preview() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ text = str(payload.get("text") or "").strip() or "Hello world"
+ language = str(payload.get("language") or "a").strip().lower() or "a"
+ speed = coerce_float(payload.get("speed"), 1.0)
+ max_seconds = coerce_float(payload.get("max_seconds"), 8.0)
+
+ settings = load_settings()
+ use_gpu = settings.get("use_gpu", False)
+
+ # Accept a direct formula string or a full profile entry.
+ formula = str(payload.get("formula") or "").strip()
+ profile_name = str(payload.get("profile") or "").strip()
+ provider = str(payload.get("tts_provider") or payload.get("provider") or "").strip().lower() or None
+ supertonic_total_steps = int(payload.get("supertonic_total_steps") or payload.get("total_steps") or settings.get("supertonic_total_steps") or 5)
+
+ voice_spec = ""
+ resolved_provider = provider or "kokoro"
+
+ profiles = load_profiles()
+ if resolved_provider == "supertonic" and not profile_name:
+ voice_spec = str(payload.get("voice") or payload.get("supertonic_voice") or "M1").strip() or "M1"
+ # Allow per-speaker overrides via payload.
+ supertonic_total_steps = int(payload.get("supertonic_total_steps") or payload.get("total_steps") or supertonic_total_steps)
+ speed = coerce_float(payload.get("supertonic_speed") or payload.get("speed"), speed)
+ elif profile_name:
+ entry = profiles.get(profile_name)
+ normalized_entry = normalize_profile_entry(entry)
+ if not normalized_entry:
+ return jsonify({"error": "Unknown profile"}), 404
+ resolved_provider = str(normalized_entry.get("provider") or "kokoro")
+ if resolved_provider == "supertonic":
+ voice_spec = str(normalized_entry.get("voice") or "M1")
+ supertonic_total_steps = int(normalized_entry.get("total_steps") or supertonic_total_steps)
+ speed = float(normalized_entry.get("speed") or speed)
+ else:
+ voice_spec = formula_from_profile(normalized_entry) or ""
+ language = str(normalized_entry.get("language") or language)
+ elif formula:
+ voice_spec = formula
+ resolved_provider = "kokoro"
+ else:
+ # Raw voices payload -> Kokoro mix.
+ voices = payload.get("voices") or []
+ pseudo = {"provider": "kokoro", "language": language, "voices": voices}
+ normalized_entry = normalize_profile_entry(pseudo)
+ voice_spec = formula_from_profile(normalized_entry) or ""
+ resolved_provider = "kokoro"
+
+ if not voice_spec:
+ return jsonify({"error": "Unable to resolve preview voice"}), 400
+
+ try:
+ return synthesize_preview(
+ text=text,
+ voice_spec=voice_spec,
+ language=language,
+ speed=speed,
+ use_gpu=use_gpu,
+ tts_provider=resolved_provider,
+ supertonic_total_steps=supertonic_total_steps,
+ max_seconds=max_seconds,
+ )
+ except Exception as exc:
+ return jsonify({"error": str(exc)}), 500
+
+@api_bp.post("/speaker-preview")
+def api_speaker_preview() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ pending_id = str(payload.get("pending_id") or "").strip()
+ text = payload.get("text", "Hello world")
+ voice = payload.get("voice", "af_heart")
+ language = payload.get("language", "a")
+ speed_value = payload.get("speed")
+ speed = coerce_float(speed_value, 1.0)
+ tts_provider = str(payload.get("tts_provider") or "").strip().lower()
+ supertonic_total_steps = int(payload.get("supertonic_total_steps") or 5)
+
+ settings = load_settings()
+ use_gpu = settings.get("use_gpu", False)
+
+ base_spec, speaker_name = split_profile_spec(voice)
+ resolved_provider = tts_provider if tts_provider in {"kokoro", "supertonic"} else ""
+
+ if speaker_name:
+ entry = normalize_profile_entry(load_profiles().get(speaker_name))
+ if entry:
+ resolved_provider = str(entry.get("provider") or resolved_provider or "")
+ if resolved_provider == "supertonic":
+ voice = str(entry.get("voice") or "M1")
+ supertonic_total_steps = int(entry.get("total_steps") or supertonic_total_steps)
+ if speed_value is None:
+ speed = coerce_float(entry.get("speed"), speed)
+ elif resolved_provider == "kokoro":
+ voice = formula_from_profile(entry) or (base_spec or voice)
+
+ if not resolved_provider:
+ resolved_provider = "supertonic" if str(base_spec or "").strip() in {"M1","M2","M3","M4","M5","F1","F2","F3","F4","F5"} else "kokoro"
+
+ pronunciation_overrides = None
+ manual_overrides = None
+ speakers = None
+ if pending_id:
+ try:
+ pending = get_service().get_pending_job(pending_id)
+ except Exception:
+ pending = None
+ if pending is not None:
+ manual_overrides = getattr(pending, "manual_overrides", None)
+ pronunciation_overrides = getattr(pending, "pronunciation_overrides", None)
+ speakers = getattr(pending, "speakers", None)
+
+ try:
+ return synthesize_preview(
+ text=text,
+ voice_spec=voice,
+ language=language,
+ speed=speed,
+ use_gpu=use_gpu
+ ,
+ tts_provider=resolved_provider,
+ supertonic_total_steps=supertonic_total_steps or int(settings.get("supertonic_total_steps") or 5),
+ pronunciation_overrides=pronunciation_overrides,
+ manual_overrides=manual_overrides,
+ speakers=speakers,
+ )
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+# --- Integration Routes ---
+
+
+def _opds_metadata_overrides(metadata_payload: Mapping[str, Any]) -> Dict[str, Any]:
+ metadata_overrides: Dict[str, Any] = {}
+
+ def _stringify_metadata_value(value: Any) -> str:
+ if value is None:
+ return ""
+ if isinstance(value, (list, tuple, set)):
+ parts = [str(item).strip() for item in value if item is not None]
+ parts = [part for part in parts if part]
+ return ", ".join(parts)
+ return str(value).strip()
+
+ raw_series = metadata_payload.get("series") or metadata_payload.get("series_name")
+ series_name = str(raw_series or "").strip()
+ if series_name:
+ metadata_overrides["series"] = series_name
+ metadata_overrides.setdefault("series_name", series_name)
+
+ series_index_value = (
+ metadata_payload.get("series_index")
+ or metadata_payload.get("series_position")
+ or metadata_payload.get("series_sequence")
+ or metadata_payload.get("book_number")
+ )
+ if series_index_value is not None:
+ series_index_text = str(series_index_value).strip()
+ if series_index_text:
+ metadata_overrides.setdefault("series_index", series_index_text)
+ metadata_overrides.setdefault("series_position", series_index_text)
+ metadata_overrides.setdefault("series_sequence", series_index_text)
+ metadata_overrides.setdefault("book_number", series_index_text)
+
+ tags_value = metadata_payload.get("tags") or metadata_payload.get("keywords")
+ if tags_value:
+ tags_text = _stringify_metadata_value(tags_value)
+ if tags_text:
+ metadata_overrides.setdefault("tags", tags_text)
+ metadata_overrides.setdefault("keywords", tags_text)
+ metadata_overrides.setdefault("genre", tags_text)
+
+ description_value = metadata_payload.get("description") or metadata_payload.get("summary")
+ if description_value:
+ description_text = _stringify_metadata_value(description_value)
+ if description_text:
+ metadata_overrides.setdefault("description", description_text)
+ metadata_overrides.setdefault("summary", description_text)
+
+ subtitle_value = (
+ metadata_payload.get("subtitle")
+ or metadata_payload.get("sub_title")
+ or metadata_payload.get("calibre_subtitle")
+ )
+ if subtitle_value:
+ subtitle_text = _stringify_metadata_value(subtitle_value)
+ if subtitle_text:
+ metadata_overrides.setdefault("subtitle", subtitle_text)
+
+ publisher_value = metadata_payload.get("publisher")
+ if publisher_value:
+ publisher_text = _stringify_metadata_value(publisher_value)
+ if publisher_text:
+ metadata_overrides.setdefault("publisher", publisher_text)
+
+ # Author mapping: Abogen templates look for either 'authors' or 'author'.
+ authors_value = (
+ metadata_payload.get("authors")
+ or metadata_payload.get("author")
+ or metadata_payload.get("creator")
+ or metadata_payload.get("dc_creator")
+ )
+ if authors_value:
+ authors_text = _stringify_metadata_value(authors_value)
+ if authors_text:
+ metadata_overrides.setdefault("authors", authors_text)
+ metadata_overrides.setdefault("author", authors_text)
+
+ return metadata_overrides
+
+@api_bp.get("/integrations/calibre-opds/feed")
+def api_calibre_opds_feed() -> ResponseReturnValue:
+ integrations = load_integration_settings()
+ calibre_settings = integrations.get("calibre_opds", {})
+
+ payload = {
+ "base_url": calibre_settings.get("base_url"),
+ "username": calibre_settings.get("username"),
+ "password": calibre_settings.get("password"),
+ "verify_ssl": calibre_settings.get("verify_ssl", True),
+ }
+
+ if not payload.get("base_url"):
+ return jsonify({"error": "Calibre OPDS base URL is not configured."}), 400
+
+ try:
+ client = CalibreOPDSClient(
+ base_url=payload.get("base_url") or "",
+ username=payload.get("username"),
+ password=payload.get("password"),
+ verify=bool(payload.get("verify_ssl", True)),
+ )
+ except ValueError as exc:
+ return jsonify({"error": str(exc)}), 400
+
+ href = request.args.get("href", type=str)
+ query = request.args.get("q", type=str)
+ letter = request.args.get("letter", type=str)
+
+ try:
+ if letter:
+ feed = client.browse_letter(letter, start_href=href)
+ elif query:
+ feed = client.search(query, start_href=href)
+ else:
+ feed = client.fetch_feed(href)
+ except CalibreOPDSError as exc:
+ return jsonify({"error": str(exc)}), 502
+ except Exception as exc:
+ return jsonify({"error": f"Unexpected error: {str(exc)}"}), 500
+
+ return jsonify({
+ "feed": feed.to_dict(),
+ "href": href or "",
+ "query": query or "",
+ })
+
+@api_bp.post("/integrations/audiobookshelf/folders")
+def api_abs_folders() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ # Use the helper to resolve saved tokens when use_saved_token is set
+ settings = audiobookshelf_settings_from_payload(payload)
+ host = settings.get("base_url")
+ token = settings.get("api_token")
+ library_id = settings.get("library_id")
+
+ if not host or not token:
+ return jsonify({"error": "Base URL and API token are required"}), 400
+
+ if not library_id:
+ return jsonify({"error": "Library ID is required to list folders"}), 400
+
+ try:
+ config = AudiobookshelfConfig(base_url=host, api_token=token, library_id=library_id)
+ client = AudiobookshelfClient(config)
+ folders = client.list_folders()
+ return jsonify({"folders": folders})
+ except Exception as e:
+ return jsonify({"error": str(e)}), 400
+
+@api_bp.post("/integrations/audiobookshelf/test")
+def api_abs_test() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ # Use the helper to resolve saved tokens when use_saved_token is set
+ settings = audiobookshelf_settings_from_payload(payload)
+ host = settings.get("base_url")
+ token = settings.get("api_token")
+
+ if not host or not token:
+ return jsonify({"error": "Base URL and API token are required"}), 400
+
+ try:
+ config = AudiobookshelfConfig(base_url=host, api_token=token)
+ client = AudiobookshelfClient(config)
+ # Just getting libraries is a good enough test
+ client.get_libraries()
+ return jsonify({"success": True, "message": "Connection successful."})
+ except Exception as e:
+ return jsonify({"error": str(e)}), 400
+
+@api_bp.post("/integrations/calibre-opds/test")
+def api_calibre_opds_test() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ # Use the helper to resolve saved passwords when use_saved_password is set
+ settings = calibre_settings_from_payload(payload)
+ base_url = settings.get("base_url")
+ username = settings.get("username")
+ password = settings.get("password")
+ verify_ssl = settings.get("verify_ssl", False)
+
+ if not base_url:
+ return jsonify({"error": "Base URL is required"}), 400
+
+ try:
+ client = CalibreOPDSClient(
+ base_url=base_url,
+ username=username,
+ password=password,
+ verify=verify_ssl,
+ timeout=10.0
+ )
+ client.fetch_feed()
+ return jsonify({"success": True, "message": "Connection successful."})
+ except Exception as e:
+ return jsonify({"error": str(e)}), 400
+
+@api_bp.post("/integrations/calibre-opds/import")
+def api_calibre_opds_import() -> ResponseReturnValue:
+ if not request.is_json:
+ return jsonify({"error": "Expected JSON payload."}), 400
+
+ data = request.get_json(force=True, silent=True) or {}
+ href = str(data.get("href") or "").strip()
+
+ if not href:
+ return jsonify({"error": "Download URL (href) is required."}), 400
+
+ metadata_payload = data.get("metadata") if isinstance(data, Mapping) else None
+ metadata_overrides: Dict[str, Any] = {}
+ if isinstance(metadata_payload, Mapping):
+ metadata_overrides = _opds_metadata_overrides(metadata_payload)
+
+ settings = load_settings()
+ integrations = load_integration_settings()
+ calibre_settings = integrations.get("calibre_opds", {})
+
+ try:
+ client = CalibreOPDSClient(
+ base_url=calibre_settings.get("base_url") or "",
+ username=calibre_settings.get("username"),
+ password=calibre_settings.get("password"),
+ verify=bool(calibre_settings.get("verify_ssl", True)),
+ )
+
+ temp_dir = Path(current_app.config.get("UPLOAD_FOLDER", "uploads"))
+ temp_dir.mkdir(exist_ok=True)
+
+ resource = client.download(href)
+ filename = resource.filename
+ content = resource.content
+
+ if not filename:
+ filename = f"{uuid.uuid4().hex}.epub"
+
+ file_path = temp_dir / f"{uuid.uuid4().hex}_{filename}"
+ file_path.write_bytes(content)
+
+ extraction = extract_from_path(file_path)
+
+ if metadata_overrides:
+ extraction.metadata.update(metadata_overrides)
+
+ result = build_pending_job_from_extraction(
+ stored_path=file_path,
+ original_name=filename,
+ extraction=extraction,
+ form={},
+ settings=settings,
+ profiles=serialize_profiles(),
+ metadata_overrides=metadata_overrides,
+ )
+
+ get_service().store_pending_job(result.pending)
+
+ return jsonify({
+ "success": True,
+ "status": "imported",
+ "pending_id": result.pending.id,
+ "redirect_url": url_for("main.wizard_step", step="book", pending_id=result.pending.id)
+ })
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+# --- LLM Routes ---
+
+@api_bp.post("/llm/models")
+def api_llm_models() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=False) or {}
+ current_settings = load_settings()
+
+ base_url = str(payload.get("base_url") or payload.get("llm_base_url") or current_settings.get("llm_base_url") or "").strip()
+ if not base_url:
+ return jsonify({"error": "LLM base URL is required."}), 400
+
+ api_key = str(payload.get("api_key") or payload.get("llm_api_key") or current_settings.get("llm_api_key") or "")
+ timeout = coerce_float(payload.get("timeout"), current_settings.get("llm_timeout", 30.0))
+
+ overrides = {
+ "llm_base_url": base_url,
+ "llm_api_key": api_key,
+ "llm_timeout": timeout,
+ }
+
+ merged = apply_overrides(current_settings, overrides)
+ configuration = build_llm_configuration(merged)
+ try:
+ models = list_models(configuration)
+ except LLMClientError as exc:
+ return jsonify({"error": str(exc)}), 400
+ return jsonify({"models": models})
+
+@api_bp.post("/llm/preview")
+def api_llm_preview() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=False) or {}
+ sample_text = str(payload.get("text") or "").strip()
+ if not sample_text:
+ return jsonify({"error": "Text is required."}), 400
+
+ base_settings = load_settings()
+ overrides: Dict[str, Any] = {
+ "llm_base_url": str(
+ payload.get("base_url")
+ or payload.get("llm_base_url")
+ or base_settings.get("llm_base_url")
+ or ""
+ ).strip(),
+ "llm_api_key": str(
+ payload.get("api_key")
+ or payload.get("llm_api_key")
+ or base_settings.get("llm_api_key")
+ or ""
+ ),
+ "llm_model": str(
+ payload.get("model")
+ or payload.get("llm_model")
+ or base_settings.get("llm_model")
+ or ""
+ ),
+ "llm_prompt": payload.get("prompt") or payload.get("llm_prompt") or base_settings.get("llm_prompt"),
+ "llm_context_mode": payload.get("context_mode") or base_settings.get("llm_context_mode"),
+ "llm_timeout": coerce_float(payload.get("timeout"), base_settings.get("llm_timeout", 30.0)),
+ "normalization_apostrophe_mode": "llm",
+ }
+
+ merged = apply_overrides(base_settings, overrides)
+ if not merged.get("llm_base_url"):
+ return jsonify({"error": "LLM base URL is required."}), 400
+ if not merged.get("llm_model"):
+ return jsonify({"error": "Select an LLM model before previewing."}), 400
+
+ apostrophe_config = build_apostrophe_config(settings=merged)
+ try:
+ normalized_text = normalize_for_pipeline(sample_text, config=apostrophe_config, settings=merged)
+ except LLMClientError as exc:
+ return jsonify({"error": str(exc)}), 400
+
+ context = {
+ "text": sample_text,
+ "normalized_text": normalized_text,
+ }
+ return jsonify(context)
+
+# --- Normalization Routes ---
+
+@api_bp.post("/normalization/preview")
+def api_normalization_preview() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=False) or {}
+ sample_text = str(payload.get("text") or "").strip()
+ if not sample_text:
+ return jsonify({"error": "Sample text is required."}), 400
+
+ base_settings = load_settings()
+ # We might want to apply overrides from payload if any normalization settings are passed
+ # For now, just use base settings as in original code (presumably)
+
+ apostrophe_config = build_apostrophe_config(settings=base_settings)
+ try:
+ normalized_text = normalize_for_pipeline(sample_text, config=apostrophe_config, settings=base_settings)
+ except Exception as exc:
+ return jsonify({"error": str(exc)}), 400
+
+ return jsonify({
+ "text": sample_text,
+ "normalized_text": normalized_text,
+ })
+
+@api_bp.post("/entity-pronunciation/preview")
+def api_entity_pronunciation_preview() -> ResponseReturnValue:
+ payload = request.get_json(force=True, silent=True) or {}
+ token = payload.get("token", "").strip()
+ pronunciation = payload.get("pronunciation", "").strip()
+ voice = payload.get("voice", "").strip()
+ language = payload.get("language", "a").strip()
+
+ if not token and not pronunciation:
+ return jsonify({"error": "Token or pronunciation required"}), 400
+
+ text_to_speak = pronunciation if pronunciation else token
+
+ if not voice:
+ settings = load_settings()
+ voice = settings.get("default_voice", "af_heart")
+
+ try:
+ # Check GPU setting
+ settings = load_settings()
+ use_gpu = coerce_bool(settings.get("use_gpu"), False)
+
+ audio_bytes = generate_preview_audio(
+ text=text_to_speak,
+ voice_spec=voice,
+ language=language,
+ speed=1.0,
+ use_gpu=use_gpu,
+ )
+ audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
+ return jsonify({"audio_base64": audio_base64})
+ except Exception as e:
+ return jsonify({"error": str(e)}), 400
diff --git a/abogen/webui/routes/books.py b/abogen/webui/routes/books.py
new file mode 100644
index 0000000..e0bfa51
--- /dev/null
+++ b/abogen/webui/routes/books.py
@@ -0,0 +1,34 @@
+from typing import Any, Dict
+
+from flask import Blueprint, render_template
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.routes.utils.settings import (
+ load_settings,
+ load_integration_settings,
+)
+from abogen.webui.routes.utils.voice import template_options
+
+books_bp = Blueprint("books", __name__)
+
+def _calibre_integration_enabled(integrations: Dict[str, Any]) -> bool:
+ calibre = integrations.get("calibre_opds", {})
+ return bool(calibre.get("enabled") and calibre.get("base_url"))
+
+@books_bp.get("/")
+def find_books_page() -> ResponseReturnValue:
+ settings = load_settings()
+ integrations = load_integration_settings()
+ return render_template(
+ "find_books.html",
+ integrations=integrations,
+ opds_available=_calibre_integration_enabled(integrations),
+ options=template_options(),
+ settings=settings,
+ )
+
+@books_bp.get("/search")
+def search_books() -> ResponseReturnValue:
+ return find_books_page()
+
+
diff --git a/abogen/webui/routes/entities.py b/abogen/webui/routes/entities.py
new file mode 100644
index 0000000..44bd420
--- /dev/null
+++ b/abogen/webui/routes/entities.py
@@ -0,0 +1,175 @@
+from typing import Mapping
+from flask import Blueprint, request, jsonify, abort, render_template, redirect, url_for
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.routes.utils.service import require_pending_job, get_service
+from abogen.webui.routes.utils.entity import (
+ refresh_entity_summary,
+ pending_entities_payload,
+ upsert_manual_override,
+ delete_manual_override,
+ search_manual_override_candidates,
+)
+from abogen.webui.routes.utils.settings import coerce_int, load_settings
+from abogen.webui.routes.utils.voice import template_options
+from abogen.pronunciation_store import (
+ delete_override as delete_pronunciation_override,
+ save_override as save_pronunciation_override,
+ get_override_stats,
+ all_overrides,
+)
+
+entities_bp = Blueprint("entities", __name__)
+
+@entities_bp.post("/analyze")
+def analyze_entities() -> ResponseReturnValue:
+ # This might be triggered via wizard update, but if there's a specific route:
+ # In original routes.py, it was likely part of wizard logic or API.
+ # I'll assume this is for the API endpoint /api/pending//entities/refresh
+ pending_id = request.form.get("pending_id") or request.args.get("pending_id")
+ if not pending_id:
+ abort(400, "Pending ID required")
+
+ pending = require_pending_job(pending_id)
+ refresh_entity_summary(pending, pending.chapters)
+ get_service().store_pending_job(pending)
+ return jsonify(pending_entities_payload(pending))
+
+@entities_bp.get("/pending/")
+def get_entities(pending_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ refresh_flag = (request.args.get("refresh") or "").strip().lower()
+ expected_cache = (request.args.get("cache_key") or "").strip()
+ refresh_requested = refresh_flag in {"1", "true", "yes", "force"}
+
+ if expected_cache and expected_cache != (pending.entity_cache_key or ""):
+ refresh_requested = True
+
+ if refresh_requested or not pending.entity_summary:
+ refresh_entity_summary(pending, pending.chapters)
+ get_service().store_pending_job(pending)
+
+ return jsonify(pending_entities_payload(pending))
+
+@entities_bp.post("/pending//refresh")
+def refresh_entities(pending_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ refresh_entity_summary(pending, pending.chapters)
+ get_service().store_pending_job(pending)
+ return jsonify(pending_entities_payload(pending))
+
+@entities_bp.get("/pending//overrides")
+def list_manual_overrides(pending_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ return jsonify({
+ "overrides": pending.manual_overrides or [],
+ "pronunciation_overrides": pending.pronunciation_overrides or [],
+ "heteronym_overrides": getattr(pending, "heteronym_overrides", None) or [],
+ "language": pending.language or "en",
+ })
+
+@entities_bp.post("/pending//overrides")
+def upsert_override(pending_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ payload = request.get_json(silent=True) or {}
+ if not isinstance(payload, Mapping):
+ abort(400, "Invalid override payload")
+
+ try:
+ override = upsert_manual_override(pending, payload)
+ except ValueError as exc:
+ abort(400, str(exc))
+
+ get_service().store_pending_job(pending)
+ return jsonify({"override": override, **pending_entities_payload(pending)})
+
+@entities_bp.delete("/pending//overrides/")
+def delete_override(pending_id: str, override_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ deleted = delete_manual_override(pending, override_id)
+ if not deleted:
+ abort(404)
+
+ get_service().store_pending_job(pending)
+ return jsonify({"deleted": True, **pending_entities_payload(pending)})
+
+@entities_bp.get("/pending//overrides/search")
+def search_candidates(pending_id: str) -> ResponseReturnValue:
+ pending = require_pending_job(pending_id)
+ query = (request.args.get("q") or request.args.get("query") or "").strip()
+ limit_param = request.args.get("limit")
+ limit_value = coerce_int(limit_param, 15, minimum=1, maximum=50) if limit_param is not None else 15
+
+ results = search_manual_override_candidates(pending, query, limit=limit_value)
+ return jsonify({"query": query, "limit": limit_value, "results": results})
+
+@entities_bp.post("/overrides")
+def upsert_global_override() -> ResponseReturnValue:
+ payload = request.form
+ action = payload.get("action", "save")
+ lang = payload.get("lang", "en")
+ token = payload.get("token", "").strip()
+
+ if action == "delete":
+ if token:
+ delete_pronunciation_override(token=token, language=lang)
+ else:
+ pronunciation = payload.get("pronunciation", "").strip()
+ voice = payload.get("voice", "").strip()
+ if token:
+ save_pronunciation_override(
+ token=token,
+ pronunciation=pronunciation,
+ voice=voice or None,
+ language=lang
+ )
+
+ return redirect(url_for("entities.entities_page", lang=lang))
+
+@entities_bp.get("/")
+def entities_page() -> str:
+ settings = load_settings()
+ lang = request.args.get("lang") or settings.get("language", "en")
+ voice_filter = request.args.get("voice", "")
+ pronunciation_filter = request.args.get("pronunciation", "")
+
+ options = template_options()
+ stats = get_override_stats(lang)
+
+ overrides = all_overrides(lang)
+
+ if voice_filter == "assigned":
+ overrides = [o for o in overrides if o.get("voice")]
+ elif voice_filter == "unassigned":
+ overrides = [o for o in overrides if not o.get("voice")]
+
+ if pronunciation_filter == "defined":
+ overrides = [o for o in overrides if o.get("pronunciation")]
+ elif pronunciation_filter == "undefined":
+ overrides = [o for o in overrides if not o.get("pronunciation")]
+
+ voice_filter_options = [
+ {"value": "", "label": "All voices"},
+ {"value": "assigned", "label": "Assigned"},
+ {"value": "unassigned", "label": "Unassigned"},
+ ]
+ pronunciation_filter_options = [
+ {"value": "", "label": "All pronunciations"},
+ {"value": "defined", "label": "Defined"},
+ {"value": "undefined", "label": "Undefined"},
+ ]
+
+ language_label = options["languages"].get(lang, lang)
+ return render_template(
+ "entities.html",
+ language=lang,
+ language_label=language_label,
+ options=options,
+ languages=options["languages"].items(),
+ stats=stats,
+ overrides=overrides,
+ voice_filter=voice_filter,
+ pronunciation_filter=pronunciation_filter,
+ voice_filter_options=voice_filter_options,
+ pronunciation_filter_options=pronunciation_filter_options,
+ )
diff --git a/abogen/webui/routes/jobs.py b/abogen/webui/routes/jobs.py
new file mode 100644
index 0000000..545db76
--- /dev/null
+++ b/abogen/webui/routes/jobs.py
@@ -0,0 +1,305 @@
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from flask import Blueprint, Response, abort, redirect, render_template, request, url_for, send_file
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.service import (
+ JobStatus,
+ load_audiobookshelf_chapters,
+ build_audiobookshelf_metadata,
+)
+from abogen.webui.routes.utils.service import get_service
+from abogen.webui.routes.utils.form import render_jobs_panel
+from abogen.webui.routes.utils.voice import template_options
+from abogen.webui.routes.utils.epub import (
+ job_download_flags,
+ locate_job_epub,
+ locate_job_audio,
+)
+from abogen.webui.routes.utils.settings import (
+ stored_integration_config,
+ build_audiobookshelf_config,
+ coerce_bool,
+)
+from abogen.webui.routes.utils.common import existing_paths
+from abogen.integrations.audiobookshelf import AudiobookshelfClient, AudiobookshelfUploadError
+
+logger = logging.getLogger(__name__)
+
+jobs_bp = Blueprint("jobs", __name__)
+
+@jobs_bp.get("/")
+def job_detail(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job:
+ # Return a friendly page instead of 404 to avoid confusion from stale browser tabs
+ return render_template("job_not_found.html"), 200
+ return render_template(
+ "job_detail.html",
+ job=job,
+ options=template_options(),
+ JobStatus=JobStatus,
+ downloads=job_download_flags(job),
+ )
+
+@jobs_bp.post("//pause")
+def pause_job(job_id: str) -> ResponseReturnValue:
+ get_service().pause(job_id)
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("jobs.job_detail", job_id=job_id))
+
+@jobs_bp.post("//resume")
+def resume_job(job_id: str) -> ResponseReturnValue:
+ get_service().resume(job_id)
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("jobs.job_detail", job_id=job_id))
+
+@jobs_bp.post("//cancel")
+def cancel_job(job_id: str) -> ResponseReturnValue:
+ get_service().cancel(job_id)
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("jobs.job_detail", job_id=job_id))
+
+@jobs_bp.post("//delete")
+def delete_job(job_id: str) -> ResponseReturnValue:
+ get_service().delete(job_id)
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("main.index"))
+
+@jobs_bp.post("//retry")
+def retry_job(job_id: str) -> ResponseReturnValue:
+ new_job = get_service().retry(job_id)
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ if new_job:
+ return redirect(url_for("jobs.job_detail", job_id=new_job.id))
+ return redirect(url_for("jobs.job_detail", job_id=job_id))
+
+@jobs_bp.post("//audiobookshelf")
+def send_job_to_audiobookshelf(job_id: str) -> ResponseReturnValue:
+ service = get_service()
+ job = service.get_job(job_id)
+ if job is None:
+ abort(404)
+
+ def _panel_response() -> ResponseReturnValue:
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("jobs.job_detail", job_id=job.id))
+
+ if job.status != JobStatus.COMPLETED:
+ return _panel_response()
+
+ settings = stored_integration_config("audiobookshelf")
+ if not settings or not coerce_bool(settings.get("enabled"), False):
+ job.add_log("Audiobookshelf upload skipped: integration is disabled.", level="warning")
+ service._persist_state()
+ return _panel_response()
+
+ config = build_audiobookshelf_config(settings)
+ if config is None:
+ job.add_log(
+ "Audiobookshelf upload skipped: configure base URL, API token, and library ID first.",
+ level="warning",
+ )
+ service._persist_state()
+ return _panel_response()
+ if not config.folder_id:
+ job.add_log(
+ "Audiobookshelf upload skipped: enter the folder name or ID in the Audiobookshelf settings.",
+ level="warning",
+ )
+ service._persist_state()
+ return _panel_response()
+
+ audio_path = locate_job_audio(job)
+ if not audio_path or not audio_path.exists():
+ job.add_log("Audiobookshelf upload skipped: audio output not found.", level="warning")
+ service._persist_state()
+ return _panel_response()
+
+ cover_path = None
+ if config.send_cover and job.cover_image_path:
+ cover_candidate = job.cover_image_path
+ if not isinstance(cover_candidate, Path):
+ cover_candidate = Path(str(cover_candidate))
+ if cover_candidate.exists():
+ cover_path = cover_candidate
+
+ subtitles = existing_paths(job.result.subtitle_paths) if config.send_subtitles else None
+ chapters = load_audiobookshelf_chapters(job) if config.send_chapters else None
+ metadata = build_audiobookshelf_metadata(job)
+ display_title = metadata.get("title") or audio_path.stem
+ overwrite_requested = request.form.get("overwrite") == "true" or request.args.get("overwrite") == "true"
+
+ try:
+ client = AudiobookshelfClient(config)
+ except ValueError as exc:
+ job.add_log(f"Audiobookshelf configuration error: {exc}", level="error")
+ service._persist_state()
+ return _panel_response()
+
+ try:
+ existing_items = client.find_existing_items(display_title, folder_id=config.folder_id)
+ except AudiobookshelfUploadError as exc:
+ job.add_log(f"Audiobookshelf lookup failed: {exc}", level="error")
+ service._persist_state()
+ return _panel_response()
+
+ if existing_items and not overwrite_requested:
+ job.add_log(
+ f"Audiobookshelf already contains '{display_title}'. Awaiting overwrite confirmation.",
+ level="warning",
+ )
+ service._persist_state()
+ if request.headers.get("HX-Request"):
+ detail = {
+ "jobId": job.id,
+ "title": display_title,
+ "url": url_for("jobs.send_job_to_audiobookshelf", job_id=job.id),
+ "target": request.headers.get("HX-Target") or "#jobs-panel",
+ "message": f'Audiobookshelf already contains "{display_title}". Overwrite?',
+ }
+ headers = {"HX-Trigger": json.dumps({"audiobookshelf-overwrite-prompt": detail})}
+ return Response("", status=204, headers=headers)
+ return _panel_response()
+
+ if existing_items and overwrite_requested:
+ try:
+ client.delete_items(existing_items)
+ except AudiobookshelfUploadError as exc:
+ job.add_log(f"Audiobookshelf overwrite aborted: {exc}", level="error")
+ service._persist_state()
+ return _panel_response()
+ else:
+ job.add_log(
+ f"Removed {len(existing_items)} existing Audiobookshelf item(s) prior to overwrite.",
+ level="info",
+ )
+
+ job.add_log("Audiobookshelf upload triggered manually.", level="info")
+ try:
+ client.upload_audiobook(
+ audio_path,
+ metadata=metadata,
+ cover_path=cover_path,
+ chapters=chapters,
+ subtitles=subtitles,
+ )
+ except AudiobookshelfUploadError as exc:
+ job.add_log(f"Audiobookshelf upload failed: {exc}", level="error")
+ except Exception as exc:
+ job.add_log(f"Audiobookshelf integration error: {exc}", level="error")
+ else:
+ job.add_log("Audiobookshelf upload queued.", level="success")
+ finally:
+ service._persist_state()
+
+ return _panel_response()
+
+@jobs_bp.post("/clear-finished")
+def clear_finished_jobs() -> ResponseReturnValue:
+ get_service().clear_finished()
+ if request.headers.get("HX-Request"):
+ return render_jobs_panel()
+ return redirect(url_for("main.index", _anchor="queue"))
+
+@jobs_bp.get("//epub")
+def job_epub(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if job is None or job.status != JobStatus.COMPLETED:
+ abort(404)
+ epub_path = locate_job_epub(job)
+ if not epub_path:
+ abort(404)
+ return send_file(
+ epub_path,
+ as_attachment=True,
+ download_name=epub_path.name,
+ mimetype="application/epub+zip",
+ )
+
+@jobs_bp.get("//download/")
+def download_file(job_id: str, file_type: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job or job.status != JobStatus.COMPLETED:
+ abort(404)
+
+ if file_type == "audio":
+ path = locate_job_audio(job)
+ if not path or not path.exists():
+ abort(404)
+ return send_file(
+ path,
+ as_attachment=True,
+ download_name=path.name,
+ )
+
+ # Handle other file types if needed (subtitles, etc.)
+ # For now, just audio and epub are explicitly handled
+ abort(404)
+
+@jobs_bp.get("//logs")
+def job_logs(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job:
+ # Return a simple page instead of 404 to avoid log spam from stale browser tabs
+ return render_template("job_logs_missing.html"), 200
+ return render_template("job_logs_static.html", job=job)
+
+
+@jobs_bp.get("//logs/partial")
+def job_logs_partial(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job:
+ # Return a non-polling section so HTMX stops retrying.
+ return render_template("partials/logs_section_missing.html"), 200
+ return render_template("partials/logs_section.html", job=job)
+
+@jobs_bp.get("//logs/stream")
+def stream_logs(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job:
+ abort(404)
+
+ def generate():
+ last_index = 0
+ while True:
+ current_logs = job.logs
+ if len(current_logs) > last_index:
+ for log in current_logs[last_index:]:
+ yield f"data: {json.dumps({'timestamp': log.timestamp, 'level': log.level, 'message': log.message})}\n\n"
+ last_index = len(current_logs)
+
+ if job.status in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+ break
+
+ import time
+ time.sleep(0.5)
+
+ return Response(generate(), mimetype="text/event-stream")
+
+@jobs_bp.get("//reader")
+def job_reader(job_id: str) -> ResponseReturnValue:
+ job = get_service().get_job(job_id)
+ if not job:
+ abort(404)
+ return render_template("reader_embed.html", job=job)
+
+@jobs_bp.get("/queue")
+def queue_page() -> str:
+ return render_template(
+ "queue.html",
+ jobs_panel=render_jobs_panel(),
+ )
+
+@jobs_bp.get("/partial")
+def jobs_partial() -> str:
+ return render_jobs_panel()
diff --git a/abogen/webui/routes/main.py b/abogen/webui/routes/main.py
new file mode 100644
index 0000000..f01b752
--- /dev/null
+++ b/abogen/webui/routes/main.py
@@ -0,0 +1,388 @@
+import logging
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Dict, Optional, cast
+
+from flask import Blueprint, redirect, render_template, request, url_for, jsonify, current_app
+from werkzeug.utils import secure_filename
+
+from abogen.webui.service import PendingJob, JobStatus
+from abogen.webui.routes.utils.service import get_service, remove_pending_job, submit_job
+from abogen.webui.routes.utils.settings import load_settings
+from abogen.webui.routes.utils.voice import template_options
+from abogen.webui.routes.utils.form import (
+ normalize_wizard_step,
+ wants_wizard_json,
+ render_wizard_partial,
+ wizard_json_response,
+ build_pending_job_from_extraction,
+ apply_book_step_form,
+ apply_prepare_form,
+ render_jobs_panel,
+)
+from abogen.text_extractor import extract_from_path
+from abogen.voice_profiles import serialize_profiles
+
+logger = logging.getLogger(__name__)
+
+main_bp = Blueprint("main", __name__)
+
+@main_bp.app_template_filter("datetimeformat")
+def datetimeformat(value: float, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
+ if not value:
+ return "—"
+ from datetime import datetime
+ return datetime.fromtimestamp(value).strftime(fmt)
+
+@main_bp.app_template_filter("durationformat")
+def durationformat(value: Optional[float]) -> str:
+ if value is None:
+ return ""
+ seconds = int(value)
+ if seconds < 60:
+ return f"{seconds}s"
+ minutes = seconds // 60
+ seconds = seconds % 60
+ if minutes < 60:
+ return f"{minutes}m {seconds}s"
+ hours = minutes // 60
+ minutes = minutes % 60
+ return f"{hours}h {minutes}m"
+
+@main_bp.route("/")
+def index():
+ pending_id = request.args.get("pending_id")
+ pending = get_service().get_pending_job(pending_id) if pending_id else None
+
+ # If we have a pending job, redirect to the wizard
+ if pending:
+ step_index = getattr(pending, "wizard_max_step_index", 0)
+ # Map index to step name roughly
+ steps = ["book", "chapters", "entities"]
+ step_name = steps[min(step_index, len(steps)-1)]
+ return redirect(url_for("main.wizard_step", step=step_name, pending_id=pending.id))
+
+ jobs = get_service().list_jobs()
+ stats = {
+ "total": len(jobs),
+ "completed": sum(1 for j in jobs if j.status == JobStatus.COMPLETED),
+ "running": sum(1 for j in jobs if j.status == JobStatus.RUNNING),
+ "pending": sum(1 for j in jobs if j.status == JobStatus.PENDING),
+ "failed": sum(1 for j in jobs if j.status == JobStatus.FAILED),
+ }
+
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=load_settings(),
+ jobs_panel=render_jobs_panel(),
+ stats=stats,
+ )
+
+@main_bp.route("/wizard")
+def wizard_start():
+ pending_id = request.args.get("pending_id")
+ step = request.args.get("step", "book")
+ if pending_id:
+ return redirect(url_for("main.wizard_step", step=step, pending_id=pending_id))
+ return redirect(url_for("main.wizard_step", step=step))
+
+@main_bp.route("/wizard/")
+def wizard_step(step: str):
+ pending_id = request.args.get("pending_id")
+ pending = get_service().get_pending_job(pending_id) if pending_id else None
+
+ normalized_step = normalize_wizard_step(step, pending)
+ if normalized_step != step:
+ return redirect(url_for("main.wizard_step", step=normalized_step, pending_id=pending_id))
+
+ if wants_wizard_json():
+ return wizard_json_response(pending, normalized_step)
+
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=load_settings(),
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step=normalized_step,
+ wizard_partial=render_wizard_partial(pending, normalized_step),
+ )
+
+@main_bp.route("/wizard/upload", methods=["POST"])
+def wizard_upload():
+ pending_id = request.form.get("pending_id")
+ pending = get_service().get_pending_job(pending_id) if pending_id else None
+
+ file = request.files.get("file") or request.files.get("source_file")
+
+ settings = load_settings()
+ profiles = serialize_profiles()
+
+ # Case 1: Updating existing job without new file
+ if pending and (not file or not file.filename):
+ try:
+ apply_book_step_form(pending, request.form, settings=settings, profiles=profiles)
+ get_service().store_pending_job(pending)
+
+ if wants_wizard_json():
+ return wizard_json_response(pending, "chapters")
+ return redirect(url_for("main.wizard_step", step="chapters", pending_id=pending.id))
+ except Exception as e:
+ logger.exception("Error updating job settings")
+ error_msg = f"Failed to update settings: {str(e)}"
+ if wants_wizard_json():
+ return wizard_json_response(pending, "book", error=error_msg, status=500)
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=settings,
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step="book",
+ wizard_partial=render_wizard_partial(pending, "book", error=error_msg),
+ )
+
+ # Case 2: New file upload (or replacing file on existing job)
+ if not file or not file.filename:
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error="No file selected", status=400)
+ return redirect(url_for("main.wizard_step", step="book"))
+
+ filename = secure_filename(file.filename)
+ temp_dir = Path(current_app.config.get("UPLOAD_FOLDER", "uploads"))
+ temp_dir.mkdir(exist_ok=True)
+ file_path = temp_dir / f"{uuid.uuid4().hex}_{filename}"
+ file.save(file_path)
+
+ try:
+ extraction = extract_from_path(file_path)
+
+ result = build_pending_job_from_extraction(
+ stored_path=file_path,
+ original_name=filename,
+ extraction=extraction,
+ form=request.form,
+ settings=settings,
+ profiles=profiles,
+ )
+
+ # If we had a pending job, we might want to preserve its ID or other properties,
+ # but for a new file it's safer to start fresh with the new extraction.
+ # The frontend will handle the ID change via the redirect.
+
+ get_service().store_pending_job(result.pending)
+
+ if wants_wizard_json():
+ return wizard_json_response(result.pending, "chapters")
+
+ return redirect(url_for("main.wizard_step", step="chapters", pending_id=result.pending.id))
+
+ except Exception as e:
+ logger.exception("Error processing upload")
+ if file_path.exists():
+ try:
+ file_path.unlink()
+ except OSError:
+ pass
+
+ error_msg = f"Failed to process file: {str(e)}"
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error=error_msg, status=500)
+
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=settings,
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step="book",
+ wizard_partial=render_wizard_partial(None, "book", error=error_msg),
+ )
+
+@main_bp.route("/wizard/text", methods=["POST"])
+def wizard_text():
+ text = request.form.get("text", "").strip()
+ title = request.form.get("title", "").strip() or "Pasted Text"
+
+ if not text:
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error="No text provided", status=400)
+ return redirect(url_for("main.wizard_step", step="book"))
+
+ temp_dir = Path(current_app.config.get("UPLOAD_FOLDER", "uploads"))
+ temp_dir.mkdir(exist_ok=True)
+ file_path = temp_dir / f"{uuid.uuid4().hex}.txt"
+ file_path.write_text(text, encoding="utf-8")
+
+ settings = load_settings()
+ profiles = serialize_profiles()
+
+ try:
+ extraction = extract_from_path(file_path)
+ # Override title since text extraction might not find one
+ extraction.metadata["title"] = title
+
+ result = build_pending_job_from_extraction(
+ stored_path=file_path,
+ original_name=f"{title}.txt",
+ extraction=extraction,
+ form=request.form,
+ settings=settings,
+ profiles=profiles,
+ )
+
+ get_service().store_pending_job(result.pending)
+
+ if wants_wizard_json():
+ return wizard_json_response(result.pending, "chapters")
+
+ return redirect(url_for("main.wizard_step", step="chapters", pending_id=result.pending.id))
+
+ except Exception as e:
+ logger.exception("Error processing text")
+ if file_path.exists():
+ try:
+ file_path.unlink()
+ except OSError:
+ pass
+
+ error_msg = f"Failed to process text: {str(e)}"
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error=error_msg, status=500)
+
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=settings,
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step="book",
+ wizard_partial=render_wizard_partial(None, "book", error=error_msg),
+ )
+
+@main_bp.route("/wizard/update", methods=["POST"])
+def wizard_update():
+ pending_id = request.values.get("pending_id")
+ if not pending_id:
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error="Missing job ID", status=400)
+ return redirect(url_for("main.wizard_step", step="book"))
+
+ pending = get_service().get_pending_job(pending_id)
+ if not pending:
+ if wants_wizard_json():
+ return wizard_json_response(None, "book", error="Job expired or not found", status=404)
+ return redirect(url_for("main.wizard_step", step="book"))
+
+ current_step = request.form.get("step", "book")
+ next_step = request.form.get("next_step")
+
+ settings = load_settings()
+ profiles = serialize_profiles()
+
+ try:
+ if current_step == "book":
+ apply_book_step_form(pending, request.form, settings=settings, profiles=profiles)
+ target_step = next_step or "chapters"
+
+ elif current_step == "chapters":
+ # This step involves re-analyzing chunks if needed
+ (
+ chunk_level,
+ overrides,
+ enabled_overrides,
+ errors,
+ selected_total,
+ selected_config,
+ apply_config_requested,
+ persist_config_requested,
+ ) = apply_prepare_form(pending, request.form)
+
+ if errors:
+ if wants_wizard_json():
+ return wizard_json_response(pending, current_step, error="\n".join(errors), status=400)
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=settings,
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step=current_step,
+ wizard_partial=render_wizard_partial(pending, current_step, error="\n".join(errors)),
+ )
+
+ target_step = next_step or "entities"
+
+ elif current_step == "entities":
+ # Just saving entity overrides
+ apply_prepare_form(pending, request.form)
+ target_step = next_step or "entities" # Stay or finish
+
+ else:
+ target_step = "book"
+
+ get_service().store_pending_job(pending)
+
+ if wants_wizard_json():
+ return wizard_json_response(pending, target_step)
+
+ return redirect(url_for("main.wizard_step", step=target_step, pending_id=pending.id))
+
+ except Exception as e:
+ logger.exception(f"Error updating wizard step {current_step}")
+ error_msg = f"Update failed: {str(e)}"
+ if wants_wizard_json():
+ return wizard_json_response(pending, current_step, error=error_msg, status=500)
+
+ return render_template(
+ "index.html",
+ options=template_options(),
+ settings=settings,
+ jobs_panel=render_jobs_panel(),
+ wizard_mode=True,
+ wizard_step=current_step,
+ wizard_partial=render_wizard_partial(pending, current_step, error=error_msg),
+ )
+
+@main_bp.route("/wizard/cancel", methods=["POST"])
+def wizard_cancel():
+ pending_id = request.values.get("pending_id")
+ if pending_id:
+ remove_pending_job(pending_id)
+
+ if wants_wizard_json():
+ return jsonify({"status": "cancelled", "redirect_url": url_for("main.index")})
+
+ return redirect(url_for("main.index"))
+
+@main_bp.route("/wizard/finish", methods=["POST"])
+def wizard_finish():
+ pending_id = request.values.get("pending_id")
+ if not pending_id:
+ if wants_wizard_json():
+ return jsonify({"error": "Missing job ID"}), 400
+ return redirect(url_for("main.index"))
+
+ pending = get_service().get_pending_job(pending_id)
+ if not pending:
+ if wants_wizard_json():
+ return jsonify({"error": "Job not found"}), 404
+ return redirect(url_for("main.index"))
+
+ # Final update from form
+ apply_prepare_form(pending, request.form)
+
+ # Submit job
+ job_id = submit_job(pending)
+
+ if wants_wizard_json():
+ return jsonify({
+ "status": "submitted",
+ "job_id": job_id,
+ "redirect_url": url_for("main.index"),
+ "jobs_panel": render_jobs_panel()
+ })
+
+ return redirect(url_for("main.index"))
diff --git a/abogen/webui/routes/settings.py b/abogen/webui/routes/settings.py
new file mode 100644
index 0000000..d0bb991
--- /dev/null
+++ b/abogen/webui/routes/settings.py
@@ -0,0 +1,296 @@
+from pathlib import Path
+
+from collections.abc import Mapping
+from typing import Any
+
+from flask import Blueprint, current_app, render_template, request, redirect, url_for, flash, send_file, abort
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.routes.utils.settings import (
+ load_settings,
+ load_integration_settings,
+ save_settings,
+ stored_integration_config,
+ coerce_bool,
+ coerce_int,
+ SAVE_MODE_LABELS,
+ llm_ready,
+ _NORMALIZATION_BOOLEAN_KEYS,
+ _NORMALIZATION_STRING_KEYS,
+ _DEFAULT_ANALYSIS_THRESHOLD,
+)
+from abogen.webui.routes.utils.voice import template_options
+from abogen.webui.debug_tts_runner import run_debug_tts_wavs
+from abogen.debug_tts_samples import DEBUG_TTS_SAMPLES
+from abogen.utils import get_user_output_path, load_config
+
+settings_bp = Blueprint("settings", __name__)
+
+_NORMALIZATION_SAMPLES = {
+ "apostrophes": "It's a beautiful day, isn't it? 'Yes,' she said, 'it is.'",
+ "currency": "The price is $10.50, but it was £8.00 yesterday.",
+ "dates": "On 2023-01-01, we celebrated the new year.",
+ "numbers": "There are 123 apples and 456 oranges.",
+ "abbreviations": "Dr. Smith lives on Elm St. near the U.S. border.",
+}
+
+@settings_bp.post("/update")
+def update_settings() -> ResponseReturnValue:
+ current = load_settings()
+ form = request.form
+
+ # General settings
+ current["language"] = (form.get("language") or "en").strip()
+ current["default_speaker"] = (form.get("default_speaker") or "").strip()
+ current["default_voice"] = (form.get("default_voice") or "").strip()
+ try:
+ current["supertonic_total_steps"] = max(2, min(15, int(form.get("supertonic_total_steps", current.get("supertonic_total_steps", 5)))))
+ except (TypeError, ValueError):
+ pass
+ try:
+ current["supertonic_speed"] = max(0.7, min(2.0, float(form.get("supertonic_speed", current.get("supertonic_speed", 1.0)))))
+ except (TypeError, ValueError):
+ pass
+ current["output_format"] = (form.get("output_format") or "mp3").strip()
+ current["subtitle_mode"] = (form.get("subtitle_mode") or "Disabled").strip()
+ current["subtitle_format"] = (form.get("subtitle_format") or "srt").strip()
+ current["save_mode"] = (form.get("save_mode") or "save_next_to_input").strip()
+
+ current["replace_single_newlines"] = coerce_bool(form.get("replace_single_newlines"), False)
+ current["use_gpu"] = coerce_bool(form.get("use_gpu"), False)
+ current["save_chapters_separately"] = coerce_bool(form.get("save_chapters_separately"), False)
+ current["merge_chapters_at_end"] = coerce_bool(form.get("merge_chapters_at_end"), True)
+ current["save_as_project"] = coerce_bool(form.get("save_as_project"), False)
+ current["separate_chapters_format"] = (form.get("separate_chapters_format") or "wav").strip()
+
+ try:
+ current["silence_between_chapters"] = max(0.0, float(form.get("silence_between_chapters", 2.0)))
+ except ValueError:
+ pass
+
+ try:
+ current["chapter_intro_delay"] = max(0.0, float(form.get("chapter_intro_delay", 0.5)))
+ except ValueError:
+ pass
+
+ current["read_title_intro"] = coerce_bool(form.get("read_title_intro"), False)
+ current["read_closing_outro"] = coerce_bool(form.get("read_closing_outro"), True)
+ current["normalize_chapter_opening_caps"] = coerce_bool(form.get("normalize_chapter_opening_caps"), True)
+ current["auto_prefix_chapter_titles"] = coerce_bool(form.get("auto_prefix_chapter_titles"), True)
+
+ try:
+ current["max_subtitle_words"] = max(1, int(form.get("max_subtitle_words", 50)))
+ except ValueError:
+ pass
+
+ current["chunk_level"] = (form.get("chunk_level") or "paragraph").strip()
+ current["generate_epub3"] = coerce_bool(form.get("generate_epub3"), False)
+
+ current["speaker_analysis_threshold"] = coerce_int(
+ form.get("speaker_analysis_threshold"),
+ _DEFAULT_ANALYSIS_THRESHOLD,
+ minimum=1,
+ maximum=25,
+ )
+
+ def _extract_checkbox(name: str, default: bool) -> bool:
+ values = form.getlist(name) if hasattr(form, "getlist") else []
+ if values:
+ return coerce_bool(values[-1], default)
+ if hasattr(form, "__contains__") and name in form:
+ return False
+ return default
+
+ # Normalization settings
+ for key in _NORMALIZATION_BOOLEAN_KEYS:
+ current[key] = _extract_checkbox(key, bool(current.get(key, True)))
+ for key in _NORMALIZATION_STRING_KEYS:
+ if hasattr(form, "__contains__") and key in form:
+ current[key] = (form.get(key) or "").strip()
+
+ # Integrations
+ # `load_settings()` returns only the general settings subset and intentionally
+ # does not include stored integrations. Seed them from the stored config so
+ # saving unrelated settings cannot wipe credentials/tokens.
+ current_integrations: dict[str, dict[str, Any]] = {}
+ cfg = load_config() or {}
+ stored_integrations = cfg.get("integrations")
+ if isinstance(stored_integrations, Mapping):
+ for name, payload in stored_integrations.items():
+ if isinstance(name, str) and isinstance(payload, Mapping):
+ current_integrations[name] = dict(payload)
+ # Ensure known integrations are loaded even if the config is still in legacy format.
+ for name in ("audiobookshelf", "calibre_opds"):
+ stored = stored_integration_config(name)
+ if stored and name not in current_integrations:
+ current_integrations[name] = dict(stored)
+ current["integrations"] = current_integrations
+
+ # Audiobookshelf
+ abs_enabled = coerce_bool(form.get("audiobookshelf_enabled"), False)
+ abs_url = (form.get("audiobookshelf_base_url") or "").strip()
+ abs_token = (form.get("audiobookshelf_api_token") or "").strip()
+ abs_library = (form.get("audiobookshelf_library_id") or "").strip()
+ abs_folder = (form.get("audiobookshelf_folder_id") or "").strip()
+ abs_verify = coerce_bool(form.get("audiobookshelf_verify_ssl"), True)
+ abs_auto_send = coerce_bool(form.get("audiobookshelf_auto_send"), False)
+ abs_cover = coerce_bool(form.get("audiobookshelf_send_cover"), True)
+ abs_chapters = coerce_bool(form.get("audiobookshelf_send_chapters"), True)
+ abs_subtitles = coerce_bool(form.get("audiobookshelf_send_subtitles"), False)
+
+ try:
+ abs_timeout = max(1.0, float(form.get("audiobookshelf_timeout", 30.0)))
+ except ValueError:
+ abs_timeout = 30.0
+
+ # Preserve existing token if not provided and not cleared
+ if not abs_token and not coerce_bool(form.get("audiobookshelf_api_token_clear"), False):
+ existing_abs = current["integrations"].get("audiobookshelf", {})
+ abs_token = existing_abs.get("api_token", "")
+
+ current["integrations"]["audiobookshelf"] = {
+ "enabled": abs_enabled,
+ "base_url": abs_url,
+ "api_token": abs_token,
+ "library_id": abs_library,
+ "folder_id": abs_folder,
+ "verify_ssl": abs_verify,
+ "auto_send": abs_auto_send,
+ "send_cover": abs_cover,
+ "send_chapters": abs_chapters,
+ "send_subtitles": abs_subtitles,
+ "timeout": abs_timeout,
+ }
+
+ # Calibre OPDS
+ calibre_enabled = coerce_bool(form.get("calibre_opds_enabled"), False)
+ calibre_url = (form.get("calibre_opds_base_url") or "").strip()
+ calibre_user = (form.get("calibre_opds_username") or "").strip()
+ calibre_pass = (form.get("calibre_opds_password") or "").strip()
+ calibre_verify = coerce_bool(form.get("calibre_opds_verify_ssl"), True)
+
+ # Preserve existing password if not provided and not cleared
+ if not calibre_pass and not coerce_bool(form.get("calibre_opds_password_clear"), False):
+ existing_calibre = current["integrations"].get("calibre_opds", {})
+ calibre_pass = existing_calibre.get("password", "")
+
+ current["integrations"]["calibre_opds"] = {
+ "enabled": calibre_enabled,
+ "base_url": calibre_url,
+ "username": calibre_user,
+ "password": calibre_pass,
+ "verify_ssl": calibre_verify,
+ }
+
+ save_settings(current)
+ flash("Settings updated successfully.", "success")
+ return redirect(url_for("settings.settings_page"))
+
+@settings_bp.route("/", methods=["GET", "POST"])
+def settings_page() -> str | ResponseReturnValue:
+ if request.method == "POST":
+ return update_settings()
+
+ debug_run_id = (request.args.get("debug_run_id") or "").strip()
+ debug_manifest = None
+ if debug_run_id:
+ run_dir = Path(current_app.config.get("OUTPUT_FOLDER") or get_user_output_path("web")) / "debug" / debug_run_id
+ manifest_path = run_dir / "manifest.json"
+ if manifest_path.exists():
+ try:
+ import json
+
+ debug_manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+ except Exception:
+ debug_manifest = None
+
+ save_locations = [{"value": key, "label": label} for key, label in SAVE_MODE_LABELS.items()]
+ default_output_dir = str(Path(get_user_output_path()).resolve())
+
+ return render_template(
+ "settings.html",
+ settings=load_settings(),
+ integrations=load_integration_settings(),
+ options=template_options(),
+ normalization_samples=_NORMALIZATION_SAMPLES,
+ save_locations=save_locations,
+ default_output_dir=default_output_dir,
+ llm_ready=llm_ready(load_settings()),
+ debug_samples=DEBUG_TTS_SAMPLES,
+ debug_manifest=debug_manifest,
+ )
+
+
+@settings_bp.post("/debug/run")
+def run_debug_wavs() -> ResponseReturnValue:
+ settings = load_settings()
+ output_root = Path(current_app.config.get("OUTPUT_FOLDER") or get_user_output_path("web"))
+ try:
+ manifest = run_debug_tts_wavs(output_root=output_root, settings=settings)
+ except Exception as exc:
+ flash(f"Debug WAV generation failed: {exc}", "error")
+ return redirect(url_for("settings.settings_page", _anchor="debug"))
+
+ flash("Debug WAV generation completed.", "success")
+ return redirect(url_for("settings.debug_wavs_page", run_id=str(manifest.get("run_id") or "")))
+
+
+@settings_bp.get("/debug/")
+def debug_wavs_page(run_id: str) -> ResponseReturnValue:
+ safe_run = (run_id or "").strip()
+ if not safe_run:
+ abort(404)
+
+ root = Path(current_app.config.get("OUTPUT_FOLDER") or get_user_output_path("web"))
+ run_dir = (root / "debug" / safe_run).resolve()
+ manifest_path = run_dir / "manifest.json"
+ if not manifest_path.exists():
+ abort(404)
+
+ try:
+ import json
+
+ manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+ except Exception:
+ abort(404)
+
+ artifacts = manifest.get("artifacts") or []
+ # Precompute download URLs for each artifact.
+ for item in artifacts:
+ filename = str(item.get("filename") or "")
+ item["url"] = url_for("settings.download_debug_wav", run_id=safe_run, filename=filename)
+
+ return render_template(
+ "debug_wavs.html",
+ run_id=safe_run,
+ artifacts=artifacts,
+ )
+
+
+@settings_bp.get("/debug//")
+def download_debug_wav(run_id: str, filename: str) -> ResponseReturnValue:
+ safe_run = (run_id or "").strip()
+ safe_name = (filename or "").strip()
+ if not safe_run or not safe_name or "/" in safe_name or "\\" in safe_name:
+ abort(404)
+ is_wav = safe_name.lower().endswith(".wav")
+ if not is_wav and safe_name != "manifest.json":
+ abort(404)
+
+ root = Path(current_app.config.get("OUTPUT_FOLDER") or get_user_output_path("web"))
+ path = (root / "debug" / safe_run / safe_name).resolve()
+ if not path.exists() or not path.is_file():
+ abort(404)
+ # Ensure path is within root/debug/run_id
+ expected_dir = (root / "debug" / safe_run).resolve()
+ if expected_dir not in path.parents:
+ abort(404)
+ wants_download = str(request.args.get("download") or "").strip().lower() in {"1", "true", "yes"}
+ mimetype = "audio/wav" if is_wav else "application/json"
+ # Inline playback should work for WAVs; allow explicit downloads via ?download=1.
+ return send_file(
+ path,
+ mimetype=mimetype,
+ as_attachment=wants_download,
+ download_name=path.name,
+ )
diff --git a/abogen/webui/routes/utils/common.py b/abogen/webui/routes/utils/common.py
new file mode 100644
index 0000000..d280bdf
--- /dev/null
+++ b/abogen/webui/routes/utils/common.py
@@ -0,0 +1,24 @@
+from typing import Any, Optional, Tuple, Iterable, List
+from pathlib import Path
+
+def split_profile_spec(value: Any) -> Tuple[str, Optional[str]]:
+ text = str(value or "").strip()
+ if not text:
+ return "", None
+ lowered = text.lower()
+ if lowered.startswith("profile:") or lowered.startswith("speaker:"):
+ _, _, remainder = text.partition(":")
+ name = remainder.strip()
+ return "", name or None
+ return text, None
+
+
+def split_speaker_spec(value: Any) -> Tuple[str, Optional[str]]:
+ """Preferred alias for split_profile_spec (supports 'speaker:' and legacy 'profile:')."""
+
+ return split_profile_spec(value)
+
+def existing_paths(paths: Optional[Iterable[Path]]) -> List[Path]:
+ if not paths:
+ return []
+ return [p for p in paths if p.exists()]
diff --git a/abogen/webui/routes/utils/entity.py b/abogen/webui/routes/utils/entity.py
new file mode 100644
index 0000000..f1acfea
--- /dev/null
+++ b/abogen/webui/routes/utils/entity.py
@@ -0,0 +1,363 @@
+import time
+import uuid
+from typing import Any, Dict, Iterable, List, Mapping, Optional
+
+from abogen.webui.service import PendingJob
+from abogen.entity_analysis import (
+ extract_entities,
+ merge_override,
+ normalize_token as normalize_entity_token,
+ normalize_manual_override_token,
+ search_tokens as search_entity_tokens,
+)
+from abogen.pronunciation_store import (
+ delete_override as delete_pronunciation_override,
+ load_overrides as load_pronunciation_overrides,
+ save_override as save_pronunciation_override,
+ search_overrides as search_pronunciation_overrides,
+)
+from abogen.webui.routes.utils.settings import load_settings
+from abogen.heteronym_overrides import extract_heteronym_overrides
+
+def collect_pronunciation_overrides(pending: PendingJob) -> List[Dict[str, Any]]:
+ language = pending.language or "en"
+ collected: Dict[str, Dict[str, Any]] = {}
+
+ summary = pending.entity_summary or {}
+ for group in ("people", "entities"):
+ entries = summary.get(group)
+ if not isinstance(entries, list):
+ continue
+ for entry in entries:
+ if not isinstance(entry, Mapping):
+ continue
+ override_payload = entry.get("override")
+ if not isinstance(override_payload, Mapping):
+ continue
+ token_value = str(entry.get("label") or override_payload.get("token") or "").strip()
+ pronunciation_value = str(override_payload.get("pronunciation") or "").strip()
+ if not token_value or not pronunciation_value:
+ continue
+ normalized = normalize_entity_token(entry.get("normalized") or token_value)
+ if not normalized:
+ continue
+ collected[normalized] = {
+ "token": token_value,
+ "normalized": normalized,
+ "pronunciation": pronunciation_value,
+ "voice": str(override_payload.get("voice") or "").strip() or None,
+ "notes": str(override_payload.get("notes") or "").strip() or None,
+ "context": str(override_payload.get("context") or "").strip() or None,
+ "source": f"{group}-override",
+ "language": language,
+ }
+
+ if isinstance(pending.speakers, Mapping):
+ for speaker_payload in pending.speakers.values():
+ if not isinstance(speaker_payload, Mapping):
+ continue
+ token_value = str(speaker_payload.get("label") or "").strip()
+ pronunciation_value = str(speaker_payload.get("pronunciation") or "").strip()
+ if not token_value or not pronunciation_value:
+ continue
+ normalized = normalize_entity_token(token_value)
+ if not normalized:
+ continue
+ collected[normalized] = {
+ "token": token_value,
+ "normalized": normalized,
+ "pronunciation": pronunciation_value,
+ "voice": str(
+ speaker_payload.get("resolved_voice")
+ or speaker_payload.get("voice")
+ or pending.voice
+ ).strip()
+ or None,
+ "notes": None,
+ "context": None,
+ "source": "speaker",
+ "language": language,
+ }
+
+ for manual_entry in pending.manual_overrides or []:
+ if not isinstance(manual_entry, Mapping):
+ continue
+ token_value = str(manual_entry.get("token") or "").strip()
+ pronunciation_value = str(manual_entry.get("pronunciation") or "").strip()
+ if not token_value or not pronunciation_value:
+ continue
+ normalized = manual_entry.get("normalized") or normalize_manual_override_token(token_value)
+ if not normalized:
+ continue
+ collected[normalized] = {
+ "token": token_value,
+ "normalized": normalized,
+ "pronunciation": pronunciation_value,
+ "voice": str(manual_entry.get("voice") or "").strip() or None,
+ "notes": str(manual_entry.get("notes") or "").strip() or None,
+ "context": str(manual_entry.get("context") or "").strip() or None,
+ "source": str(manual_entry.get("source") or "manual"),
+ "language": language,
+ }
+
+ return list(collected.values())
+
+
+def sync_pronunciation_overrides(pending: PendingJob) -> None:
+ pending.pronunciation_overrides = collect_pronunciation_overrides(pending)
+
+ if not pending.pronunciation_overrides:
+ return
+
+ summary = pending.entity_summary or {}
+ manual_map: Dict[str, Mapping[str, Any]] = {}
+ for override in pending.manual_overrides or []:
+ if not isinstance(override, Mapping):
+ continue
+ normalized = override.get("normalized") or normalize_entity_token(override.get("token") or "")
+ pronunciation_value = str(override.get("pronunciation") or "").strip()
+ if not normalized or not pronunciation_value:
+ continue
+ manual_map[normalized] = override
+ for group in ("people", "entities"):
+ entries = summary.get(group)
+ if not isinstance(entries, list):
+ continue
+ for entry in entries:
+ if not isinstance(entry, dict):
+ continue
+ normalized = normalize_entity_token(entry.get("normalized") or entry.get("label") or "")
+ manual_override = manual_map.get(normalized)
+ if manual_override:
+ entry["override"] = {
+ "token": manual_override.get("token"),
+ "pronunciation": manual_override.get("pronunciation"),
+ "voice": manual_override.get("voice"),
+ "notes": manual_override.get("notes"),
+ "context": manual_override.get("context"),
+ "source": manual_override.get("source"),
+ }
+
+
+def refresh_entity_summary(pending: PendingJob, chapters: Iterable[Mapping[str, Any]]) -> None:
+ settings = load_settings()
+ language = pending.language or "en"
+ chapter_list: List[Mapping[str, Any]] = [chapter for chapter in chapters if isinstance(chapter, Mapping)]
+ if not chapter_list:
+ pending.entity_summary = {}
+ pending.entity_cache_key = ""
+ pending.pronunciation_overrides = pending.pronunciation_overrides or []
+ pending.heteronym_overrides = pending.heteronym_overrides or []
+ return
+
+ enabled_only = [chapter for chapter in chapter_list if chapter.get("enabled")]
+ target_chapters = enabled_only or chapter_list
+
+ # Always compute heteronym overrides (English only). Preserve any prior selections.
+ try:
+ pending.heteronym_overrides = extract_heteronym_overrides(
+ target_chapters,
+ language=language,
+ existing=getattr(pending, "heteronym_overrides", None),
+ )
+ except Exception:
+ pending.heteronym_overrides = getattr(pending, "heteronym_overrides", []) or []
+
+ if not bool(settings.get("enable_entity_recognition", True)):
+ pending.entity_summary = {}
+ pending.entity_cache_key = ""
+ pending.pronunciation_overrides = pending.pronunciation_overrides or []
+ return
+
+ result = extract_entities(target_chapters, language=language)
+ summary = dict(result.summary)
+ tokens: List[str] = []
+ for group in ("people", "entities"):
+ entries = summary.get(group)
+ if not isinstance(entries, list):
+ continue
+ for entry in entries:
+ if not isinstance(entry, Mapping):
+ continue
+ token_value = str(entry.get("normalized") or entry.get("label") or "").strip()
+ if token_value:
+ tokens.append(token_value)
+
+ overrides_from_store = load_pronunciation_overrides(language=language, tokens=tokens)
+ merged_summary = merge_override(summary, overrides_from_store)
+ if result.errors:
+ merged_summary["errors"] = list(result.errors)
+ merged_summary["cache_key"] = result.cache_key
+ pending.entity_summary = merged_summary
+ pending.entity_cache_key = result.cache_key
+ sync_pronunciation_overrides(pending)
+
+
+def find_manual_override(pending: PendingJob, identifier: str) -> Optional[Dict[str, Any]]:
+ for entry in pending.manual_overrides or []:
+ if not isinstance(entry, dict):
+ continue
+ if entry.get("id") == identifier or entry.get("normalized") == identifier:
+ return entry
+ return None
+
+
+def upsert_manual_override(pending: PendingJob, payload: Mapping[str, Any]) -> Dict[str, Any]:
+ token_value = str(payload.get("token") or "").strip()
+ if not token_value:
+ raise ValueError("Token is required")
+ pronunciation_value = str(payload.get("pronunciation") or "").strip()
+ voice_value = str(payload.get("voice") or "").strip()
+ notes_value = str(payload.get("notes") or "").strip()
+ context_value = str(payload.get("context") or "").strip()
+ normalized = payload.get("normalized") or normalize_manual_override_token(token_value)
+ if not normalized:
+ raise ValueError("Token is required")
+
+ existing = find_manual_override(pending, payload.get("id", "")) or find_manual_override(pending, normalized)
+ timestamp = time.time()
+ language = pending.language or "en"
+
+ if existing:
+ existing.update(
+ {
+ "token": token_value,
+ "normalized": normalized,
+ "pronunciation": pronunciation_value,
+ "voice": voice_value,
+ "notes": notes_value,
+ "context": context_value,
+ "updated_at": timestamp,
+ }
+ )
+ manual_entry = existing
+ else:
+ manual_entry = {
+ "id": payload.get("id") or uuid.uuid4().hex,
+ "token": token_value,
+ "normalized": normalized,
+ "pronunciation": pronunciation_value,
+ "voice": voice_value,
+ "notes": notes_value,
+ "context": context_value,
+ "language": language,
+ "source": payload.get("source") or "manual",
+ "created_at": timestamp,
+ "updated_at": timestamp,
+ }
+ if isinstance(pending.manual_overrides, list):
+ pending.manual_overrides.append(manual_entry)
+ else:
+ pending.manual_overrides = [manual_entry]
+
+ save_pronunciation_override(
+ language=language,
+ token=token_value,
+ pronunciation=pronunciation_value or None,
+ voice=voice_value or None,
+ notes=notes_value or None,
+ context=context_value or None,
+ )
+
+ sync_pronunciation_overrides(pending)
+ return dict(manual_entry)
+
+
+def delete_manual_override(pending: PendingJob, override_id: str) -> bool:
+ if not override_id:
+ return False
+ entries = pending.manual_overrides or []
+ for index, entry in enumerate(entries):
+ if not isinstance(entry, dict):
+ continue
+ if entry.get("id") == override_id:
+ token_value = entry.get("token") or ""
+ language = pending.language or "en"
+ delete_pronunciation_override(language=language, token=token_value)
+ entries.pop(index)
+ pending.manual_overrides = entries
+ sync_pronunciation_overrides(pending)
+ return True
+ return False
+
+
+def search_manual_override_candidates(pending: PendingJob, query: str, *, limit: int = 15) -> List[Dict[str, Any]]:
+ normalized_query = (query or "").strip()
+ summary_index = (pending.entity_summary or {}).get("index", {})
+ matches = search_entity_tokens(summary_index, normalized_query, limit=limit)
+ registry: Dict[str, Dict[str, Any]] = {}
+
+ for entry in matches:
+ normalized = normalize_entity_token(entry.get("normalized") or entry.get("token") or "")
+ if not normalized:
+ continue
+ registry.setdefault(
+ normalized,
+ {
+ "token": entry.get("token"),
+ "normalized": normalized,
+ "category": entry.get("category") or "entity",
+ "count": entry.get("count", 0),
+ "samples": entry.get("samples", []),
+ "source": "entity",
+ },
+ )
+
+ language = pending.language or "en"
+ store_matches = search_pronunciation_overrides(language=language, query=normalized_query, limit=limit)
+ for entry in store_matches:
+ normalized = entry.get("normalized")
+ if not normalized:
+ continue
+ registry.setdefault(
+ normalized,
+ {
+ "token": entry.get("token"),
+ "normalized": normalized,
+ "category": "history",
+ "count": entry.get("usage_count", 0),
+ "samples": [entry.get("context")] if entry.get("context") else [],
+ "source": "history",
+ "pronunciation": entry.get("pronunciation"),
+ "voice": entry.get("voice"),
+ },
+ )
+
+ for entry in pending.manual_overrides or []:
+ if not isinstance(entry, Mapping):
+ continue
+ normalized = entry.get("normalized")
+ if not normalized:
+ continue
+ registry.setdefault(
+ normalized,
+ {
+ "token": entry.get("token"),
+ "normalized": normalized,
+ "category": "manual",
+ "count": 0,
+ "samples": [entry.get("context")] if entry.get("context") else [],
+ "source": "manual",
+ "pronunciation": entry.get("pronunciation"),
+ "voice": entry.get("voice"),
+ },
+ )
+
+ ordered = sorted(registry.values(), key=lambda item: (-int(item.get("count") or 0), item.get("token") or ""))
+ if limit:
+ return ordered[:limit]
+ return ordered
+
+
+def pending_entities_payload(pending: PendingJob) -> Dict[str, Any]:
+ settings = load_settings()
+ recognition_enabled = bool(settings.get("enable_entity_recognition", True))
+ return {
+ "summary": pending.entity_summary or {},
+ "manual_overrides": pending.manual_overrides or [],
+ "pronunciation_overrides": pending.pronunciation_overrides or [],
+ "heteronym_overrides": getattr(pending, "heteronym_overrides", None) or [],
+ "cache_key": pending.entity_cache_key,
+ "language": pending.language or "en",
+ "recognition_enabled": recognition_enabled,
+ }
diff --git a/abogen/webui/routes/utils/epub.py b/abogen/webui/routes/utils/epub.py
new file mode 100644
index 0000000..00a00c6
--- /dev/null
+++ b/abogen/webui/routes/utils/epub.py
@@ -0,0 +1,434 @@
+import json
+import math
+import posixpath
+import zipfile
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Set, Tuple
+from xml.etree import ElementTree as ET
+
+from abogen.webui.service import Job, JobStatus
+
+def _coerce_path(value: Any) -> Optional[Path]:
+ if isinstance(value, Path):
+ return value
+ if isinstance(value, str):
+ candidate = Path(value)
+ return candidate
+ return None
+
+
+def normalize_epub_path(base_dir: str, href: str) -> str:
+ if not href:
+ return ""
+ sanitized = href.split("#", 1)[0].split("?", 1)[0].strip()
+ sanitized = sanitized.replace("\\", "/")
+ if not sanitized:
+ return ""
+ if sanitized.startswith("/"):
+ sanitized = sanitized[1:]
+ base_dir = ""
+ normalized_base = base_dir.strip("/")
+ sanitized_lower = sanitized.lower()
+ if normalized_base:
+ base_lower = normalized_base.lower()
+ prefix = base_lower + "/"
+ if sanitized_lower.startswith(prefix):
+ remainder = sanitized[len(prefix):]
+ if remainder.lower().startswith(prefix):
+ sanitized = remainder
+ sanitized_lower = sanitized.lower()
+ base_dir = ""
+ elif sanitized_lower == base_lower:
+ base_dir = ""
+ base = base_dir.strip("/")
+ combined = posixpath.join(base, sanitized) if base else sanitized
+ normalized = posixpath.normpath(combined)
+ if normalized in {"", "."}:
+ return ""
+ normalized = normalized.replace("\\", "/")
+ segments = [segment for segment in normalized.split("/") if segment and segment != "."]
+ if not segments:
+ return ""
+ deduped: List[str] = []
+ last_lower: Optional[str] = None
+ for segment in segments:
+ segment_lower = segment.lower()
+ if last_lower == segment_lower:
+ continue
+ deduped.append(segment)
+ last_lower = segment_lower
+ normalized = "/".join(deduped)
+ if normalized.startswith("../") or normalized == "..":
+ return ""
+ return normalized
+
+
+def decode_text(payload: bytes) -> str:
+ for encoding in ("utf-8", "utf-16", "windows-1252"):
+ try:
+ return payload.decode(encoding)
+ except UnicodeDecodeError:
+ continue
+ return payload.decode("utf-8", "ignore")
+
+
+def coerce_positive_time(value: Any) -> Optional[float]:
+ try:
+ numeric = float(value)
+ except (TypeError, ValueError):
+ return None
+ if not math.isfinite(numeric) or numeric < 0:
+ return None
+ return numeric
+
+
+def load_job_metadata(job: Job) -> Dict[str, Any]:
+ result = getattr(job, "result", None)
+ artifacts = getattr(result, "artifacts", None)
+ if not isinstance(artifacts, Mapping):
+ return {}
+ metadata_ref = artifacts.get("metadata")
+ if isinstance(metadata_ref, Path):
+ metadata_path = metadata_ref
+ elif isinstance(metadata_ref, str):
+ metadata_path = Path(metadata_ref)
+ else:
+ return {}
+ if not metadata_path.exists():
+ return {}
+ try:
+ return json.loads(metadata_path.read_text(encoding="utf-8"))
+ except (OSError, json.JSONDecodeError, UnicodeDecodeError):
+ return {}
+
+
+def resolve_book_title(job: Job, *metadata_sources: Mapping[str, Any]) -> str:
+ for source in metadata_sources:
+ if not isinstance(source, Mapping):
+ continue
+ for key in ("title", "book_title", "name", "album", "album_title"):
+ value = source.get(key)
+ if isinstance(value, str):
+ candidate = value.strip()
+ if candidate:
+ return candidate
+ filename = job.original_filename or ""
+ stem = Path(filename).stem if filename else ""
+ return stem or filename
+
+
+class _NavMapParser(HTMLParser):
+ def __init__(self, base_dir: str) -> None:
+ super().__init__()
+ self._base_dir = base_dir
+ self._in_nav = False
+ self._nav_depth = 0
+ self._current_href: Optional[str] = None
+ self._buffer: List[str] = []
+ self.links: Dict[str, str] = {}
+
+ def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None:
+ tag_lower = tag.lower()
+ if tag_lower == "nav":
+ attributes = dict(attrs)
+ nav_type = (attributes.get("epub:type") or attributes.get("type") or "").strip().lower()
+ nav_role = (attributes.get("role") or "").strip().lower()
+ type_tokens = {token.strip() for token in nav_type.split() if token}
+ role_tokens = {token.strip() for token in nav_role.split() if token}
+ if "toc" in type_tokens or "doc-toc" in role_tokens:
+ self._in_nav = True
+ self._nav_depth = 1
+ return
+ if self._in_nav:
+ self._nav_depth += 1
+ return
+ if not self._in_nav:
+ return
+ if tag_lower == "a":
+ attributes = dict(attrs)
+ href = attributes.get("href") or ""
+ normalized = normalize_epub_path(self._base_dir, href)
+ if normalized:
+ self._current_href = normalized
+ self._buffer = []
+
+ def handle_endtag(self, tag: str) -> None:
+ tag_lower = tag.lower()
+ if tag_lower == "nav" and self._in_nav:
+ self._nav_depth -= 1
+ if self._nav_depth <= 0:
+ self._in_nav = False
+ return
+ if not self._in_nav:
+ return
+ if tag_lower == "a" and self._current_href:
+ text = "".join(self._buffer).strip()
+ if text:
+ self.links.setdefault(self._current_href, text)
+ self._current_href = None
+ self._buffer = []
+
+ def handle_data(self, data: str) -> None:
+ if self._in_nav and self._current_href and data:
+ self._buffer.append(data)
+
+
+def parse_nav_document(payload: bytes, base_dir: str) -> Dict[str, str]:
+ parser = _NavMapParser(base_dir)
+ parser.feed(decode_text(payload))
+ parser.close()
+ return parser.links
+
+
+def parse_ncx_document(payload: bytes, base_dir: str) -> Dict[str, str]:
+ try:
+ root = ET.fromstring(payload)
+ except ET.ParseError:
+ return {}
+ nav_map: Dict[str, str] = {}
+ for nav_point in root.findall(".//{*}navPoint"):
+ content = nav_point.find(".//{*}content")
+ if content is None:
+ continue
+ src = content.attrib.get("src", "")
+ normalized = normalize_epub_path(base_dir, src)
+ if not normalized:
+ continue
+ label_el = nav_point.find(".//{*}text")
+ label = (label_el.text or "").strip() if label_el is not None and label_el.text else ""
+ if not label:
+ label = posixpath.basename(normalized) or f"Section {len(nav_map) + 1}"
+ nav_map.setdefault(normalized, label)
+ return nav_map
+
+
+def extract_epub_chapters(epub_path: Path) -> List[Dict[str, str]]:
+ chapters: List[Dict[str, str]] = []
+ if not epub_path or not epub_path.exists():
+ return chapters
+ try:
+ with zipfile.ZipFile(epub_path, "r") as archive:
+ container_bytes = archive.read("META-INF/container.xml")
+ container_root = ET.fromstring(container_bytes)
+ rootfile = container_root.find(".//{*}rootfile")
+ if rootfile is None:
+ return chapters
+ opf_path = (rootfile.attrib.get("full-path") or "").strip()
+ if not opf_path:
+ return chapters
+ opf_dir = posixpath.dirname(opf_path)
+ opf_bytes = archive.read(opf_path)
+ opf_root = ET.fromstring(opf_bytes)
+
+ manifest: Dict[str, Dict[str, str]] = {}
+ for item in opf_root.findall(".//{*}manifest/{*}item"):
+ item_id = item.attrib.get("id")
+ href = item.attrib.get("href")
+ if not item_id or not href:
+ continue
+ manifest[item_id] = {
+ "href": normalize_epub_path(opf_dir, href),
+ "properties": item.attrib.get("properties", ""),
+ "media_type": item.attrib.get("media-type", ""),
+ }
+
+ spine_hrefs: List[str] = []
+ nav_id: Optional[str] = None
+ spine = opf_root.find(".//{*}spine")
+ if spine is not None:
+ nav_id = spine.attrib.get("toc")
+ for itemref in spine.findall(".//{*}itemref"):
+ idref = itemref.attrib.get("idref")
+ if not idref:
+ continue
+ entry = manifest.get(idref)
+ if not entry:
+ continue
+ href = entry["href"]
+ if href and href not in spine_hrefs:
+ spine_hrefs.append(href)
+
+ nav_href: Optional[str] = None
+ for entry in manifest.values():
+ properties = entry.get("properties") or ""
+ if "nav" in {token.strip() for token in properties.split() if token}:
+ nav_href = entry["href"]
+ break
+ if not nav_href and nav_id:
+ toc_entry = manifest.get(nav_id)
+ if toc_entry:
+ nav_href = toc_entry["href"]
+
+ nav_titles: Dict[str, str] = {}
+ if nav_href:
+ nav_base = posixpath.dirname(nav_href)
+ try:
+ nav_bytes = archive.read(nav_href)
+ except KeyError:
+ nav_bytes = None
+ if nav_bytes is not None:
+ if nav_href.lower().endswith(".ncx"):
+ nav_titles = parse_ncx_document(nav_bytes, nav_base)
+ else:
+ nav_titles = parse_nav_document(nav_bytes, nav_base)
+
+ if not nav_titles and nav_id and nav_id in manifest:
+ toc_entry = manifest[nav_id]
+ nav_base = posixpath.dirname(toc_entry["href"])
+ try:
+ nav_bytes = archive.read(toc_entry["href"])
+ except KeyError:
+ nav_bytes = None
+ if nav_bytes is not None:
+ nav_titles = parse_ncx_document(nav_bytes, nav_base)
+
+ for index, href in enumerate(spine_hrefs, start=1):
+ normalized = href
+ if not normalized:
+ continue
+ title = (
+ nav_titles.get(normalized)
+ or nav_titles.get(normalized.split("#", 1)[0])
+ or posixpath.basename(normalized)
+ or f"Chapter {index}"
+ )
+ chapters.append({"href": normalized, "title": title})
+
+ if not chapters and nav_titles:
+ for index, (href, title) in enumerate(nav_titles.items(), start=1):
+ normalized = href
+ if not normalized:
+ continue
+ label = title or posixpath.basename(normalized) or f"Chapter {index}"
+ chapters.append({"href": normalized, "title": label})
+
+ return chapters
+ except (FileNotFoundError, zipfile.BadZipFile, KeyError, ET.ParseError, UnicodeDecodeError):
+ return []
+ return chapters
+
+
+def read_epub_bytes(epub_path: Path, raw_href: str) -> bytes:
+ normalized = normalize_epub_path("", raw_href)
+ if not normalized:
+ raise ValueError("Invalid resource path")
+ with zipfile.ZipFile(epub_path, "r") as archive:
+ return archive.read(normalized)
+
+
+def iter_job_result_paths(job: Job) -> List[Path]:
+ result = getattr(job, "result", None)
+ if result is None:
+ return []
+ resolved_seen: Set[Path] = set()
+ collected: List[Path] = []
+
+ def _remember(candidate: Optional[Path]) -> None:
+ if not candidate:
+ return
+ try:
+ resolved = candidate.resolve()
+ except OSError:
+ return
+ if resolved in resolved_seen:
+ return
+ resolved_seen.add(resolved)
+ collected.append(candidate)
+
+ artifacts = getattr(result, "artifacts", None)
+ if isinstance(artifacts, Mapping):
+ for value in artifacts.values():
+ candidate = _coerce_path(value)
+ if candidate and candidate.exists() and candidate.is_file():
+ _remember(candidate)
+
+ for attr in ("audio_path", "epub_path"):
+ candidate = _coerce_path(getattr(result, attr, None))
+ if candidate and candidate.exists() and candidate.is_file():
+ _remember(candidate)
+
+ return collected
+
+
+def iter_job_artifact_dirs(job: Job) -> List[Path]:
+ result = getattr(job, "result", None)
+ if result is None:
+ return []
+ artifacts = getattr(result, "artifacts", None)
+ directories: List[Path] = []
+ if isinstance(artifacts, Mapping):
+ for value in artifacts.values():
+ candidate = _coerce_path(value)
+ if candidate and candidate.exists() and candidate.is_dir():
+ directories.append(candidate)
+ return directories
+
+
+def normalize_suffixes(suffixes: Iterable[str]) -> List[str]:
+ normalized: List[str] = []
+ for suffix in suffixes:
+ if not suffix:
+ continue
+ cleaned = suffix.lower().strip()
+ if not cleaned:
+ continue
+ if not cleaned.startswith("."):
+ cleaned = f".{cleaned.lstrip('.')}"
+ normalized.append(cleaned)
+ return normalized
+
+
+def find_job_file(job: Job, suffixes: Iterable[str]) -> Optional[Path]:
+ ordered_suffixes = normalize_suffixes(suffixes)
+ if not ordered_suffixes:
+ return None
+ files = iter_job_result_paths(job)
+ for suffix in ordered_suffixes:
+ for candidate in files:
+ if candidate.suffix.lower() == suffix:
+ return candidate
+ directories = iter_job_artifact_dirs(job)
+ for suffix in ordered_suffixes:
+ pattern = f"*{suffix}"
+ for directory in directories:
+ try:
+ match = next((path for path in directory.rglob(pattern) if path.is_file()), None)
+ except OSError:
+ match = None
+ if match:
+ return match
+ return None
+
+
+def locate_job_epub(job: Job) -> Optional[Path]:
+ path = find_job_file(job, [".epub"])
+ if path:
+ return path
+ return None
+
+
+def locate_job_m4b(job: Job) -> Optional[Path]:
+ return find_job_file(job, [".m4b"])
+
+
+def locate_job_audio(job: Job, preferred_suffixes: Optional[Iterable[str]] = None) -> Optional[Path]:
+ suffix_order: List[str] = []
+ if preferred_suffixes:
+ suffix_order.extend(preferred_suffixes)
+ suffix_order.extend([".m4b", ".mp3", ".flac", ".opus", ".ogg", ".m4a", ".wav"])
+ path = find_job_file(job, suffix_order)
+ if path:
+ return path
+ files = iter_job_result_paths(job)
+ return files[0] if files else None
+
+
+def job_download_flags(job: Job) -> Dict[str, bool]:
+ if job.status != JobStatus.COMPLETED:
+ return {"audio": False, "m4b": False, "epub3": False}
+ return {
+ "audio": locate_job_audio(job) is not None,
+ "m4b": locate_job_m4b(job) is not None,
+ "epub3": locate_job_epub(job) is not None,
+ }
diff --git a/abogen/webui/routes/utils/form.py b/abogen/webui/routes/utils/form.py
new file mode 100644
index 0000000..41d605e
--- /dev/null
+++ b/abogen/webui/routes/utils/form.py
@@ -0,0 +1,1097 @@
+import re
+import time
+import uuid
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, cast
+from flask import request, render_template, jsonify
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.service import PendingJob, JobStatus
+from abogen.webui.routes.utils.service import get_service
+from abogen.webui.routes.utils.settings import (
+ load_settings,
+ coerce_bool,
+ coerce_int,
+ _CHUNK_LEVEL_VALUES,
+ _DEFAULT_ANALYSIS_THRESHOLD,
+ _NORMALIZATION_BOOLEAN_KEYS,
+ _NORMALIZATION_STRING_KEYS,
+ SAVE_MODE_LABELS,
+ audiobookshelf_manual_available,
+)
+from abogen.webui.routes.utils.voice import (
+ parse_voice_formula,
+ formula_from_profile,
+ resolve_voice_setting,
+ resolve_voice_choice,
+ prepare_speaker_metadata,
+ template_options,
+)
+from abogen.webui.routes.utils.entity import sync_pronunciation_overrides
+from abogen.webui.routes.utils.epub import job_download_flags
+from abogen.webui.routes.utils.common import split_profile_spec
+from abogen.utils import calculate_text_length
+from abogen.voice_profiles import serialize_profiles, normalize_profile_entry
+from abogen.chunking import ChunkLevel, build_chunks_for_chapters
+from abogen.constants import VOICES_INTERNAL
+from abogen.speaker_configs import get_config
+from abogen.kokoro_text_normalization import normalize_roman_numeral_titles
+from dataclasses import dataclass
+from pathlib import Path
+import mimetypes
+
+@dataclass
+class PendingBuildResult:
+ pending: PendingJob
+ selected_speaker_config: Optional[str]
+ config_languages: List[str]
+ speaker_config_payload: Optional[Dict[str, Any]]
+
+_WIZARD_STEP_ORDER = ["book", "chapters", "entities"]
+_WIZARD_STEP_META = {
+ "book": {
+ "index": 1,
+ "title": "Book parameters",
+ "hint": "Choose your source file or paste text, then set the defaults used for chapter analysis and speaker casting.",
+ },
+ "chapters": {
+ "index": 2,
+ "title": "Select chapters",
+ "hint": "Choose which chapters to convert. We'll analyse entities automatically when you continue.",
+ },
+ "entities": {
+ "index": 3,
+ "title": "Review entities",
+ "hint": "Assign pronunciations, voices, and manual overrides before queueing the conversion.",
+ },
+}
+
+_SUPPLEMENT_TITLE_PATTERNS: List[tuple[re.Pattern[str], float]] = [
+ (re.compile(r"\btitle\s+page\b"), 3.0),
+ (re.compile(r"\bcopyright\b"), 2.4),
+ (re.compile(r"\btable\s+of\s+contents\b"), 2.8),
+ (re.compile(r"\bcontents\b"), 2.0),
+ (re.compile(r"\backnowledg(e)?ments?\b"), 2.0),
+ (re.compile(r"\bdedication\b"), 2.0),
+ (re.compile(r"\babout\s+the\s+author(s)?\b"), 2.4),
+ (re.compile(r"\balso\s+by\b"), 2.0),
+ (re.compile(r"\bpraise\s+for\b"), 2.0),
+ (re.compile(r"\bcolophon\b"), 2.2),
+ (re.compile(r"\bpublication\s+data\b"), 2.2),
+ (re.compile(r"\btranscriber'?s?\s+note\b"), 2.2),
+ (re.compile(r"\bglossary\b"), 2.0),
+ (re.compile(r"\bindex\b"), 2.0),
+ (re.compile(r"\bbibliograph(y|ies)\b"), 2.0),
+ (re.compile(r"\breferences\b"), 1.8),
+ (re.compile(r"\bappendix\b"), 1.9),
+]
+
+_CONTENT_TITLE_PATTERNS: List[re.Pattern[str]] = [
+ re.compile(r"\bchapter\b"),
+ re.compile(r"\bbook\b"),
+ re.compile(r"\bpart\b"),
+ re.compile(r"\bsection\b"),
+ re.compile(r"\bscene\b"),
+ re.compile(r"\bprologue\b"),
+ re.compile(r"\bepilogue\b"),
+ re.compile(r"\bintroduction\b"),
+ re.compile(r"\bstory\b"),
+]
+
+_SUPPLEMENT_TEXT_KEYWORDS: List[tuple[str, float]] = [
+ ("copyright", 1.2),
+ ("all rights reserved", 1.1),
+ ("isbn", 0.9),
+ ("library of congress", 1.0),
+ ("table of contents", 1.0),
+ ("dedicated to", 0.8),
+ ("acknowledg", 0.8),
+ ("printed in", 0.6),
+ ("permission", 0.6),
+ ("publisher", 0.5),
+ ("praise for", 0.9),
+ ("also by", 0.9),
+ ("glossary", 0.8),
+ ("index", 0.8),
+ ("newsletter", 3.2),
+ ("mailing list", 2.6),
+ ("sign-up", 2.2),
+]
+
+def supplement_score(title: str, text: str, index: int) -> float:
+ normalized_title = (title or "").lower()
+ score = 0.0
+
+ for pattern, weight in _SUPPLEMENT_TITLE_PATTERNS:
+ if pattern.search(normalized_title):
+ score += weight
+
+ for pattern in _CONTENT_TITLE_PATTERNS:
+ if pattern.search(normalized_title):
+ score -= 2.0
+
+ stripped_text = (text or "").strip()
+ length = len(stripped_text)
+ if length <= 150:
+ score += 0.9
+ elif length <= 400:
+ score += 0.6
+ elif length <= 800:
+ score += 0.35
+
+ lowercase_text = stripped_text.lower()
+ for keyword, weight in _SUPPLEMENT_TEXT_KEYWORDS:
+ if keyword in lowercase_text:
+ score += weight
+
+ if index == 0 and score > 0:
+ score += 0.25
+
+ return score
+
+
+def should_preselect_chapter(
+ title: str,
+ text: str,
+ index: int,
+ total_count: int,
+) -> bool:
+ if total_count <= 1:
+ return True
+ score = supplement_score(title, text, index)
+ return score < 1.9
+
+
+def ensure_at_least_one_chapter_enabled(chapters: List[Dict[str, Any]]) -> None:
+ if not chapters:
+ return
+ if any(chapter.get("enabled") for chapter in chapters):
+ return
+ best_index = max(range(len(chapters)), key=lambda idx: chapters[idx].get("characters", 0))
+ chapters[best_index]["enabled"] = True
+
+def apply_prepare_form(
+ pending: PendingJob, form: Mapping[str, Any]
+) -> tuple[
+ ChunkLevel,
+ List[Dict[str, Any]],
+ List[Dict[str, Any]],
+ List[str],
+ int,
+ str,
+ bool,
+ bool,
+]:
+ raw_chunk_level = (form.get("chunk_level") or pending.chunk_level or "paragraph").strip().lower()
+ if raw_chunk_level not in _CHUNK_LEVEL_VALUES:
+ raw_chunk_level = pending.chunk_level if pending.chunk_level in _CHUNK_LEVEL_VALUES else "paragraph"
+ pending.chunk_level = raw_chunk_level
+ chunk_level_literal = cast(ChunkLevel, pending.chunk_level)
+
+ pending.speaker_mode = "single"
+
+ pending.generate_epub3 = coerce_bool(form.get("generate_epub3"), False)
+
+ threshold_default = getattr(pending, "speaker_analysis_threshold", _DEFAULT_ANALYSIS_THRESHOLD)
+ raw_threshold = form.get("speaker_analysis_threshold")
+ if raw_threshold is not None:
+ pending.speaker_analysis_threshold = coerce_int(
+ raw_threshold,
+ threshold_default,
+ minimum=1,
+ maximum=25,
+ )
+ else:
+ pending.speaker_analysis_threshold = threshold_default
+
+ if not pending.speakers:
+ narrator: Dict[str, Any] = {
+ "id": "narrator",
+ "label": "Narrator",
+ "voice": pending.voice,
+ }
+ if pending.voice_profile:
+ narrator["voice_profile"] = pending.voice_profile
+ pending.speakers = {"narrator": narrator}
+ else:
+ existing_narrator = pending.speakers.get("narrator")
+ if isinstance(existing_narrator, dict):
+ existing_narrator.setdefault("id", "narrator")
+ existing_narrator["label"] = existing_narrator.get("label", "Narrator")
+ existing_narrator["voice"] = pending.voice
+ if pending.voice_profile:
+ existing_narrator["voice_profile"] = pending.voice_profile
+ pending.speakers["narrator"] = existing_narrator
+
+ selected_config = (form.get("applied_speaker_config") or "").strip()
+ apply_config_requested = str(form.get("apply_speaker_config", "")).strip() in {"1", "true", "on"}
+ persist_config_requested = str(form.get("save_speaker_config", "")).strip() in {"1", "true", "on"}
+
+ pending.applied_speaker_config = selected_config or None
+
+ errors: List[str] = []
+
+ if isinstance(pending.speakers, dict):
+ for speaker_id, payload in list(pending.speakers.items()):
+ if not isinstance(payload, dict):
+ continue
+ field_key = f"speaker-{speaker_id}-pronunciation"
+ raw_value = form.get(field_key, "")
+ pronunciation = raw_value.strip()
+ if pronunciation:
+ payload["pronunciation"] = pronunciation
+ else:
+ payload.pop("pronunciation", None)
+
+ voice_value = (form.get(f"speaker-{speaker_id}-voice") or "").strip()
+ formula_key = f"speaker-{speaker_id}-formula"
+ formula_value = (form.get(formula_key) or "").strip()
+ has_formula = False
+ if formula_value:
+ try:
+ parse_voice_formula(formula_value)
+ except ValueError as exc:
+ label = payload.get("label") or speaker_id.replace("_", " ").title()
+ errors.append(f"Invalid custom mix for {label}: {exc}")
+ else:
+ payload["voice_formula"] = formula_value
+ payload["resolved_voice"] = formula_value
+ payload.pop("voice_profile", None)
+ has_formula = True
+ else:
+ payload.pop("voice_formula", None)
+
+ if voice_value == "__custom_mix":
+ voice_value = ""
+
+ if voice_value:
+ payload["voice"] = voice_value
+ if not has_formula:
+ payload["resolved_voice"] = voice_value
+ else:
+ payload.pop("voice", None)
+ if not has_formula:
+ payload.pop("resolved_voice", None)
+
+ lang_key = f"speaker-{speaker_id}-languages"
+ languages: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ values = cast(Iterable[str], getter(lang_key))
+ languages = [code.strip() for code in values if code]
+ else:
+ raw_langs = form.get(lang_key)
+ if isinstance(raw_langs, str):
+ languages = [item.strip() for item in raw_langs.split(",") if item.strip()]
+ payload["config_languages"] = languages
+
+ profiles = serialize_profiles()
+ raw_delay = form.get("chapter_intro_delay")
+ if raw_delay is not None:
+ raw_normalized = raw_delay.strip()
+ if raw_normalized:
+ try:
+ pending.chapter_intro_delay = max(0.0, float(raw_normalized))
+ except ValueError:
+ errors.append("Enter a valid number for the chapter intro delay.")
+ else:
+ pending.chapter_intro_delay = 0.0
+
+ intro_values: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ raw_intro_values = getter("read_title_intro")
+ if raw_intro_values:
+ intro_values = list(cast(Iterable[str], raw_intro_values))
+ else:
+ raw_intro = form.get("read_title_intro")
+ if raw_intro is not None:
+ intro_values = [raw_intro]
+ if intro_values:
+ pending.read_title_intro = coerce_bool(intro_values[-1], pending.read_title_intro)
+ elif hasattr(form, "__contains__") and "read_title_intro" in form:
+ pending.read_title_intro = False
+
+ outro_values: List[str] = []
+ if callable(getter):
+ raw_outro_values = getter("read_closing_outro")
+ if raw_outro_values:
+ outro_values = list(cast(Iterable[str], raw_outro_values))
+ else:
+ raw_outro = form.get("read_closing_outro")
+ if raw_outro is not None:
+ outro_values = [raw_outro]
+ if outro_values:
+ pending.read_closing_outro = coerce_bool(
+ outro_values[-1], getattr(pending, "read_closing_outro", True)
+ )
+ elif hasattr(form, "__contains__") and "read_closing_outro" in form:
+ pending.read_closing_outro = False
+
+ caps_values: List[str] = []
+ if callable(getter):
+ raw_caps_values = getter("normalize_chapter_opening_caps")
+ if raw_caps_values:
+ caps_values = list(cast(Iterable[str], raw_caps_values))
+ else:
+ raw_caps = form.get("normalize_chapter_opening_caps")
+ if raw_caps is not None:
+ caps_values = [raw_caps]
+ if caps_values:
+ pending.normalize_chapter_opening_caps = coerce_bool(
+ caps_values[-1], getattr(pending, "normalize_chapter_opening_caps", True)
+ )
+ elif hasattr(form, "__contains__") and "normalize_chapter_opening_caps" in form:
+ pending.normalize_chapter_opening_caps = False
+
+ overrides: List[Dict[str, Any]] = []
+ selected_total = 0
+
+ for index, chapter in enumerate(pending.chapters):
+ enabled = form.get(f"chapter-{index}-enabled") == "on"
+ title_input = (form.get(f"chapter-{index}-title") or "").strip()
+ title = title_input or chapter.get("title") or f"Chapter {index + 1}"
+ voice_selection = form.get(f"chapter-{index}-voice", "__default")
+ formula_input = (form.get(f"chapter-{index}-formula") or "").strip()
+
+ entry: Dict[str, Any] = {
+ "id": chapter.get("id") or f"{index:04d}",
+ "index": index,
+ "order": index,
+ "source_title": chapter.get("title") or title,
+ "title": title,
+ "text": chapter.get("text", ""),
+ "enabled": enabled,
+ }
+ entry["characters"] = calculate_text_length(entry["text"])
+
+ if enabled:
+ if voice_selection.startswith("voice:"):
+ entry["voice"] = voice_selection.split(":", 1)[1]
+ entry["resolved_voice"] = entry["voice"]
+ elif voice_selection.startswith("profile:"):
+ profile_name = voice_selection.split(":", 1)[1]
+ entry["voice_profile"] = profile_name
+ profile_entry = profiles.get(profile_name) or {}
+ formula_value = formula_from_profile(profile_entry)
+ if formula_value:
+ entry["voice_formula"] = formula_value
+ entry["resolved_voice"] = formula_value
+ else:
+ errors.append(f"Profile '{profile_name}' has no configured voices.")
+ elif voice_selection == "formula":
+ if not formula_input:
+ errors.append(f"Provide a custom formula for chapter {index + 1}.")
+ else:
+ try:
+ parse_voice_formula(formula_input)
+ except ValueError as exc:
+ errors.append(str(exc))
+ else:
+ entry["voice_formula"] = formula_input
+ entry["resolved_voice"] = formula_input
+ selected_total += entry["characters"]
+
+ overrides.append(entry)
+ pending.chapters[index] = dict(entry)
+
+ enabled_overrides = [entry for entry in overrides if entry.get("enabled")]
+
+ heteronym_entries = getattr(pending, "heteronym_overrides", None)
+ if isinstance(heteronym_entries, list) and heteronym_entries:
+ for entry in heteronym_entries:
+ if not isinstance(entry, dict):
+ continue
+ entry_id = str(entry.get("entry_id") or entry.get("id") or "").strip()
+ if not entry_id:
+ continue
+ raw_choice = form.get(f"heteronym-{entry_id}-choice")
+ if raw_choice is None:
+ continue
+ choice = str(raw_choice).strip()
+ if not choice:
+ continue
+ options = entry.get("options")
+ if isinstance(options, list) and options:
+ allowed = {
+ str(opt.get("key")).strip()
+ for opt in options
+ if isinstance(opt, dict) and str(opt.get("key") or "").strip()
+ }
+ if allowed and choice not in allowed:
+ continue
+ entry["choice"] = choice
+
+ sync_pronunciation_overrides(pending)
+
+ return (
+ chunk_level_literal,
+ overrides,
+ enabled_overrides,
+ errors,
+ selected_total,
+ selected_config,
+ apply_config_requested,
+ persist_config_requested,
+ )
+
+def apply_book_step_form(
+ pending: PendingJob,
+ form: Mapping[str, Any],
+ *,
+ settings: Mapping[str, Any],
+ profiles: Mapping[str, Any],
+) -> None:
+ language_fallback = pending.language or settings.get("language", "en")
+ raw_language = (form.get("language") or language_fallback or "en").strip()
+ if raw_language:
+ pending.language = raw_language
+
+ subtitle_mode = (form.get("subtitle_mode") or pending.subtitle_mode or "Disabled").strip()
+ if subtitle_mode:
+ pending.subtitle_mode = subtitle_mode
+
+ pending.generate_epub3 = coerce_bool(form.get("generate_epub3"), bool(pending.generate_epub3))
+
+ chunk_level_default = str(settings.get("chunk_level", "paragraph")).strip().lower()
+ raw_chunk_level = (form.get("chunk_level") or pending.chunk_level or chunk_level_default).strip().lower()
+ if raw_chunk_level not in _CHUNK_LEVEL_VALUES:
+ raw_chunk_level = chunk_level_default if chunk_level_default in _CHUNK_LEVEL_VALUES else (pending.chunk_level or "paragraph")
+ pending.chunk_level = raw_chunk_level
+
+ threshold_default = pending.speaker_analysis_threshold or settings.get("speaker_analysis_threshold", _DEFAULT_ANALYSIS_THRESHOLD)
+ raw_threshold = form.get("speaker_analysis_threshold")
+ if raw_threshold is not None:
+ pending.speaker_analysis_threshold = coerce_int(
+ raw_threshold,
+ threshold_default,
+ minimum=1,
+ maximum=25,
+ )
+
+ raw_delay = form.get("chapter_intro_delay")
+ if raw_delay is not None:
+ try:
+ pending.chapter_intro_delay = max(0.0, float(str(raw_delay).strip() or 0.0))
+ except ValueError:
+ pass
+
+ intro_default = pending.read_title_intro if isinstance(pending.read_title_intro, bool) else bool(settings.get("read_title_intro", False))
+ intro_values: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ raw_intro_values = getter("read_title_intro")
+ if raw_intro_values:
+ intro_values = list(cast(Iterable[str], raw_intro_values))
+ else:
+ raw_intro_flag = form.get("read_title_intro")
+ if raw_intro_flag is not None:
+ intro_values = [raw_intro_flag]
+ if intro_values:
+ pending.read_title_intro = coerce_bool(intro_values[-1], intro_default)
+ elif hasattr(form, "__contains__") and "read_title_intro" in form:
+ pending.read_title_intro = False
+ else:
+ pending.read_title_intro = intro_default
+
+ outro_default = (
+ pending.read_closing_outro
+ if isinstance(getattr(pending, "read_closing_outro", None), bool)
+ else bool(settings.get("read_closing_outro", True))
+ )
+ outro_values: List[str] = []
+ if callable(getter):
+ raw_outro_values = getter("read_closing_outro")
+ if raw_outro_values:
+ outro_values = list(cast(Iterable[str], raw_outro_values))
+ else:
+ raw_outro_flag = form.get("read_closing_outro")
+ if raw_outro_flag is not None:
+ outro_values = [raw_outro_flag]
+ if outro_values:
+ pending.read_closing_outro = coerce_bool(outro_values[-1], outro_default)
+ elif hasattr(form, "__contains__") and "read_closing_outro" in form:
+ pending.read_closing_outro = False
+ else:
+ pending.read_closing_outro = outro_default
+
+ caps_default = (
+ pending.normalize_chapter_opening_caps
+ if isinstance(getattr(pending, "normalize_chapter_opening_caps", None), bool)
+ else bool(settings.get("normalize_chapter_opening_caps", True))
+ )
+ caps_values: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ raw_caps_values = getter("normalize_chapter_opening_caps")
+ if raw_caps_values:
+ caps_values = list(cast(Iterable[str], raw_caps_values))
+ else:
+ raw_caps_flag = form.get("normalize_chapter_opening_caps")
+ if raw_caps_flag is not None:
+ caps_values = [raw_caps_flag]
+ if caps_values:
+ pending.normalize_chapter_opening_caps = coerce_bool(caps_values[-1], caps_default)
+ elif hasattr(form, "__contains__") and "normalize_chapter_opening_caps" in form:
+ pending.normalize_chapter_opening_caps = False
+ else:
+ pending.normalize_chapter_opening_caps = caps_default
+
+ def _extract_checkbox(name: str, default: bool) -> bool:
+ values: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ raw_values = getter(name)
+ if raw_values:
+ values = list(cast(Iterable[str], raw_values))
+ else:
+ raw_flag = form.get(name)
+ if raw_flag is not None:
+ values = [raw_flag]
+ if values:
+ return coerce_bool(values[-1], default)
+ if hasattr(form, "__contains__") and name in form:
+ return False
+ return default
+
+ overrides_existing = getattr(pending, "normalization_overrides", None)
+ overrides: Dict[str, Any] = dict(overrides_existing or {})
+ for key in _NORMALIZATION_BOOLEAN_KEYS:
+ default_toggle = overrides.get(key, bool(settings.get(key, True)))
+ overrides[key] = _extract_checkbox(key, default_toggle)
+ for key in _NORMALIZATION_STRING_KEYS:
+ default_val = overrides.get(key, str(settings.get(key, "")))
+ val = form.get(key)
+ if val is not None:
+ overrides[key] = str(val)
+ else:
+ overrides[key] = default_val
+ pending.normalization_overrides = overrides
+
+ speed_value = form.get("speed")
+ if speed_value is not None:
+ try:
+ pending.speed = float(speed_value)
+ except ValueError:
+ pass
+
+ # NOTE: Do not auto-set a global TTS provider at the book level based on the
+ # narrator defaults. Provider is resolved per-speaker/per-chunk from the voice
+ # spec (e.g. "speaker:Name" for saved speakers, or a Kokoro mix formula).
+ # This enables mixed-provider conversions (e.g. narrator=SuperTonic, characters=Kokoro).
+ provider_value = str(form.get("tts_provider") or "").strip().lower()
+ if provider_value in {"kokoro", "supertonic"}:
+ pending.tts_provider = provider_value
+
+ # Determine the base speaker selection (saved speaker ref or raw voice).
+ narrator_voice_raw = (
+ form.get("voice")
+ or pending.voice
+ or settings.get("default_speaker")
+ or settings.get("default_voice")
+ or ""
+ ).strip()
+
+ profiles_map = dict(profiles) if isinstance(profiles, Mapping) else dict(profiles or {})
+ base_spec, _selected_speaker_name = split_profile_spec(narrator_voice_raw)
+
+ profile_selection = (form.get("voice_profile") or pending.voice_profile or "__standard").strip()
+ custom_formula_raw = (form.get("voice_formula") or "").strip()
+ narrator_voice_raw = (base_spec or narrator_voice_raw or settings.get("default_voice") or "").strip()
+ resolved_default_voice, inferred_profile, _ = resolve_voice_setting(
+ narrator_voice_raw,
+ profiles=profiles_map,
+ )
+
+ if profile_selection in {"__standard", "", None} and inferred_profile:
+ profile_selection = inferred_profile
+
+ if profile_selection == "__formula":
+ profile_name = ""
+ custom_formula = custom_formula_raw
+ elif profile_selection in {"__standard", "", None}:
+ profile_name = ""
+ custom_formula = ""
+ else:
+ profile_name = profile_selection
+ custom_formula = ""
+
+ base_voice_spec = resolved_default_voice or narrator_voice_raw
+ if not base_voice_spec and VOICES_INTERNAL:
+ base_voice_spec = VOICES_INTERNAL[0]
+
+ voice_choice, resolved_language, selected_profile = resolve_voice_choice(
+ pending.language,
+ base_voice_spec,
+ profile_name,
+ custom_formula,
+ profiles_map,
+ )
+
+ if resolved_language:
+ pending.language = resolved_language
+
+ if profile_selection == "__formula" and custom_formula_raw:
+ pending.voice = custom_formula_raw
+ pending.voice_profile = None
+ elif profile_selection not in {"__standard", "", None, "__formula"}:
+ pending.voice_profile = selected_profile or profile_selection
+ pending.voice = voice_choice
+ else:
+ pending.voice_profile = None
+ fallback_voice = base_voice_spec or narrator_voice_raw
+ pending.voice = voice_choice or fallback_voice
+
+ pending.applied_speaker_config = (form.get("speaker_config") or "").strip() or None
+
+ # Metadata updates
+ if "meta_title" in form:
+ pending.metadata_tags["title"] = str(form.get("meta_title", "")).strip()
+
+ if "meta_subtitle" in form:
+ pending.metadata_tags["subtitle"] = str(form.get("meta_subtitle", "")).strip()
+
+ if "meta_author" in form:
+ authors = str(form.get("meta_author", "")).strip()
+ pending.metadata_tags["authors"] = authors
+ pending.metadata_tags["author"] = authors
+
+ if "meta_series" in form:
+ series = str(form.get("meta_series", "")).strip()
+ pending.metadata_tags["series"] = series
+ pending.metadata_tags["series_name"] = series
+ pending.metadata_tags["seriesname"] = series
+ pending.metadata_tags["series_title"] = series
+ pending.metadata_tags["seriestitle"] = series
+ # If user manually edits series, update opds_series too so it persists
+ if "opds_series" in pending.metadata_tags:
+ pending.metadata_tags["opds_series"] = series
+
+ if "meta_series_index" in form:
+ idx = str(form.get("meta_series_index", "")).strip()
+ pending.metadata_tags["series_index"] = idx
+ pending.metadata_tags["series_sequence"] = idx
+
+ if "meta_publisher" in form:
+ pending.metadata_tags["publisher"] = str(form.get("meta_publisher", "")).strip()
+
+ if "meta_description" in form:
+ desc = str(form.get("meta_description", "")).strip()
+ pending.metadata_tags["description"] = desc
+ pending.metadata_tags["summary"] = desc
+
+ if coerce_bool(form.get("remove_cover"), False):
+ pending.cover_image_path = None
+ pending.cover_image_mime = None
+
+def persist_cover_image(extraction_result: Any, stored_path: Path) -> tuple[Optional[Path], Optional[str]]:
+ cover_bytes = getattr(extraction_result, "cover_image", None)
+ if not cover_bytes:
+ return None, None
+
+ mime = getattr(extraction_result, "cover_mime", None)
+ extension = mimetypes.guess_extension(mime or "") or ".png"
+ base_stem = Path(stored_path).stem or "cover"
+ candidate = stored_path.parent / f"{base_stem}_cover{extension}"
+ counter = 1
+ while candidate.exists():
+ candidate = stored_path.parent / f"{base_stem}_cover_{counter}{extension}"
+ counter += 1
+
+ try:
+ candidate.write_bytes(cover_bytes)
+ except OSError:
+ return None, None
+
+ return candidate, mime
+
+def build_pending_job_from_extraction(
+ *,
+ stored_path: Path,
+ original_name: str,
+ extraction: Any,
+ form: Mapping[str, Any],
+ settings: Mapping[str, Any],
+ profiles: Mapping[str, Any],
+ metadata_overrides: Optional[Mapping[str, Any]] = None,
+) -> PendingBuildResult:
+ profiles_map = dict(profiles)
+ cover_path, cover_mime = persist_cover_image(extraction, stored_path)
+
+ if getattr(extraction, "chapters", None):
+ original_titles = [chapter.title for chapter in extraction.chapters]
+ normalized_titles = normalize_roman_numeral_titles(original_titles)
+ if normalized_titles != original_titles:
+ for chapter, new_title in zip(extraction.chapters, normalized_titles):
+ chapter.title = new_title
+
+ metadata_tags = dict(getattr(extraction, "metadata", {}) or {})
+ if metadata_overrides:
+ normalized_keys = {str(existing_key).casefold(): str(existing_key) for existing_key in metadata_tags.keys()}
+ for key, value in metadata_overrides.items():
+ if value is None:
+ continue
+ key_text = str(key or "").strip()
+ if not key_text:
+ continue
+ value_text = str(value).strip()
+ if not value_text:
+ continue
+ lookup = key_text.casefold()
+ existing_key = normalized_keys.get(lookup)
+ if existing_key:
+ existing_value = str(metadata_tags.get(existing_key) or "").strip()
+ if existing_value:
+ continue
+ target_key = existing_key
+ else:
+ target_key = key_text
+ normalized_keys[lookup] = target_key
+ metadata_tags[target_key] = value_text
+
+ total_chars = getattr(extraction, "total_characters", None) or calculate_text_length(
+ getattr(extraction, "combined_text", "")
+ )
+ chapters_source = getattr(extraction, "chapters", []) or []
+ total_chapter_count = len(chapters_source)
+ chapters_payload: List[Dict[str, Any]] = []
+ for index, chapter in enumerate(chapters_source):
+ enabled = should_preselect_chapter(chapter.title, chapter.text, index, total_chapter_count)
+ chapters_payload.append(
+ {
+ "id": f"{index:04d}",
+ "index": index,
+ "title": chapter.title,
+ "text": chapter.text,
+ "characters": calculate_text_length(chapter.text),
+ "enabled": enabled,
+ }
+ )
+
+ if not chapters_payload:
+ chapters_payload.append(
+ {
+ "id": "0000",
+ "index": 0,
+ "title": original_name,
+ "text": "",
+ "characters": 0,
+ "enabled": True,
+ }
+ )
+
+ ensure_at_least_one_chapter_enabled(chapters_payload)
+
+ language = str(form.get("language") or "a").strip() or "a"
+ profiles_map = dict(profiles) if isinstance(profiles, Mapping) else dict(profiles or {})
+ default_voice_setting = settings.get("default_voice") or ""
+ resolved_default_voice, inferred_profile, inferred_language = resolve_voice_setting(
+ default_voice_setting,
+ profiles=profiles_map,
+ )
+ base_voice_input = str(form.get("voice") or "").strip()
+ profile_selection = (form.get("voice_profile") or "__standard").strip()
+ custom_formula_raw = str(form.get("voice_formula") or "").strip()
+
+ if profile_selection in {"__standard", ""} and inferred_profile:
+ profile_selection = inferred_profile
+
+ base_voice = base_voice_input or resolved_default_voice or str(default_voice_setting).strip()
+ if not base_voice and VOICES_INTERNAL:
+ base_voice = VOICES_INTERNAL[0]
+ selected_speaker_config = (form.get("speaker_config") or "").strip()
+ speaker_config_payload = get_config(selected_speaker_config) if selected_speaker_config else None
+
+ if profile_selection == "__formula":
+ profile_name = ""
+ custom_formula = custom_formula_raw
+ elif profile_selection in {"__standard", ""}:
+ profile_name = ""
+ custom_formula = ""
+ else:
+ profile_name = profile_selection
+ custom_formula = ""
+
+ voice, language, selected_profile = resolve_voice_choice(
+ language,
+ base_voice,
+ profile_name,
+ custom_formula,
+ profiles_map,
+ )
+
+ try:
+ speed = float(form.get("speed", 1.0))
+ except (TypeError, ValueError):
+ speed = 1.0
+
+ subtitle_mode = str(form.get("subtitle_mode") or "Disabled")
+ output_format = settings["output_format"]
+ subtitle_format = settings["subtitle_format"]
+ save_mode_key = settings["save_mode"]
+ save_mode = SAVE_MODE_LABELS.get(save_mode_key, SAVE_MODE_LABELS["save_next_to_input"])
+ replace_single_newlines = settings["replace_single_newlines"]
+ use_gpu = settings["use_gpu"]
+ save_chapters_separately = settings["save_chapters_separately"]
+ merge_chapters_at_end = settings["merge_chapters_at_end"] or not save_chapters_separately
+ save_as_project = settings["save_as_project"]
+ separate_chapters_format = settings["separate_chapters_format"]
+ silence_between_chapters = settings["silence_between_chapters"]
+ chapter_intro_delay = settings["chapter_intro_delay"]
+ read_title_intro = settings["read_title_intro"]
+ read_closing_outro = settings.get("read_closing_outro", True)
+ normalize_chapter_opening_caps = settings["normalize_chapter_opening_caps"]
+ max_subtitle_words = settings["max_subtitle_words"]
+ auto_prefix_chapter_titles = settings["auto_prefix_chapter_titles"]
+
+ chunk_level_default = str(settings.get("chunk_level", "paragraph")).strip().lower()
+ raw_chunk_level = str(form.get("chunk_level") or chunk_level_default).strip().lower()
+ if raw_chunk_level not in _CHUNK_LEVEL_VALUES:
+ raw_chunk_level = chunk_level_default if chunk_level_default in _CHUNK_LEVEL_VALUES else "paragraph"
+ chunk_level_value = raw_chunk_level
+ chunk_level_literal = cast(ChunkLevel, chunk_level_value)
+
+ speaker_mode_value = "single"
+
+ generate_epub3_default = bool(settings.get("generate_epub3", False))
+ generate_epub3 = coerce_bool(form.get("generate_epub3"), generate_epub3_default)
+
+ selected_chapter_sources = [entry for entry in chapters_payload if entry.get("enabled")]
+ raw_chunks = build_chunks_for_chapters(selected_chapter_sources, level=chunk_level_literal)
+ analysis_chunks = build_chunks_for_chapters(selected_chapter_sources, level="sentence")
+
+ analysis_threshold = coerce_int(
+ settings.get("speaker_analysis_threshold"),
+ _DEFAULT_ANALYSIS_THRESHOLD,
+ minimum=1,
+ maximum=25,
+ )
+
+ initial_analysis = False
+ (
+ processed_chunks,
+ speakers,
+ analysis_payload,
+ config_languages,
+ _,
+ ) = prepare_speaker_metadata(
+ chapters=selected_chapter_sources,
+ chunks=raw_chunks,
+ analysis_chunks=analysis_chunks,
+ voice=voice,
+ voice_profile=selected_profile or None,
+ threshold=analysis_threshold,
+ run_analysis=initial_analysis,
+ speaker_config=speaker_config_payload,
+ apply_config=bool(speaker_config_payload),
+ )
+
+ def _extract_checkbox(name: str, default: bool) -> bool:
+ values: List[str] = []
+ getter = getattr(form, "getlist", None)
+ if callable(getter):
+ raw_values = getter(name)
+ if raw_values:
+ values = list(cast(Iterable[str], raw_values))
+ else:
+ raw_flag = form.get(name)
+ if raw_flag is not None:
+ values = [raw_flag]
+ if values:
+ return coerce_bool(values[-1], default)
+ return default
+
+ normalization_overrides = {}
+ for key in _NORMALIZATION_BOOLEAN_KEYS:
+ default_val = bool(settings.get(key, True))
+ normalization_overrides[key] = _extract_checkbox(key, default_val)
+
+ for key in _NORMALIZATION_STRING_KEYS:
+ default_val = str(settings.get(key, ""))
+ val = form.get(key)
+ if val is not None:
+ normalization_overrides[key] = str(val)
+ else:
+ normalization_overrides[key] = default_val
+
+ pending = PendingJob(
+ id=uuid.uuid4().hex,
+ original_filename=original_name,
+ stored_path=stored_path,
+ language=language,
+ voice=voice,
+ speed=speed,
+ use_gpu=use_gpu,
+ subtitle_mode=subtitle_mode,
+ output_format=output_format,
+ save_mode=save_mode,
+ output_folder=None,
+ replace_single_newlines=replace_single_newlines,
+ subtitle_format=subtitle_format,
+ total_characters=total_chars,
+ save_chapters_separately=save_chapters_separately,
+ merge_chapters_at_end=merge_chapters_at_end,
+ separate_chapters_format=separate_chapters_format,
+ silence_between_chapters=silence_between_chapters,
+ save_as_project=save_as_project,
+ voice_profile=selected_profile or None,
+ max_subtitle_words=max_subtitle_words,
+ metadata_tags=metadata_tags,
+ chapters=chapters_payload,
+ normalization_overrides=normalization_overrides,
+ created_at=time.time(),
+ cover_image_path=cover_path,
+ cover_image_mime=cover_mime,
+ chapter_intro_delay=chapter_intro_delay,
+ read_title_intro=bool(read_title_intro),
+ read_closing_outro=bool(read_closing_outro),
+ normalize_chapter_opening_caps=bool(normalize_chapter_opening_caps),
+ auto_prefix_chapter_titles=bool(auto_prefix_chapter_titles),
+ chunk_level=chunk_level_value,
+ speaker_mode=speaker_mode_value,
+ generate_epub3=generate_epub3,
+ chunks=processed_chunks,
+ speakers=speakers,
+ speaker_analysis=analysis_payload,
+ speaker_analysis_threshold=analysis_threshold,
+ analysis_requested=initial_analysis,
+ )
+
+ return PendingBuildResult(
+ pending=pending,
+ selected_speaker_config=selected_speaker_config or None,
+ config_languages=list(config_languages or []),
+ speaker_config_payload=speaker_config_payload,
+ )
+
+def render_jobs_panel() -> str:
+ jobs = get_service().list_jobs()
+ active_statuses = {JobStatus.PENDING, JobStatus.RUNNING, JobStatus.PAUSED}
+ active_jobs = [job for job in jobs if job.status in active_statuses]
+ active_jobs.sort(key=lambda job: ((job.queue_position or 10_000), -job.created_at))
+ finished_jobs = [job for job in jobs if job.status not in active_statuses]
+ download_flags = {job.id: job_download_flags(job) for job in jobs}
+ return render_template(
+ "partials/jobs.html",
+ active_jobs=active_jobs,
+ finished_jobs=finished_jobs[:5],
+ total_finished=len(finished_jobs),
+ JobStatus=JobStatus,
+ download_flags=download_flags,
+ audiobookshelf_manual_available=audiobookshelf_manual_available(),
+ )
+
+
+def normalize_wizard_step(step: Optional[str], pending: Optional[PendingJob] = None) -> str:
+ if pending is None:
+ default_step = "book"
+ else:
+ default_step = "chapters"
+ if not step:
+ chosen = default_step
+ else:
+ normalized = step.strip().lower()
+ if normalized in {"", "upload", "settings"}:
+ chosen = default_step
+ elif normalized == "speakers":
+ chosen = "entities"
+ elif normalized in _WIZARD_STEP_ORDER:
+ chosen = normalized
+ else:
+ chosen = default_step
+ return chosen
+
+
+def wants_wizard_json() -> bool:
+ format_hint = request.args.get("format", "").strip().lower()
+ if format_hint == "json":
+ return True
+ accept_header = (request.headers.get("Accept") or "").lower()
+ if "application/json" in accept_header:
+ return True
+ requested_with = (request.headers.get("X-Requested-With") or "").lower()
+ if requested_with in {"xmlhttprequest", "fetch"}:
+ return True
+ wizard_header = (request.headers.get("X-Abogen-Wizard") or "").lower()
+ return wizard_header == "json"
+
+
+def render_wizard_partial(
+ pending: Optional[PendingJob],
+ step: str,
+ *,
+ error: Optional[str] = None,
+ notice: Optional[str] = None,
+) -> str:
+ templates = {
+ "book": "partials/new_job_step_book.html",
+ "chapters": "partials/new_job_step_chapters.html",
+ "entities": "partials/new_job_step_entities.html",
+ }
+ template_name = templates[step]
+ context: Dict[str, Any] = {
+ "pending": pending,
+ "readonly": False,
+ "options": template_options(),
+ "settings": load_settings(),
+ "error": error,
+ "notice": notice,
+ }
+ return render_template(template_name, **context)
+
+
+def wizard_step_payload(
+ pending: Optional[PendingJob],
+ step: str,
+ html: str,
+ *,
+ error: Optional[str] = None,
+ notice: Optional[str] = None,
+) -> Dict[str, Any]:
+ meta = _WIZARD_STEP_META.get(step, {})
+ try:
+ active_index = _WIZARD_STEP_ORDER.index(step)
+ except ValueError:
+ active_index = 0
+ max_recorded_index = active_index
+ if pending is not None:
+ stored_index = int(getattr(pending, "wizard_max_step_index", -1))
+ if stored_index < 0:
+ stored_index = -1
+ max_recorded_index = max(active_index, stored_index)
+ max_allowed = len(_WIZARD_STEP_ORDER) - 1
+ if max_recorded_index > max_allowed:
+ max_recorded_index = max_allowed
+ if stored_index != max_recorded_index:
+ pending.wizard_max_step_index = max_recorded_index
+ get_service().store_pending_job(pending)
+ else:
+ max_allowed = len(_WIZARD_STEP_ORDER) - 1
+ if max_recorded_index > max_allowed:
+ max_recorded_index = max_allowed
+ completed = [slug for idx, slug in enumerate(_WIZARD_STEP_ORDER) if idx <= max_recorded_index]
+ return {
+ "step": step,
+ "step_index": int(meta.get("index", active_index + 1)),
+ "total_steps": len(_WIZARD_STEP_ORDER),
+ "title": meta.get("title", ""),
+ "hint": meta.get("hint", ""),
+ "html": html,
+ "completed_steps": completed,
+ "pending_id": pending.id if pending else "",
+ "filename": pending.original_filename if pending and pending.original_filename else "",
+ "error": error or "",
+ "notice": notice or "",
+ }
+
+
+def wizard_json_response(
+ pending: Optional[PendingJob],
+ step: str,
+ *,
+ error: Optional[str] = None,
+ notice: Optional[str] = None,
+ status: int = 200,
+) -> ResponseReturnValue:
+ html = render_wizard_partial(pending, step, error=error, notice=notice)
+ payload = wizard_step_payload(pending, step, html, error=error, notice=notice)
+ return jsonify(payload), status
diff --git a/abogen/webui/routes/utils/preview.py b/abogen/webui/routes/utils/preview.py
new file mode 100644
index 0000000..95c3040
--- /dev/null
+++ b/abogen/webui/routes/utils/preview.py
@@ -0,0 +1,210 @@
+import io
+import threading
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple
+import numpy as np
+import soundfile as sf
+from flask import current_app, send_file
+from flask.typing import ResponseReturnValue
+
+
+SPLIT_PATTERN = r"\n+"
+SAMPLE_RATE = 24000
+
+_preview_pipelines: Dict[Tuple[str, str], Any] = {}
+_preview_pipeline_lock = threading.Lock()
+
+
+def _select_device() -> str:
+ import platform
+
+ system = platform.system()
+ if system == "Darwin" and platform.processor() == "arm":
+ return "mps"
+ return "cuda"
+
+
+def _to_float32(audio_segment) -> np.ndarray:
+ if audio_segment is None:
+ return np.zeros(0, dtype="float32")
+
+ tensor = audio_segment
+ if hasattr(tensor, "detach"):
+ tensor = tensor.detach()
+ if hasattr(tensor, "cpu"):
+ try:
+ tensor = tensor.cpu()
+ except Exception:
+ pass
+ if hasattr(tensor, "numpy"):
+ return np.asarray(tensor.numpy(), dtype="float32").reshape(-1)
+ return np.asarray(tensor, dtype="float32").reshape(-1)
+
+def get_preview_pipeline(language: str, device: str) -> Any:
+ key = (language, device)
+ with _preview_pipeline_lock:
+ pipeline = _preview_pipelines.get(key)
+ if pipeline is not None:
+ return pipeline
+ from abogen.utils import load_numpy_kpipeline
+
+ _, KPipeline = load_numpy_kpipeline()
+ pipeline = KPipeline(lang_code=language, repo_id="hexgrad/Kokoro-82M", device=device)
+ _preview_pipelines[key] = pipeline
+ return pipeline
+
+def generate_preview_audio(
+ text: str,
+ voice_spec: str,
+ language: str,
+ speed: float,
+ use_gpu: bool,
+ tts_provider: str = "kokoro",
+ supertonic_total_steps: int = 5,
+ max_seconds: float = 8.0,
+ pronunciation_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ manual_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ speakers: Optional[Mapping[str, Any]] = None,
+) -> bytes:
+ if not text.strip():
+ raise ValueError("Preview text is required")
+
+ provider = (tts_provider or "kokoro").strip().lower()
+
+ # Apply pronunciation/manual overrides first so tokens like `Unfu*k` still match
+ # before any downstream normalization potentially strips punctuation.
+ source_text = text
+ if pronunciation_overrides or manual_overrides or speakers:
+ try:
+ from abogen.webui import conversion_runner as runner
+
+ class _PreviewJob:
+ def __init__(self):
+ self.language = language
+ self.voice = voice_spec
+ self.speakers = speakers
+ self.manual_overrides = list(manual_overrides or [])
+ self.pronunciation_overrides = list(pronunciation_overrides or [])
+
+ job = _PreviewJob()
+ merged = runner._merge_pronunciation_overrides(job)
+ rules = runner._compile_pronunciation_rules(merged)
+ source_text = runner._apply_pronunciation_rules(source_text, rules)
+ except Exception:
+ current_app.logger.exception("Preview override application failed; using raw text")
+ source_text = text
+
+ normalized_text = source_text
+ if provider != "supertonic":
+ try:
+ from abogen.kokoro_text_normalization import normalize_for_pipeline
+
+ normalized_text = normalize_for_pipeline(source_text)
+ except Exception:
+ current_app.logger.exception("Preview normalization failed; using raw text")
+ normalized_text = source_text
+
+ if provider == "supertonic":
+ from abogen.tts_supertonic import SupertonicPipeline
+
+ pipeline = SupertonicPipeline(sample_rate=SAMPLE_RATE, auto_download=True, total_steps=supertonic_total_steps)
+ segments = pipeline(
+ normalized_text,
+ voice=voice_spec,
+ speed=speed,
+ split_pattern=SPLIT_PATTERN,
+ total_steps=supertonic_total_steps,
+ )
+ else:
+ device = "cpu"
+ if use_gpu:
+ try:
+ device = _select_device()
+ except Exception:
+ device = "cpu"
+ use_gpu = False
+
+ pipeline = get_preview_pipeline(language, device)
+ if pipeline is None:
+ raise RuntimeError("Preview pipeline is unavailable")
+
+ voice_choice: Any = voice_spec
+ if voice_spec and "*" in voice_spec:
+ from abogen.voice_formulas import get_new_voice
+
+ voice_choice = get_new_voice(pipeline, voice_spec, use_gpu)
+
+ segments = pipeline(
+ normalized_text,
+ voice=voice_choice,
+ speed=speed,
+ split_pattern=SPLIT_PATTERN,
+ )
+
+ audio_chunks: List[np.ndarray] = []
+ accumulated = 0
+ max_samples = int(max(1.0, max_seconds) * SAMPLE_RATE)
+
+ for segment in segments:
+ graphemes = getattr(segment, "graphemes", "").strip()
+ if not graphemes:
+ continue
+ audio = _to_float32(getattr(segment, "audio", None))
+ if audio.size == 0:
+ continue
+ remaining = max_samples - accumulated
+ if remaining <= 0:
+ break
+ if audio.shape[0] > remaining:
+ audio = audio[:remaining]
+ audio_chunks.append(audio)
+ accumulated += audio.shape[0]
+ if accumulated >= max_samples:
+ break
+
+ if not audio_chunks:
+ raise RuntimeError("Preview could not be generated")
+
+ audio_data = np.concatenate(audio_chunks)
+ buffer = io.BytesIO()
+ sf.write(buffer, audio_data, SAMPLE_RATE, format="WAV")
+ return buffer.getvalue()
+
+def synthesize_preview(
+ text: str,
+ voice_spec: str,
+ language: str,
+ speed: float,
+ use_gpu: bool,
+ tts_provider: str = "kokoro",
+ supertonic_total_steps: int = 5,
+ max_seconds: float = 8.0,
+ pronunciation_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ manual_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ speakers: Optional[Mapping[str, Any]] = None,
+) -> ResponseReturnValue:
+ try:
+ audio_bytes = generate_preview_audio(
+ text=text,
+ voice_spec=voice_spec,
+ language=language,
+ speed=speed,
+ use_gpu=use_gpu,
+ tts_provider=tts_provider,
+ supertonic_total_steps=supertonic_total_steps,
+ max_seconds=max_seconds,
+ pronunciation_overrides=pronunciation_overrides,
+ manual_overrides=manual_overrides,
+ speakers=speakers,
+ )
+ except Exception as e:
+ raise e
+
+ buffer = io.BytesIO(audio_bytes)
+ response = send_file(
+ buffer,
+ mimetype="audio/wav",
+ as_attachment=False,
+ download_name="speaker_preview.wav",
+ )
+ response.headers["Cache-Control"] = "no-store"
+ return response
diff --git a/abogen/webui/routes/utils/service.py b/abogen/webui/routes/utils/service.py
new file mode 100644
index 0000000..b48f94a
--- /dev/null
+++ b/abogen/webui/routes/utils/service.py
@@ -0,0 +1,67 @@
+from typing import cast
+from flask import current_app, abort
+from abogen.webui.service import ConversionService, PendingJob
+
+def get_service() -> ConversionService:
+ return current_app.extensions["conversion_service"]
+
+def require_pending_job(pending_id: str) -> PendingJob:
+ pending = get_service().get_pending_job(pending_id)
+ if not pending:
+ abort(404)
+ return cast(PendingJob, pending)
+
+def remove_pending_job(pending_id: str) -> None:
+ get_service().pop_pending_job(pending_id)
+
+def submit_job(pending: PendingJob) -> str:
+ service = get_service()
+ service.pop_pending_job(pending.id)
+
+ job = service.enqueue(
+ original_filename=pending.original_filename,
+ stored_path=pending.stored_path,
+ language=pending.language,
+ tts_provider=getattr(pending, "tts_provider", "kokoro"),
+ voice=pending.voice,
+ speed=pending.speed,
+ supertonic_total_steps=getattr(pending, "supertonic_total_steps", 5),
+ use_gpu=pending.use_gpu,
+ subtitle_mode=pending.subtitle_mode,
+ output_format=pending.output_format,
+ save_mode=pending.save_mode,
+ output_folder=pending.output_folder,
+ replace_single_newlines=pending.replace_single_newlines,
+ subtitle_format=pending.subtitle_format,
+ total_characters=pending.total_characters,
+ chapters=pending.chapters,
+ save_chapters_separately=pending.save_chapters_separately,
+ merge_chapters_at_end=pending.merge_chapters_at_end,
+ separate_chapters_format=pending.separate_chapters_format,
+ silence_between_chapters=pending.silence_between_chapters,
+ save_as_project=pending.save_as_project,
+ voice_profile=pending.voice_profile,
+ max_subtitle_words=pending.max_subtitle_words,
+ metadata_tags=pending.metadata_tags,
+ cover_image_path=pending.cover_image_path,
+ cover_image_mime=pending.cover_image_mime,
+ chapter_intro_delay=pending.chapter_intro_delay,
+ read_title_intro=pending.read_title_intro,
+ read_closing_outro=pending.read_closing_outro,
+ auto_prefix_chapter_titles=pending.auto_prefix_chapter_titles,
+ normalize_chapter_opening_caps=pending.normalize_chapter_opening_caps,
+ chunk_level=pending.chunk_level,
+ chunks=pending.chunks,
+ speakers=pending.speakers,
+ speaker_mode=pending.speaker_mode,
+ generate_epub3=pending.generate_epub3,
+ speaker_analysis=pending.speaker_analysis,
+ speaker_analysis_threshold=pending.speaker_analysis_threshold,
+ analysis_requested=pending.analysis_requested,
+ entity_summary=getattr(pending, "entity_summary", None),
+ manual_overrides=getattr(pending, "manual_overrides", None),
+ pronunciation_overrides=getattr(pending, "pronunciation_overrides", None),
+ heteronym_overrides=getattr(pending, "heteronym_overrides", None),
+ normalization_overrides=pending.normalization_overrides,
+ )
+ return job.id
diff --git a/abogen/webui/routes/utils/settings.py b/abogen/webui/routes/utils/settings.py
new file mode 100644
index 0000000..c96a66c
--- /dev/null
+++ b/abogen/webui/routes/utils/settings.py
@@ -0,0 +1,752 @@
+import os
+import re
+from typing import Any, Dict, Mapping, Optional
+
+from abogen.constants import (
+ LANGUAGE_DESCRIPTIONS,
+ SUBTITLE_FORMATS,
+ SUPPORTED_SOUND_FORMATS,
+ VOICES_INTERNAL,
+)
+from abogen.normalization_settings import (
+ DEFAULT_LLM_PROMPT,
+ environment_llm_defaults,
+)
+from abogen.utils import load_config, save_config
+from abogen.integrations.calibre_opds import CalibreOPDSClient
+from abogen.integrations.audiobookshelf import AudiobookshelfConfig
+from abogen.webui.routes.utils.common import split_profile_spec
+
+SAVE_MODE_LABELS = {
+ "save_next_to_input": "Save next to input file",
+ "save_to_desktop": "Save to Desktop",
+ "choose_output_folder": "Choose output folder",
+ "default_output": "Use default save location",
+}
+
+LEGACY_SAVE_MODE_MAP = {label: key for key, label in SAVE_MODE_LABELS.items()}
+
+_CHUNK_LEVEL_OPTIONS = [
+ {"value": "paragraph", "label": "Paragraphs"},
+ {"value": "sentence", "label": "Sentences"},
+]
+
+_CHUNK_LEVEL_VALUES = {option["value"] for option in _CHUNK_LEVEL_OPTIONS}
+
+_DEFAULT_ANALYSIS_THRESHOLD = 3
+
+_APOSTROPHE_MODE_OPTIONS = [
+ {"value": "off", "label": "Off"},
+ {"value": "spacy", "label": "spaCy (built-in)"},
+ {"value": "llm", "label": "LLM assisted"},
+]
+
+_NORMALIZATION_BOOLEAN_KEYS = {
+ "normalization_numbers",
+ "normalization_titles",
+ "normalization_terminal",
+ "normalization_phoneme_hints",
+ "normalization_caps_quotes",
+ "normalization_currency",
+ "normalization_footnotes",
+ "normalization_internet_slang",
+ "normalization_apostrophes_contractions",
+ "normalization_apostrophes_plural_possessives",
+ "normalization_apostrophes_sibilant_possessives",
+ "normalization_apostrophes_decades",
+ "normalization_apostrophes_leading_elisions",
+ "normalization_contraction_aux_be",
+ "normalization_contraction_aux_have",
+ "normalization_contraction_modal_will",
+ "normalization_contraction_modal_would",
+ "normalization_contraction_negation_not",
+ "normalization_contraction_let_us",
+}
+
+_NORMALIZATION_STRING_KEYS = {
+ "normalization_numbers_year_style",
+ "normalization_apostrophe_mode",
+}
+
+BOOLEAN_SETTINGS = {
+ "replace_single_newlines",
+ "use_gpu",
+ "save_chapters_separately",
+ "merge_chapters_at_end",
+ "save_as_project",
+ "generate_epub3",
+ "enable_entity_recognition",
+ "read_title_intro",
+ "read_closing_outro",
+ "auto_prefix_chapter_titles",
+ "normalize_chapter_opening_caps",
+ "normalization_numbers",
+ "normalization_titles",
+ "normalization_terminal",
+ "normalization_phoneme_hints",
+ "normalization_caps_quotes",
+ "normalization_currency",
+ "normalization_footnotes",
+ "normalization_internet_slang",
+ "normalization_apostrophes_contractions",
+ "normalization_apostrophes_plural_possessives",
+ "normalization_apostrophes_sibilant_possessives",
+ "normalization_apostrophes_decades",
+ "normalization_apostrophes_leading_elisions",
+ "normalization_contraction_aux_be",
+ "normalization_contraction_aux_have",
+ "normalization_contraction_modal_will",
+ "normalization_contraction_modal_would",
+ "normalization_contraction_negation_not",
+ "normalization_contraction_let_us",
+}
+
+FLOAT_SETTINGS = {"silence_between_chapters", "chapter_intro_delay", "llm_timeout"}
+INT_SETTINGS = {"max_subtitle_words", "speaker_analysis_threshold"}
+
+_NORMALIZATION_GROUPS = [
+ {
+ "label": "General Rules",
+ "options": [
+ {"key": "normalization_numbers", "label": "Convert grouped numbers to words"},
+ {"key": "normalization_currency", "label": "Convert currency symbols ($10 → ten dollars)"},
+ {"key": "normalization_titles", "label": "Expand titles and suffixes (Dr., St., Jr., …)"},
+ {"key": "normalization_internet_slang", "label": "Expand internet slang (pls → please)"},
+ {"key": "normalization_footnotes", "label": "Remove footnote indicators ([1], [2])"},
+ {"key": "normalization_terminal", "label": "Ensure sentences end with terminal punctuation"},
+ {"key": "normalization_caps_quotes", "label": "Convert ALL CAPS dialogue inside quotes"},
+ ]
+ },
+ {
+ "label": "Apostrophes & Contractions",
+ "options": [
+ {"key": "normalization_apostrophes_contractions", "label": "Expand contractions (it's → it is)"},
+ {"key": "normalization_apostrophes_plural_possessives", "label": "Collapse plural possessives (dogs' → dogs)"},
+ {"key": "normalization_apostrophes_sibilant_possessives", "label": "Mark sibilant possessives (boss's → boss + IZ marker)"},
+ {"key": "normalization_apostrophes_decades", "label": "Expand decades ('90s → 1990s)"},
+ {"key": "normalization_apostrophes_leading_elisions", "label": "Expand leading elisions ('tis → it is)"},
+ {"key": "normalization_phoneme_hints", "label": "Add phoneme hints for possessives"},
+ {"key": "normalization_contraction_aux_be", "label": "Expand auxiliary 'be' (I'm → I am)"},
+ {"key": "normalization_contraction_aux_have", "label": "Expand auxiliary 'have' (I've → I have)"},
+ {"key": "normalization_contraction_modal_will", "label": "Expand modal 'will' (I'll → I will)"},
+ {"key": "normalization_contraction_modal_would", "label": "Expand modal 'would' (I'd → I would)"},
+ {"key": "normalization_contraction_negation_not", "label": "Expand negation 'not' (don't → do not)"},
+ {"key": "normalization_contraction_let_us", "label": "Expand 'let's' → let us"},
+ ]
+ }
+]
+
+
+def integration_defaults() -> Dict[str, Dict[str, Any]]:
+ return {
+ "calibre_opds": {
+ "enabled": False,
+ "base_url": "",
+ "username": "",
+ "password": "",
+ "verify_ssl": True,
+ },
+ "audiobookshelf": {
+ "enabled": False,
+ "base_url": "",
+ "api_token": "",
+ "library_id": "",
+ "collection_id": "",
+ "folder_id": "",
+ "verify_ssl": True,
+ "send_cover": True,
+ "send_chapters": True,
+ "send_subtitles": False,
+ "auto_send": False,
+ "timeout": 30.0,
+ },
+ }
+
+
+def has_output_override() -> bool:
+ return bool(os.environ.get("ABOGEN_OUTPUT_DIR") or os.environ.get("ABOGEN_OUTPUT_ROOT"))
+
+
+def settings_defaults() -> Dict[str, Any]:
+ llm_env_defaults = environment_llm_defaults()
+ return {
+ "output_format": "wav",
+ "subtitle_format": "srt",
+ "save_mode": "default_output" if has_output_override() else "save_next_to_input",
+ "default_speaker": "",
+ "default_voice": VOICES_INTERNAL[0] if VOICES_INTERNAL else "",
+ "supertonic_total_steps": 5,
+ "supertonic_speed": 1.0,
+ "replace_single_newlines": False,
+ "use_gpu": True,
+ "save_chapters_separately": False,
+ "merge_chapters_at_end": True,
+ "save_as_project": False,
+ "separate_chapters_format": "wav",
+ "silence_between_chapters": 2.0,
+ "chapter_intro_delay": 0.5,
+ "read_title_intro": False,
+ "read_closing_outro": True,
+ "normalize_chapter_opening_caps": True,
+ "max_subtitle_words": 50,
+ "chunk_level": "paragraph",
+ "enable_entity_recognition": True,
+ "generate_epub3": False,
+ "auto_prefix_chapter_titles": True,
+ "speaker_analysis_threshold": _DEFAULT_ANALYSIS_THRESHOLD,
+ "speaker_pronunciation_sentence": "This is {{name}} speaking.",
+ "speaker_random_languages": [],
+ "llm_base_url": llm_env_defaults.get("llm_base_url", ""),
+ "llm_api_key": llm_env_defaults.get("llm_api_key", ""),
+ "llm_model": llm_env_defaults.get("llm_model", ""),
+ "llm_timeout": llm_env_defaults.get("llm_timeout", 30.0),
+ "llm_prompt": llm_env_defaults.get("llm_prompt", DEFAULT_LLM_PROMPT),
+ "llm_context_mode": llm_env_defaults.get("llm_context_mode", "sentence"),
+ "normalization_numbers": True,
+ "normalization_currency": True,
+ "normalization_footnotes": True,
+ "normalization_titles": True,
+ "normalization_terminal": True,
+ "normalization_phoneme_hints": True,
+ "normalization_caps_quotes": True,
+ "normalization_internet_slang": False,
+ "normalization_apostrophes_contractions": True,
+ "normalization_apostrophes_plural_possessives": True,
+ "normalization_apostrophes_sibilant_possessives": True,
+ "normalization_apostrophes_decades": True,
+ "normalization_apostrophes_leading_elisions": True,
+ "normalization_apostrophe_mode": "spacy",
+ "normalization_numbers_year_style": "american",
+ "normalization_contraction_aux_be": True,
+ "normalization_contraction_aux_have": True,
+ "normalization_contraction_modal_will": True,
+ "normalization_contraction_modal_would": True,
+ "normalization_contraction_negation_not": True,
+ "normalization_contraction_let_us": True,
+ }
+
+
+def llm_ready(settings: Mapping[str, Any]) -> bool:
+ base_url = str(settings.get("llm_base_url") or "").strip()
+ return bool(base_url)
+
+
+_PROMPT_TOKEN_RE = re.compile(r"{{\s*([a-zA-Z0-9_]+)\s*}}")
+
+
+def render_prompt_template(template: str, context: Mapping[str, str]) -> str:
+ if not template:
+ return ""
+
+ def _replace(match: re.Match[str]) -> str:
+ key = match.group(1)
+ return context.get(key, "")
+
+ return _PROMPT_TOKEN_RE.sub(_replace, template)
+
+
+def coerce_bool(value: Any, default: bool) -> bool:
+ if isinstance(value, bool):
+ return value
+ if isinstance(value, str):
+ return value.lower() in {"true", "1", "yes", "on"}
+ if value is None:
+ return default
+ return bool(value)
+
+
+def coerce_float(value: Any, default: float) -> float:
+ try:
+ return max(0.0, float(value))
+ except (TypeError, ValueError):
+ return default
+
+
+def coerce_int(value: Any, default: int, *, minimum: int = 1, maximum: int = 200) -> int:
+ try:
+ parsed = int(value)
+ except (TypeError, ValueError):
+ return default
+ return max(minimum, min(parsed, maximum))
+
+
+def normalize_save_mode(value: Any, default: str) -> str:
+ if isinstance(value, str):
+ if value in SAVE_MODE_LABELS:
+ return value
+ if value in LEGACY_SAVE_MODE_MAP:
+ return LEGACY_SAVE_MODE_MAP[value]
+ return default
+
+
+def normalize_setting_value(key: str, value: Any, defaults: Dict[str, Any]) -> Any:
+ if key in BOOLEAN_SETTINGS:
+ return coerce_bool(value, defaults[key])
+ if key in FLOAT_SETTINGS:
+ return coerce_float(value, defaults[key])
+ if key in INT_SETTINGS:
+ return coerce_int(value, defaults[key])
+ if key == "save_mode":
+ return normalize_save_mode(value, defaults[key])
+ if key == "output_format":
+ return value if value in SUPPORTED_SOUND_FORMATS else defaults[key]
+ if key == "subtitle_format":
+ valid = {item[0] for item in SUBTITLE_FORMATS}
+ return value if value in valid else defaults[key]
+ if key == "separate_chapters_format":
+ if isinstance(value, str):
+ normalized = value.lower()
+ if normalized in {"wav", "flac", "mp3", "opus"}:
+ return normalized
+ return defaults[key]
+ if key == "default_voice":
+ if isinstance(value, str):
+ text = value.strip()
+ if not text:
+ return defaults[key]
+ spec, profile_name = split_profile_spec(text)
+ if profile_name:
+ return f"speaker:{profile_name}"
+ return spec
+ return defaults[key]
+ if key == "default_speaker":
+ if isinstance(value, str):
+ text = value.strip()
+ if not text:
+ return ""
+ spec, profile_name = split_profile_spec(text)
+ if profile_name:
+ return f"speaker:{profile_name}"
+ return spec
+ return ""
+ if key == "chunk_level":
+ if isinstance(value, str) and value in _CHUNK_LEVEL_VALUES:
+ return value
+ return defaults[key]
+ if key == "normalization_apostrophe_mode":
+ if isinstance(value, str):
+ normalized_mode = value.strip().lower()
+ if normalized_mode in {"off", "spacy", "llm"}:
+ return normalized_mode
+ return defaults[key]
+ if key == "normalization_numbers_year_style":
+ if isinstance(value, str):
+ normalized_style = value.strip().lower()
+ if normalized_style in {"american", "off"}:
+ return normalized_style
+ return defaults[key]
+ if key == "llm_context_mode":
+ if isinstance(value, str):
+ normalized_scope = value.strip().lower()
+ if normalized_scope == "sentence":
+ return normalized_scope
+ return defaults[key]
+ if key == "llm_prompt":
+ candidate = str(value or "").strip()
+ return candidate if candidate else defaults[key]
+ if key in {"llm_base_url", "llm_api_key", "llm_model"}:
+ return str(value or "").strip()
+ if key == "speaker_random_languages":
+ if isinstance(value, (list, tuple, set)):
+ return [code for code in value if isinstance(code, str) and code in LANGUAGE_DESCRIPTIONS]
+ if isinstance(value, str):
+ parts = [item.strip().lower() for item in value.split(",") if item.strip()]
+ return [code for code in parts if code in LANGUAGE_DESCRIPTIONS]
+ return defaults.get(key, [])
+ if key == "supertonic_total_steps":
+ try:
+ steps = int(value)
+ except (TypeError, ValueError):
+ return defaults.get(key, 5)
+ return max(2, min(15, steps))
+ if key == "supertonic_speed":
+ try:
+ speed = float(value)
+ except (TypeError, ValueError):
+ return defaults.get(key, 1.0)
+ return max(0.7, min(2.0, speed))
+ return value if value is not None else defaults.get(key)
+
+
+def load_settings() -> Dict[str, Any]:
+ defaults = settings_defaults()
+ cfg = load_config() or {}
+ settings: Dict[str, Any] = {}
+ for key, default in defaults.items():
+ raw_value = cfg.get(key, default)
+ settings[key] = normalize_setting_value(key, raw_value, defaults)
+ return settings
+
+
+def load_integration_settings() -> Dict[str, Dict[str, Any]]:
+ defaults = integration_defaults()
+ cfg = load_config() or {}
+ # Integrations are stored under the "integrations" key in the config
+ stored_integrations = cfg.get("integrations", {})
+ if not isinstance(stored_integrations, Mapping):
+ stored_integrations = {}
+
+ integrations: Dict[str, Dict[str, Any]] = {}
+ for key, default in defaults.items():
+ stored = stored_integrations.get(key)
+ merged: Dict[str, Any] = dict(default)
+ if isinstance(stored, Mapping):
+ for field, default_value in default.items():
+ value = stored.get(field, default_value)
+ if isinstance(default_value, bool):
+ merged[field] = coerce_bool(value, default_value)
+ elif isinstance(default_value, float):
+ try:
+ merged[field] = float(value)
+ except (TypeError, ValueError):
+ merged[field] = default_value
+ elif isinstance(default_value, int):
+ try:
+ merged[field] = int(value)
+ except (TypeError, ValueError):
+ merged[field] = default_value
+ else:
+ merged[field] = str(value or "")
+ if key == "calibre_opds":
+ merged["has_password"] = bool(isinstance(stored, Mapping) and stored.get("password"))
+ # Do not clear the password here, let the template decide whether to show it or not
+ # merged["password"] = ""
+ elif key == "audiobookshelf":
+ merged["has_api_token"] = bool(isinstance(stored, Mapping) and stored.get("api_token"))
+ # Do not clear the token here
+ # merged["api_token"] = ""
+ integrations[key] = merged
+
+ # Environment variable fallbacks for Calibre OPDS
+ calibre = integrations["calibre_opds"]
+ if not calibre.get("base_url"):
+ calibre["base_url"] = os.environ.get("CALIBRE_SERVER_HOST", "")
+ if not calibre.get("username"):
+ calibre["username"] = os.environ.get("OPDS_USERNAME", "")
+ if not calibre.get("password"):
+ calibre["password"] = os.environ.get("OPDS_PASSWORD", "")
+
+ # If we have a password (from storage or env), mark it as present for the UI
+ if calibre.get("password"):
+ calibre["has_password"] = True
+
+ # Auto-enable if configured via env but not explicitly disabled in config
+ stored_calibre = stored_integrations.get("calibre_opds")
+ if stored_calibre is None and calibre.get("base_url"):
+ calibre["enabled"] = True
+
+ return integrations
+
+
+def stored_integration_config(name: str) -> Dict[str, Any]:
+ cfg = load_config() or {}
+ # Check under "integrations" first (new structure)
+ integrations = cfg.get("integrations")
+ if isinstance(integrations, Mapping):
+ entry = integrations.get(name)
+ if isinstance(entry, Mapping):
+ return dict(entry)
+
+ # Fallback to top-level (legacy structure)
+ entry = cfg.get(name)
+ if isinstance(entry, Mapping):
+ return dict(entry)
+ return {}
+
+
+def calibre_settings_from_payload(payload: Mapping[str, Any]) -> Dict[str, Any]:
+ defaults = integration_defaults()["calibre_opds"]
+ stored = stored_integration_config("calibre_opds")
+
+ base_url = str(
+ payload.get("base_url")
+ or payload.get("calibre_opds_base_url")
+ or stored.get("base_url")
+ or ""
+ ).strip()
+ username = str(
+ payload.get("username")
+ or payload.get("calibre_opds_username")
+ or stored.get("username")
+ or ""
+ ).strip()
+ password_input = str(
+ payload.get("password")
+ or payload.get("calibre_opds_password")
+ or ""
+ ).strip()
+ use_saved_password = coerce_bool(
+ payload.get("use_saved_password")
+ or payload.get("calibre_opds_use_saved_password"),
+ False,
+ )
+ clear_saved_password = coerce_bool(
+ payload.get("clear_saved_password")
+ or payload.get("calibre_opds_password_clear"),
+ False,
+ )
+ password = ""
+ if password_input:
+ password = password_input
+ elif use_saved_password and not clear_saved_password:
+ password = str(stored.get("password") or "")
+
+ verify_ssl = coerce_bool(
+ payload.get("verify_ssl")
+ or payload.get("calibre_opds_verify_ssl"),
+ defaults["verify_ssl"],
+ )
+ enabled = coerce_bool(
+ payload.get("enabled")
+ or payload.get("calibre_opds_enabled"),
+ coerce_bool(stored.get("enabled"), False),
+ )
+
+ return {
+ "enabled": enabled,
+ "base_url": base_url,
+ "username": username,
+ "password": password,
+ "verify_ssl": verify_ssl,
+ }
+
+
+def audiobookshelf_settings_from_payload(payload: Mapping[str, Any]) -> Dict[str, Any]:
+ defaults = integration_defaults()["audiobookshelf"]
+ stored = stored_integration_config("audiobookshelf")
+
+ base_url = str(
+ payload.get("base_url")
+ or payload.get("audiobookshelf_base_url")
+ or stored.get("base_url")
+ or ""
+ ).strip()
+ library_id = str(
+ payload.get("library_id")
+ or payload.get("audiobookshelf_library_id")
+ or stored.get("library_id")
+ or ""
+ ).strip()
+ collection_id = str(
+ payload.get("collection_id")
+ or payload.get("audiobookshelf_collection_id")
+ or stored.get("collection_id")
+ or ""
+ ).strip()
+ folder_id = str(
+ payload.get("folder_id")
+ or payload.get("audiobookshelf_folder_id")
+ or stored.get("folder_id")
+ or ""
+ ).strip()
+ token_input = str(
+ payload.get("api_token")
+ or payload.get("audiobookshelf_api_token")
+ or ""
+ ).strip()
+ use_saved_token = coerce_bool(
+ payload.get("use_saved_token")
+ or payload.get("audiobookshelf_use_saved_token"),
+ False,
+ )
+ clear_saved_token = coerce_bool(
+ payload.get("clear_saved_token")
+ or payload.get("audiobookshelf_api_token_clear"),
+ False,
+ )
+ if token_input:
+ api_token = token_input
+ elif use_saved_token and not clear_saved_token:
+ api_token = str(stored.get("api_token") or "")
+ else:
+ api_token = ""
+
+ verify_ssl = coerce_bool(
+ payload.get("verify_ssl")
+ or payload.get("audiobookshelf_verify_ssl"),
+ defaults["verify_ssl"],
+ )
+ send_cover = coerce_bool(
+ payload.get("send_cover")
+ or payload.get("audiobookshelf_send_cover"),
+ defaults["send_cover"],
+ )
+ send_chapters = coerce_bool(
+ payload.get("send_chapters")
+ or payload.get("audiobookshelf_send_chapters"),
+ defaults["send_chapters"],
+ )
+ send_subtitles = coerce_bool(
+ payload.get("send_subtitles")
+ or payload.get("audiobookshelf_send_subtitles"),
+ defaults["send_subtitles"],
+ )
+ auto_send = coerce_bool(
+ payload.get("auto_send")
+ or payload.get("audiobookshelf_auto_send"),
+ defaults["auto_send"],
+ )
+ timeout_raw = (
+ payload.get("timeout")
+ or payload.get("audiobookshelf_timeout")
+ or stored.get("timeout")
+ or defaults["timeout"]
+ )
+ try:
+ timeout = float(timeout_raw)
+ except (TypeError, ValueError):
+ timeout = defaults["timeout"]
+
+ enabled = coerce_bool(
+ payload.get("enabled")
+ or payload.get("audiobookshelf_enabled"),
+ coerce_bool(stored.get("enabled"), False),
+ )
+
+ return {
+ "enabled": enabled,
+ "base_url": base_url,
+ "library_id": library_id,
+ "collection_id": collection_id,
+ "folder_id": folder_id,
+ "api_token": api_token,
+ "verify_ssl": verify_ssl,
+ "send_cover": send_cover,
+ "send_chapters": send_chapters,
+ "send_subtitles": send_subtitles,
+ "auto_send": auto_send,
+ "timeout": timeout,
+ }
+
+
+def build_audiobookshelf_config(settings: Mapping[str, Any]) -> Optional[AudiobookshelfConfig]:
+ base_url = str(settings.get("base_url") or "").strip()
+ api_token = str(settings.get("api_token") or "").strip()
+ library_id = str(settings.get("library_id") or "").strip()
+ if not (base_url and api_token and library_id):
+ return None
+ try:
+ timeout = float(settings.get("timeout", 3600.0))
+ except (TypeError, ValueError):
+ timeout = 3600.0
+ return AudiobookshelfConfig(
+ base_url=base_url,
+ api_token=api_token,
+ library_id=library_id,
+ collection_id=(str(settings.get("collection_id") or "").strip() or None),
+ folder_id=(str(settings.get("folder_id") or "").strip() or None),
+ verify_ssl=coerce_bool(settings.get("verify_ssl"), True),
+ send_cover=coerce_bool(settings.get("send_cover"), True),
+ send_chapters=coerce_bool(settings.get("send_chapters"), True),
+ send_subtitles=coerce_bool(settings.get("send_subtitles"), False),
+ timeout=timeout,
+ )
+
+
+def calibre_integration_enabled(
+ integrations: Optional[Mapping[str, Any]] = None,
+) -> bool:
+ if integrations is None:
+ integrations = load_integration_settings()
+ payload = integrations.get("calibre_opds") if isinstance(integrations, Mapping) else None
+ if not isinstance(payload, Mapping):
+ return False
+ base_url = str(payload.get("base_url") or "").strip()
+ enabled_flag = coerce_bool(payload.get("enabled"), False)
+ return bool(enabled_flag and base_url)
+
+
+def audiobookshelf_manual_available() -> bool:
+ settings = stored_integration_config("audiobookshelf")
+ if not settings:
+ return False
+ return coerce_bool(settings.get("enabled"), False)
+
+
+def build_calibre_client(settings: Mapping[str, Any]) -> CalibreOPDSClient:
+ base_url = str(settings.get("base_url") or "").strip()
+ if not base_url:
+ raise ValueError("Calibre OPDS base URL is required")
+ username = str(settings.get("username") or "").strip() or None
+ password = str(settings.get("password") or "").strip() or None
+ verify_ssl = coerce_bool(settings.get("verify_ssl"), True)
+ timeout_raw = settings.get("timeout", 15.0)
+ try:
+ timeout = float(timeout_raw)
+ except (TypeError, ValueError):
+ timeout = 15.0
+ return CalibreOPDSClient(
+ base_url,
+ username=username,
+ password=password,
+ timeout=timeout,
+ verify=verify_ssl,
+ )
+
+
+def apply_integration_form(cfg: Dict[str, Any], form: Mapping[str, Any]) -> None:
+ defaults = integration_defaults()
+
+ current_calibre = dict(cfg.get("calibre_opds") or {})
+ calibre_enabled = coerce_bool(form.get("calibre_opds_enabled"), False)
+ calibre_base = str(form.get("calibre_opds_base_url") or current_calibre.get("base_url") or "").strip()
+ calibre_username = str(form.get("calibre_opds_username") or current_calibre.get("username") or "").strip()
+ calibre_password_input = str(form.get("calibre_opds_password") or "")
+ calibre_clear = coerce_bool(form.get("calibre_opds_password_clear"), False)
+ if calibre_password_input:
+ calibre_password = calibre_password_input
+ elif calibre_clear:
+ calibre_password = ""
+ else:
+ calibre_password = str(current_calibre.get("password") or "")
+ calibre_verify = coerce_bool(form.get("calibre_opds_verify_ssl"), defaults["calibre_opds"]["verify_ssl"])
+ cfg["calibre_opds"] = {
+ "enabled": calibre_enabled,
+ "base_url": calibre_base,
+ "username": calibre_username,
+ "password": calibre_password,
+ "verify_ssl": calibre_verify,
+ }
+
+ current_abs = dict(cfg.get("audiobookshelf") or {})
+ abs_enabled = coerce_bool(form.get("audiobookshelf_enabled"), False)
+ abs_base = str(form.get("audiobookshelf_base_url") or current_abs.get("base_url") or "").strip()
+ abs_library = str(form.get("audiobookshelf_library_id") or current_abs.get("library_id") or "").strip()
+ abs_collection = str(form.get("audiobookshelf_collection_id") or current_abs.get("collection_id") or "").strip()
+ abs_folder = str(form.get("audiobookshelf_folder_id") or current_abs.get("folder_id") or "").strip()
+ abs_token_input = str(form.get("audiobookshelf_api_token") or "")
+ abs_token_clear = coerce_bool(form.get("audiobookshelf_api_token_clear"), False)
+ if abs_token_input:
+ abs_token = abs_token_input
+ elif abs_token_clear:
+ abs_token = ""
+ else:
+ abs_token = str(current_abs.get("api_token") or "")
+ abs_verify = coerce_bool(form.get("audiobookshelf_verify_ssl"), defaults["audiobookshelf"]["verify_ssl"])
+ abs_send_cover = coerce_bool(form.get("audiobookshelf_send_cover"), defaults["audiobookshelf"]["send_cover"])
+ abs_send_chapters = coerce_bool(form.get("audiobookshelf_send_chapters"), defaults["audiobookshelf"]["send_chapters"])
+ abs_send_subtitles = coerce_bool(form.get("audiobookshelf_send_subtitles"), defaults["audiobookshelf"]["send_subtitles"])
+ abs_auto_send = coerce_bool(form.get("audiobookshelf_auto_send"), defaults["audiobookshelf"]["auto_send"])
+ timeout_raw = form.get("audiobookshelf_timeout", current_abs.get("timeout", defaults["audiobookshelf"]["timeout"]))
+ try:
+ abs_timeout = float(timeout_raw)
+ except (TypeError, ValueError):
+ abs_timeout = defaults["audiobookshelf"]["timeout"]
+ cfg["audiobookshelf"] = {
+ "enabled": abs_enabled,
+ "base_url": abs_base,
+ "api_token": abs_token,
+ "library_id": abs_library,
+ "collection_id": abs_collection,
+ "folder_id": abs_folder,
+ "verify_ssl": abs_verify,
+ "send_cover": abs_send_cover,
+ "send_chapters": abs_send_chapters,
+ "send_subtitles": abs_send_subtitles,
+ "auto_send": abs_auto_send,
+ "timeout": abs_timeout,
+ }
+
+
+def save_settings(settings: Dict[str, Any]) -> None:
+ save_config(settings)
diff --git a/abogen/webui/routes/utils/voice.py b/abogen/webui/routes/utils/voice.py
new file mode 100644
index 0000000..3d9081a
--- /dev/null
+++ b/abogen/webui/routes/utils/voice.py
@@ -0,0 +1,809 @@
+import threading
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, cast
+import numpy as np
+
+from abogen.speaker_configs import slugify_label
+from abogen.speaker_analysis import analyze_speakers
+from abogen.webui.routes.utils.settings import load_settings, settings_defaults, _DEFAULT_ANALYSIS_THRESHOLD, _CHUNK_LEVEL_OPTIONS, _APOSTROPHE_MODE_OPTIONS, _NORMALIZATION_GROUPS
+from abogen.webui.routes.utils.common import split_profile_spec
+from abogen.voice_profiles import (
+ load_profiles,
+ serialize_profiles,
+)
+from abogen.voice_formulas import get_new_voice, parse_formula_terms
+from abogen.constants import (
+ LANGUAGE_DESCRIPTIONS,
+ SUBTITLE_FORMATS,
+ SUPPORTED_SOUND_FORMATS,
+ SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
+ SAMPLE_VOICE_TEXTS,
+ VOICES_INTERNAL,
+)
+from abogen.speaker_configs import list_configs
+from abogen.utils import load_numpy_kpipeline
+from abogen.webui.conversion_runner import _select_device, _to_float32, SAMPLE_RATE, SPLIT_PATTERN
+
+_preview_pipeline_lock = threading.RLock()
+_preview_pipelines: Dict[Tuple[str, str], Any] = {}
+
+def build_narrator_roster(
+ voice: str,
+ voice_profile: Optional[str],
+ existing: Optional[Mapping[str, Any]] = None,
+) -> Dict[str, Any]:
+ roster: Dict[str, Any] = {
+ "narrator": {
+ "id": "narrator",
+ "label": "Narrator",
+ "voice": voice,
+ }
+ }
+ if voice_profile:
+ roster["narrator"]["voice_profile"] = voice_profile
+ existing_entry: Optional[Mapping[str, Any]] = None
+ if existing is not None:
+ existing_entry = existing.get("narrator") if isinstance(existing, Mapping) else None
+ if isinstance(existing_entry, Mapping):
+ roster_entry = roster["narrator"]
+ for key in ("label", "voice", "voice_profile", "voice_formula", "pronunciation"):
+ value = existing_entry.get(key)
+ if value is not None and value != "":
+ roster_entry[key] = value
+ return roster
+
+
+def build_speaker_roster(
+ analysis: Dict[str, Any],
+ base_voice: str,
+ voice_profile: Optional[str],
+ existing: Optional[Mapping[str, Any]] = None,
+ order: Optional[Iterable[str]] = None,
+) -> Dict[str, Any]:
+ roster = build_narrator_roster(base_voice, voice_profile, existing)
+ existing_map: Dict[str, Any] = dict(existing) if isinstance(existing, Mapping) else {}
+ speakers = analysis.get("speakers", {}) if isinstance(analysis, dict) else {}
+ ordered_ids: Iterable[str]
+ if order is not None:
+ ordered_ids = [sid for sid in order if sid in speakers]
+ else:
+ ordered_ids = speakers.keys()
+
+ for speaker_id in ordered_ids:
+ payload = speakers.get(speaker_id, {})
+ if speaker_id == "narrator":
+ continue
+ if isinstance(payload, Mapping) and payload.get("suppressed"):
+ continue
+ previous = existing_map.get(speaker_id)
+ roster[speaker_id] = {
+ "id": speaker_id,
+ "label": payload.get("label") or speaker_id.replace("_", " ").title(),
+ "analysis_confidence": payload.get("confidence"),
+ "analysis_count": payload.get("count"),
+ "gender": payload.get("gender", "unknown"),
+ }
+ detected_gender = payload.get("detected_gender")
+ if detected_gender:
+ roster[speaker_id]["detected_gender"] = detected_gender
+ samples = payload.get("sample_quotes")
+ if isinstance(samples, list):
+ roster[speaker_id]["sample_quotes"] = samples
+ if isinstance(previous, Mapping):
+ for key in ("voice", "voice_profile", "voice_formula", "resolved_voice", "pronunciation"):
+ value = previous.get(key)
+ if value is not None and value != "":
+ roster[speaker_id][key] = value
+ if "sample_quotes" not in roster[speaker_id]:
+ prev_samples = previous.get("sample_quotes")
+ if isinstance(prev_samples, list):
+ roster[speaker_id]["sample_quotes"] = prev_samples
+ if "detected_gender" not in roster[speaker_id]:
+ prev_detected = previous.get("detected_gender")
+ if isinstance(prev_detected, str) and prev_detected:
+ roster[speaker_id]["detected_gender"] = prev_detected
+ return roster
+
+
+def match_configured_speaker(
+ config_speakers: Mapping[str, Any],
+ roster_id: str,
+ roster_label: str,
+) -> Optional[Mapping[str, Any]]:
+ if not config_speakers:
+ return None
+ entry = config_speakers.get(roster_id)
+ if entry:
+ return cast(Mapping[str, Any], entry)
+ slug = slugify_label(roster_label)
+ if slug != roster_id and slug in config_speakers:
+ return cast(Mapping[str, Any], config_speakers[slug])
+ lower_label = roster_label.strip().lower()
+ for record in config_speakers.values():
+ if not isinstance(record, Mapping):
+ continue
+ if str(record.get("label", "")).strip().lower() == lower_label:
+ return record
+ return None
+
+
+def apply_speaker_config_to_roster(
+ roster: Mapping[str, Any],
+ config: Optional[Mapping[str, Any]],
+ *,
+ persist_changes: bool = False,
+ fallback_languages: Optional[Iterable[str]] = None,
+) -> Tuple[Dict[str, Any], List[str], Optional[Dict[str, Any]]]:
+ if not isinstance(roster, Mapping):
+ effective_languages = [code for code in (fallback_languages or []) if isinstance(code, str) and code]
+ return {}, effective_languages, None
+ updated_roster: Dict[str, Any] = {key: dict(value) for key, value in roster.items() if isinstance(value, Mapping)}
+ if not config:
+ effective_languages = [code for code in (fallback_languages or []) if isinstance(code, str) and code]
+ return updated_roster, effective_languages, None
+
+ speakers_map = config.get("speakers")
+ if not isinstance(speakers_map, Mapping):
+ effective_languages = [code for code in (fallback_languages or []) if isinstance(code, str) and code]
+ return updated_roster, effective_languages, None
+
+ config_languages = config.get("languages")
+ if isinstance(config_languages, list):
+ allowed_languages = [code for code in config_languages if isinstance(code, str) and code]
+ else:
+ allowed_languages = []
+ if not allowed_languages and fallback_languages:
+ allowed_languages = [code for code in fallback_languages if isinstance(code, str) and code]
+
+ default_voice = config.get("default_voice") if isinstance(config.get("default_voice"), str) else ""
+ used_voices = {entry.get("resolved_voice") or entry.get("voice") for entry in updated_roster.values()} - {None}
+ narrator_voice = ""
+ narrator_entry = updated_roster.get("narrator") if isinstance(updated_roster, Mapping) else None
+ if isinstance(narrator_entry, Mapping):
+ narrator_voice = str(
+ narrator_entry.get("resolved_voice")
+ or narrator_entry.get("default_voice")
+ or ""
+ ).strip()
+ if narrator_voice:
+ used_voices.add(narrator_voice)
+
+ config_changed = False
+ new_config_payload: Dict[str, Any] = {
+ "language": config.get("language", "a"),
+ "languages": allowed_languages,
+ "default_voice": default_voice,
+ "speakers": dict(speakers_map),
+ "version": config.get("version", 1),
+ "notes": config.get("notes", ""),
+ }
+
+ speakers_payload = new_config_payload["speakers"]
+
+ for speaker_id, roster_entry in updated_roster.items():
+ if speaker_id == "narrator":
+ continue
+ label = str(roster_entry.get("label") or speaker_id)
+ config_entry = match_configured_speaker(speakers_map, speaker_id, label)
+ if config_entry is None:
+ continue
+ voice_id = str(config_entry.get("voice") or "").strip()
+ voice_profile = str(config_entry.get("voice_profile") or "").strip()
+ voice_formula = str(config_entry.get("voice_formula") or "").strip()
+ resolved_voice = str(config_entry.get("resolved_voice") or "").strip()
+ languages = config_entry.get("languages") if isinstance(config_entry.get("languages"), list) else []
+ chosen_voice = resolved_voice or voice_formula or voice_id or roster_entry.get("voice")
+ usable_languages = languages or allowed_languages
+
+ if chosen_voice:
+ roster_entry["resolved_voice"] = chosen_voice
+ roster_entry["voice"] = chosen_voice if not voice_profile and not voice_formula else roster_entry.get("voice", chosen_voice)
+ if voice_profile:
+ roster_entry["voice_profile"] = voice_profile
+ if voice_formula:
+ roster_entry["voice_formula"] = voice_formula
+ roster_entry["resolved_voice"] = voice_formula
+ if not voice_formula and not voice_profile and resolved_voice:
+ roster_entry["resolved_voice"] = resolved_voice
+ roster_entry["config_languages"] = usable_languages or []
+
+ if chosen_voice:
+ used_voices.add(chosen_voice)
+
+ # persist updates back to config payload if required
+ if persist_changes:
+ slug = config_entry.get("id") or slugify_label(label)
+ speakers_payload[slug] = {
+ "id": slug,
+ "label": label,
+ "gender": config_entry.get("gender", "unknown"),
+ "voice": voice_id,
+ "voice_profile": voice_profile,
+ "voice_formula": voice_formula,
+ "resolved_voice": roster_entry.get("resolved_voice", resolved_voice or voice_id),
+ "languages": usable_languages,
+ }
+
+ new_config = new_config_payload if (persist_changes and config_changed) else None
+ return updated_roster, allowed_languages, new_config
+
+
+def filter_voice_catalog(
+ catalog: Iterable[Mapping[str, Any]],
+ *,
+ gender: str,
+ allowed_languages: Optional[Iterable[str]] = None,
+) -> List[str]:
+ allowed_set = {code.lower() for code in (allowed_languages or []) if isinstance(code, str) and code}
+ gender_normalized = (gender or "unknown").lower()
+ gender_code = ""
+ if gender_normalized == "male":
+ gender_code = "m"
+ elif gender_normalized == "female":
+ gender_code = "f"
+
+ matches: List[str] = []
+ seen: set[str] = set()
+
+ def _consider(entry: Mapping[str, Any]) -> None:
+ voice_id = entry.get("id")
+ if not isinstance(voice_id, str) or not voice_id:
+ return
+ if voice_id in seen:
+ return
+ seen.add(voice_id)
+ matches.append(voice_id)
+
+ primary: List[Mapping[str, Any]] = []
+ fallback: List[Mapping[str, Any]] = []
+ for entry in catalog:
+ if not isinstance(entry, Mapping):
+ continue
+ voice_lang = str(entry.get("language", "")).lower()
+ voice_gender_code = str(entry.get("gender_code", "")).lower()
+ if allowed_set and voice_lang not in allowed_set:
+ continue
+ if gender_code and voice_gender_code != gender_code:
+ fallback.append(entry)
+ continue
+ primary.append(entry)
+
+ for entry in primary:
+ _consider(entry)
+
+ if not matches:
+ for entry in fallback:
+ _consider(entry)
+
+ if not matches:
+ for entry in catalog:
+ if isinstance(entry, Mapping):
+ _consider(entry)
+
+ return matches
+
+
+def build_voice_catalog() -> List[Dict[str, str]]:
+ catalog: List[Dict[str, str]] = []
+ gender_map = {"f": "Female", "m": "Male"}
+ for voice_id in VOICES_INTERNAL:
+ prefix, _, rest = voice_id.partition("_")
+ language_code = prefix[0] if prefix else "a"
+ gender_code = prefix[1] if len(prefix) > 1 else ""
+ catalog.append(
+ {
+ "id": voice_id,
+ "language": language_code,
+ "language_label": LANGUAGE_DESCRIPTIONS.get(language_code, language_code.upper()),
+ "gender": gender_map.get(gender_code, "Unknown"),
+ "gender_code": gender_code,
+ "display_name": rest.replace("_", " ").title() if rest else voice_id,
+ }
+ )
+ return catalog
+
+
+def inject_recommended_voices(
+ roster: Mapping[str, Any],
+ *,
+ fallback_languages: Optional[Iterable[str]] = None,
+) -> None:
+ voice_catalog = build_voice_catalog()
+ fallback_list = [code for code in (fallback_languages or []) if isinstance(code, str) and code]
+ for speaker_id, payload in roster.items():
+ if not isinstance(payload, dict):
+ continue
+ languages = payload.get("config_languages")
+ if isinstance(languages, list) and languages:
+ language_list = languages
+ else:
+ language_list = fallback_list
+ gender = str(payload.get("gender", "unknown"))
+ payload["recommended_voices"] = filter_voice_catalog(
+ voice_catalog,
+ gender=gender,
+ allowed_languages=language_list,
+ )
+
+
+def extract_speaker_config_form(form: Mapping[str, Any]) -> Tuple[str, Dict[str, Any], List[str]]:
+ getter = getattr(form, "getlist", None)
+
+ def _get_list(name: str) -> List[str]:
+ if callable(getter):
+ values = cast(Iterable[Any], getter(name))
+ return [str(value).strip() for value in values if value]
+ raw_value = form.get(name)
+ if isinstance(raw_value, str):
+ return [item.strip() for item in raw_value.split(",") if item.strip()]
+ return []
+
+ name = (form.get("config_name") or "").strip()
+ language = str(form.get("config_language") or "a").strip() or "a"
+ allowed_languages = []
+ default_voice = (form.get("config_default_voice") or "").strip()
+ notes = (form.get("config_notes") or "").strip()
+
+ try:
+ parsed = int(form.get("config_version") or 1)
+ version = max(1, min(parsed, 9999))
+ except (TypeError, ValueError):
+ version = 1
+
+ speaker_rows = _get_list("speaker_rows")
+ speakers: Dict[str, Dict[str, Any]] = {}
+ for row_key in speaker_rows:
+ prefix = f"speaker-{row_key}-"
+ label = (form.get(prefix + "label") or "").strip()
+ if not label:
+ continue
+ raw_gender = (form.get(prefix + "gender") or "unknown").strip().lower()
+ gender = raw_gender if raw_gender in {"male", "female", "unknown"} else "unknown"
+ voice = (form.get(prefix + "voice") or "").strip()
+ voice_profile = (form.get(prefix + "profile") or "").strip()
+ voice_formula = (form.get(prefix + "formula") or "").strip()
+ speaker_id = (form.get(prefix + "id") or "").strip() or slugify_label(label)
+ speakers[speaker_id] = {
+ "id": speaker_id,
+ "label": label,
+ "gender": gender,
+ "voice": voice,
+ "voice_profile": voice_profile,
+ "voice_formula": voice_formula,
+ "resolved_voice": voice_formula or voice,
+ "languages": [],
+ }
+
+ payload = {
+ "language": language,
+ "languages": allowed_languages,
+ "default_voice": default_voice,
+ "speakers": speakers,
+ "notes": notes,
+ "version": version,
+ }
+
+ errors: List[str] = []
+ if not name:
+ errors.append("Configuration name is required.")
+ if not speakers:
+ errors.append("Add at least one speaker to the configuration.")
+
+ return name, payload, errors
+
+
+def prepare_speaker_metadata(
+ *,
+ chapters: List[Dict[str, Any]],
+ chunks: List[Dict[str, Any]],
+ analysis_chunks: Optional[List[Dict[str, Any]]] = None,
+ voice: str,
+ voice_profile: Optional[str],
+ threshold: int,
+ existing_roster: Optional[Mapping[str, Any]] = None,
+ run_analysis: bool = True,
+ speaker_config: Optional[Mapping[str, Any]] = None,
+ apply_config: bool = False,
+ persist_config: bool = False,
+) -> tuple[List[Dict[str, Any]], Dict[str, Any], Dict[str, Any], List[str], Optional[Dict[str, Any]]]:
+ chunk_list = [dict(chunk) for chunk in chunks]
+ analysis_source = [dict(chunk) for chunk in (analysis_chunks or chunks)]
+ threshold_value = max(1, int(threshold))
+ analysis_enabled = run_analysis
+ settings_state = load_settings()
+ global_random_languages = [
+ code
+ for code in settings_state.get("speaker_random_languages", [])
+ if isinstance(code, str) and code
+ ]
+
+ if not analysis_enabled:
+ for chunk in chunk_list:
+ chunk["speaker_id"] = "narrator"
+ chunk["speaker_label"] = "Narrator"
+ analysis_payload = {
+ "version": "1.0",
+ "narrator": "narrator",
+ "assignments": {str(chunk.get("id")): "narrator" for chunk in chunk_list},
+ "speakers": {
+ "narrator": {
+ "id": "narrator",
+ "label": "Narrator",
+ "count": len(chunk_list),
+ "confidence": "low",
+ "sample_quotes": [],
+ "suppressed": False,
+ }
+ },
+ "suppressed": [],
+ "stats": {
+ "total_chunks": len(chunk_list),
+ "explicit_chunks": 0,
+ "active_speakers": 0,
+ "unique_speakers": 1,
+ "suppressed": 0,
+ },
+ }
+ roster = build_narrator_roster(voice, voice_profile, existing_roster)
+ narrator_pron = roster["narrator"].get("pronunciation")
+ if narrator_pron:
+ analysis_payload["speakers"]["narrator"]["pronunciation"] = narrator_pron
+ return chunk_list, roster, analysis_payload, [], None
+
+ analysis_result = analyze_speakers(
+ chapters,
+ analysis_source,
+ threshold=threshold_value,
+ max_speakers=0,
+ )
+ analysis_payload = analysis_result.to_dict()
+ speakers_payload = analysis_payload.get("speakers", {})
+ ordered_ids = [
+ sid
+ for sid, meta in sorted(
+ (
+ (sid, meta)
+ for sid, meta in speakers_payload.items()
+ if sid != "narrator" and isinstance(meta, Mapping) and not meta.get("suppressed")
+ ),
+ key=lambda item: item[1].get("count", 0),
+ reverse=True,
+ )
+ ]
+ analysis_payload["ordered_speakers"] = ordered_ids
+ assignments = analysis_payload.get("assignments", {})
+ suppressed_ids = analysis_payload.get("suppressed", [])
+ suppressed_details: List[Dict[str, Any]] = []
+ speakers_payload = analysis_payload.get("speakers", {})
+ if isinstance(suppressed_ids, Iterable):
+ for suppressed_id in suppressed_ids:
+ speaker_meta = speakers_payload.get(suppressed_id) if isinstance(speakers_payload, dict) else None
+ if isinstance(speaker_meta, dict):
+ suppressed_details.append(
+ {
+ "id": suppressed_id,
+ "label": speaker_meta.get("label")
+ or str(suppressed_id).replace("_", " ").title(),
+ "pronunciation": speaker_meta.get("pronunciation"),
+ }
+ )
+ else:
+ suppressed_details.append(
+ {
+ "id": suppressed_id,
+ "label": str(suppressed_id).replace("_", " ").title(),
+ "pronunciation": None,
+ }
+ )
+ analysis_payload["suppressed_details"] = suppressed_details
+ roster = build_speaker_roster(
+ analysis_payload,
+ voice,
+ voice_profile,
+ existing=existing_roster,
+ order=analysis_payload.get("ordered_speakers"),
+ )
+ applied_languages: List[str] = []
+ updated_config: Optional[Dict[str, Any]] = None
+ if apply_config and speaker_config:
+ roster, applied_languages, updated_config = apply_speaker_config_to_roster(
+ roster,
+ speaker_config,
+ persist_changes=persist_config,
+ fallback_languages=global_random_languages,
+ )
+ speakers_payload = analysis_payload.get("speakers")
+ if isinstance(speakers_payload, dict):
+ for roster_id, roster_payload in roster.items():
+ speaker_meta = speakers_payload.get(roster_id)
+ if isinstance(speaker_meta, dict):
+ for key in ("voice", "voice_profile", "voice_formula", "resolved_voice"):
+ value = roster_payload.get(key)
+ if value:
+ speaker_meta[key] = value
+ effective_languages: List[str] = []
+ if applied_languages:
+ effective_languages = applied_languages
+ elif isinstance(analysis_payload.get("config_languages"), list):
+ effective_languages = [
+ code for code in analysis_payload.get("config_languages", []) if isinstance(code, str) and code
+ ]
+ elif global_random_languages:
+ effective_languages = list(global_random_languages)
+
+ if effective_languages:
+ analysis_payload["config_languages"] = effective_languages
+ speakers_payload = analysis_payload.get("speakers")
+ if isinstance(speakers_payload, dict):
+ for roster_id, roster_payload in roster.items():
+ if roster_id in speakers_payload and isinstance(roster_payload, dict):
+ pronunciation_value = roster_payload.get("pronunciation")
+ if pronunciation_value:
+ speakers_payload[roster_id]["pronunciation"] = pronunciation_value
+
+ fallback_languages = effective_languages or []
+ inject_recommended_voices(roster, fallback_languages=fallback_languages)
+
+ for chunk in chunk_list:
+ chunk_id = str(chunk.get("id"))
+ speaker_id = assignments.get(chunk_id, "narrator")
+ chunk["speaker_id"] = speaker_id
+ speaker_meta = roster.get(speaker_id)
+ chunk["speaker_label"] = speaker_meta.get("label") if isinstance(speaker_meta, dict) else speaker_id
+
+ return chunk_list, roster, analysis_payload, applied_languages, updated_config
+
+
+def formula_from_profile(entry: Dict[str, Any]) -> Optional[str]:
+ voices = entry.get("voices") or []
+ if not voices:
+ return None
+ total = sum(weight for _, weight in voices)
+ if total <= 0:
+ return None
+
+ def _format_weight(value: float) -> str:
+ normalized = value / total if total else 0.0
+ return (f"{normalized:.4f}").rstrip("0").rstrip(".") or "0"
+
+ parts = [f"{name}*{_format_weight(weight)}" for name, weight in voices if weight > 0]
+ return "+".join(parts) if parts else None
+
+
+def template_options() -> Dict[str, Any]:
+ current_settings = load_settings()
+ profiles = serialize_profiles()
+ ordered_profiles = sorted(profiles.items())
+ profile_options = []
+ for name, entry in ordered_profiles:
+ provider = str((entry or {}).get("provider") or "kokoro").strip().lower()
+ profile_options.append(
+ {
+ "name": name,
+ "language": (entry or {}).get("language", ""),
+ "provider": provider,
+ "formula": formula_from_profile(entry or {}) or "",
+ "voice": (entry or {}).get("voice", ""),
+ "total_steps": (entry or {}).get("total_steps"),
+ "speed": (entry or {}).get("speed"),
+ }
+ )
+ voice_catalog = build_voice_catalog()
+ return {
+ "languages": LANGUAGE_DESCRIPTIONS,
+ "voices": VOICES_INTERNAL,
+ "subtitle_formats": SUBTITLE_FORMATS,
+ "supported_langs_for_subs": SUPPORTED_LANGUAGES_FOR_SUBTITLE_GENERATION,
+ "output_formats": SUPPORTED_SOUND_FORMATS,
+ "voice_profiles": ordered_profiles,
+ "voice_profile_options": profile_options,
+ "separate_formats": ["wav", "flac", "mp3", "opus"],
+ "voice_catalog": voice_catalog,
+ "voice_catalog_map": {entry["id"]: entry for entry in voice_catalog},
+ "sample_voice_texts": SAMPLE_VOICE_TEXTS,
+ "voice_profiles_data": profiles,
+ "speaker_configs": list_configs(),
+ "chunk_levels": _CHUNK_LEVEL_OPTIONS,
+ "speaker_analysis_threshold": current_settings.get(
+ "speaker_analysis_threshold", _DEFAULT_ANALYSIS_THRESHOLD
+ ),
+ "speaker_pronunciation_sentence": current_settings.get(
+ "speaker_pronunciation_sentence", settings_defaults()["speaker_pronunciation_sentence"]
+ ),
+ "apostrophe_modes": _APOSTROPHE_MODE_OPTIONS,
+ "normalization_groups": _NORMALIZATION_GROUPS,
+ }
+
+
+def resolve_profile_voice(
+ profile_name: Optional[str],
+ *,
+ profiles: Optional[Mapping[str, Any]] = None,
+) -> tuple[str, Optional[str]]:
+ if not profile_name:
+ return "", None
+ source = profiles if isinstance(profiles, Mapping) else None
+ if source is None:
+ source = load_profiles()
+ entry = source.get(profile_name) if isinstance(source, Mapping) else None
+ if not isinstance(entry, Mapping):
+ return "", None
+ formula = formula_from_profile(dict(entry)) or ""
+ language = entry.get("language") if isinstance(entry.get("language"), str) else None
+ if isinstance(language, str):
+ language = language.strip().lower() or None
+ return formula, language
+
+
+def resolve_voice_setting(
+ value: Any,
+ *,
+ profiles: Optional[Mapping[str, Any]] = None,
+) -> tuple[str, Optional[str], Optional[str]]:
+ base_spec, profile_name = split_profile_spec(value)
+ if profile_name:
+ formula, language = resolve_profile_voice(profile_name, profiles=profiles)
+ return formula or "", profile_name, language
+ return base_spec, None, None
+
+
+def resolve_voice_choice(
+ language: str,
+ base_voice: str,
+ profile_name: str,
+ custom_formula: str,
+ profiles: Dict[str, Any],
+) -> tuple[str, str, Optional[str]]:
+ resolved_voice = base_voice
+ resolved_language = language
+ selected_profile = None
+
+ if profile_name:
+ from abogen.voice_profiles import normalize_profile_entry
+
+ entry_raw = profiles.get(profile_name)
+ entry = normalize_profile_entry(entry_raw)
+ provider = str((entry or {}).get("provider") or "").strip().lower()
+
+ # Provider-aware behavior:
+ # - Kokoro profiles typically represent mixes (formula strings).
+ # - SuperTonic profiles represent a discrete voice id + settings.
+ # In that case, we return a speaker reference so downstream can
+ # resolve provider per-speaker and allow mixed-provider casting.
+ if provider == "supertonic":
+ resolved_voice = f"speaker:{profile_name}"
+ selected_profile = profile_name
+ profile_language = (entry or {}).get("language")
+ if profile_language:
+ resolved_language = str(profile_language)
+ else:
+ formula = formula_from_profile(entry or {}) if entry else None
+ if formula:
+ resolved_voice = formula
+ selected_profile = profile_name
+ profile_language = (entry or {}).get("language")
+ if profile_language:
+ resolved_language = profile_language
+
+ if custom_formula:
+ resolved_voice = custom_formula
+ selected_profile = None
+
+ return resolved_voice, resolved_language, selected_profile
+
+
+def parse_voice_formula(formula: str) -> List[tuple[str, float]]:
+ voices = parse_formula_terms(formula)
+ total = sum(weight for _, weight in voices)
+ if total <= 0:
+ raise ValueError("Voice weights must sum to a positive value")
+ return voices
+
+
+def sanitize_voice_entries(entries: Iterable[Any]) -> List[Dict[str, Any]]:
+ sanitized: List[Dict[str, Any]] = []
+ for entry in entries or []:
+ if isinstance(entry, dict):
+ voice_id = entry.get("id") or entry.get("voice")
+ if not voice_id:
+ continue
+ enabled = entry.get("enabled", True)
+ if not enabled:
+ continue
+ sanitized.append({"voice": voice_id, "weight": entry.get("weight")})
+ elif isinstance(entry, (list, tuple)) and len(entry) >= 2:
+ sanitized.append({"voice": entry[0], "weight": entry[1]})
+ return sanitized
+
+
+def pairs_to_formula(pairs: Iterable[Tuple[str, float]]) -> Optional[str]:
+ voices = [(voice, float(weight)) for voice, weight in pairs if float(weight) > 0]
+ if not voices:
+ return None
+ total = sum(weight for _, weight in voices)
+ if total <= 0:
+ return None
+
+ def _format_value(value: float) -> str:
+ normalized = value / total if total else 0.0
+ return (f"{normalized:.4f}").rstrip("0").rstrip(".") or "0"
+
+ parts = [f"{voice}*{_format_value(weight)}" for voice, weight in voices]
+ return "+".join(parts)
+
+
+def profiles_payload() -> Dict[str, Any]:
+ return {"profiles": serialize_profiles()}
+
+
+def get_preview_pipeline(language: str, device: str):
+ key = (language, device)
+ with _preview_pipeline_lock:
+ pipeline = _preview_pipelines.get(key)
+ if pipeline is not None:
+ return pipeline
+ _, KPipeline = load_numpy_kpipeline()
+ pipeline = KPipeline(lang_code=language, repo_id="hexgrad/Kokoro-82M", device=device)
+ _preview_pipelines[key] = pipeline
+ return pipeline
+
+
+def synthesize_audio_from_normalized(
+ *,
+ normalized_text: str,
+ voice_spec: str,
+ language: str,
+ speed: float,
+ use_gpu: bool,
+ max_seconds: float,
+) -> np.ndarray:
+ if not normalized_text.strip():
+ raise ValueError("Preview text is required")
+
+ device = "cpu"
+ if use_gpu:
+ try:
+ device = _select_device()
+ except Exception:
+ device = "cpu"
+ use_gpu = False
+
+ pipeline = get_preview_pipeline(language, device)
+ if pipeline is None:
+ raise RuntimeError("Preview pipeline is unavailable")
+
+ voice_choice: Any = voice_spec
+ if voice_spec and "*" in voice_spec:
+ voice_choice = get_new_voice(pipeline, voice_spec, use_gpu)
+
+ segments = pipeline(
+ normalized_text,
+ voice=voice_choice,
+ speed=speed,
+ split_pattern=SPLIT_PATTERN,
+ )
+
+ audio_chunks: List[np.ndarray] = []
+ accumulated = 0
+ max_samples = int(max(1.0, max_seconds) * SAMPLE_RATE)
+
+ for segment in segments:
+ graphemes = getattr(segment, "graphemes", "").strip()
+ if not graphemes:
+ continue
+ audio = _to_float32(getattr(segment, "audio", None))
+ if audio.size == 0:
+ continue
+ remaining = max_samples - accumulated
+ if remaining <= 0:
+ break
+ if audio.shape[0] > remaining:
+ audio = audio[:remaining]
+ audio_chunks.append(audio)
+ accumulated += audio.shape[0]
+ if accumulated >= max_samples:
+ break
+
+ if not audio_chunks:
+ raise RuntimeError("Preview could not be generated")
+
+ return np.concatenate(audio_chunks)
diff --git a/abogen/webui/routes/voices.py b/abogen/webui/routes/voices.py
new file mode 100644
index 0000000..a7e9ce7
--- /dev/null
+++ b/abogen/webui/routes/voices.py
@@ -0,0 +1,140 @@
+from typing import Any, Dict, List, Optional
+from flask import Blueprint, render_template, request, jsonify, abort, flash, redirect, url_for
+from flask.typing import ResponseReturnValue
+
+from abogen.webui.routes.utils.voice import (
+ template_options,
+ resolve_voice_setting,
+ resolve_voice_choice,
+ parse_voice_formula,
+)
+from abogen.webui.routes.utils.settings import load_settings, coerce_bool
+from abogen.webui.routes.utils.preview import synthesize_preview
+from abogen.speaker_configs import (
+ list_configs,
+ get_config,
+ load_configs,
+ save_configs,
+ delete_config,
+)
+from abogen.constants import VOICES_INTERNAL
+
+voices_bp = Blueprint("voices", __name__)
+
+@voices_bp.get("/")
+def voice_profiles() -> ResponseReturnValue:
+ return render_template("voices.html", options=template_options())
+
+@voices_bp.post("/test")
+def test_voice() -> ResponseReturnValue:
+ text = (request.form.get("text") or "").strip()
+ voice = (request.form.get("voice") or "").strip()
+ speed = float(request.form.get("speed", 1.0))
+
+ # This seems to be the form-based preview
+ settings = load_settings()
+ use_gpu = coerce_bool(settings.get("use_gpu"), True)
+
+ try:
+ return synthesize_preview(
+ text=text,
+ voice_spec=voice,
+ language="a", # Default language
+ speed=speed,
+ use_gpu=use_gpu,
+ )
+ except Exception as e:
+ abort(400, str(e))
+
+@voices_bp.get("/configs")
+def speaker_configs() -> ResponseReturnValue:
+ return jsonify({"configs": list_configs()})
+
+@voices_bp.post("/configs/save")
+def save_speaker_config() -> ResponseReturnValue:
+ payload = request.get_json(force=True)
+ name = (payload.get("name") or "").strip()
+ config = payload.get("config")
+
+ if not name:
+ abort(400, "Config name is required")
+ if not config:
+ abort(400, "Config data is required")
+
+ configs = load_configs()
+ configs[name] = config
+ save_configs(configs)
+ return jsonify({"status": "saved", "configs": list_configs()})
+
+@voices_bp.post("/configs/delete")
+def delete_speaker_config() -> ResponseReturnValue:
+ payload = request.get_json(force=True)
+ name = (payload.get("name") or "").strip()
+
+ if not name:
+ abort(400, "Config name is required")
+
+ delete_config(name)
+ return jsonify({"status": "deleted", "configs": list_configs()})
+
+@voices_bp.route("/presets", methods=["GET", "POST"])
+def speaker_configs_page() -> ResponseReturnValue:
+ configs = load_configs()
+ editing_name = request.args.get("config")
+ message = None
+ error = None
+
+ if request.method == "POST":
+ try:
+ name = request.form.get("config_name", "").strip()
+ if not name:
+ raise ValueError("Preset name is required")
+
+ language = request.form.get("config_language", "en")
+
+ speakers = []
+ row_keys = request.form.getlist("speaker_rows")
+ for key in row_keys:
+ s_id = request.form.get(f"speaker-{key}-id", key)
+ label = request.form.get(f"speaker-{key}-label", "")
+ gender = request.form.get(f"speaker-{key}-gender", "unknown")
+ voice = request.form.get(f"speaker-{key}-voice", "")
+
+ if label:
+ speakers.append({
+ "id": s_id,
+ "label": label,
+ "gender": gender,
+ "voice": voice or None
+ })
+
+ config = {
+ "name": name,
+ "language": language,
+ "speakers": speakers,
+ "version": 1
+ }
+
+ configs[name] = config
+ save_configs(configs)
+ message = f"Preset '{name}' saved."
+ editing_name = name
+ except Exception as e:
+ error = str(e)
+
+ editing = configs.get(editing_name, {}) if editing_name else {}
+
+ return render_template(
+ "speakers.html",
+ options=template_options(),
+ configs=configs.values(),
+ editing_name=editing_name,
+ editing=editing,
+ message=message,
+ error=error
+ )
+
+@voices_bp.post("/presets//delete")
+def delete_speaker_config_named(name: str) -> ResponseReturnValue:
+ delete_config(name)
+ return redirect(url_for("voices.speaker_configs_page"))
diff --git a/abogen/webui/service.py b/abogen/webui/service.py
new file mode 100644
index 0000000..a04e9ce
--- /dev/null
+++ b/abogen/webui/service.py
@@ -0,0 +1,1618 @@
+from __future__ import annotations
+
+import json
+import logging
+import math
+import os
+import re
+import shutil
+import sys
+import threading
+import time
+import uuid
+import traceback
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional, Mapping, Tuple
+
+from abogen.utils import get_internal_cache_path, get_user_settings_dir, load_config
+from abogen.voice_cache import bootstrap_voice_cache
+from abogen.integrations.audiobookshelf import (
+ AudiobookshelfClient,
+ AudiobookshelfConfig,
+ AudiobookshelfUploadError,
+)
+
+
+def _create_set_event() -> threading.Event:
+ event = threading.Event()
+ event.set()
+ return event
+
+
+STATE_VERSION = 8
+
+
+_JOB_LOGGER = logging.getLogger("abogen.jobs")
+if not _JOB_LOGGER.handlers:
+ handler = logging.StreamHandler(sys.stdout)
+ handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s", "%Y-%m-%d %H:%M:%S"))
+ _JOB_LOGGER.addHandler(handler)
+ _JOB_LOGGER.propagate = False
+_JOB_LOGGER.setLevel(logging.DEBUG)
+
+_JOB_LEVEL_MAP: Dict[str, int] = {
+ "critical": logging.CRITICAL,
+ "error": logging.ERROR,
+ "warning": logging.WARNING,
+ "info": logging.INFO,
+ "success": logging.INFO,
+ "debug": logging.DEBUG,
+ "trace": logging.DEBUG,
+}
+
+
+_PEOPLE_SPLIT_RE = re.compile(r"[;,/&]|\band\b", re.IGNORECASE)
+
+
+def _emit_job_log(job_id: str, level: str, message: str) -> None:
+ normalized = (level or "info").lower()
+ log_level = _JOB_LEVEL_MAP.get(normalized, logging.INFO)
+ try:
+ _JOB_LOGGER.log(log_level, "[job %s] %s", job_id, message)
+ except Exception:
+ # Logging failures should never disrupt job processing, but we should know about them.
+ try:
+ sys.stderr.write(f"Logging failed for job {job_id}: {message}\n")
+ traceback.print_exc(file=sys.stderr)
+ except Exception:
+ pass
+
+
+class JobStatus(str, Enum):
+ PENDING = "pending"
+ RUNNING = "running"
+ PAUSED = "paused"
+ COMPLETED = "completed"
+ FAILED = "failed"
+ CANCELLED = "cancelled"
+
+
+@dataclass
+class JobLog:
+ timestamp: float
+ message: str
+ level: str = "info"
+
+
+@dataclass
+class JobResult:
+ audio_path: Optional[Path] = None
+ subtitle_paths: List[Path] = field(default_factory=list)
+ artifacts: Dict[str, Path] = field(default_factory=dict)
+ epub_path: Optional[Path] = None
+
+
+@dataclass
+class Job:
+ id: str
+ original_filename: str
+ stored_path: Path
+ language: str
+ voice: str
+ speed: float
+ use_gpu: bool
+ subtitle_mode: str
+ output_format: str
+ save_mode: str
+ output_folder: Optional[Path]
+ replace_single_newlines: bool
+ subtitle_format: str
+ created_at: float
+ tts_provider: str = "kokoro"
+ supertonic_total_steps: int = 5
+ save_chapters_separately: bool = False
+ merge_chapters_at_end: bool = True
+ separate_chapters_format: str = "wav"
+ silence_between_chapters: float = 2.0
+ save_as_project: bool = False
+ voice_profile: Optional[str] = None
+ metadata_tags: Dict[str, str] = field(default_factory=dict)
+ max_subtitle_words: int = 50
+ chapter_intro_delay: float = 0.5
+ read_title_intro: bool = False
+ read_closing_outro: bool = True
+ auto_prefix_chapter_titles: bool = True
+ normalize_chapter_opening_caps: bool = True
+ status: JobStatus = JobStatus.PENDING
+ started_at: Optional[float] = None
+ finished_at: Optional[float] = None
+ progress: float = 0.0
+ total_characters: int = 0
+ processed_characters: int = 0
+ logs: List[JobLog] = field(default_factory=list)
+ error: Optional[str] = None
+ result: JobResult = field(default_factory=JobResult)
+ chapters: List[Dict[str, Any]] = field(default_factory=list)
+ queue_position: Optional[int] = None
+ cancel_requested: bool = False
+ pause_requested: bool = False
+ paused: bool = False
+ resume_token: Optional[str] = None
+ pause_event: threading.Event = field(default_factory=_create_set_event, repr=False, compare=False)
+ cover_image_path: Optional[Path] = None
+ cover_image_mime: Optional[str] = None
+ chunk_level: str = "paragraph"
+ chunks: List[Dict[str, Any]] = field(default_factory=list)
+ speakers: Dict[str, Any] = field(default_factory=dict)
+ speaker_mode: str = "single"
+ generate_epub3: bool = False
+ speaker_analysis: Dict[str, Any] = field(default_factory=dict)
+ speaker_analysis_threshold: int = 3
+ analysis_requested: bool = False
+ entity_summary: Dict[str, Any] = field(default_factory=dict)
+ manual_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ pronunciation_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ heteronym_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ normalization_overrides: Dict[str, Any] = field(default_factory=dict)
+ speaker_voice_languages: List[str] = field(default_factory=list)
+ applied_speaker_config: Optional[str] = None
+
+ @property
+ def estimated_time_remaining(self) -> Optional[float]:
+ """
+ Returns the estimated seconds remaining based on current progress and elapsed time.
+ Returns None if the job hasn't started, is finished, or progress is 0.
+ """
+ if self.status != JobStatus.RUNNING or not self.started_at or self.progress <= 0:
+ return None
+
+ elapsed = time.time() - self.started_at
+ if elapsed <= 0:
+ return None
+
+ # Estimate total time based on current progress
+ total_estimated = elapsed / self.progress
+ remaining = total_estimated - elapsed
+ return max(0.0, remaining)
+
+ def add_log(self, message: str, level: str = "info") -> None:
+ entry = JobLog(timestamp=time.time(), message=message, level=level)
+ self.logs.append(entry)
+ _emit_job_log(self.id, level, message)
+
+ def as_dict(self) -> Dict[str, object]:
+ return {
+ "id": self.id,
+ "original_filename": self.original_filename,
+ "status": self.status.value,
+ "use_gpu": self.use_gpu,
+ "created_at": self.created_at,
+ "started_at": self.started_at,
+ "finished_at": self.finished_at,
+ "progress": self.progress,
+ "total_characters": self.total_characters,
+ "processed_characters": self.processed_characters,
+ "error": self.error,
+ "logs": [log.__dict__ for log in self.logs],
+ "result": {
+ "audio": str(self.result.audio_path) if self.result.audio_path else None,
+ "subtitles": [str(path) for path in self.result.subtitle_paths],
+ "artifacts": {key: str(path) for key, path in self.result.artifacts.items()},
+ },
+ "queue_position": self.queue_position,
+ "options": {
+ "tts_provider": getattr(self, "tts_provider", "kokoro"),
+ "supertonic_total_steps": getattr(self, "supertonic_total_steps", 5),
+ "save_chapters_separately": self.save_chapters_separately,
+ "merge_chapters_at_end": self.merge_chapters_at_end,
+ "separate_chapters_format": self.separate_chapters_format,
+ "silence_between_chapters": self.silence_between_chapters,
+ "save_as_project": self.save_as_project,
+ "voice_profile": self.voice_profile,
+ "max_subtitle_words": self.max_subtitle_words,
+ "chapter_intro_delay": self.chapter_intro_delay,
+ "read_title_intro": getattr(self, "read_title_intro", False),
+ "read_closing_outro": getattr(self, "read_closing_outro", True),
+ "auto_prefix_chapter_titles": getattr(self, "auto_prefix_chapter_titles", True),
+ "normalize_chapter_opening_caps": getattr(self, "normalize_chapter_opening_caps", True),
+ },
+ "metadata_tags": dict(self.metadata_tags),
+ "chapters": [
+ {
+ "id": entry.get("id"),
+ "index": entry.get("index"),
+ "order": entry.get("order"),
+ "title": entry.get("title"),
+ "enabled": bool(entry.get("enabled", True)),
+ "voice": entry.get("voice"),
+ "voice_profile": entry.get("voice_profile"),
+ "voice_formula": entry.get("voice_formula"),
+ "resolved_voice": entry.get("resolved_voice"),
+ "characters": len(str(entry.get("text", ""))),
+ }
+ for entry in self.chapters
+ ],
+ "chunk_level": self.chunk_level,
+ "chunks": [dict(chunk) for chunk in self.chunks],
+ "speakers": dict(self.speakers),
+ "speaker_mode": self.speaker_mode,
+ "generate_epub3": self.generate_epub3,
+ "speaker_analysis": dict(self.speaker_analysis),
+ "speaker_analysis_threshold": self.speaker_analysis_threshold,
+ "analysis_requested": self.analysis_requested,
+ "speaker_voice_languages": list(self.speaker_voice_languages),
+ "applied_speaker_config": self.applied_speaker_config,
+ "entity_summary": dict(self.entity_summary),
+ "manual_overrides": [dict(entry) for entry in self.manual_overrides],
+ "pronunciation_overrides": [dict(entry) for entry in self.pronunciation_overrides],
+ "heteronym_overrides": [dict(entry) for entry in self.heteronym_overrides],
+ "normalization_overrides": dict(self.normalization_overrides),
+ }
+
+
+def _normalize_metadata_casefold(values: Optional[Mapping[str, Any]]) -> Dict[str, Any]:
+ normalized: Dict[str, Any] = {}
+ if not values:
+ return normalized
+ for key, value in values.items():
+ if value is None:
+ continue
+ key_text = str(key).strip().lower()
+ if not key_text:
+ continue
+ if isinstance(value, (list, tuple, set)):
+ normalized[key_text] = value
+ else:
+ text = str(value).strip()
+ if text:
+ normalized[key_text] = text
+ return normalized
+
+
+def _split_people_field(raw: Any) -> List[str]:
+ if raw is None:
+ return []
+ if isinstance(raw, (list, tuple, set)):
+ results: List[str] = []
+ for item in raw:
+ results.extend(_split_people_field(item))
+ return results
+ text = str(raw or "").strip()
+ if not text:
+ return []
+ tokens = [_token.strip() for _token in _PEOPLE_SPLIT_RE.split(text) if _token.strip()]
+ seen: set[str] = set()
+ ordered: List[str] = []
+ for token in tokens:
+ key = token.casefold()
+ if key in seen:
+ continue
+ seen.add(key)
+ ordered.append(token)
+ return ordered
+
+
+_LIST_SPLIT_RE = re.compile(r"[;,\n]")
+_SERIES_SEQUENCE_NUMBER_RE = re.compile(r"\d+(?:\.\d+)?")
+
+_SERIES_SEQUENCE_TAG_KEYS: Tuple[str, ...] = (
+ "series_index",
+ "series_position",
+ "series_sequence",
+ "series_number",
+ "seriesnumber",
+ "book_number",
+ "booknumber",
+)
+
+
+def _split_simple_list(raw: Any) -> List[str]:
+ if raw is None:
+ return []
+ if isinstance(raw, (list, tuple, set)):
+ results: List[str] = []
+ for item in raw:
+ results.extend(_split_simple_list(item))
+ return results
+ text = str(raw or "").strip()
+ if not text:
+ return []
+ tokens = [_token.strip() for _token in _LIST_SPLIT_RE.split(text) if _token.strip()]
+ seen: set[str] = set()
+ ordered: List[str] = []
+ for token in tokens:
+ key = token.casefold()
+ if key in seen:
+ continue
+ seen.add(key)
+ ordered.append(token)
+ return ordered
+
+
+def _first_nonempty(*values: Any) -> Optional[str]:
+ for value in values:
+ if value is None:
+ continue
+ if isinstance(value, (list, tuple, set)):
+ items = list(value)
+ if not items:
+ continue
+ value = items[0]
+ text = str(value).strip()
+ if text:
+ return text
+ return None
+
+
+def _extract_year(raw: Optional[str]) -> Optional[int]:
+ if not raw:
+ return None
+ text = str(raw).strip()
+ if not text:
+ return None
+ match = re.search(r"(19|20)\d{2}", text)
+ if match:
+ try:
+ return int(match.group(0))
+ except ValueError:
+ return None
+ try:
+ parsed = int(text)
+ except ValueError:
+ return None
+ if 0 < parsed < 3000:
+ return parsed
+ return None
+
+
+def build_audiobookshelf_metadata(job: Job) -> Dict[str, Any]:
+ tags = _normalize_metadata_casefold(job.metadata_tags)
+ filename = Path(job.original_filename or "").stem or job.original_filename or "Audiobook"
+ title = _first_nonempty(
+ tags.get("title"),
+ tags.get("book_title"),
+ tags.get("name"),
+ tags.get("album"),
+ filename,
+ )
+ authors = _split_people_field(
+ tags.get("authors")
+ or tags.get("author")
+ or tags.get("album_artist")
+ or tags.get("artist")
+ )
+ narrators = _split_people_field(tags.get("narrators") or tags.get("narrator"))
+ description = _first_nonempty(tags.get("description"), tags.get("summary"), tags.get("comment"))
+ genres = _split_simple_list(tags.get("genre"))
+ keywords = _split_simple_list(tags.get("tags") or tags.get("keywords"))
+ language = _first_nonempty(tags.get("language"), tags.get("lang")) or job.language or ""
+ series_name = _first_nonempty(
+ tags.get("series"),
+ tags.get("series_name"),
+ tags.get("seriesname"),
+ tags.get("series_title"),
+ tags.get("seriestitle"),
+ )
+
+ series_sequence = None
+ for key in _SERIES_SEQUENCE_TAG_KEYS:
+ raw_value = tags.get(key)
+ normalized_sequence = _normalize_series_sequence(raw_value)
+ if normalized_sequence:
+ series_sequence = normalized_sequence
+ break
+ if not series_name:
+ series_sequence = None
+ data: Dict[str, Any] = {
+ "title": title,
+ "subtitle": tags.get("subtitle"),
+ "authors": authors,
+ "narrators": narrators,
+ "description": description,
+ "publisher": tags.get("publisher"),
+ "genres": genres,
+ "tags": keywords,
+ "language": language,
+ "publishedYear": _extract_year(tags.get("published") or tags.get("publication_year") or tags.get("date") or tags.get("year")),
+ "seriesName": series_name,
+ "seriesSequence": series_sequence,
+ "isbn": _first_nonempty(tags.get("isbn"), tags.get("asin")),
+ }
+ published_date = _first_nonempty(tags.get("published"), tags.get("publication_date"), tags.get("date"))
+ if published_date:
+ data["publishedDate"] = published_date
+
+ rating_text = _first_nonempty(tags.get("rating"), tags.get("my_rating"))
+ if rating_text:
+ try:
+ data["rating"] = float(str(rating_text).strip())
+ except ValueError:
+ pass
+ rating_max_text = _first_nonempty(tags.get("rating_max"), tags.get("rating_scale"))
+ if rating_max_text:
+ try:
+ data["ratingMax"] = float(str(rating_max_text).strip())
+ except ValueError:
+ pass
+ # Remove empty values
+ cleaned: Dict[str, Any] = {}
+ for key, value in data.items():
+ if value is None:
+ continue
+ if isinstance(value, str) and not value.strip():
+ continue
+ if isinstance(value, (list, tuple)) and not value:
+ continue
+ cleaned[key] = value
+ return cleaned
+
+
+def _normalize_series_sequence(raw: Any) -> Optional[str]:
+ if raw is None:
+ return None
+
+ if isinstance(raw, (int, float)):
+ if isinstance(raw, float) and (math.isnan(raw) or math.isinf(raw)):
+ return None
+ text = str(raw)
+ else:
+ text = str(raw).strip()
+
+ if not text:
+ return None
+
+ candidate = text.replace(",", ".")
+ match = _SERIES_SEQUENCE_NUMBER_RE.search(candidate)
+ if not match:
+ return None
+
+ normalized = match.group(0)
+ if "." in normalized:
+ normalized = normalized.rstrip("0").rstrip(".")
+ if not normalized:
+ normalized = "0"
+ return normalized
+
+ try:
+ return str(int(normalized))
+ except ValueError:
+ cleaned = normalized.lstrip("0")
+ return cleaned or "0"
+
+
+def load_audiobookshelf_chapters(job: Job) -> Optional[List[Dict[str, Any]]]:
+ metadata_ref = job.result.artifacts.get("metadata")
+ if not metadata_ref:
+ return None
+ metadata_path = metadata_ref if isinstance(metadata_ref, Path) else Path(str(metadata_ref))
+ if not metadata_path.exists():
+ return None
+ try:
+ payload = json.loads(metadata_path.read_text(encoding="utf-8"))
+ except (OSError, json.JSONDecodeError):
+ return None
+ chapters = payload.get("chapters")
+ if not isinstance(chapters, list):
+ return None
+ cleaned: List[Dict[str, Any]] = []
+ for entry in chapters:
+ if not isinstance(entry, Mapping):
+ continue
+ title = _first_nonempty(entry.get("title"), entry.get("original_title"))
+ start = entry.get("start")
+ end = entry.get("end")
+ if title is None or not isinstance(start, (int, float)):
+ continue
+ chapter_payload: Dict[str, Any] = {
+ "title": title,
+ "start": float(start),
+ }
+ if isinstance(end, (int, float)):
+ chapter_payload["end"] = float(end)
+ cleaned.append(chapter_payload)
+ return cleaned or None
+
+
+def _existing_paths(paths: Iterable[Any]) -> List[Path]:
+ resolved: List[Path] = []
+ for item in paths:
+ candidate = item if isinstance(item, Path) else Path(str(item))
+ if candidate.exists():
+ resolved.append(candidate)
+ return resolved
+
+
+@dataclass
+class PendingJob:
+ id: str
+ original_filename: str
+ stored_path: Path
+ language: str
+ voice: str
+ speed: float
+ use_gpu: bool
+ subtitle_mode: str
+ output_format: str
+ save_mode: str
+ output_folder: Optional[Path]
+ replace_single_newlines: bool
+ subtitle_format: str
+ total_characters: int
+ save_chapters_separately: bool
+ merge_chapters_at_end: bool
+ separate_chapters_format: str
+ silence_between_chapters: float
+ save_as_project: bool
+ voice_profile: Optional[str]
+ max_subtitle_words: int
+ metadata_tags: Dict[str, Any]
+ chapters: List[Dict[str, Any]]
+ normalization_overrides: Dict[str, Any]
+ created_at: float
+ tts_provider: str = "kokoro"
+ supertonic_total_steps: int = 5
+ cover_image_path: Optional[Path] = None
+ cover_image_mime: Optional[str] = None
+ chapter_intro_delay: float = 0.5
+ read_title_intro: bool = False
+ read_closing_outro: bool = True
+ auto_prefix_chapter_titles: bool = True
+ normalize_chapter_opening_caps: bool = True
+ chunk_level: str = "paragraph"
+ chunks: List[Dict[str, Any]] = field(default_factory=list)
+ speakers: Dict[str, Any] = field(default_factory=dict)
+ speaker_mode: str = "single"
+ generate_epub3: bool = False
+ speaker_analysis: Dict[str, Any] = field(default_factory=dict)
+ speaker_analysis_threshold: int = 3
+ analysis_requested: bool = False
+ speaker_voice_languages: List[str] = field(default_factory=list)
+ applied_speaker_config: Optional[str] = None
+ entity_summary: Dict[str, Any] = field(default_factory=dict)
+ manual_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ pronunciation_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ heteronym_overrides: List[Dict[str, Any]] = field(default_factory=list)
+ entity_cache_key: Optional[str] = None
+ wizard_max_step_index: int = 0
+
+
+class ConversionService:
+ def __init__(
+ self,
+ output_root: Path,
+ runner: Callable[[Job], None],
+ *,
+ uploads_root: Optional[Path] = None,
+ poll_interval: float = 0.5,
+ ) -> None:
+ self._jobs: Dict[str, Job] = {}
+ self._queue: List[str] = []
+ self._lock = threading.RLock()
+ self._worker_thread: Optional[threading.Thread] = None
+ self._stop_event = threading.Event()
+ self._wake_event = threading.Event()
+ self._output_root = output_root
+ self._uploads_root = uploads_root or output_root / "uploads"
+ self._runner = runner
+ self._poll_interval = poll_interval
+ self._pending_jobs: Dict[str, PendingJob] = {}
+ self._state_path = self._determine_state_path()
+ self._ensure_directories()
+ self._bootstrap_voice_cache()
+ self._load_state()
+
+ # Public API ---------------------------------------------------------
+ def list_jobs(self) -> List[Job]:
+ with self._lock:
+ return sorted(self._jobs.values(), key=lambda job: job.created_at, reverse=True)
+
+ def get_job(self, job_id: str) -> Optional[Job]:
+ with self._lock:
+ return self._jobs.get(job_id)
+
+ def enqueue(
+ self,
+ *,
+ original_filename: str,
+ stored_path: Path,
+ language: str,
+ voice: str,
+ speed: float,
+ tts_provider: str = "kokoro",
+ supertonic_total_steps: int = 5,
+ use_gpu: bool,
+ subtitle_mode: str,
+ output_format: str,
+ save_mode: str,
+ output_folder: Optional[Path],
+ replace_single_newlines: bool,
+ subtitle_format: str,
+ total_characters: int,
+ chapters: Optional[Iterable[Any]] = None,
+ save_chapters_separately: bool = False,
+ merge_chapters_at_end: bool = True,
+ separate_chapters_format: str = "wav",
+ silence_between_chapters: float = 2.0,
+ save_as_project: bool = False,
+ voice_profile: Optional[str] = None,
+ max_subtitle_words: int = 50,
+ metadata_tags: Optional[Mapping[str, Any]] = None,
+ cover_image_path: Optional[Path] = None,
+ cover_image_mime: Optional[str] = None,
+ chapter_intro_delay: float = 0.5,
+ read_title_intro: bool = False,
+ read_closing_outro: bool = True,
+ auto_prefix_chapter_titles: bool = True,
+ normalize_chapter_opening_caps: bool = True,
+ chunk_level: str = "paragraph",
+ chunks: Optional[Iterable[Any]] = None,
+ speakers: Optional[Mapping[str, Any]] = None,
+ speaker_mode: str = "single",
+ generate_epub3: bool = False,
+ speaker_analysis: Optional[Mapping[str, Any]] = None,
+ speaker_analysis_threshold: int = 3,
+ analysis_requested: bool = False,
+ entity_summary: Optional[Mapping[str, Any]] = None,
+ manual_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ pronunciation_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ heteronym_overrides: Optional[Iterable[Mapping[str, Any]]] = None,
+ normalization_overrides: Optional[Mapping[str, Any]] = None,
+ ) -> Job:
+ job_id = uuid.uuid4().hex
+ normalized_metadata = self._normalize_metadata_tags(metadata_tags)
+ normalized_chapters = self._normalize_chapters(chapters)
+ normalized_chunks = self._normalize_chunks(chunks)
+ if total_characters <= 0 and normalized_chapters:
+ total_characters = sum(len(str(entry.get("text", ""))) for entry in normalized_chapters)
+ job = Job(
+ id=job_id,
+ original_filename=original_filename,
+ stored_path=stored_path,
+ language=language,
+ voice=voice,
+ speed=speed,
+ tts_provider=tts_provider,
+ supertonic_total_steps=int(supertonic_total_steps or 5),
+ use_gpu=use_gpu,
+ subtitle_mode=subtitle_mode,
+ output_format=output_format,
+ save_mode=save_mode,
+ output_folder=output_folder,
+ replace_single_newlines=replace_single_newlines,
+ subtitle_format=subtitle_format,
+ save_chapters_separately=save_chapters_separately,
+ merge_chapters_at_end=merge_chapters_at_end,
+ separate_chapters_format=separate_chapters_format,
+ silence_between_chapters=silence_between_chapters,
+ save_as_project=save_as_project,
+ voice_profile=voice_profile,
+ max_subtitle_words=max_subtitle_words,
+ metadata_tags=normalized_metadata,
+ created_at=time.time(),
+ total_characters=total_characters,
+ chapters=normalized_chapters,
+ cover_image_path=cover_image_path,
+ cover_image_mime=cover_image_mime,
+ chapter_intro_delay=chapter_intro_delay,
+ read_title_intro=bool(read_title_intro),
+ read_closing_outro=bool(read_closing_outro),
+ auto_prefix_chapter_titles=bool(auto_prefix_chapter_titles),
+ normalize_chapter_opening_caps=bool(normalize_chapter_opening_caps),
+ chunk_level=chunk_level,
+ chunks=normalized_chunks,
+ speakers=dict(speakers or {}),
+ speaker_mode=speaker_mode,
+ generate_epub3=bool(generate_epub3),
+ speaker_analysis=dict(speaker_analysis or {}),
+ speaker_analysis_threshold=int(speaker_analysis_threshold or 3),
+ analysis_requested=bool(analysis_requested),
+ entity_summary=dict(entity_summary or {}),
+ manual_overrides=[dict(entry) for entry in manual_overrides] if manual_overrides else [],
+ pronunciation_overrides=[dict(entry) for entry in pronunciation_overrides] if pronunciation_overrides else [],
+ heteronym_overrides=[dict(entry) for entry in heteronym_overrides] if heteronym_overrides else [],
+ normalization_overrides=dict(normalization_overrides or {}),
+ )
+ with self._lock:
+ self._jobs[job_id] = job
+ self._queue.append(job_id)
+ self._update_queue_positions_locked()
+ self._wake_event.set()
+ self._ensure_worker()
+ job.add_log("Job queued")
+ return job
+
+ def store_pending_job(self, pending: PendingJob) -> None:
+ with self._lock:
+ self._pending_jobs[pending.id] = pending
+
+ def get_pending_job(self, pending_id: str) -> Optional[PendingJob]:
+ with self._lock:
+ return self._pending_jobs.get(pending_id)
+
+ def pop_pending_job(self, pending_id: str) -> Optional[PendingJob]:
+ with self._lock:
+ return self._pending_jobs.pop(pending_id, None)
+
+ def cancel(self, job_id: str) -> bool:
+ with self._lock:
+ job = self._jobs.get(job_id)
+ if job is None:
+ return False
+ if job.status in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+ return False
+ job.cancel_requested = True
+ job.pause_requested = False
+ job.paused = False
+ job.add_log("Cancellation requested", level="warning")
+ job.pause_event.set()
+ if job.status == JobStatus.PENDING:
+ job.status = JobStatus.CANCELLED
+ self._queue.remove(job_id)
+ job.finished_at = time.time()
+ self._update_queue_positions_locked()
+ self._persist_state()
+ return True
+
+ def pause(self, job_id: str) -> bool:
+ with self._lock:
+ job = self._jobs.get(job_id)
+ if job is None:
+ return False
+ if job.status in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+ return False
+ if job.pause_requested or job.paused:
+ return True
+
+ job.pause_requested = True
+ job.add_log("Pause requested; finishing current chunk before stopping.", level="warning")
+
+ if job.status == JobStatus.PENDING:
+ if job_id in self._queue:
+ self._queue.remove(job_id)
+ self._update_queue_positions_locked()
+ job.status = JobStatus.PAUSED
+ job.paused = True
+ job.pause_event.clear()
+ self._persist_state()
+ return True
+
+ def resume(self, job_id: str) -> bool:
+ with self._lock:
+ job = self._jobs.get(job_id)
+ if job is None:
+ return False
+ if job.status in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+ return False
+
+ job.pause_requested = False
+
+ if job.status == JobStatus.PAUSED and job.started_at is None:
+ job.status = JobStatus.PENDING
+ job.paused = False
+ job.pause_event.set()
+ if job_id not in self._queue:
+ self._queue.insert(0, job_id)
+ self._update_queue_positions_locked()
+ self._wake_event.set()
+ job.add_log("Resume requested; returning job to queue.", level="info")
+ else:
+ job.paused = False
+ job.pause_event.set()
+ if job.status == JobStatus.PAUSED:
+ job.status = JobStatus.RUNNING
+ job.add_log("Resume requested", level="info")
+
+ self._persist_state()
+ return True
+
+ def retry(self, job_id: str) -> Optional[Job]:
+ with self._lock:
+ job = self._jobs.get(job_id)
+ if job is None:
+ return None
+ if job.status not in {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED}:
+ job.add_log(
+ "Retry requested while job still active; ignoring.",
+ level="warning",
+ )
+ return None
+
+ stored_path = job.stored_path
+ if not isinstance(stored_path, Path):
+ stored_path = Path(str(stored_path))
+
+ if not stored_path.exists():
+ job.add_log(
+ f"Retry requested but source file is missing: {stored_path}",
+ level="error",
+ )
+ return None
+
+ new_job = self.enqueue(
+ original_filename=job.original_filename,
+ stored_path=stored_path,
+ language=job.language,
+ voice=job.voice,
+ speed=job.speed,
+ use_gpu=job.use_gpu,
+ subtitle_mode=job.subtitle_mode,
+ output_format=job.output_format,
+ save_mode=job.save_mode,
+ output_folder=job.output_folder,
+ replace_single_newlines=job.replace_single_newlines,
+ subtitle_format=job.subtitle_format,
+ total_characters=job.total_characters,
+ chapters=job.chapters,
+ save_chapters_separately=job.save_chapters_separately,
+ merge_chapters_at_end=job.merge_chapters_at_end,
+ separate_chapters_format=job.separate_chapters_format,
+ silence_between_chapters=job.silence_between_chapters,
+ save_as_project=job.save_as_project,
+ voice_profile=job.voice_profile,
+ max_subtitle_words=job.max_subtitle_words,
+ metadata_tags=job.metadata_tags,
+ cover_image_path=job.cover_image_path,
+ cover_image_mime=job.cover_image_mime,
+ chapter_intro_delay=job.chapter_intro_delay,
+ read_title_intro=job.read_title_intro,
+ auto_prefix_chapter_titles=job.auto_prefix_chapter_titles,
+ normalize_chapter_opening_caps=job.normalize_chapter_opening_caps,
+ chunk_level=job.chunk_level,
+ chunks=job.chunks,
+ speakers=job.speakers,
+ speaker_mode=job.speaker_mode,
+ generate_epub3=job.generate_epub3,
+ speaker_analysis=job.speaker_analysis,
+ speaker_analysis_threshold=job.speaker_analysis_threshold,
+ analysis_requested=job.analysis_requested,
+ entity_summary=job.entity_summary,
+ manual_overrides=job.manual_overrides,
+ pronunciation_overrides=job.pronunciation_overrides,
+ normalization_overrides=job.normalization_overrides,
+ )
+
+ new_job.speaker_voice_languages = list(job.speaker_voice_languages)
+ new_job.applied_speaker_config = job.applied_speaker_config
+ new_job.add_log(f"Retry created from job {job.id}", level="info")
+ job.add_log(f"Retry scheduled as job {new_job.id}", level="info")
+ self._remove_job_locked(job_id)
+ return new_job
+
+ def delete(self, job_id: str) -> bool:
+ with self._lock:
+ job = self._jobs.get(job_id)
+ if job is None:
+ return False
+ if job.status in {JobStatus.RUNNING}:
+ return False
+ self._jobs.pop(job_id)
+ if job_id in self._queue:
+ self._queue.remove(job_id)
+ self._update_queue_positions_locked()
+ self._persist_state()
+ return True
+
+ def clear_finished(self, *, statuses: Optional[Iterable[JobStatus]] = None) -> int:
+ finished_statuses = set(statuses or {JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED})
+ removed = 0
+ with self._lock:
+ # Remove any queued entries first to avoid stale references
+ filtered_queue: List[str] = []
+ for job_id in self._queue:
+ job = self._jobs.get(job_id)
+ if job and job.status in finished_statuses:
+ continue
+ filtered_queue.append(job_id)
+ self._queue = filtered_queue
+
+ for job_id, job in list(self._jobs.items()):
+ if job.status in finished_statuses:
+ self._jobs.pop(job_id)
+ removed += 1
+
+ if removed:
+ self._update_queue_positions_locked()
+ self._persist_state()
+ return removed
+
+ def shutdown(self) -> None:
+ self._stop_event.set()
+ self._wake_event.set()
+ if self._worker_thread and self._worker_thread.is_alive():
+ self._worker_thread.join(timeout=5)
+ self._worker_thread = None
+
+ # Internal -----------------------------------------------------------
+ def _ensure_directories(self) -> None:
+ self._output_root.mkdir(parents=True, exist_ok=True)
+ self._uploads_root.mkdir(parents=True, exist_ok=True)
+ self._state_path.parent.mkdir(parents=True, exist_ok=True)
+
+ def _bootstrap_voice_cache(self) -> None:
+ try:
+ downloaded, errors = bootstrap_voice_cache(
+ on_progress=lambda msg: _JOB_LOGGER.debug("[voice cache] %s", msg)
+ )
+ except RuntimeError as exc:
+ _JOB_LOGGER.warning("Voice cache bootstrap skipped: %s", exc)
+ return
+
+ if downloaded:
+ count = len(downloaded)
+ suffix = "s" if count != 1 else ""
+ _JOB_LOGGER.info("Voice cache ready: downloaded %d new asset%s.", count, suffix)
+ if errors:
+ for voice_id, message in errors.items():
+ _JOB_LOGGER.warning("Voice cache failed for %s: %s", voice_id, message)
+
+ def _ensure_worker(self) -> None:
+ with self._lock:
+ if self._worker_thread and self._worker_thread.is_alive():
+ return
+ self._stop_event.clear()
+ self._worker_thread = threading.Thread(
+ target=self._worker_loop,
+ name="abogen-conversion-worker",
+ daemon=True,
+ )
+ self._worker_thread.start()
+
+ def _worker_loop(self) -> None:
+ while not self._stop_event.is_set():
+ job = None
+ with self._lock:
+ self._wake_event.clear()
+ while self._queue and self._jobs[self._queue[0]].status in {
+ JobStatus.CANCELLED,
+ JobStatus.COMPLETED,
+ JobStatus.FAILED,
+ }:
+ self._queue.pop(0)
+ if self._queue:
+ job = self._jobs[self._queue.pop(0)]
+ else:
+ self._update_queue_positions_locked()
+ if job is None:
+ self._wake_event.wait(timeout=self._poll_interval)
+ continue
+ if job.cancel_requested:
+ job.add_log("Job cancelled before start", level="warning")
+ job.status = JobStatus.CANCELLED
+ job.finished_at = time.time()
+ continue
+ self._run_job(job)
+
+ def _run_job(self, job: Job) -> None:
+ job.pause_event.set()
+ job.pause_requested = False
+ job.paused = False
+ job.status = JobStatus.RUNNING
+ job.started_at = time.time()
+ job.add_log("Job started", level="info")
+ self._persist_state()
+ try:
+ self._runner(job)
+ except Exception as exc: # pragma: no cover - defensive
+ job.error = str(exc)
+ job.status = JobStatus.FAILED
+ job.finished_at = time.time()
+ exc_type = exc.__class__.__name__
+ job.add_log(f"Job failed ({exc_type}): {exc}", level="error")
+ tb_lines = traceback.format_exception(exc.__class__, exc, exc.__traceback__)
+ for line in tb_lines[:20]:
+ trimmed = line.rstrip()
+ if trimmed:
+ for snippet in trimmed.splitlines():
+ job.add_log(f"TRACE: {snippet}", level="debug")
+ else:
+ if job.cancel_requested:
+ job.status = JobStatus.CANCELLED
+ job.add_log("Job cancelled", level="warning")
+ elif job.status != JobStatus.FAILED:
+ job.status = JobStatus.COMPLETED
+ job.add_log("Job completed", level="success")
+ self._post_completion_hooks(job)
+ job.finished_at = time.time()
+ finally:
+ job.pause_event.set()
+ self._persist_state()
+ with self._lock:
+ self._update_queue_positions_locked()
+
+ def _update_queue_positions_locked(self) -> None:
+ for index, job_id in enumerate(self._queue, start=1):
+ job = self._jobs.get(job_id)
+ if job:
+ job.queue_position = index
+ self._persist_state()
+
+ def _remove_job_locked(self, job_id: str) -> None:
+ self._jobs.pop(job_id, None)
+ if job_id in self._queue:
+ self._queue.remove(job_id)
+ self._update_queue_positions_locked()
+
+ def _post_completion_hooks(self, job: Job) -> None:
+ try:
+ self._maybe_send_to_audiobookshelf(job)
+ except AudiobookshelfUploadError as exc:
+ job.add_log(f"Audiobookshelf upload failed: {exc}", level="error")
+ except Exception as exc: # pragma: no cover - defensive guard
+ job.add_log(f"Audiobookshelf integration error: {exc}", level="error")
+
+ def _maybe_send_to_audiobookshelf(self, job: Job) -> None:
+ cfg = load_config() or {}
+ integration_cfg = cfg.get("audiobookshelf")
+ if not isinstance(integration_cfg, Mapping):
+ return
+ enabled = self._coerce_bool(integration_cfg.get("enabled"), False)
+ auto_send = self._coerce_bool(integration_cfg.get("auto_send"), False)
+ if not (enabled and auto_send):
+ return
+
+ base_url = str(integration_cfg.get("base_url") or "").strip()
+ api_token = str(integration_cfg.get("api_token") or "").strip()
+ library_id = str(integration_cfg.get("library_id") or "").strip()
+ folder_id = str(integration_cfg.get("folder_id") or "").strip()
+ if not base_url or not api_token or not library_id:
+ job.add_log(
+ "Audiobookshelf upload skipped: configure base URL, API token, and library ID first.",
+ level="warning",
+ )
+ return
+ if not folder_id:
+ job.add_log(
+ "Audiobookshelf upload skipped: enter the folder name or ID in the Audiobookshelf settings.",
+ level="warning",
+ )
+ return
+
+ audio_ref = job.result.audio_path
+ audio_path = audio_ref if isinstance(audio_ref, Path) else Path(str(audio_ref)) if audio_ref else None
+ if not audio_path or not audio_path.exists():
+ job.add_log("Audiobookshelf upload skipped: audio output not found.", level="warning")
+ return
+
+ timeout_raw = integration_cfg.get("timeout", 3600.0)
+ try:
+ timeout_value = float(timeout_raw)
+ except (TypeError, ValueError):
+ timeout_value = 3600.0
+
+ config = AudiobookshelfConfig(
+ base_url=base_url,
+ api_token=api_token,
+ library_id=library_id,
+ collection_id=(str(integration_cfg.get("collection_id") or "").strip() or None),
+ folder_id=folder_id,
+ verify_ssl=self._coerce_bool(integration_cfg.get("verify_ssl"), True),
+ send_cover=self._coerce_bool(integration_cfg.get("send_cover"), True),
+ send_chapters=self._coerce_bool(integration_cfg.get("send_chapters"), True),
+ send_subtitles=self._coerce_bool(integration_cfg.get("send_subtitles"), False),
+ timeout=timeout_value,
+ )
+
+ cover_ref = job.cover_image_path
+ cover_path = None
+ if config.send_cover and cover_ref:
+ cover_candidate = cover_ref if isinstance(cover_ref, Path) else Path(str(cover_ref))
+ if cover_candidate.exists():
+ cover_path = cover_candidate
+
+ subtitles = _existing_paths(job.result.subtitle_paths) if config.send_subtitles else None
+ chapters = load_audiobookshelf_chapters(job) if config.send_chapters else None
+ metadata = build_audiobookshelf_metadata(job)
+
+ client = AudiobookshelfClient(config)
+
+ display_title = metadata.get("title") or audio_path.stem
+ try:
+ existing_items = client.find_existing_items(display_title, folder_id=config.folder_id)
+ except AudiobookshelfUploadError as exc:
+ job.add_log(f"Audiobookshelf lookup failed: {exc}", level="error")
+ return
+
+ if existing_items:
+ job.add_log(
+ f"Removing existing Audiobookshelf item(s) for '{display_title}' before upload.",
+ level="info",
+ )
+ try:
+ client.delete_items(existing_items)
+ except Exception as exc:
+ job.add_log(f"Failed to remove existing item(s): {exc}", level="warning")
+
+ client.upload_audiobook(
+ audio_path,
+ metadata=metadata,
+ cover_path=cover_path,
+ chapters=chapters,
+ subtitles=subtitles,
+ )
+ job.add_log("Audiobookshelf upload queued.", level="info")
+
+ # Persistence ------------------------------------------------------
+ def _serialize_job(self, job: Job) -> Dict[str, Any]:
+ result_audio = str(job.result.audio_path) if job.result.audio_path else None
+ result_subtitles = [str(path) for path in job.result.subtitle_paths]
+ result_artifacts = {key: str(path) for key, path in job.result.artifacts.items()}
+ result_epub = str(job.result.epub_path) if job.result.epub_path else None
+ return {
+ "id": job.id,
+ "original_filename": job.original_filename,
+ "stored_path": str(job.stored_path),
+ "language": job.language,
+ "tts_provider": getattr(job, "tts_provider", "kokoro"),
+ "voice": job.voice,
+ "speed": job.speed,
+ "supertonic_total_steps": getattr(job, "supertonic_total_steps", 5),
+ "use_gpu": job.use_gpu,
+ "subtitle_mode": job.subtitle_mode,
+ "output_format": job.output_format,
+ "save_mode": job.save_mode,
+ "output_folder": str(job.output_folder) if job.output_folder else None,
+ "replace_single_newlines": job.replace_single_newlines,
+ "subtitle_format": job.subtitle_format,
+ "created_at": job.created_at,
+ "save_chapters_separately": job.save_chapters_separately,
+ "merge_chapters_at_end": job.merge_chapters_at_end,
+ "separate_chapters_format": job.separate_chapters_format,
+ "silence_between_chapters": job.silence_between_chapters,
+ "save_as_project": job.save_as_project,
+ "voice_profile": job.voice_profile,
+ "metadata_tags": job.metadata_tags,
+ "max_subtitle_words": job.max_subtitle_words,
+ "status": job.status.value,
+ "started_at": job.started_at,
+ "finished_at": job.finished_at,
+ "progress": job.progress,
+ "total_characters": job.total_characters,
+ "processed_characters": job.processed_characters,
+ "error": job.error,
+ "logs": [log.__dict__ for log in job.logs][-500:],
+ "result": {
+ "audio_path": result_audio,
+ "subtitle_paths": result_subtitles,
+ "artifacts": result_artifacts,
+ "epub_path": result_epub,
+ },
+ "chapters": [dict(entry) for entry in job.chapters],
+ "queue_position": job.queue_position,
+ "cancel_requested": job.cancel_requested,
+ "pause_requested": job.pause_requested,
+ "paused": job.paused,
+ "resume_token": job.resume_token,
+ "cover_image_path": str(job.cover_image_path) if job.cover_image_path else None,
+ "cover_image_mime": job.cover_image_mime,
+ "chapter_intro_delay": job.chapter_intro_delay,
+ "read_title_intro": job.read_title_intro,
+ "auto_prefix_chapter_titles": job.auto_prefix_chapter_titles,
+ "normalize_chapter_opening_caps": job.normalize_chapter_opening_caps,
+ "chunk_level": job.chunk_level,
+ "chunks": [dict(entry) for entry in job.chunks],
+ "speakers": dict(job.speakers),
+ "speaker_mode": job.speaker_mode,
+ "generate_epub3": job.generate_epub3,
+ "speaker_analysis": dict(job.speaker_analysis),
+ "speaker_analysis_threshold": job.speaker_analysis_threshold,
+ "analysis_requested": job.analysis_requested,
+ "entity_summary": dict(job.entity_summary),
+ "manual_overrides": [dict(entry) for entry in job.manual_overrides],
+ "pronunciation_overrides": [dict(entry) for entry in job.pronunciation_overrides],
+ "heteronym_overrides": [dict(entry) for entry in job.heteronym_overrides],
+ "normalization_overrides": dict(job.normalization_overrides),
+ }
+
+ def _persist_state(self) -> None:
+ try:
+ with self._lock:
+ snapshot = {
+ "version": STATE_VERSION,
+ "jobs": [self._serialize_job(job) for job in self._jobs.values()],
+ "queue": list(self._queue),
+ }
+ tmp_path = self._state_path.with_suffix(".tmp")
+ with tmp_path.open("w", encoding="utf-8") as handle:
+ json.dump(snapshot, handle, indent=2)
+ os.replace(tmp_path, self._state_path)
+ except Exception:
+ # Persistence failures should not disrupt runtime; ignore.
+ pass
+
+ def _determine_state_path(self) -> Path:
+ override_file = os.environ.get("ABOGEN_QUEUE_STATE_PATH")
+ if override_file:
+ target_path = Path(override_file).expanduser()
+ target_path.parent.mkdir(parents=True, exist_ok=True)
+ return target_path
+
+ override_dir = os.environ.get("ABOGEN_QUEUE_STATE_DIR")
+ if override_dir:
+ base_dir = Path(override_dir).expanduser()
+ else:
+ settings_override = os.environ.get("ABOGEN_SETTINGS_DIR")
+ if settings_override:
+ base_dir = Path(settings_override).expanduser() / "queue"
+ else:
+ try:
+ base_dir = Path(get_user_settings_dir()) / "queue"
+ except ModuleNotFoundError:
+ base_dir = Path(get_internal_cache_path("jobs"))
+ base_dir.mkdir(parents=True, exist_ok=True)
+ target_path = base_dir / "queue_state.json"
+
+ legacy_path = Path(get_internal_cache_path("jobs")) / "queue_state.json"
+ if legacy_path.exists() and not target_path.exists():
+ try:
+ shutil.move(str(legacy_path), target_path)
+ except Exception:
+ try:
+ shutil.copy2(str(legacy_path), target_path)
+ except Exception:
+ pass
+
+ return target_path
+
+ def _deserialize_job(self, payload: Dict[str, Any]) -> Job:
+ stored_path = Path(payload["stored_path"])
+ output_folder_raw = payload.get("output_folder")
+ output_folder = Path(output_folder_raw) if output_folder_raw else None
+ job = Job(
+ id=payload["id"],
+ original_filename=payload["original_filename"],
+ stored_path=stored_path,
+ language=payload.get("language", "a"),
+ tts_provider=str(payload.get("tts_provider") or "kokoro"),
+ voice=payload.get("voice", ""),
+ speed=float(payload.get("speed", 1.0)),
+ use_gpu=bool(payload.get("use_gpu", True)),
+ subtitle_mode=payload.get("subtitle_mode", "Disabled"),
+ output_format=payload.get("output_format", "wav"),
+ save_mode=payload.get("save_mode", "Save next to input file"),
+ output_folder=output_folder,
+ replace_single_newlines=bool(payload.get("replace_single_newlines", False)),
+ subtitle_format=payload.get("subtitle_format", "srt"),
+ created_at=float(payload.get("created_at", time.time())),
+ supertonic_total_steps=int(payload.get("supertonic_total_steps", 5)),
+ save_chapters_separately=bool(payload.get("save_chapters_separately", False)),
+ merge_chapters_at_end=bool(payload.get("merge_chapters_at_end", True)),
+ separate_chapters_format=payload.get("separate_chapters_format", "wav"),
+ silence_between_chapters=float(payload.get("silence_between_chapters", 2.0)),
+ save_as_project=bool(payload.get("save_as_project", False)),
+ voice_profile=payload.get("voice_profile"),
+ metadata_tags=payload.get("metadata_tags", {}),
+ max_subtitle_words=int(payload.get("max_subtitle_words", 50)),
+ chapter_intro_delay=float(payload.get("chapter_intro_delay", 0.5)),
+ read_title_intro=bool(payload.get("read_title_intro", False)),
+ auto_prefix_chapter_titles=bool(payload.get("auto_prefix_chapter_titles", True)),
+ normalize_chapter_opening_caps=bool(payload.get("normalize_chapter_opening_caps", True)),
+ )
+ job.status = JobStatus(payload.get("status", job.status.value))
+ job.started_at = payload.get("started_at")
+ job.finished_at = payload.get("finished_at")
+ job.progress = float(payload.get("progress", 0.0))
+ job.total_characters = int(payload.get("total_characters", 0))
+ job.processed_characters = int(payload.get("processed_characters", 0))
+ job.error = payload.get("error")
+ job.logs = [JobLog(**entry) for entry in payload.get("logs", [])]
+ result_payload = payload.get("result", {})
+ audio_path_raw = result_payload.get("audio_path")
+ job.result.audio_path = Path(audio_path_raw) if audio_path_raw else None
+ job.result.subtitle_paths = [Path(item) for item in result_payload.get("subtitle_paths", [])]
+ job.result.artifacts = {
+ key: Path(value) for key, value in result_payload.get("artifacts", {}).items()
+ }
+ epub_path_raw = result_payload.get("epub_path")
+ job.result.epub_path = Path(epub_path_raw) if epub_path_raw else None
+ job.chapters = payload.get("chapters", [])
+ job.queue_position = payload.get("queue_position")
+ job.cancel_requested = bool(payload.get("cancel_requested", False))
+ job.pause_requested = bool(payload.get("pause_requested", False))
+ job.paused = bool(payload.get("paused", False))
+ job.resume_token = payload.get("resume_token")
+ cover_path_raw = payload.get("cover_image_path")
+ job.cover_image_path = Path(cover_path_raw) if cover_path_raw else None
+ job.cover_image_mime = payload.get("cover_image_mime")
+ job.chunk_level = str(payload.get("chunk_level", job.chunk_level or "paragraph"))
+ job.chunks = self._normalize_chunks(payload.get("chunks"))
+ job.speakers = dict(payload.get("speakers", {}))
+ job.speaker_mode = str(payload.get("speaker_mode", job.speaker_mode or "single"))
+ job.generate_epub3 = bool(payload.get("generate_epub3", job.generate_epub3))
+ job.speaker_analysis = payload.get("speaker_analysis", {})
+ job.speaker_analysis_threshold = int(
+ payload.get("speaker_analysis_threshold", job.speaker_analysis_threshold or 3)
+ )
+ job.analysis_requested = bool(payload.get("analysis_requested", job.analysis_requested))
+ job.entity_summary = payload.get("entity_summary", {})
+ job.manual_overrides = [dict(entry) for entry in payload.get("manual_overrides", []) if isinstance(entry, Mapping)]
+ job.pronunciation_overrides = [
+ dict(entry) for entry in payload.get("pronunciation_overrides", []) if isinstance(entry, Mapping)
+ ]
+ job.heteronym_overrides = [
+ dict(entry) for entry in payload.get("heteronym_overrides", []) if isinstance(entry, Mapping)
+ ]
+ job.normalization_overrides = dict(payload.get("normalization_overrides", {}) or {})
+ job.pause_event.set()
+ return job
+
+ def _load_state(self) -> None:
+ if not self._state_path.exists():
+ return
+ try:
+ with self._state_path.open("r", encoding="utf-8") as handle:
+ payload = json.load(handle)
+ except Exception:
+ return
+
+ version = int(payload.get("version", 0) or 0)
+ if version not in {STATE_VERSION, STATE_VERSION - 1}:
+ return
+
+ jobs_payload = payload.get("jobs", [])
+ queue_payload = payload.get("queue", [])
+ loaded_jobs: Dict[str, Job] = {}
+ requeue: List[str] = []
+
+ for entry in jobs_payload:
+ try:
+ job = self._deserialize_job(entry)
+ except Exception:
+ continue
+
+ if job.status in {JobStatus.RUNNING, JobStatus.PAUSED}:
+ job.status = JobStatus.PENDING
+ job.add_log("Job restored after restart: resetting to pending queue.", level="warning")
+ job.progress = 0.0
+ job.processed_characters = 0
+ job.pause_requested = False
+ job.paused = False
+ job.pause_event.set()
+ requeue.append(job.id)
+ elif job.status == JobStatus.PENDING:
+ requeue.append(job.id)
+
+ loaded_jobs[job.id] = job
+
+ with self._lock:
+ self._jobs = loaded_jobs
+ self._queue = [job_id for job_id in queue_payload if job_id in loaded_jobs]
+ for job_id in requeue:
+ if job_id not in self._queue:
+ self._queue.append(job_id)
+ self._update_queue_positions_locked()
+
+ if self._queue:
+ self._ensure_worker()
+
+ @staticmethod
+ def _coerce_bool(value: Any, default: bool = True) -> bool:
+ if isinstance(value, bool):
+ return value
+ if isinstance(value, str):
+ lowered = value.strip().lower()
+ if lowered in {"true", "1", "yes", "on"}:
+ return True
+ if lowered in {"false", "0", "no", "off"}:
+ return False
+ return default
+ if value is None:
+ return default
+ return bool(value)
+
+ @staticmethod
+ def _coerce_optional_int(value: Any) -> Optional[int]:
+ if value is None:
+ return None
+ try:
+ return int(value)
+ except (TypeError, ValueError):
+ return None
+
+ @staticmethod
+ def _normalize_metadata_tags(values: Optional[Mapping[str, Any]]) -> Dict[str, str]:
+ if not values:
+ return {}
+ normalized: Dict[str, str] = {}
+ for key, raw_value in values.items():
+ if raw_value is None:
+ continue
+ key_str = str(key).strip()
+ if not key_str:
+ continue
+ normalized[key_str] = str(raw_value)
+ return normalized
+
+ @classmethod
+ def _normalize_chapters(cls, chapters: Optional[Iterable[Any]]) -> List[Dict[str, Any]]:
+ if not chapters:
+ return []
+
+ normalized: List[Dict[str, Any]] = []
+ for order, raw in enumerate(chapters):
+ if raw is None:
+ continue
+
+ if isinstance(raw, str):
+ raw_dict: Dict[str, Any] = {"title": raw}
+ elif isinstance(raw, dict):
+ raw_dict = dict(raw)
+ else:
+ continue
+
+ entry: Dict[str, Any] = {}
+
+ id_value = raw_dict.get("id") or raw_dict.get("chapter_id") or raw_dict.get("key")
+ if id_value is not None:
+ entry["id"] = str(id_value)
+
+ index_value = (
+ cls._coerce_optional_int(raw_dict.get("index"))
+ or cls._coerce_optional_int(raw_dict.get("original_index"))
+ or cls._coerce_optional_int(raw_dict.get("source_index"))
+ or cls._coerce_optional_int(raw_dict.get("chapter_index"))
+ )
+ if index_value is not None:
+ entry["index"] = index_value
+
+ order_value = (
+ cls._coerce_optional_int(raw_dict.get("order"))
+ or cls._coerce_optional_int(raw_dict.get("position"))
+ or cls._coerce_optional_int(raw_dict.get("sort"))
+ or cls._coerce_optional_int(raw_dict.get("sort_order"))
+ )
+ entry["order"] = order_value if order_value is not None else order
+
+ source_title = (
+ raw_dict.get("source_title")
+ or raw_dict.get("original_title")
+ or raw_dict.get("base_title")
+ )
+ if source_title:
+ entry["source_title"] = str(source_title)
+
+ title_value = (
+ raw_dict.get("title")
+ or raw_dict.get("name")
+ or raw_dict.get("label")
+ or raw_dict.get("chapter")
+ )
+ if title_value is not None:
+ entry["title"] = str(title_value)
+ elif source_title:
+ entry["title"] = str(source_title)
+ else:
+ entry["title"] = f"Chapter {order + 1}"
+
+ text_value = raw_dict.get("text")
+ if text_value is None:
+ text_value = raw_dict.get("content") or raw_dict.get("body") or raw_dict.get("value")
+ if text_value is not None:
+ entry["text"] = str(text_value)
+
+ enabled = cls._coerce_bool(
+ raw_dict.get("enabled", raw_dict.get("include", raw_dict.get("selected", True))),
+ True,
+ )
+ if "disabled" in raw_dict and cls._coerce_bool(raw_dict.get("disabled"), False):
+ enabled = False
+ entry["enabled"] = enabled
+
+ metadata_payload = raw_dict.get("metadata") or raw_dict.get("metadata_tags")
+ normalized_metadata = cls._normalize_metadata_tags(metadata_payload)
+ if normalized_metadata:
+ entry["metadata"] = normalized_metadata
+
+ voice_value = raw_dict.get("voice")
+ if voice_value:
+ entry["voice"] = str(voice_value)
+
+ profile_value = raw_dict.get("voice_profile")
+ if profile_value:
+ entry["voice_profile"] = str(profile_value)
+
+ formula_value = raw_dict.get("voice_formula") or raw_dict.get("formula")
+ if formula_value:
+ entry["voice_formula"] = str(formula_value)
+
+ resolved_value = raw_dict.get("resolved_voice")
+ if resolved_value:
+ entry["resolved_voice"] = str(resolved_value)
+
+ if "characters" in raw_dict:
+ try:
+ entry["characters"] = int(raw_dict.get("characters", 0))
+ except (TypeError, ValueError):
+ entry["characters"] = len(str(entry.get("text", "")))
+ else:
+ entry["characters"] = len(str(entry.get("text", "")))
+
+ normalized.append(entry)
+
+ return normalized
+
+ @classmethod
+ def _normalize_chunks(cls, chunks: Optional[Iterable[Any]]) -> List[Dict[str, Any]]:
+ if not chunks:
+ return []
+
+ normalized: List[Dict[str, Any]] = []
+ for order, raw in enumerate(chunks):
+ if raw is None:
+ continue
+ if isinstance(raw, dict):
+ entry = dict(raw)
+ else:
+ continue
+
+ chunk: Dict[str, Any] = {}
+
+ identifier = entry.get("id") or entry.get("chunk_id")
+ if identifier is not None:
+ chunk["id"] = str(identifier)
+
+ try:
+ chunk_index = int(entry.get("chunk_index", order))
+ except (TypeError, ValueError):
+ chunk_index = order
+ chunk["chunk_index"] = chunk_index
+
+ try:
+ chapter_index = int(entry.get("chapter_index", 0))
+ except (TypeError, ValueError):
+ chapter_index = 0
+ chunk["chapter_index"] = chapter_index
+
+ level_raw = str(entry.get("level", "paragraph")).lower()
+ if level_raw not in {"paragraph", "sentence"}:
+ level_raw = "paragraph"
+ chunk["level"] = level_raw
+
+ text_value = entry.get("text")
+ if text_value is not None:
+ chunk["text"] = str(text_value)
+ else:
+ chunk["text"] = ""
+
+ normalized_value = entry.get("normalized_text")
+ if normalized_value is not None:
+ chunk["normalized_text"] = str(normalized_value)
+
+ for text_key in ("display_text", "original_text"):
+ if text_key in entry and entry[text_key] is not None:
+ chunk[text_key] = str(entry[text_key])
+
+ speaker_value = entry.get("speaker_id", entry.get("speaker"))
+ chunk["speaker_id"] = str(speaker_value) if speaker_value else "narrator"
+
+ for key in ("voice", "voice_profile", "voice_formula", "audio_path", "start", "end"):
+ if key in entry and entry[key] is not None:
+ chunk[key] = entry[key]
+
+ normalized.append(chunk)
+ return normalized
+
+
+def default_storage_root() -> Path:
+ base = Path.cwd()
+ uploads = base / "var" / "uploads"
+ outputs = base / "var" / "outputs"
+ outputs.mkdir(parents=True, exist_ok=True)
+ uploads.mkdir(parents=True, exist_ok=True)
+ return outputs
+
+
+def build_service(
+ runner: Callable[[Job], None],
+ *,
+ output_root: Optional[Path] = None,
+ uploads_root: Optional[Path] = None,
+) -> ConversionService:
+ output_root = output_root or default_storage_root()
+ service = ConversionService(
+ output_root=output_root,
+ uploads_root=uploads_root,
+ runner=runner,
+ )
+ return service
diff --git a/abogen/webui/static/dashboard.js b/abogen/webui/static/dashboard.js
new file mode 100644
index 0000000..e2d0028
--- /dev/null
+++ b/abogen/webui/static/dashboard.js
@@ -0,0 +1,582 @@
+import { initReaderUI } from "./reader.js";
+import { initWizard } from "./wizard.js";
+
+const dashboardState = (window.AbogenDashboardState = window.AbogenDashboardState || {
+ boundKeydown: false,
+ boundBeforeUnload: false,
+});
+
+const initDashboard = () => {
+ const uploadModal =
+ document.querySelector('[data-role="new-job-modal"]') ||
+ document.querySelector('[data-role="upload-modal"]');
+ const openModalButtons = document.querySelectorAll('[data-role="open-upload-modal"]');
+ const scope = uploadModal || document;
+ const sourceFileInput = scope.querySelector('#source_file');
+ const dropzone = document.querySelector('[data-role="upload-dropzone"]');
+ const dropzoneFilename = document.querySelector('[data-role="upload-dropzone-filename"]');
+
+ const parseJSONScript = (id) => {
+ const element = document.getElementById(id);
+ if (!element) return null;
+ try {
+ const raw = element.textContent || "";
+ return raw ? JSON.parse(raw) : null;
+ } catch (error) {
+ console.warn(`Failed to parse JSON script: ${id}`, error);
+ return null;
+ }
+ };
+
+ const profileSelect = scope.querySelector('[data-role="voice-profile"]');
+ const voiceField = scope.querySelector('[data-role="voice-field"]');
+ const voiceSelect = scope.querySelector('[data-role="voice-select"]');
+ const formulaField = scope.querySelector('[data-role="formula-field"]');
+ const formulaInput = scope.querySelector('[data-role="voice-formula"]');
+ const languageSelect = uploadModal?.querySelector("#language") || document.getElementById("language");
+ const speedInput = uploadModal?.querySelector('#speed') || document.getElementById('speed');
+ const previewButton = scope.querySelector('[data-role="voice-preview-button"]');
+ const previewStatus = scope.querySelector('[data-role="voice-preview-status"]');
+ const previewAudio = scope.querySelector('[data-role="voice-preview-audio"]');
+ const sampleVoiceTexts = parseJSONScript('voice-sample-texts') || {};
+
+ const setDropzoneStatus = (message, state = "") => {
+ if (!dropzoneFilename) return;
+ if (!message) {
+ dropzoneFilename.hidden = true;
+ dropzoneFilename.textContent = "";
+ dropzoneFilename.removeAttribute("data-state");
+ return;
+ }
+ dropzoneFilename.hidden = false;
+ dropzoneFilename.textContent = message;
+ if (state) {
+ dropzoneFilename.dataset.state = state;
+ } else {
+ dropzoneFilename.removeAttribute("data-state");
+ }
+ };
+
+ const updateDropzoneFilename = () => {
+ if (!sourceFileInput) {
+ setDropzoneStatus("");
+ return;
+ }
+ const file = sourceFileInput.files && sourceFileInput.files[0];
+ if (file) {
+ setDropzoneStatus(`Selected: ${file.name}`);
+ } else {
+ setDropzoneStatus("");
+ }
+ };
+
+ const assignDroppedFile = (file) => {
+ if (!sourceFileInput || !file) {
+ return false;
+ }
+ try {
+ if (typeof DataTransfer === "undefined") {
+ throw new Error("DataTransfer API unavailable");
+ }
+ const transfer = new DataTransfer();
+ transfer.items.add(file);
+ sourceFileInput.files = transfer.files;
+ sourceFileInput.dispatchEvent(new Event("change", { bubbles: true }));
+ try {
+ sourceFileInput.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus errors
+ }
+ return true;
+ } catch (error) {
+ console.warn("Unable to assign dropped file to input", error);
+ setDropzoneStatus("Drag & drop isn't supported here. Click to choose a file instead.", "error");
+ return false;
+ }
+ };
+
+ const setDropzoneActive = (isActive) => {
+ if (!dropzone) return;
+ dropzone.classList.toggle("is-dragging", isActive);
+ if (isActive) {
+ dropzone.dataset.state = "drag";
+ } else {
+ delete dropzone.dataset.state;
+ }
+ };
+
+ let lastTrigger = null;
+ let previewAbortController = null;
+ let previewObjectUrl = null;
+ let suppressPauseStatus = false;
+
+ const dispatchUploadModalEvent = (type, detail = {}) => {
+ const eventName = `upload-modal:${type}`;
+ if (uploadModal) {
+ uploadModal.dispatchEvent(new CustomEvent(eventName, { detail, bubbles: true }));
+ return;
+ }
+ document.dispatchEvent(new CustomEvent(eventName, { detail }));
+ };
+
+ const openUploadModal = (trigger) => {
+ if (!uploadModal) return;
+ lastTrigger = trigger || null;
+ uploadModal.hidden = false;
+ uploadModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ const focusTarget = uploadModal.querySelector("#source_file") || uploadModal.querySelector("#source_text") || uploadModal;
+ if (focusTarget instanceof HTMLElement) {
+ focusTarget.focus({ preventScroll: true });
+ }
+ dispatchUploadModalEvent("open", { trigger: lastTrigger });
+ };
+
+ const closeUploadModal = () => {
+ if (!uploadModal || uploadModal.hidden) {
+ return;
+ }
+ uploadModal.hidden = true;
+ delete uploadModal.dataset.open;
+ document.body.classList.remove("modal-open");
+ if (lastTrigger && lastTrigger instanceof HTMLElement) {
+ lastTrigger.focus({ preventScroll: true });
+ }
+ dispatchUploadModalEvent("close", { trigger: lastTrigger });
+ };
+
+ openModalButtons.forEach((button) => {
+ if (!button || button.dataset.dashboardBound === "true") {
+ return;
+ }
+ button.dataset.dashboardBound = "true";
+ button.addEventListener("click", (event) => {
+ event.preventDefault();
+ openUploadModal(button);
+ });
+ });
+
+ if (uploadModal && uploadModal.dataset.dashboardCloseBound !== "true") {
+ uploadModal.dataset.dashboardCloseBound = "true";
+ uploadModal.addEventListener("click", (event) => {
+ const target = event.target;
+ if (
+ target instanceof Element &&
+ (target.closest('[data-role="new-job-modal-close"]') ||
+ target.closest('[data-role="upload-modal-close"]') ||
+ target.closest('[data-role="wizard-close"]') ||
+ target.closest('[data-role="wizard-cancel"]'))
+ ) {
+ event.preventDefault();
+ closeUploadModal();
+ }
+ });
+ }
+
+ if (!dashboardState.boundKeydown) {
+ dashboardState.boundKeydown = true;
+ document.addEventListener("keydown", (event) => {
+ if (event.key === "Escape") {
+ if (uploadModal && !uploadModal.hidden) {
+ closeUploadModal();
+ return;
+ }
+ }
+ });
+ }
+
+ initReaderUI({ onBeforeOpen: closeUploadModal });
+
+ if (sourceFileInput) {
+ if (sourceFileInput.dataset.dashboardChangeBound !== "true") {
+ sourceFileInput.dataset.dashboardChangeBound = "true";
+ sourceFileInput.addEventListener("change", updateDropzoneFilename);
+ }
+ updateDropzoneFilename();
+ } else {
+ setDropzoneStatus("");
+ }
+
+ const resolveSampleText = (language) => {
+ const fallback = typeof sampleVoiceTexts === "object" && sampleVoiceTexts?.a
+ ? sampleVoiceTexts.a
+ : "This is a sample of the selected voice.";
+ if (!language || typeof sampleVoiceTexts !== "object" || !sampleVoiceTexts) {
+ return fallback;
+ }
+ const normalizedKey = language.toLowerCase();
+ if (typeof sampleVoiceTexts[normalizedKey] === "string" && sampleVoiceTexts[normalizedKey].trim()) {
+ return sampleVoiceTexts[normalizedKey];
+ }
+ const baseKey = normalizedKey.split(/[_.-]/)[0];
+ if (baseKey && typeof sampleVoiceTexts[baseKey] === "string" && sampleVoiceTexts[baseKey].trim()) {
+ return sampleVoiceTexts[baseKey];
+ }
+ return fallback;
+ };
+
+ const getSelectedLanguage = () => {
+ const value = languageSelect?.value || "a";
+ return (value || "a").trim() || "a";
+ };
+
+ const getSelectedSpeed = () => {
+ const raw = speedInput?.value || "1";
+ const parsed = Number.parseFloat(raw);
+ return Number.isFinite(parsed) ? parsed : 1;
+ };
+
+ const cancelPreviewRequest = () => {
+ if (!previewAbortController) return;
+ previewAbortController.abort();
+ previewAbortController = null;
+ };
+
+ const stopPreviewAudio = () => {
+ if (previewAudio) {
+ suppressPauseStatus = true;
+ try {
+ previewAudio.pause();
+ } catch (error) {
+ // Ignore pause errors
+ }
+ previewAudio.removeAttribute("src");
+ previewAudio.load();
+ previewAudio.hidden = true;
+ suppressPauseStatus = false;
+ }
+ if (previewObjectUrl) {
+ URL.revokeObjectURL(previewObjectUrl);
+ previewObjectUrl = null;
+ }
+ };
+
+ const setPreviewStatus = (message, state = "") => {
+ if (!previewStatus) return;
+ if (!message) {
+ previewStatus.textContent = "";
+ previewStatus.hidden = true;
+ previewStatus.removeAttribute("data-state");
+ return;
+ }
+ previewStatus.textContent = message;
+ previewStatus.hidden = false;
+ if (state) {
+ previewStatus.dataset.state = state;
+ } else {
+ previewStatus.removeAttribute("data-state");
+ }
+ };
+
+ const setPreviewLoading = (isLoading) => {
+ if (!previewButton) return;
+ previewButton.disabled = isLoading;
+ if (isLoading) {
+ previewButton.dataset.loading = "true";
+ } else {
+ previewButton.removeAttribute("data-loading");
+ }
+ };
+
+ const buildPreviewRequest = () => {
+ const language = getSelectedLanguage();
+ const speed = getSelectedSpeed();
+ const basePayload = {
+ language,
+ speed,
+ max_seconds: 8,
+ text: resolveSampleText(language),
+ };
+
+ const profileValue = profileSelect?.value || "__standard";
+
+ if (profileValue && profileValue !== "__standard") {
+ if (profileValue === "__formula") {
+ const formulaValue = (formulaInput?.value || "").trim();
+ if (!formulaValue) {
+ return { error: "Enter a custom voice formula to preview." };
+ }
+ return {
+ endpoint: "/api/voice-profiles/preview",
+ payload: { ...basePayload, formula: formulaValue },
+ };
+ }
+ return {
+ endpoint: "/api/voice-profiles/preview",
+ payload: { ...basePayload, profile: profileValue },
+ };
+ }
+
+ const selectedVoice = (voiceSelect?.value || voiceSelect?.dataset.default || "").trim();
+ if (!selectedVoice) {
+ return { error: "Select a narrator voice to preview." };
+ }
+ return {
+ endpoint: "/api/speaker-preview",
+ payload: { ...basePayload, voice: selectedVoice },
+ };
+ };
+
+ const resetPreview = () => {
+ cancelPreviewRequest();
+ stopPreviewAudio();
+ setPreviewStatus("", "");
+ };
+
+ if (previewAudio) {
+ previewAudio.addEventListener("ended", () => {
+ setPreviewStatus("Preview finished", "info");
+ });
+ previewAudio.addEventListener("pause", () => {
+ if (suppressPauseStatus || previewAudio.ended || previewAudio.currentTime === 0) {
+ return;
+ }
+ setPreviewStatus("Preview paused", "info");
+ });
+ }
+
+ const handleVoicePreview = async () => {
+ if (!previewButton) return;
+ const request = buildPreviewRequest();
+ if (!request) {
+ return;
+ }
+ if (request.error) {
+ setPreviewStatus(request.error, "error");
+ cancelPreviewRequest();
+ stopPreviewAudio();
+ return;
+ }
+
+ cancelPreviewRequest();
+ stopPreviewAudio();
+ previewAbortController = new AbortController();
+ setPreviewLoading(true);
+ setPreviewStatus("Generating preview…", "loading");
+
+ try {
+ const response = await fetch(request.endpoint, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(request.payload),
+ signal: previewAbortController.signal,
+ });
+ if (!response.ok) {
+ const message = await response.text();
+ throw new Error(message || `Preview failed (status ${response.status})`);
+ }
+ const blob = await response.blob();
+ previewObjectUrl = URL.createObjectURL(blob);
+ if (previewAudio) {
+ previewAudio.src = previewObjectUrl;
+ previewAudio.hidden = false;
+ try {
+ await previewAudio.play();
+ setPreviewStatus("Preview playing", "success");
+ } catch (error) {
+ setPreviewStatus("Preview ready. Press play to listen.", "success");
+ }
+ } else {
+ setPreviewStatus("Preview ready.", "success");
+ }
+ } catch (error) {
+ if (error.name === "AbortError") {
+ return;
+ }
+ console.error("Voice preview failed", error);
+ setPreviewStatus(error.message || "Preview failed", "error");
+ stopPreviewAudio();
+ } finally {
+ setPreviewLoading(false);
+ }
+ };
+
+ if (previewButton && previewButton.dataset.dashboardBound !== "true") {
+ previewButton.dataset.dashboardBound = "true";
+ previewButton.addEventListener("click", (event) => {
+ event.preventDefault();
+ handleVoicePreview();
+ });
+ }
+
+ if (dropzone && dropzone.dataset.dashboardDragBound !== "true") {
+ dropzone.dataset.dashboardDragBound = "true";
+ let dragDepth = 0;
+
+ dropzone.addEventListener("dragenter", (event) => {
+ event.preventDefault();
+ dragDepth += 1;
+ setDropzoneActive(true);
+ });
+
+ dropzone.addEventListener("dragover", (event) => {
+ event.preventDefault();
+ if (event.dataTransfer) {
+ event.dataTransfer.dropEffect = "copy";
+ }
+ });
+
+ const handleDragLeave = (event) => {
+ if (event && dropzone.contains(event.relatedTarget)) {
+ return;
+ }
+ dragDepth = Math.max(0, dragDepth - 1);
+ if (dragDepth === 0) {
+ setDropzoneActive(false);
+ }
+ };
+
+ dropzone.addEventListener("dragleave", (event) => {
+ handleDragLeave(event);
+ });
+
+ dropzone.addEventListener("dragend", () => {
+ dragDepth = 0;
+ setDropzoneActive(false);
+ });
+
+ dropzone.addEventListener("drop", (event) => {
+ event.preventDefault();
+ dragDepth = 0;
+ setDropzoneActive(false);
+ const files = event.dataTransfer && event.dataTransfer.files;
+ if (!files || !files.length) {
+ return;
+ }
+ openUploadModal(dropzone);
+ assignDroppedFile(files[0]);
+ });
+
+ dropzone.addEventListener("click", (event) => {
+ if (event.target.closest('[data-role="open-upload-modal"]')) {
+ return;
+ }
+ openUploadModal(dropzone);
+ });
+
+ dropzone.addEventListener("keydown", (event) => {
+ if (event.key === "Enter" || event.key === " ") {
+ event.preventDefault();
+ openUploadModal(dropzone);
+ }
+ });
+ }
+
+ [voiceSelect, profileSelect, formulaInput, languageSelect, speedInput].forEach((input) => {
+ if (!input) return;
+ const eventName = input === formulaInput ? "input" : "change";
+ input.addEventListener(eventName, () => {
+ resetPreview();
+ });
+ });
+
+ const hydrateDefaultVoice = () => {
+ if (!voiceSelect) return;
+ const defaultVoice = voiceSelect.dataset.default;
+ if (!defaultVoice) return;
+ const option = voiceSelect.querySelector(`option[value="${defaultVoice}"]`);
+ if (option) {
+ voiceSelect.value = defaultVoice;
+ }
+ };
+
+ const applySavedProfile = (option) => {
+ if (!option) return;
+ const presetFormula = option.dataset.formula || "";
+ const profileLang = option.dataset.language || "";
+ if (formulaInput) {
+ formulaInput.value = presetFormula;
+ formulaInput.readOnly = true;
+ formulaInput.dataset.state = "locked";
+ }
+ if (profileLang && languageSelect) {
+ languageSelect.value = profileLang;
+ }
+ };
+
+ const updateVoiceControls = () => {
+ if (!profileSelect) {
+ return;
+ }
+ const value = profileSelect.value || "__standard";
+ const isStandard = value === "__standard";
+ const isFormula = value === "__formula";
+ const isSavedProfile = !isStandard && !isFormula;
+
+ const showVoiceField = isStandard;
+ if (voiceField) {
+ voiceField.hidden = !showVoiceField;
+ voiceField.setAttribute("aria-hidden", showVoiceField ? "false" : "true");
+ voiceField.dataset.state = showVoiceField ? "visible" : "hidden";
+ }
+ if (voiceSelect) {
+ voiceSelect.disabled = !isStandard;
+ voiceSelect.dataset.state = isStandard ? "editable" : "locked";
+ if (isStandard) {
+ hydrateDefaultVoice();
+ }
+ }
+
+ if (isSavedProfile) {
+ applySavedProfile(profileSelect.selectedOptions[0] || null);
+ } else if (!isFormula && formulaInput) {
+ formulaInput.value = "";
+ }
+
+ const showFormulaField = isFormula;
+ if (formulaField) {
+ const shouldShow = showFormulaField;
+ formulaField.hidden = !shouldShow;
+ formulaField.setAttribute("aria-hidden", shouldShow ? "false" : "true");
+ formulaField.dataset.state = shouldShow ? "visible" : "hidden";
+ }
+ if (formulaInput) {
+ if (isFormula) {
+ formulaInput.disabled = false;
+ formulaInput.readOnly = false;
+ formulaInput.dataset.state = "editable";
+ } else if (isSavedProfile) {
+ formulaInput.disabled = false;
+ formulaInput.readOnly = true;
+ formulaInput.dataset.state = "locked";
+ } else {
+ formulaInput.disabled = true;
+ formulaInput.readOnly = true;
+ formulaInput.value = "";
+ formulaInput.dataset.state = "editable";
+ }
+ }
+ };
+
+ if (profileSelect) {
+ if (profileSelect.dataset.dashboardBound !== "true") {
+ profileSelect.dataset.dashboardBound = "true";
+ profileSelect.addEventListener("change", updateVoiceControls);
+ }
+ updateVoiceControls();
+ } else {
+ hydrateDefaultVoice();
+ }
+
+ if (!dashboardState.boundBeforeUnload) {
+ dashboardState.boundBeforeUnload = true;
+ window.addEventListener("beforeunload", () => {
+ cancelPreviewRequest();
+ stopPreviewAudio();
+ });
+ }
+};
+
+window.AbogenDashboard = window.AbogenDashboard || {};
+window.AbogenDashboard.init = initDashboard;
+
+const bootDashboard = () => {
+ initDashboard();
+ initWizard();
+};
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", bootDashboard, { once: true });
+} else {
+ bootDashboard();
+}
diff --git a/abogen/webui/static/entities.js b/abogen/webui/static/entities.js
new file mode 100644
index 0000000..7484c06
--- /dev/null
+++ b/abogen/webui/static/entities.js
@@ -0,0 +1,247 @@
+(function () {
+ const root = document.querySelector('[data-override-root]');
+ if (!root) {
+ return;
+ }
+
+ const previewUrl = root.dataset.previewUrl || "";
+ const defaultLanguage = root.dataset.language || "a";
+ const table = root.querySelector('[data-role="override-table"]');
+ const rows = table ? Array.from(table.querySelectorAll('[data-role="override-row"]')) : [];
+ const filterInput = root.querySelector('[data-role="override-filter"]');
+ const filterClearButton = root.querySelector('[data-role="override-filter-clear"]');
+ const filterEmptyMessage = root.querySelector('[data-role="filter-empty"]');
+
+ function base64ToBlob(base64, mimeType) {
+ const binary = atob(base64);
+ const length = binary.length;
+ const bytes = new Uint8Array(length);
+ for (let index = 0; index < length; index += 1) {
+ bytes[index] = binary.charCodeAt(index);
+ }
+ return new Blob([bytes], { type: mimeType });
+ }
+
+ function getControl(form, selector) {
+ if (!form) {
+ return null;
+ }
+ const direct = form.querySelector(selector);
+ if (direct) {
+ return direct;
+ }
+ if (!form.id) {
+ return null;
+ }
+ return root.querySelector(`${selector}[form="${form.id}"]`) || document.querySelector(`${selector}[form="${form.id}"]`);
+ }
+
+ function resetPreview(container) {
+ if (!container) {
+ return;
+ }
+ const messageEl = container.querySelector('[data-role="preview-message"]');
+ const audioEl = container.querySelector('[data-role="preview-audio"]');
+ if (messageEl) {
+ messageEl.textContent = "";
+ messageEl.removeAttribute('data-state');
+ }
+ if (audioEl) {
+ const priorUrl = audioEl.dataset.objectUrl;
+ if (priorUrl) {
+ URL.revokeObjectURL(priorUrl);
+ delete audioEl.dataset.objectUrl;
+ }
+ audioEl.pause();
+ audioEl.removeAttribute('src');
+ audioEl.hidden = true;
+ }
+ }
+
+ function buildPreviewPayload(form) {
+ if (!form) {
+ return null;
+ }
+ const tokenInput = getControl(form, 'input[name="token"]');
+ const pronunciationInput = getControl(form, 'input[name="pronunciation"]');
+ const voiceSelect = getControl(form, 'select[name="voice"]');
+ const languageInput = getControl(form, 'input[name="lang"]');
+
+ const token = tokenInput && 'value' in tokenInput ? tokenInput.value.trim() : "";
+ const pronunciation = pronunciationInput && 'value' in pronunciationInput ? pronunciationInput.value.trim() : "";
+ const voice = voiceSelect && 'value' in voiceSelect ? voiceSelect.value.trim() : "";
+ const language = languageInput && 'value' in languageInput ? languageInput.value.trim() : defaultLanguage;
+
+ if (!token && !pronunciation) {
+ return null;
+ }
+ return {
+ token,
+ pronunciation,
+ voice,
+ language,
+ };
+ }
+
+ async function requestPreview(button) {
+ if (!previewUrl) {
+ return;
+ }
+ const formId = button.dataset.formId || "";
+ const form = formId ? document.getElementById(formId) : button.closest('form');
+ const container = button.closest('[data-role="preview-container"]');
+ const messageEl = container ? container.querySelector('[data-role="preview-message"]') : null;
+ const audioEl = container ? container.querySelector('[data-role="preview-audio"]') : null;
+
+ resetPreview(container);
+
+ const payload = buildPreviewPayload(form);
+ if (!payload) {
+ if (messageEl) {
+ messageEl.textContent = "Enter a token or pronunciation first.";
+ messageEl.dataset.state = "error";
+ }
+ return;
+ }
+
+ button.disabled = true;
+ button.setAttribute('data-loading', 'true');
+
+ try {
+ const response = await fetch(previewUrl, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify(payload),
+ });
+
+ const contentType = response.headers.get('Content-Type') || '';
+ let data = null;
+ if (contentType.includes('application/json')) {
+ try {
+ data = await response.json();
+ } catch (parseError) {
+ if (!response.ok) {
+ throw new Error('Preview failed.');
+ }
+ throw parseError instanceof Error ? parseError : new Error('Preview failed.');
+ }
+ } else {
+ if (!response.ok) {
+ const fallback = await response.text().catch(() => '');
+ throw new Error(fallback || 'Preview failed.');
+ }
+ throw new Error('Preview failed.');
+ }
+
+ if (!response.ok || (data && data.error)) {
+ throw new Error((data && data.error) || 'Preview failed.');
+ }
+ if (!data || typeof data !== 'object') {
+ throw new Error('Preview failed.');
+ }
+ if (!data.audio_base64) {
+ throw new Error('Preview did not return audio.');
+ }
+
+ if (audioEl) {
+ const blob = base64ToBlob(data.audio_base64, 'audio/wav');
+ const objectUrl = URL.createObjectURL(blob);
+ audioEl.src = objectUrl;
+ audioEl.dataset.objectUrl = objectUrl;
+ audioEl.hidden = false;
+ audioEl.load();
+ audioEl.play().catch(() => {
+ /* playback might require user interaction; ignore */
+ });
+ }
+
+ if (messageEl) {
+ messageEl.textContent = data.normalized_text || data.text || 'Preview ready.';
+ messageEl.dataset.state = "success";
+ }
+ } catch (error) {
+ if (messageEl) {
+ messageEl.textContent = error instanceof Error ? error.message : 'Preview failed.';
+ messageEl.dataset.state = "error";
+ }
+ } finally {
+ button.disabled = false;
+ button.removeAttribute('data-loading');
+ }
+ }
+
+ function attachPreviewHandlers() {
+ const previewButtons = root.querySelectorAll('[data-role="preview-button"]');
+ previewButtons.forEach((button) => {
+ button.addEventListener('click', () => {
+ requestPreview(button);
+ });
+ });
+ }
+
+ function applyFilter() {
+ if (!filterInput || rows.length === 0) {
+ return;
+ }
+ const term = filterInput.value.trim().toLowerCase();
+ let visibleCount = 0;
+ rows.forEach((row) => {
+ const token = row.dataset.token || "";
+ const pronunciationInput = row.querySelector('input[name="pronunciation"]');
+ const voiceSelect = row.querySelector('select[name="voice"]');
+
+ const pronunciationValue = pronunciationInput && 'value' in pronunciationInput
+ ? pronunciationInput.value.trim().toLowerCase()
+ : "";
+ const voiceOption = voiceSelect && 'selectedIndex' in voiceSelect && voiceSelect.selectedIndex >= 0
+ ? voiceSelect.options[voiceSelect.selectedIndex]
+ : null;
+ const voiceValue = voiceOption && voiceOption.textContent
+ ? voiceOption.textContent.trim().toLowerCase()
+ : "";
+
+ if (!term || token.includes(term) || pronunciationValue.includes(term) || voiceValue.includes(term)) {
+ row.hidden = false;
+ visibleCount += 1;
+ } else {
+ row.hidden = true;
+ }
+ });
+
+ if (filterEmptyMessage) {
+ filterEmptyMessage.hidden = visibleCount !== 0;
+ }
+ }
+
+ if (filterInput) {
+ filterInput.addEventListener('input', applyFilter);
+ }
+
+ if (filterClearButton && filterInput) {
+ filterClearButton.addEventListener('click', () => {
+ filterInput.value = "";
+ applyFilter();
+ filterInput.focus();
+ });
+ }
+
+ if (table) {
+ table.addEventListener('input', (event) => {
+ const target = event.target;
+ if (target && (target.matches('input[name="pronunciation"]') || target.matches('select[name="voice"]'))) {
+ applyFilter();
+ }
+ });
+ table.addEventListener('change', (event) => {
+ const target = event.target;
+ if (target && target.matches('select[name="voice"]')) {
+ applyFilter();
+ }
+ });
+ }
+
+ attachPreviewHandlers();
+ applyFilter();
+})();
diff --git a/abogen/webui/static/find_books.js b/abogen/webui/static/find_books.js
new file mode 100644
index 0000000..a02abf6
--- /dev/null
+++ b/abogen/webui/static/find_books.js
@@ -0,0 +1,1057 @@
+const modal = document.querySelector('[data-role="opds-modal"]');
+const browser = modal?.querySelector('[data-role="opds-browser"]') || null;
+
+if (modal && browser) {
+ const statusEl = browser.querySelector('[data-role="opds-status"]');
+ const resultsEl = browser.querySelector('[data-role="opds-results"]');
+ const navEl = browser.querySelector('[data-role="opds-nav"]');
+ const navBottomEl = browser.querySelector('[data-role="opds-nav-bottom"]');
+ const alphaPickerEl = browser.querySelector('[data-role="opds-alpha-picker"]');
+ const tabsEl = modal.querySelector('[data-role="opds-tabs"]');
+ const searchForm = modal.querySelector('[data-role="opds-search"]');
+ const searchInput = searchForm?.querySelector('input[name="q"]');
+ const refreshButton = searchForm?.querySelector('[data-action="opds-refresh"]');
+ const openButtons = document.querySelectorAll('[data-action="open-opds-modal"]');
+ const closeTargets = modal.querySelectorAll('[data-role="opds-modal-close"]');
+
+ const TabIds = {
+ ROOT: 'root',
+ SEARCH: 'search',
+ CUSTOM: 'custom',
+ };
+
+ const EntryTypes = {
+ BOOK: 'book',
+ NAVIGATION: 'navigation',
+ OTHER: 'other',
+ };
+
+ const LETTER_ALL = 'ALL';
+ const LETTER_NUMERIC = '#';
+ const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+
+ const state = {
+ query: '',
+ currentHref: '',
+ activeTab: TabIds.ROOT,
+ tabs: [],
+ tabsReady: false,
+ requestToken: 0,
+ feedTitle: '',
+ lastEntries: [],
+ activeLetter: LETTER_ALL,
+ availableLetters: new Set(),
+ totalStats: null,
+ filteredStats: null,
+ status: { message: '', level: null },
+ baseStatus: null,
+ lastContextKey: '',
+ currentLinks: {},
+ alphabetBaseHref: '',
+ };
+
+ let isOpen = false;
+ let lastTrigger = null;
+
+ const truncate = (text, limit = 160) => {
+ if (!text || typeof text !== 'string') {
+ return '';
+ }
+ if (text.length <= limit) {
+ return text;
+ }
+ return `${text.slice(0, limit - 1).trim()}…`;
+ };
+
+ const formatAuthors = (authors) => {
+ if (!Array.isArray(authors) || !authors.length) {
+ return '';
+ }
+ return authors.filter((author) => !!author).join(', ');
+ };
+
+ const formatSeriesIndex = (position) => {
+ if (position === null || position === undefined) {
+ return '';
+ }
+ const numeric = Number(position);
+ if (Number.isFinite(numeric)) {
+ if (Math.abs(numeric - Math.round(numeric)) < 0.01) {
+ return String(Math.round(numeric));
+ }
+ return numeric.toLocaleString(undefined, {
+ minimumFractionDigits: 1,
+ maximumFractionDigits: 2,
+ });
+ }
+ if (typeof position === 'string') {
+ const trimmed = position.trim();
+ if (trimmed) {
+ return trimmed;
+ }
+ }
+ return '';
+ };
+
+ const formatSeriesLabel = (entry) => {
+ if (!entry) {
+ return '';
+ }
+ const rawSeries = typeof entry.series === 'string' ? entry.series.trim() : '';
+ const rawIndex =
+ entry.series_index ??
+ entry.seriesIndex ??
+ entry.series_position ??
+ entry.seriesPosition ??
+ entry.book_number ??
+ entry.bookNumber ??
+ null;
+ const indexLabel = formatSeriesIndex(rawIndex);
+ if (rawSeries && indexLabel) {
+ return `${rawSeries} · Book ${indexLabel}`;
+ }
+ if (rawSeries) {
+ return rawSeries;
+ }
+ if (indexLabel) {
+ return `Book ${indexLabel}`;
+ }
+ return '';
+ };
+
+ const deriveBrowseMode = () => {
+ const title = (state.feedTitle || '').toLowerCase();
+ if (!title) {
+ return 'generic';
+ }
+ if (title.includes('author')) {
+ return 'author';
+ }
+ if (title.includes('series')) {
+ return 'series';
+ }
+ if (title.includes('title')) {
+ return 'title';
+ }
+ if (title.includes('books')) {
+ return 'title';
+ }
+ return 'generic';
+ };
+
+ const stripLeadingArticle = (text) => text.replace(/^(?:the|a|an)\s+/i, '').trim();
+
+ const extractAlphabetSource = (entry) => {
+ if (!entry) {
+ return '';
+ }
+ const mode = deriveBrowseMode();
+ if (mode === 'author') {
+ if (Array.isArray(entry.authors) && entry.authors.length) {
+ return entry.authors[0] || '';
+ }
+ }
+ if (mode === 'series' && entry.series) {
+ return entry.series;
+ }
+ if (entry.title) {
+ return entry.title;
+ }
+ if (entry.series) {
+ return entry.series;
+ }
+ const navLink = findNavigationLink(entry);
+ if (navLink?.title) {
+ return navLink.title;
+ }
+ return '';
+ };
+
+ const deriveAlphabetKey = (entry) => {
+ const mode = deriveBrowseMode();
+ let source = (extractAlphabetSource(entry) || '').trim();
+ if (!source) {
+ return '';
+ }
+ if (mode === 'author') {
+ if (source.includes(',')) {
+ source = source.split(',')[0];
+ } else {
+ const parts = source.split(/\s+/);
+ if (parts.length > 1) {
+ source = parts[parts.length - 1];
+ }
+ }
+ } else if (mode === 'title') {
+ source = stripLeadingArticle(source);
+ }
+ source = source.replace(/^[^\p{L}\p{N}]+/u, '');
+ return source;
+ };
+
+ const deriveAlphabetLetter = (entry) => {
+ const key = deriveAlphabetKey(entry);
+ if (!key) {
+ return LETTER_NUMERIC;
+ }
+ const initial = key.charAt(0).toUpperCase();
+ if (initial >= 'A' && initial <= 'Z') {
+ return initial;
+ }
+ return LETTER_NUMERIC;
+ };
+
+ const collectAlphabetCounts = (entries) => {
+ const counts = new Map();
+ if (!Array.isArray(entries)) {
+ return counts;
+ }
+ entries.forEach((entry) => {
+ const letter = deriveAlphabetLetter(entry);
+ counts.set(letter, (counts.get(letter) || 0) + 1);
+ });
+ return counts;
+ };
+
+ const detectEntryType = (entry, navigationLink) => {
+ if (!entry) {
+ return EntryTypes.OTHER;
+ }
+ const downloadLink = entry.download && entry.download.href ? entry.download.href : null;
+ if (downloadLink) {
+ return EntryTypes.BOOK;
+ }
+ const navLink = navigationLink === undefined ? findNavigationLink(entry) : navigationLink;
+ if (navLink && navLink.href) {
+ return EntryTypes.NAVIGATION;
+ }
+ return EntryTypes.OTHER;
+ };
+
+ const computeEntryStats = (entries) => {
+ const stats = {
+ [EntryTypes.BOOK]: 0,
+ [EntryTypes.NAVIGATION]: 0,
+ [EntryTypes.OTHER]: 0,
+ };
+ if (!Array.isArray(entries)) {
+ return stats;
+ }
+ entries.forEach((entry) => {
+ const type = detectEntryType(entry);
+ stats[type] += 1;
+ });
+ return stats;
+ };
+
+ const shouldShowAlphabetPicker = (entries, stats) => {
+ if (!alphaPickerEl || state.query) {
+ return false;
+ }
+ if (!Array.isArray(entries) || entries.length === 0) {
+ return false;
+ }
+ return true;
+ };
+
+ const refreshAlphabetActiveState = () => {
+ if (!alphaPickerEl) {
+ return;
+ }
+ const buttons = alphaPickerEl.querySelectorAll('button[data-letter]');
+ buttons.forEach((button) => {
+ const value = button.dataset.letter || LETTER_ALL;
+ const isActive = value === state.activeLetter;
+ button.classList.toggle('is-active', isActive);
+ button.setAttribute('aria-pressed', isActive ? 'true' : 'false');
+ });
+ };
+
+ const describeAlphabetLetter = (letter) => {
+ if (letter === LETTER_ALL) {
+ return 'all entries';
+ }
+ if (letter === LETTER_NUMERIC) {
+ return 'numbers or symbols';
+ }
+ return `letter ${letter}`;
+ };
+
+ const updateAlphabetPicker = (entries, { reset = false, stats = null } = {}) => {
+ if (!alphaPickerEl) {
+ return;
+ }
+ const list = Array.isArray(entries) ? entries : [];
+ if (reset) {
+ state.activeLetter = LETTER_ALL;
+ }
+ const counts = collectAlphabetCounts(list);
+ state.availableLetters = new Set(counts.keys());
+ const shouldShow = shouldShowAlphabetPicker(list, stats);
+ if (!shouldShow) {
+ alphaPickerEl.innerHTML = '';
+ alphaPickerEl.hidden = true;
+ state.activeLetter = LETTER_ALL;
+ return;
+ }
+
+ alphaPickerEl.hidden = false;
+ alphaPickerEl.innerHTML = '';
+ const letters = [LETTER_ALL, ...ALPHABET, LETTER_NUMERIC];
+ letters.forEach((letter) => {
+ const button = document.createElement('button');
+ button.type = 'button';
+ button.className = 'opds-alpha-picker__button';
+ button.dataset.letter = letter;
+ button.textContent = letter === LETTER_ALL ? 'All' : letter === LETTER_NUMERIC ? '# / 0-9' : letter;
+ const enabledCount = letter === LETTER_ALL ? list.length : counts.get(letter) || 0;
+ button.title = `Show entries for ${describeAlphabetLetter(letter)} (${enabledCount} in view)`;
+ button.addEventListener('click', () => {
+ handleAlphabetSelect(letter).catch((error) => {
+ console.error('Alphabet picker failed', error);
+ });
+ });
+ alphaPickerEl.appendChild(button);
+ });
+ refreshAlphabetActiveState();
+ };
+
+ const handleAlphabetSelect = async (letter) => {
+ const normalized = letter || LETTER_ALL;
+ if (normalized === LETTER_ALL) {
+ state.activeLetter = LETTER_ALL;
+ refreshAlphabetActiveState();
+ const startLink = resolveRelLink(state.currentLinks, 'start') || resolveRelLink(state.currentLinks, '/start');
+ const upLink = resolveRelLink(state.currentLinks, 'up') || resolveRelLink(state.currentLinks, '/up');
+ const baseHref = startLink?.href || state.alphabetBaseHref || upLink?.href || state.currentHref || '';
+ await loadFeed({ href: baseHref, query: '', letter: '', activeTab: baseHref ? TabIds.CUSTOM : TabIds.ROOT, updateTabs: true });
+ return;
+ }
+
+ state.activeLetter = normalized;
+ refreshAlphabetActiveState();
+ const startLink = resolveRelLink(state.currentLinks, 'start') || resolveRelLink(state.currentLinks, '/start');
+ const baseHref = startLink?.href || state.alphabetBaseHref || state.currentHref || '';
+ await loadFeed({ href: baseHref, query: '', letter: normalized, activeTab: TabIds.CUSTOM, updateTabs: true });
+ };
+
+ const applyAlphabetFilter = (entries) => {
+ if (!Array.isArray(entries) || !entries.length) {
+ return [];
+ }
+ if (state.activeLetter === LETTER_ALL) {
+ return entries.slice();
+ }
+ return entries.filter((entry) => {
+ const letter = deriveAlphabetLetter(entry);
+ if (state.activeLetter === LETTER_NUMERIC) {
+ return letter === LETTER_NUMERIC;
+ }
+ return letter === state.activeLetter;
+ });
+ };
+
+ const setEntries = (entries, { resetAlphabet = false, activeLetter = null } = {}) => {
+ const list = Array.isArray(entries) ? entries.slice() : [];
+ state.lastEntries = list;
+ const totalStats = computeEntryStats(list);
+ state.totalStats = totalStats;
+ if (resetAlphabet) {
+ state.activeLetter = LETTER_ALL;
+ } else if (activeLetter && activeLetter !== LETTER_ALL) {
+ state.activeLetter = activeLetter;
+ }
+ const filtered = applyAlphabetFilter(list);
+ const filteredStats = renderEntries(filtered);
+ state.filteredStats = filteredStats;
+ updateAlphabetPicker(list, { reset: resetAlphabet, stats: totalStats });
+ return { stats: totalStats, filteredStats };
+ };
+
+ const setStatus = (message, level, { persist = false } = {}) => {
+ if (!statusEl) {
+ return;
+ }
+ statusEl.textContent = message || '';
+ if (level) {
+ statusEl.dataset.state = level;
+ } else {
+ delete statusEl.dataset.state;
+ }
+ state.status = { message: message || '', level: level || null };
+ if (persist) {
+ state.baseStatus = { ...state.status };
+ }
+ };
+
+ const clearStatus = () => setStatus('', null);
+
+ const restoreBaseStatus = () => {
+ if (state.baseStatus) {
+ setStatus(state.baseStatus.message, state.baseStatus.level);
+ } else {
+ clearStatus();
+ }
+ };
+
+ const focusSearch = () => {
+ if (!searchInput) {
+ return;
+ }
+ window.requestAnimationFrame(() => {
+ try {
+ searchInput.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus issues
+ }
+ });
+ };
+
+ const resolveRelLink = (links, rel) => {
+ if (!links) {
+ return null;
+ }
+ if (links[rel]) {
+ return links[rel];
+ }
+ const key = Object.keys(links).find((entry) => entry === rel || entry.endsWith(rel));
+ return key ? links[key] : null;
+ };
+
+ const findNavigationLink = (entry) => {
+ if (!entry || !Array.isArray(entry.links)) {
+ return null;
+ }
+ const candidates = entry.links.filter((link) => link && link.href);
+ return (
+ candidates.find((link) => {
+ const rel = (link.rel || '').toLowerCase();
+ const type = (link.type || '').toLowerCase();
+ if (!link.href) {
+ return false;
+ }
+ if (rel.includes('acquisition')) {
+ return false;
+ }
+ if (rel === 'self') {
+ return false;
+ }
+ if (type.includes('opds-catalog')) {
+ return true;
+ }
+ if (rel.includes('subsection') || rel.includes('collection')) {
+ return true;
+ }
+ if (rel.startsWith('http://opds-spec.org/sort') || rel.startsWith('http://opds-spec.org/group')) {
+ return true;
+ }
+ return false;
+ }) || null
+ );
+ };
+
+ const resolveTabIdForHref = (href) => {
+ if (!href) {
+ return TabIds.ROOT;
+ }
+ const matching = state.tabs.find((tab) => tab.href === href);
+ return matching ? matching.id : null;
+ };
+
+ const buildTabsFromFeed = (feed) => {
+ if (!feed || !Array.isArray(feed.entries)) {
+ return;
+ }
+ const seen = new Set();
+ const nextTabs = [];
+ feed.entries.forEach((entry) => {
+ const navLink = findNavigationLink(entry);
+ if (!navLink || !navLink.href) {
+ return;
+ }
+ if (seen.has(navLink.href)) {
+ return;
+ }
+ seen.add(navLink.href);
+ const label = entry.title || navLink.title || 'Catalog view';
+ nextTabs.push({
+ id: navLink.href,
+ label,
+ href: navLink.href,
+ });
+ });
+ state.tabs = nextTabs;
+ state.tabsReady = true;
+ renderTabs();
+ };
+
+ const renderTabs = () => {
+ if (!tabsEl) {
+ return;
+ }
+ tabsEl.innerHTML = '';
+ const tabs = [];
+ tabs.push({ id: TabIds.ROOT, label: 'Catalog home', href: '' });
+ state.tabs.forEach((tab) => tabs.push(tab));
+ if (state.activeTab === TabIds.SEARCH && state.query) {
+ tabs.push({
+ id: TabIds.SEARCH,
+ label: `Search: "${truncate(state.query, 32)}"`,
+ href: '',
+ isSearch: true,
+ });
+ }
+ tabs.forEach((tab) => {
+ const button = document.createElement('button');
+ button.type = 'button';
+ button.className = 'opds-tab';
+ if (tab.isSearch) {
+ button.classList.add('opds-tab--search');
+ }
+ if (state.activeTab === tab.id || (tab.id !== TabIds.SEARCH && state.activeTab === tab.href)) {
+ button.classList.add('is-active');
+ }
+ button.textContent = tab.label;
+ button.addEventListener('click', () => {
+ if (tab.id === TabIds.SEARCH) {
+ loadFeed({ href: '', query: state.query, activeTab: TabIds.SEARCH });
+ return;
+ }
+ if (tab.id === TabIds.ROOT) {
+ loadFeed({ href: '', query: '', activeTab: TabIds.ROOT, updateTabs: true });
+ return;
+ }
+ loadFeed({ href: tab.href, query: '', activeTab: tab.id });
+ });
+ tabsEl.appendChild(button);
+ });
+ tabsEl.classList.toggle('is-empty', tabs.length <= 1);
+ };
+
+ const renderNav = (links) => {
+ const targets = [navEl, navBottomEl].filter(Boolean);
+ if (!targets.length) {
+ return;
+ }
+ targets.forEach((el) => {
+ el.innerHTML = '';
+ });
+
+ const descriptors = [
+ { key: 'up', label: 'Up one level' },
+ { key: 'previous', label: 'Previous page' },
+ { key: 'next', label: 'Next page' },
+ ];
+ descriptors.forEach(({ key, label }) => {
+ if (state.activeLetter !== LETTER_ALL && key !== 'up') {
+ return;
+ }
+ const link = resolveRelLink(links, key) || resolveRelLink(links, `/${key}`);
+ const hasLink = Boolean(link && link.href);
+
+ if (!hasLink && key !== 'previous') {
+ return;
+ }
+
+ targets.forEach((targetEl) => {
+ const button = document.createElement('button');
+ button.type = 'button';
+ button.className = 'button button--ghost';
+ button.textContent = label;
+
+ if (hasLink) {
+ button.addEventListener('click', () => {
+ const targetQuery = key === 'up' ? '' : state.query;
+ const tabId = resolveTabIdForHref(link.href);
+ loadFeed({ href: link.href, query: targetQuery, activeTab: tabId || (targetQuery ? TabIds.SEARCH : TabIds.CUSTOM) });
+ });
+ } else if (key === 'previous') {
+ button.disabled = true;
+ button.setAttribute('aria-disabled', 'true');
+ }
+ targetEl.appendChild(button);
+ });
+ });
+
+ targets.forEach((el) => {
+ el.hidden = !el.childElementCount;
+ });
+ };
+
+ const createEntry = (entry) => {
+ const item = document.createElement('li');
+ item.className = 'opds-browser__entry';
+
+ const header = document.createElement('div');
+ header.className = 'opds-browser__entry-head';
+
+ const title = document.createElement('h3');
+ title.className = 'opds-browser__title';
+ const positionLabel = Number.isFinite(entry?.position) ? Number(entry.position) : null;
+ const baseTitle = entry.title || 'Untitled';
+ title.textContent = positionLabel !== null ? `${positionLabel}. ${baseTitle}` : baseTitle;
+ header.appendChild(title);
+
+ const authors = formatAuthors(entry.authors);
+ if (authors) {
+ const meta = document.createElement('p');
+ meta.className = 'opds-browser__meta';
+ meta.textContent = authors;
+ header.appendChild(meta);
+ }
+
+ const seriesMetaText = formatSeriesLabel(entry);
+ if (seriesMetaText) {
+ const seriesMeta = document.createElement('p');
+ seriesMeta.className = 'opds-browser__meta';
+ seriesMeta.textContent = seriesMetaText;
+ header.appendChild(seriesMeta);
+ }
+
+ if (entry.rating !== null && entry.rating !== undefined && entry.rating !== '') {
+ const ratingMeta = document.createElement('p');
+ ratingMeta.className = 'opds-browser__meta';
+ const ratingMax = entry.rating_max ?? entry.ratingMax ?? 5;
+ ratingMeta.textContent = `Rating: ${entry.rating}${ratingMax ? ` / ${ratingMax}` : ''}`;
+ header.appendChild(ratingMeta);
+ }
+
+ if (Array.isArray(entry.tags) && entry.tags.length > 0) {
+ const tagsMeta = document.createElement('p');
+ tagsMeta.className = 'opds-browser__meta';
+ tagsMeta.textContent = `Tags: ${entry.tags.join(', ')}`;
+ header.appendChild(tagsMeta);
+ }
+
+ item.appendChild(header);
+
+ const summarySource = entry.summary || entry?.alternate?.title || entry?.download?.title || '';
+ if (summarySource) {
+ const summary = document.createElement('p');
+ summary.className = 'opds-browser__summary';
+ summary.textContent = truncate(summarySource, 420);
+ item.appendChild(summary);
+ }
+
+ const actions = document.createElement('div');
+ actions.className = 'opds-browser__actions';
+
+ const downloadLink = entry.download && entry.download.href ? entry.download.href : null;
+ const alternateLink = entry.alternate && entry.alternate.href ? entry.alternate.href : null;
+ const navigationLink = findNavigationLink(entry);
+ const entryType = detectEntryType(entry, navigationLink);
+
+ if (entryType === EntryTypes.NAVIGATION && navigationLink) {
+ item.classList.add('opds-browser__entry--navigation');
+ }
+
+ if (entryType === EntryTypes.BOOK) {
+ const queueButton = document.createElement('button');
+ queueButton.type = 'button';
+ queueButton.className = 'button';
+ queueButton.textContent = 'Configure conversion';
+ queueButton.addEventListener('click', () => importEntry(entry, queueButton));
+ actions.appendChild(queueButton);
+ } else if (entryType === EntryTypes.NAVIGATION && navigationLink) {
+ const browseButton = document.createElement('button');
+ browseButton.type = 'button';
+ browseButton.className = 'button button--ghost';
+ browseButton.textContent = 'Browse view';
+ browseButton.addEventListener('click', () => {
+ clearStatus();
+ const tabId = resolveTabIdForHref(navigationLink.href);
+ loadFeed({ href: navigationLink.href, query: '', activeTab: tabId || TabIds.CUSTOM });
+ });
+ actions.appendChild(browseButton);
+ }
+
+ if (alternateLink && entryType !== EntryTypes.NAVIGATION) {
+ const previewLink = document.createElement('a');
+ previewLink.className = 'button button--ghost';
+ previewLink.href = alternateLink;
+ previewLink.target = '_blank';
+ previewLink.rel = 'noreferrer';
+ previewLink.textContent = 'Open in Calibre';
+ actions.appendChild(previewLink);
+ }
+
+ if (!actions.childElementCount) {
+ const fallback = document.createElement('span');
+ fallback.className = 'opds-browser__hint';
+ fallback.textContent = 'No downloadable formats exposed.';
+ actions.appendChild(fallback);
+ }
+
+ item.appendChild(actions);
+ return { element: item, type: entryType };
+ };
+
+ const renderEntries = (entries) => {
+ if (!resultsEl) {
+ return { [EntryTypes.BOOK]: 0, [EntryTypes.NAVIGATION]: 0, [EntryTypes.OTHER]: 0 };
+ }
+ resultsEl.innerHTML = '';
+ const list = Array.isArray(entries) ? entries : [];
+ if (!list.length) {
+ const empty = document.createElement('li');
+ empty.className = 'opds-browser__empty';
+ if (state.activeLetter !== LETTER_ALL) {
+ empty.textContent = `No entries start with ${describeAlphabetLetter(state.activeLetter)}.`;
+ } else if (state.query) {
+ empty.textContent = 'No results returned for this view yet.';
+ } else {
+ empty.textContent = 'No catalog entries found here yet.';
+ }
+ resultsEl.appendChild(empty);
+ return { [EntryTypes.BOOK]: 0, [EntryTypes.NAVIGATION]: 0, [EntryTypes.OTHER]: 0 };
+ }
+ const fragment = document.createDocumentFragment();
+ const stats = {
+ [EntryTypes.BOOK]: 0,
+ [EntryTypes.NAVIGATION]: 0,
+ [EntryTypes.OTHER]: 0,
+ };
+ list.forEach((entry) => {
+ const { element, type } = createEntry(entry);
+ stats[type] += 1;
+ fragment.appendChild(element);
+ });
+ resultsEl.appendChild(fragment);
+ return stats;
+ };
+
+ const importEntry = async (entry, trigger) => {
+ if (!entry?.download?.href) {
+ setStatus('This entry cannot be imported automatically.', 'error');
+ return;
+ }
+ const button = trigger;
+ const originalLabel = button ? button.textContent : '';
+ if (button) {
+ button.disabled = true;
+ button.dataset.loading = 'true';
+ button.textContent = 'Preparing…';
+ }
+ setStatus('Downloading book from Calibre. This can take a minute…', 'loading');
+ try {
+ const requestPayload = {
+ href: entry.download.href,
+ title: entry.title || '',
+ };
+ const metadata = {};
+ if (entry.series) {
+ metadata.series = entry.series;
+ metadata.series_name = entry.series;
+ }
+ const seriesIndex = entry.series_index ?? entry.seriesIndex ?? null;
+ if (seriesIndex !== null && seriesIndex !== undefined && seriesIndex !== '') {
+ metadata.series_index = seriesIndex;
+ metadata.series_position = seriesIndex;
+ metadata.book_number = seriesIndex;
+ }
+ if (Array.isArray(entry.tags) && entry.tags.length > 0) {
+ const tagsText = entry.tags.join(', ');
+ metadata.tags = tagsText;
+ metadata.keywords = tagsText;
+ metadata.genre = tagsText;
+ }
+ if (typeof entry.summary === 'string' && entry.summary.trim()) {
+ metadata.description = entry.summary;
+ metadata.summary = entry.summary;
+ }
+
+ if (Array.isArray(entry.authors) && entry.authors.length > 0) {
+ const authorsText = entry.authors.map((name) => String(name || '').trim()).filter(Boolean).join(', ');
+ if (authorsText) {
+ metadata.authors = authorsText;
+ metadata.author = authorsText;
+ }
+ }
+
+ if (typeof entry.subtitle === 'string' && entry.subtitle.trim()) {
+ metadata.subtitle = entry.subtitle.trim();
+ }
+ if (entry.rating !== null && entry.rating !== undefined && entry.rating !== '') {
+ metadata.rating = String(entry.rating);
+ }
+ if (entry.rating_max !== null && entry.rating_max !== undefined && entry.rating_max !== '') {
+ metadata.rating_max = String(entry.rating_max);
+ }
+ if (entry.published) {
+ metadata.published = entry.published;
+ metadata.publication_date = entry.published;
+ try {
+ const publishedDate = new Date(entry.published);
+ if (!Number.isNaN(publishedDate.getTime())) {
+ const year = String(publishedDate.getUTCFullYear());
+ metadata.publication_year = year;
+ metadata.year = year;
+ }
+ } catch (error) {
+ // Ignore invalid date parsing issues
+ }
+ }
+ if (Object.keys(metadata).length > 0) {
+ requestPayload.metadata = metadata;
+ }
+ const response = await fetch('/api/integrations/calibre-opds/import', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(requestPayload),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Unable to queue this book.');
+ }
+ setStatus('Preparing the conversion wizard…', 'success');
+ closeModal();
+ const redirectUrl = payload.redirect_url || '';
+ if (redirectUrl) {
+ const wizard = window.AbogenWizard;
+ if (wizard?.requestStep) {
+ try {
+ const target = new URL(redirectUrl, window.location.origin);
+ if (payload.pending_id && !target.searchParams.has('pending_id')) {
+ target.searchParams.set('pending_id', payload.pending_id);
+ }
+ target.searchParams.set('format', 'json');
+ if (!target.searchParams.has('step')) {
+ target.searchParams.set('step', 'book');
+ }
+ await wizard.requestStep(target.toString(), { method: 'GET' });
+ } catch (wizardError) {
+ console.error('Unable to open wizard via JSON payload', wizardError);
+ window.location.assign(redirectUrl);
+ }
+ } else {
+ window.location.assign(redirectUrl);
+ }
+ }
+
+ } catch (error) {
+ setStatus(error instanceof Error ? error.message : 'Unable to queue this book.', 'error');
+ } finally {
+ if (button) {
+ button.disabled = false;
+ delete button.dataset.loading;
+ if (originalLabel) {
+ button.textContent = originalLabel;
+ }
+ }
+ }
+ };
+
+ const loadFeed = async ({ href = '', query = '', letter = '', activeTab = null, updateTabs = false } = {}) => {
+ const params = new URLSearchParams();
+ const normalizedHref = href || '';
+ const normalizedQuery = (query || '').trim();
+ let normalizedLetter = (letter || '').trim();
+ if (normalizedLetter === LETTER_ALL) {
+ normalizedLetter = '';
+ }
+ if (normalizedQuery) {
+ normalizedLetter = '';
+ }
+ if (normalizedLetter && normalizedLetter !== LETTER_NUMERIC) {
+ normalizedLetter = normalizedLetter.toUpperCase();
+ }
+ if (normalizedHref) {
+ params.set('href', normalizedHref);
+ }
+ if (normalizedQuery) {
+ params.set('q', normalizedQuery);
+ }
+ if (!normalizedQuery && normalizedLetter) {
+ params.set('letter', normalizedLetter);
+ }
+
+ const requestId = ++state.requestToken;
+ setStatus('Loading catalog…', 'loading');
+
+ try {
+ const url = `/api/integrations/calibre-opds/feed${params.toString() ? `?${params.toString()}` : ''}`;
+ const response = await fetch(url);
+ const payload = await response.json();
+ if (requestId !== state.requestToken) {
+ return;
+ }
+ if (!response.ok) {
+ throw new Error(payload.error || 'Unable to load the Calibre catalog.');
+ }
+ const feed = payload.feed || {};
+ state.feedTitle = feed.title || '';
+ state.currentHref = normalizedHref;
+ state.currentLinks = feed.links || {};
+ const selfLink = resolveRelLink(state.currentLinks, 'self');
+ if (selfLink?.href) {
+ state.currentHref = selfLink.href;
+ }
+ state.query = normalizedLetter ? '' : normalizedQuery;
+ if (!normalizedLetter) {
+ const startLink = resolveRelLink(state.currentLinks, 'start') || resolveRelLink(state.currentLinks, '/start');
+ if (startLink?.href) {
+ state.alphabetBaseHref = startLink.href;
+ } else if (state.currentHref) {
+ state.alphabetBaseHref = state.currentHref;
+ }
+ }
+ if (typeof activeTab === 'string') {
+ state.activeTab = activeTab;
+ } else if (normalizedQuery) {
+ state.activeTab = TabIds.SEARCH;
+ } else if (normalizedLetter) {
+ state.activeTab = TabIds.CUSTOM;
+ } else if (normalizedHref) {
+ state.activeTab = resolveTabIdForHref(normalizedHref) || TabIds.CUSTOM;
+ } else {
+ state.activeTab = TabIds.ROOT;
+ }
+
+ if (searchInput) {
+ searchInput.value = state.query || '';
+ }
+
+ if (updateTabs || !state.tabsReady) {
+ buildTabsFromFeed(feed);
+ } else {
+ renderTabs();
+ }
+
+ renderNav(feed.links);
+ const { stats } = setEntries(feed.entries || [], {
+ resetAlphabet: !normalizedLetter,
+ activeLetter: normalizedLetter || null,
+ });
+ const books = stats?.[EntryTypes.BOOK] || 0;
+ const views = stats?.[EntryTypes.NAVIGATION] || 0;
+
+ if (normalizedLetter) {
+ const letterDescription = describeAlphabetLetter(normalizedLetter);
+ if (books && views) {
+ setStatus(
+ `Showing ${books} book${books === 1 ? '' : 's'} and ${views} catalog view${views === 1 ? '' : 's'} for ${letterDescription}.`,
+ 'success',
+ { persist: true },
+ );
+ } else if (books) {
+ setStatus(`Found ${books} book${books === 1 ? '' : 's'} for ${letterDescription}.`, 'success', { persist: true });
+ } else if (views) {
+ setStatus(`Browse ${views} catalog view${views === 1 ? '' : 's'} for ${letterDescription}.`, 'info', { persist: true });
+ } else {
+ setStatus(`No catalog entries found for ${letterDescription}.`, 'info', { persist: true });
+ }
+ return;
+ }
+
+ if (normalizedQuery) {
+ if (books) {
+ setStatus(`Found ${books} book${books === 1 ? '' : 's'} for "${normalizedQuery}".`, 'success', { persist: true });
+ } else if (views) {
+ setStatus(
+ `Browse ${views} catalog view${views === 1 ? '' : 's'} related to "${normalizedQuery}".`,
+ 'info',
+ { persist: true },
+ );
+ } else {
+ setStatus(`No results for "${normalizedQuery}".`, 'error', { persist: true });
+ }
+ return;
+ }
+
+ if (books && views) {
+ setStatus(`Showing ${books} book${books === 1 ? '' : 's'} and ${views} catalog view${views === 1 ? '' : 's'}.`, 'success', { persist: true });
+ } else if (books) {
+ setStatus(`Found ${books} book${books === 1 ? '' : 's'} in this view.`, 'success', { persist: true });
+ } else if (views) {
+ setStatus(`Browse ${views} catalog view${views === 1 ? '' : 's'} to drill deeper.`, 'info', { persist: true });
+ } else {
+ setStatus('No catalog entries found here yet.', 'info', { persist: true });
+ }
+ } catch (error) {
+ if (requestId !== state.requestToken) {
+ return;
+ }
+ setStatus(error instanceof Error ? error.message : 'Unable to load the Calibre catalog.', 'error', { persist: true });
+ setEntries([], { resetAlphabet: true });
+ if (navEl) {
+ navEl.innerHTML = '';
+ }
+ state.currentLinks = {};
+ }
+ };
+
+ const openModal = (trigger) => {
+ if (isOpen) {
+ focusSearch();
+ return;
+ }
+ isOpen = true;
+ lastTrigger = trigger || null;
+ modal.hidden = false;
+ modal.dataset.open = 'true';
+ document.body.classList.add('modal-open');
+ focusSearch();
+ loadFeed({ href: state.currentHref || '', query: state.query || '', activeTab: state.activeTab || TabIds.ROOT, updateTabs: !state.tabsReady });
+ };
+
+ const closeModal = () => {
+ if (!isOpen) {
+ return;
+ }
+ isOpen = false;
+ modal.hidden = true;
+ delete modal.dataset.open;
+ document.body.classList.remove('modal-open');
+ if (lastTrigger instanceof HTMLElement) {
+ lastTrigger.focus({ preventScroll: true });
+ }
+ };
+
+ const handleKeydown = (event) => {
+ if (event.key === 'Escape' && isOpen) {
+ event.preventDefault();
+ closeModal();
+ }
+ };
+
+ document.addEventListener('keydown', handleKeydown);
+
+ openButtons.forEach((button) => {
+ button.addEventListener('click', (event) => {
+ event.preventDefault();
+ openModal(button);
+ });
+ });
+
+ closeTargets.forEach((target) => {
+ target.addEventListener('click', (event) => {
+ event.preventDefault();
+ closeModal();
+ });
+ });
+
+ modal.addEventListener('click', (event) => {
+ if (event.target === modal) {
+ closeModal();
+ }
+ });
+
+ if (searchForm && searchInput) {
+ searchForm.addEventListener('submit', (event) => {
+ event.preventDefault();
+ const query = searchInput.value.trim();
+ if (!query) {
+ loadFeed({ href: '', query: '', activeTab: TabIds.ROOT, updateTabs: true });
+ } else {
+ loadFeed({ href: '', query, activeTab: TabIds.SEARCH });
+ }
+ });
+ }
+
+ if (refreshButton && searchInput) {
+ refreshButton.addEventListener('click', () => {
+ searchInput.value = '';
+ loadFeed({ href: '', query: '', activeTab: TabIds.ROOT, updateTabs: true });
+ });
+ }
+}
diff --git a/abogen/webui/static/prepare.js b/abogen/webui/static/prepare.js
new file mode 100644
index 0000000..e01efc5
--- /dev/null
+++ b/abogen/webui/static/prepare.js
@@ -0,0 +1,2863 @@
+const prepareState = (window.AbogenPrepareState = window.AbogenPrepareState || {
+ modalEventsBound: false,
+});
+
+const initPrepare = (root = document) => {
+ const rootEl = root instanceof HTMLElement ? root : document;
+ const form = rootEl.querySelector(".prepare-form") || document.querySelector(".prepare-form");
+ if (!form) return;
+ if (form.dataset.prepareInitialized === "true") {
+ return;
+ }
+ form.dataset.prepareInitialized = "true";
+
+ const wizardModal = document.querySelector('[data-role="wizard-modal"]');
+ const uploadModal =
+ document.querySelector('[data-role="new-job-modal"]') ||
+ document.querySelector('[data-role="upload-modal"]');
+ const openUploadTriggers = Array.from(document.querySelectorAll('[data-role="open-upload-modal"]'));
+
+ const showWizardModal = () => {
+ if (!wizardModal) return;
+ wizardModal.hidden = false;
+ wizardModal.dataset.open = "true";
+ wizardModal.removeAttribute("aria-hidden");
+ document.body.classList.add("modal-open");
+ };
+
+ const hideWizardModal = () => {
+ if (!wizardModal) return;
+ wizardModal.hidden = true;
+ delete wizardModal.dataset.open;
+ wizardModal.setAttribute("aria-hidden", "true");
+ };
+
+ const triggerUploadModal = () => {
+ const existingTrigger = openUploadTriggers.find((button) => button !== null);
+ if (existingTrigger) {
+ existingTrigger.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ return;
+ }
+ if (!uploadModal) return;
+ uploadModal.hidden = false;
+ uploadModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ const focusTarget = uploadModal.querySelector("#source_file") || uploadModal.querySelector("#source_text") || uploadModal;
+ if (focusTarget instanceof HTMLElement) {
+ focusTarget.focus({ preventScroll: true });
+ }
+ };
+
+ showWizardModal();
+
+ if (!prepareState.modalEventsBound) {
+ prepareState.modalEventsBound = true;
+ document.addEventListener("upload-modal:open", hideWizardModal);
+ document.addEventListener("upload-modal:close", showWizardModal);
+ }
+
+ const parseJSONScript = (id) => {
+ const el = document.getElementById(id);
+ if (!el) return null;
+ try {
+ const content = el.textContent || "";
+ return content ? JSON.parse(content) : null;
+ } catch (error) {
+ console.warn(`Failed to parse JSON script for ${id}`, error);
+ return null;
+ }
+ };
+
+ const voiceCatalog = parseJSONScript("voice-catalog-data") || [];
+ const languageMap = parseJSONScript("voice-language-map") || {};
+ const voiceCatalogMap = new Map(voiceCatalog.map((voice) => [voice.id, voice]));
+
+ const sampleIndexState = new WeakMap();
+ const speakerHints = new Map();
+
+ const canonicalizeEntityKey = (value) => (value || "").toLowerCase().replace(/\s+/g, " ").trim();
+
+ const readSpeakerSamples = (speakerItem) => {
+ if (!speakerItem) return [];
+ const template = speakerItem.querySelector('template[data-role="speaker-samples"]');
+ if (!template) return [];
+ let parsed = [];
+ try {
+ const raw = template.innerHTML || "[]";
+ const data = JSON.parse(raw);
+ if (Array.isArray(data)) {
+ parsed = data;
+ }
+ } catch (error) {
+ console.warn("Unable to parse speaker samples", error);
+ return [];
+ }
+
+ const seen = new Set();
+ const normalised = [];
+ for (const entry of parsed) {
+ let excerpt = "";
+ let genderHint = "";
+ if (typeof entry === "string") {
+ excerpt = entry;
+ } else if (entry && typeof entry === "object") {
+ excerpt = String(entry.excerpt || "");
+ genderHint = typeof entry.gender_hint === "string" ? entry.gender_hint : "";
+ }
+ const key = excerpt.trim();
+ if (!key || seen.has(key)) {
+ continue;
+ }
+ seen.add(key);
+ normalised.push({ excerpt: key, genderHint });
+ }
+ return normalised;
+ };
+
+ const registerSpeakerHintFromNode = (node) => {
+ if (!node) return;
+ const nameNode = node.querySelector(".speaker-list__name");
+ const label = nameNode?.textContent || "";
+ const key = canonicalizeEntityKey(label);
+ if (!key) return;
+ const genderInput = node.querySelector('[data-role="gender-input"]');
+ const voiceSelect = node.querySelector('[data-role="speaker-voice"]');
+ const formulaInput = node.querySelector('[data-role="speaker-formula"]');
+ let resolvedVoice = "";
+ if (voiceSelect) {
+ const selectedValue = voiceSelect.value || voiceSelect.dataset.prevManual || "";
+ if (selectedValue && selectedValue !== "__custom_mix") {
+ resolvedVoice = selectedValue;
+ } else if (voiceSelect.dataset.defaultVoice) {
+ resolvedVoice = voiceSelect.dataset.defaultVoice;
+ } else if (form.dataset.baseVoice) {
+ resolvedVoice = form.dataset.baseVoice;
+ }
+ } else if (form.dataset.baseVoice) {
+ resolvedVoice = form.dataset.baseVoice;
+ }
+ if (!resolvedVoice && formulaInput?.value?.trim()) {
+ const formula = formulaInput.value.trim();
+ const firstTerm = formula.split("+")[0] || "";
+ const [voiceId] = firstTerm.split("*");
+ if (voiceId) {
+ resolvedVoice = voiceId.trim();
+ }
+ }
+ speakerHints.set(key, {
+ gender: (genderInput?.value || "unknown").toLowerCase(),
+ voice: resolvedVoice,
+ });
+ };
+
+ const rebuildSpeakerHints = () => {
+ speakerHints.clear();
+ form.querySelectorAll(".speaker-list__item").forEach((item) => registerSpeakerHintFromNode(item));
+ };
+
+ const getPronunciationText = (container) => {
+ if (!container) return "";
+ const input = container.querySelector('[data-role="speaker-pronunciation"]');
+ const raw = input?.value?.trim();
+ if (raw) {
+ return raw;
+ }
+ return (container.dataset.defaultPronunciation || "").trim();
+ };
+
+ const syncPronunciationPreview = (container) => {
+ if (!container) return;
+ const text = getPronunciationText(container);
+ const previewButtons = container.querySelectorAll('[data-role="speaker-preview"][data-preview-source]');
+ previewButtons.forEach((button) => {
+ const source = button.dataset.previewSource;
+ if (["pronunciation", "generated", "mix"].includes(source)) {
+ button.dataset.previewText = text;
+ }
+ });
+ };
+
+ const setSpeakerSample = (speakerItem, index) => {
+ if (!speakerItem) return;
+ const samples = readSpeakerSamples(speakerItem);
+ if (!samples.length) return;
+ const maxIndex = samples.length;
+ const normalisedIndex = ((index % maxIndex) + maxIndex) % maxIndex;
+ sampleIndexState.set(speakerItem, normalisedIndex);
+ const sample = samples[normalisedIndex];
+ const article = speakerItem.querySelector('[data-role="speaker-sample"]');
+ if (!article) return;
+ const textNode = article.querySelector('[data-role="sample-text"]');
+ const hintNode = article.querySelector('[data-role="sample-hint"]');
+ if (textNode) {
+ textNode.textContent = sample.excerpt;
+ }
+ if (hintNode) {
+ if (sample.genderHint) {
+ hintNode.hidden = false;
+ hintNode.textContent = sample.genderHint;
+ } else {
+ hintNode.hidden = true;
+ hintNode.textContent = "";
+ }
+ }
+ const previewButton = article.querySelector('[data-role="speaker-preview"][data-preview-source="sample"]');
+ if (previewButton) {
+ previewButton.dataset.previewText = sample.excerpt;
+ }
+ const voiceBrowserButton = article.querySelector('[data-role="open-voice-browser"]');
+ if (voiceBrowserButton) {
+ voiceBrowserButton.dataset.sampleIndex = String(normalisedIndex);
+ }
+ };
+
+ const initialiseSpeakerItem = (speakerItem) => {
+ syncPronunciationPreview(speakerItem);
+ const samples = readSpeakerSamples(speakerItem);
+ if (samples.length) {
+ setSpeakerSample(speakerItem, 0);
+ const nextButton = speakerItem.querySelector('[data-role="speaker-next-sample"]');
+ if (nextButton) {
+ nextButton.disabled = samples.length <= 1;
+ }
+ }
+ };
+
+ const formatCustomMixLabel = (formula) => {
+ if (!formula) return "Custom mix";
+ const segments = formula
+ .split("+")
+ .map((segment) => segment.trim())
+ .filter((segment) => segment.length);
+ if (!segments.length) {
+ return "Custom mix";
+ }
+ const parts = segments.map((segment) => {
+ const [voiceIdRaw, weightRaw] = segment.split("*").map((token) => token.trim());
+ const voiceId = voiceIdRaw || "";
+ const voiceMeta = voiceCatalogMap.get(voiceId);
+ const displayName = voiceMeta?.display_name || voiceId || "Voice";
+ const weight = Number.parseFloat(weightRaw || "");
+ if (!Number.isNaN(weight)) {
+ return `${displayName} ${(weight * 100).toFixed(0)}%`;
+ }
+ return displayName;
+ });
+ return parts.join(" + ");
+ };
+
+ const ensureCustomMixOption = (select) => {
+ if (!select) return null;
+ let option = select.querySelector('option[data-role="custom-mix-option"]');
+ if (!option) {
+ option = document.createElement("option");
+ option.value = "__custom_mix";
+ option.dataset.role = "custom-mix-option";
+ option.hidden = true;
+ option.disabled = true;
+ option.textContent = "Custom mix";
+ const firstOptGroup = select.querySelector("optgroup");
+ if (firstOptGroup) {
+ select.insertBefore(option, firstOptGroup);
+ } else {
+ select.appendChild(option);
+ }
+ }
+ return option;
+ };
+
+ const updateCustomMixOption = (select, formula) => {
+ const option = ensureCustomMixOption(select);
+ if (!option) return;
+ if (formula) {
+ option.hidden = false;
+ option.disabled = false;
+ option.textContent = formatCustomMixLabel(formula);
+ } else {
+ option.hidden = true;
+ option.disabled = true;
+ option.textContent = "Custom mix";
+ }
+ };
+
+ const chapterRows = Array.from(form.querySelectorAll("[data-role=chapter-row]"));
+
+ const setRowExpansion = (row, expanded) => {
+ if (!row) return;
+ const details = row.querySelector('[data-role="chapter-details"]');
+ const toggle = row.querySelector('[data-role="chapter-toggle"]');
+ const isExpanded = Boolean(expanded);
+ row.dataset.expanded = isExpanded ? "true" : "false";
+ if (details) {
+ details.hidden = !isExpanded;
+ details.setAttribute("aria-hidden", isExpanded ? "false" : "true");
+ }
+ if (toggle) {
+ toggle.setAttribute("aria-expanded", isExpanded ? "true" : "false");
+ toggle.setAttribute("aria-label", isExpanded ? "Hide chapter details" : "Show chapter details");
+ }
+ };
+
+ const toggleRowExpansion = (row, force) => {
+ if (!row) return;
+ const current = row.dataset.expanded === "true";
+ const next = typeof force === "boolean" ? force : !current;
+ setRowExpansion(row, next);
+ };
+
+ const isRowEnabled = (row) => {
+ const checkbox = row?.querySelector('[data-role="chapter-enabled"]');
+ return checkbox ? checkbox.checked : true;
+ };
+
+ const updateRowState = (row) => {
+ const enabled = row.querySelector('[data-role=chapter-enabled]');
+ const inputs = Array.from(row.querySelectorAll("input[type=text], select, textarea"));
+ const toggle = row.querySelector('[data-role="chapter-toggle"]');
+ const isChecked = enabled ? enabled.checked : true;
+ row.dataset.disabled = isChecked ? "false" : "true";
+
+ inputs.forEach((input) => {
+ if (input === enabled) return;
+ input.disabled = !isChecked;
+ if (!isChecked) {
+ if (input.tagName === "SELECT") {
+ input.dataset.prevValue = input.value;
+ input.value = "__default";
+ }
+ if (input.dataset.role === "formula-input") {
+ input.value = "";
+ input.hidden = true;
+ input.setAttribute("aria-hidden", "true");
+ }
+ } else if (input.tagName === "SELECT" && input.dataset.prevValue) {
+ input.value = input.dataset.prevValue;
+ }
+ });
+
+ const select = row.querySelector("select[data-role=voice-select]");
+ toggleFormula(select);
+
+ if (!isChecked) {
+ setRowExpansion(row, false);
+ }
+
+ if (toggle) {
+ toggle.disabled = !isChecked;
+ toggle.setAttribute("aria-disabled", isChecked ? "false" : "true");
+ }
+
+ };
+
+ const toggleFormula = (select) => {
+ if (!select) return;
+ const container = select.closest("[data-role=chapter-row]");
+ const formulaInput = container.querySelector('[data-role=formula-input]');
+ const isFormula = select.value === "formula";
+ formulaInput.hidden = !isFormula;
+ formulaInput.setAttribute("aria-hidden", isFormula ? "false" : "true");
+ if (!isFormula) {
+ formulaInput.value = "";
+ }
+ if (isFormula) {
+ formulaInput.required = true;
+ } else {
+ formulaInput.required = false;
+ }
+ };
+
+ chapterRows.forEach((row) => {
+ setRowExpansion(row, row.dataset.expanded === "true");
+ const enabled = row.querySelector('[data-role=chapter-enabled]');
+ if (enabled) {
+ enabled.addEventListener("change", () => updateRowState(row));
+ updateRowState(row);
+ }
+ const select = row.querySelector("select[data-role=voice-select]");
+ if (select) {
+ select.addEventListener("change", () => toggleFormula(select));
+ toggleFormula(select);
+ }
+ const toggleButton = row.querySelector('[data-role="chapter-toggle"]');
+ if (toggleButton) {
+ toggleButton.addEventListener("click", () => {
+ if (!isRowEnabled(row)) {
+ setRowExpansion(row, false);
+ return;
+ }
+ toggleRowExpansion(row);
+ });
+ }
+ });
+
+ const updatePreviewVoice = (select) => {
+ const container = select.closest(".speaker-list__item");
+ if (!container) return;
+ const previewButtons = container.querySelectorAll('[data-role="speaker-preview"]');
+ if (!previewButtons.length) return;
+
+ const formulaInput = container.querySelector('[data-role="speaker-formula"]');
+ const mixContainer = container.querySelector('[data-role="speaker-mix"]');
+ const mixLabel = container.querySelector('[data-role="speaker-mix-label"]');
+
+ const formulaValue = formulaInput?.value?.trim() || "";
+ updateCustomMixOption(select, formulaValue);
+
+ const defaultVoice = select.dataset.defaultVoice || "";
+ let assignedVoice = select.value || defaultVoice;
+ if (select.value === "__custom_mix" || formulaValue) {
+ assignedVoice = formulaValue || defaultVoice;
+ }
+
+ if (formulaValue) {
+ if (mixContainer) mixContainer.hidden = false;
+ if (mixLabel) mixLabel.textContent = formulaValue;
+ } else {
+ if (mixContainer) mixContainer.hidden = true;
+ if (mixLabel) mixLabel.textContent = "";
+ if (assignedVoice === "__custom_mix" || !assignedVoice) {
+ assignedVoice = defaultVoice;
+ }
+ }
+
+ previewButtons.forEach((button) => {
+ const kind = button.dataset.previewKind || "";
+ if (kind === "generated") {
+ button.hidden = !formulaValue;
+ button.dataset.voice = assignedVoice;
+ return;
+ }
+
+ const context = button.dataset.previewContext || "";
+ if (context === "mix") {
+ button.dataset.voice = formulaValue || assignedVoice;
+ return;
+ }
+
+ button.dataset.voice = assignedVoice || defaultVoice || button.dataset.voice || "";
+ });
+ };
+
+ const voiceSelects = Array.from(form.querySelectorAll('[data-role="speaker-voice"]'));
+ voiceSelects.forEach((select) => {
+ ensureCustomMixOption(select);
+ select.addEventListener("change", (event) => {
+ const target = event.target;
+ const container = target.closest(".speaker-list__item");
+ if (!container) return;
+ const formulaInput = container.querySelector('[data-role="speaker-formula"]');
+ const mixContainer = container.querySelector('[data-role="speaker-mix"]');
+ const mixLabel = container.querySelector('[data-role="speaker-mix-label"]');
+
+ if (target.value === "__custom_mix") {
+ if (!formulaInput?.value?.trim()) {
+ const previous = target.dataset.prevManual || "";
+ target.value = previous;
+ }
+ updatePreviewVoice(target);
+ registerSpeakerHintFromNode(container);
+ return;
+ }
+
+ if (!target.dataset.suppressFormulaClear) {
+ if (formulaInput) {
+ formulaInput.value = "";
+ }
+ if (mixLabel) {
+ mixLabel.textContent = "";
+ }
+ if (mixContainer) {
+ mixContainer.hidden = true;
+ }
+ updateCustomMixOption(target, "");
+ }
+
+ target.dataset.prevManual = target.value || "";
+ updatePreviewVoice(target);
+ delete target.dataset.suppressFormulaClear;
+ if (container) {
+ registerSpeakerHintFromNode(container);
+ }
+ });
+ updatePreviewVoice(select);
+ });
+
+ const speakerItems = Array.from(form.querySelectorAll(".speaker-list__item"));
+ speakerItems.forEach((item) => {
+ initialiseSpeakerItem(item);
+ const pronunciationInput = item.querySelector('[data-role="speaker-pronunciation"]');
+ if (pronunciationInput) {
+ const sync = () => syncPronunciationPreview(item);
+ pronunciationInput.addEventListener("input", sync);
+ pronunciationInput.addEventListener("change", sync);
+ }
+ registerSpeakerHintFromNode(item);
+ });
+ rebuildSpeakerHints();
+
+ const activeStepInput = form.querySelector('[data-role="active-step-input"]');
+ const analysisButtons = Array.from(form.querySelectorAll('[data-role="submit-speaker-analysis"]'));
+ analysisButtons.forEach((button) => {
+ button.addEventListener("click", () => {
+ if (activeStepInput) {
+ activeStepInput.value = "entities";
+ }
+ });
+ });
+
+ const voiceModal = document.querySelector('[data-role="voice-modal"]');
+ let activeGenderFilter = "";
+
+ const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+
+ const parseFormula = (formula) => {
+ const mix = new Map();
+ if (!formula) return mix;
+ const parts = formula.split("+");
+ parts.forEach((part) => {
+ const segment = part.trim();
+ if (!segment) return;
+ const pieces = segment.split("*");
+ const voiceId = pieces[0].trim();
+ if (!voiceId) return;
+ let weight = 1;
+ if (pieces[1]) {
+ const parsed = Number.parseFloat(pieces[1].trim());
+ if (!Number.isNaN(parsed) && parsed > 0) {
+ weight = parsed;
+ }
+ }
+ mix.set(voiceId, clamp(weight, 0.05, 1));
+ });
+ return mix;
+ };
+
+ const normaliseMix = (mix) => {
+ const entries = Array.from(mix.entries());
+ const total = entries.reduce((sum, [, weight]) => sum + weight, 0);
+ if (!total) return mix;
+ entries.forEach(([voiceId, weight]) => {
+ mix.set(voiceId, weight / total);
+ });
+ return mix;
+ };
+
+ const formatMix = (mix) => {
+ const entries = Array.from(mix.entries());
+ if (!entries.length) return "";
+ let total = entries.reduce((sum, [, weight]) => sum + weight, 0);
+ if (total < 0.5) {
+ const scale = 0.5 / total;
+ entries.forEach(([voiceId, weight]) => {
+ mix.set(voiceId, clamp(weight * scale, 0.05, 1));
+ });
+ total = entries.reduce((sum, [, weight]) => sum + weight, 0);
+ }
+ return entries
+ .map(([voiceId, weight]) => `${voiceId}*${(weight / total).toFixed(2)}`)
+ .join("+");
+ };
+
+ const genderLabel = (value) => {
+ switch ((value || "unknown").toLowerCase()) {
+ case "male":
+ return "Male";
+ case "female":
+ return "Female";
+ case "either":
+ return "Either";
+ default:
+ return "Unknown";
+ }
+ };
+
+ const buildRandomMix = (gender, countOverride) => {
+ const genderCode = (gender || "unknown").toLowerCase();
+ const pool = voiceCatalog.filter((voice) => {
+ const code = (voice.gender_code || "").toLowerCase();
+ if (genderCode === "female") return code === "f";
+ if (genderCode === "male") return code === "m";
+ if (genderCode === "either") return code === "f" || code === "m";
+ return true;
+ });
+ if (!pool.length) {
+ return null;
+ }
+ const voices = [...pool];
+ for (let i = voices.length - 1; i > 0; i -= 1) {
+ const j = Math.floor(Math.random() * (i + 1));
+ [voices[i], voices[j]] = [voices[j], voices[i]];
+ }
+ const count = clamp(countOverride || Math.floor(Math.random() * 4) + 1, 1, 4);
+ const selected = voices.slice(0, count);
+ const mix = new Map();
+ const rawWeights = selected.map(() => Math.random() + 0.2);
+ const total = rawWeights.reduce((sum, weight) => sum + weight, 0);
+ selected.forEach((voice, index) => {
+ mix.set(voice.id, rawWeights[index] / total);
+ });
+ return mix;
+ };
+
+ const applyFormulaToSpeaker = (speakerItem, formula) => {
+ if (!speakerItem) return;
+ const select = speakerItem.querySelector('[data-role="speaker-voice"]');
+ const formulaInput = speakerItem.querySelector('[data-role="speaker-formula"]');
+ const mixLabel = speakerItem.querySelector('[data-role="speaker-mix-label"]');
+ const mixContainer = speakerItem.querySelector('[data-role="speaker-mix"]');
+
+ if (formulaInput) {
+ formulaInput.value = formula || "";
+ }
+ if (mixLabel) {
+ mixLabel.textContent = formula || "";
+ }
+ if (mixContainer) {
+ mixContainer.hidden = !formula;
+ }
+
+ if (!select) {
+ return;
+ }
+
+ ensureCustomMixOption(select);
+
+ if (formula) {
+ if (select.value !== "__custom_mix") {
+ select.dataset.prevManual = select.value || select.dataset.prevManual || select.dataset.defaultVoice || "";
+ }
+ select.dataset.suppressFormulaClear = "1";
+ updateCustomMixOption(select, formula);
+ select.value = "__custom_mix";
+ } else {
+ const fallback = select.dataset.prevManual || select.dataset.defaultVoice || "";
+ select.dataset.suppressFormulaClear = "1";
+ updateCustomMixOption(select, "");
+ select.value = fallback;
+ }
+
+ updatePreviewVoice(select);
+ delete select.dataset.suppressFormulaClear;
+ registerSpeakerHintFromNode(speakerItem);
+ };
+
+ const hideGenderMenus = () => {
+ form.querySelectorAll('[data-role="gender-menu"]').forEach((menu) => {
+ menu.hidden = true;
+ menu.setAttribute("aria-hidden", "true");
+ });
+ form.querySelectorAll('[data-role="gender-pill"]').forEach((pill) => {
+ pill.classList.remove("is-open");
+ });
+ };
+
+ const setGenderForSpeaker = (genderContainer, value) => {
+ if (!genderContainer) return;
+ const normalized = value || "unknown";
+ const input = genderContainer.querySelector('[data-role="gender-input"]');
+ if (input) {
+ input.value = normalized;
+ }
+ const pill = genderContainer.querySelector('[data-role="gender-pill"]');
+ if (pill) {
+ pill.dataset.current = normalized;
+ pill.textContent = `${genderLabel(normalized)} voice`;
+ }
+ const options = genderContainer.querySelectorAll('[data-role="gender-option"]');
+ options.forEach((option) => {
+ if ((option.dataset.value || "unknown") === normalized) {
+ option.dataset.state = "active";
+ } else {
+ option.removeAttribute("data-state");
+ }
+ });
+ const speakerItem = genderContainer.closest(".speaker-list__item");
+ registerSpeakerHintFromNode(speakerItem);
+ };
+
+ Array.from(form.querySelectorAll('[data-role="speaker-gender"]')).forEach((container) => {
+ const input = container.querySelector('[data-role="gender-input"]');
+ setGenderForSpeaker(container, input?.value || "unknown");
+ });
+
+ const modalState = {
+ speakerItem: null,
+ samples: [],
+ recommended: new Set(),
+ mix: new Map(),
+ highlighted: "",
+ defaultVoice: "",
+ previewSettings: { language: "a", speed: "1", useGpu: "true" },
+ };
+
+ const resetModalState = () => {
+ modalState.speakerItem = null;
+ modalState.samples = [];
+ modalState.recommended = new Set();
+ modalState.mix = new Map();
+ modalState.highlighted = "";
+ modalState.defaultVoice = "";
+ modalState.previewSettings = { language: "a", speed: "1", useGpu: "true" };
+ };
+
+ const getMixFormula = () => formatMix(normaliseMix(new Map(modalState.mix)));
+
+ const renderVoiceList = (elements) => {
+ if (!elements) return;
+ const { list, searchInput, languageSelect } = elements;
+ if (!list) return;
+ list.innerHTML = "";
+ const term = (searchInput?.value || "").trim().toLowerCase();
+ const languageFilter = languageSelect?.value || "";
+ const filtered = voiceCatalog
+ .filter((voice) => {
+ if (languageFilter && voice.language !== languageFilter) return false;
+ if (activeGenderFilter && voice.gender_code !== activeGenderFilter) return false;
+ if (term) {
+ const haystacks = [voice.display_name, voice.id, voice.language_label, languageMap[voice.language]]
+ .filter(Boolean)
+ .map((value) => value.toLowerCase());
+ if (!haystacks.some((value) => value.includes(term))) {
+ return false;
+ }
+ }
+ return true;
+ })
+ .sort((a, b) => {
+ const aRecommended = modalState.recommended.has(a.id) ? 0 : 1;
+ const bRecommended = modalState.recommended.has(b.id) ? 0 : 1;
+ if (aRecommended !== bRecommended) {
+ return aRecommended - bRecommended;
+ }
+ return a.display_name.localeCompare(b.display_name);
+ });
+
+ if (!filtered.length) {
+ const emptyItem = document.createElement("li");
+ emptyItem.className = "voice-browser__empty";
+ emptyItem.textContent = "No voices matched your filters.";
+ list.appendChild(emptyItem);
+ return;
+ }
+
+ filtered.forEach((voice) => {
+ const item = document.createElement("li");
+ const button = document.createElement("button");
+ button.type = "button";
+ button.className = "voice-browser__entry";
+ button.dataset.role = "voice-modal-item";
+ button.dataset.voiceId = voice.id;
+ if (modalState.mix.has(voice.id)) {
+ button.dataset.inMix = "true";
+ }
+ if (modalState.highlighted === voice.id) {
+ button.setAttribute("aria-current", "true");
+ }
+ if (modalState.recommended.has(voice.id)) {
+ button.dataset.recommended = "true";
+ }
+ const nameSpan = document.createElement("span");
+ nameSpan.className = "voice-browser__entry-name";
+ nameSpan.textContent = voice.display_name;
+ const metaSpan = document.createElement("span");
+ metaSpan.className = "voice-browser__entry-meta";
+ metaSpan.textContent = `${voice.language_label} · ${voice.gender}`;
+ button.appendChild(nameSpan);
+ button.appendChild(metaSpan);
+ item.appendChild(button);
+ list.appendChild(item);
+ });
+ };
+
+ const renderMix = (elements) => {
+ const { mixList, mixTotal } = elements;
+ if (!mixList) return;
+ mixList.innerHTML = "";
+ const entries = Array.from(normaliseMix(new Map(modalState.mix)).entries());
+ const total = entries.reduce((sum, [, weight]) => sum + weight, 0);
+ if (mixTotal) {
+ mixTotal.textContent = `Total weight: ${total.toFixed(2)}`;
+ }
+ if (!entries.length) {
+ const empty = document.createElement("p");
+ empty.className = "voice-browser__empty";
+ empty.textContent = "Add voices from the list to build a blend.";
+ mixList.appendChild(empty);
+ return;
+ }
+ entries.forEach(([voiceId, weight]) => {
+ const wrapper = document.createElement("div");
+ wrapper.className = "voice-browser__mix-item";
+ wrapper.dataset.voiceId = voiceId;
+
+ const header = document.createElement("div");
+ header.className = "voice-browser__mix-header";
+ const voiceMeta = voiceCatalogMap.get(voiceId) || {};
+ const title = document.createElement("span");
+ title.className = "voice-browser__mix-name";
+ title.textContent = voiceMeta.display_name || voiceId;
+ const weightLabel = document.createElement("span");
+ weightLabel.className = "voice-browser__mix-weight";
+ weightLabel.textContent = weight.toFixed(2);
+ const removeBtn = document.createElement("button");
+ removeBtn.type = "button";
+ removeBtn.className = "voice-browser__mix-remove";
+ removeBtn.setAttribute("aria-label", `Remove ${title.textContent} from blend`);
+ removeBtn.textContent = "✕";
+ removeBtn.addEventListener("click", () => {
+ modalState.mix.delete(voiceId);
+ if (modalState.highlighted === voiceId) {
+ modalState.highlighted = "";
+ }
+ renderMix(elements);
+ renderVoiceList(elements);
+ updateModalMeta(elements);
+ updateApplyState(elements);
+ });
+ header.appendChild(title);
+ header.appendChild(weightLabel);
+ header.appendChild(removeBtn);
+
+ const slider = document.createElement("input");
+ slider.type = "range";
+ slider.min = "5";
+ slider.max = "100";
+ slider.step = "1";
+ slider.value = String(Math.round(weight * 100));
+ slider.addEventListener("input", () => {
+ const value = clamp(Number.parseInt(slider.value, 10) / 100, 0.05, 1);
+ modalState.mix.set(voiceId, value);
+ modalState.highlighted = voiceId;
+ renderMix(elements);
+ updateModalMeta(elements);
+ updateApplyState(elements);
+ });
+
+ wrapper.appendChild(header);
+ wrapper.appendChild(slider);
+ mixList.appendChild(wrapper);
+ });
+ };
+
+ const renderSamples = (elements) => {
+ if (!elements) return;
+ const { samplesContainer } = elements;
+ if (!samplesContainer) return;
+ samplesContainer.innerHTML = "";
+
+ if (!modalState.samples.length) {
+ const empty = document.createElement("p");
+ empty.className = "hint";
+ empty.textContent = "No sample paragraphs available yet.";
+ samplesContainer.appendChild(empty);
+ return;
+ }
+
+ const formula = getMixFormula();
+ modalState.samples.forEach((text, index) => {
+ const sample = document.createElement("article");
+ sample.className = "voice-browser__sample";
+ sample.dataset.sampleIndex = String(index);
+ if (index === 0) {
+ sample.dataset.active = "true";
+ }
+
+ const paragraph = document.createElement("p");
+ paragraph.textContent = text;
+ const actions = document.createElement("div");
+ actions.className = "voice-browser__sample-actions";
+
+ const previewButton = document.createElement("button");
+ previewButton.type = "button";
+ previewButton.className = "button button--ghost button--small";
+ previewButton.dataset.role = "speaker-preview";
+ previewButton.dataset.previewText = text;
+ previewButton.dataset.language = modalState.previewSettings.language;
+ previewButton.dataset.speed = modalState.previewSettings.speed;
+ previewButton.dataset.useGpu = modalState.previewSettings.useGpu;
+ previewButton.dataset.voice = formula || modalState.defaultVoice || "";
+ previewButton.textContent = "Preview sample";
+
+ actions.appendChild(previewButton);
+ sample.appendChild(paragraph);
+ sample.appendChild(actions);
+ samplesContainer.appendChild(sample);
+ });
+ };
+
+ const updateModalMeta = (elements) => {
+ if (!elements) return;
+ const { nameLabel, metaLabel } = elements;
+ if (!nameLabel || !metaLabel) return;
+ if (!modalState.mix.size) {
+ nameLabel.textContent = "Select voices to build a blend";
+ metaLabel.textContent = "";
+ return;
+ }
+ const highlight = modalState.highlighted && modalState.mix.has(modalState.highlighted)
+ ? modalState.highlighted
+ : Array.from(modalState.mix.keys())[0];
+ modalState.highlighted = highlight;
+ const voice = voiceCatalogMap.get(highlight);
+ if (!voice) {
+ nameLabel.textContent = highlight;
+ metaLabel.textContent = "";
+ return;
+ }
+ nameLabel.textContent = voice.display_name;
+ metaLabel.textContent = `${voice.language_label} · ${voice.gender}`;
+ };
+
+ const updateApplyState = (elements) => {
+ const { applyButton } = elements || {};
+ if (!applyButton) return;
+ const formula = getMixFormula();
+ applyButton.disabled = !formula;
+ };
+
+ const refreshModal = (elements) => {
+ renderVoiceList(elements);
+ renderMix(elements);
+ renderSamples(elements);
+ updateModalMeta(elements);
+ updateApplyState(elements);
+ };
+
+ const openVoiceBrowser = (speakerItem, sampleIndex = 0) => {
+ if (!voiceModal) return;
+ modalState.speakerItem = speakerItem;
+ const select = speakerItem.querySelector('[data-role="speaker-voice"]');
+ const previewTrigger = speakerItem.querySelector('[data-role="speaker-preview"][data-preview-source="pronunciation"]');
+ const formulaInput = speakerItem.querySelector('[data-role="speaker-formula"]');
+ modalState.defaultVoice = select?.dataset.defaultVoice || previewTrigger?.dataset.voice || "";
+ modalState.mix = formulaInput?.value ? parseFormula(formulaInput.value) : new Map();
+ if (!modalState.mix.size && select && select.value) {
+ modalState.mix.set(select.value, 1);
+ }
+ modalState.mix = normaliseMix(modalState.mix);
+
+ modalState.previewSettings = {
+ language: previewTrigger?.dataset.language || "a",
+ speed: previewTrigger?.dataset.speed || "1",
+ useGpu: previewTrigger?.dataset.useGpu || "true",
+ };
+
+ const samples = readSpeakerSamples(speakerItem);
+ let excerpts = samples.map((sample) => sample.excerpt);
+ const storedIndex = sampleIndexState.get(speakerItem) || 0;
+ let effectiveIndex = Number.isFinite(sampleIndex) ? sampleIndex : 0;
+ if (!Number.isFinite(effectiveIndex) || effectiveIndex < 0 || effectiveIndex >= excerpts.length) {
+ effectiveIndex = storedIndex;
+ }
+ if (excerpts.length && effectiveIndex > 0 && effectiveIndex < excerpts.length) {
+ const [selected] = excerpts.splice(effectiveIndex, 1);
+ excerpts.unshift(selected);
+ }
+ if (!excerpts.length) {
+ const sampleButton = speakerItem.querySelector('[data-role="speaker-preview"][data-preview-source="sample"]');
+ const previewText = sampleButton?.dataset.previewText?.trim();
+ if (previewText) {
+ excerpts = [previewText];
+ }
+ }
+ modalState.samples = Array.from(new Set(excerpts));
+ modalState.recommended = new Set(
+ Array.from(speakerItem.querySelectorAll('[data-role="recommended-voice"]')).map((btn) => btn.dataset.voice).filter(Boolean)
+ );
+ activeGenderFilter = "";
+
+ const elements = {
+ list: voiceModal.querySelector('[data-role="voice-modal-list"]'),
+ searchInput: voiceModal.querySelector('[data-role="voice-modal-search"]'),
+ languageSelect: voiceModal.querySelector('[data-role="voice-modal-language"]'),
+ genderButtons: Array.from(voiceModal.querySelectorAll('[data-role="voice-modal-gender"]')),
+ mixList: voiceModal.querySelector('[data-role="voice-modal-mix-list"]'),
+ mixTotal: voiceModal.querySelector('[data-role="voice-modal-mix-total"]'),
+ samplesContainer: voiceModal.querySelector('[data-role="voice-modal-samples"]'),
+ applyButton: voiceModal.querySelector('[data-role="voice-modal-apply"]'),
+ nameLabel: voiceModal.querySelector('[data-role="voice-modal-selected-name"]'),
+ metaLabel: voiceModal.querySelector('[data-role="voice-modal-selected-meta"]'),
+ };
+
+ if (elements.searchInput) elements.searchInput.value = "";
+ if (elements.languageSelect) elements.languageSelect.value = "";
+ elements.genderButtons.forEach((button) => {
+ button.setAttribute("aria-pressed", button.dataset.value === "" ? "true" : "false");
+ });
+
+ refreshModal(elements);
+
+ voiceModal.hidden = false;
+ voiceModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ if (elements.searchInput) {
+ setTimeout(() => elements.searchInput.focus({ preventScroll: true }), 0);
+ }
+ };
+
+ const closeVoiceBrowser = () => {
+ if (!voiceModal || voiceModal.hidden) return;
+ voiceModal.hidden = true;
+ voiceModal.removeAttribute("data-open");
+ document.body.classList.remove("modal-open");
+ resetModalState();
+ };
+
+ if (voiceModal) {
+ const elements = {
+ list: voiceModal.querySelector('[data-role="voice-modal-list"]'),
+ searchInput: voiceModal.querySelector('[data-role="voice-modal-search"]'),
+ languageSelect: voiceModal.querySelector('[data-role="voice-modal-language"]'),
+ genderButtons: Array.from(voiceModal.querySelectorAll('[data-role="voice-modal-gender"]')),
+ mixList: voiceModal.querySelector('[data-role="voice-modal-mix-list"]'),
+ mixTotal: voiceModal.querySelector('[data-role="voice-modal-mix-total"]'),
+ samplesContainer: voiceModal.querySelector('[data-role="voice-modal-samples"]'),
+ applyButton: voiceModal.querySelector('[data-role="voice-modal-apply"]'),
+ nameLabel: voiceModal.querySelector('[data-role="voice-modal-selected-name"]'),
+ metaLabel: voiceModal.querySelector('[data-role="voice-modal-selected-meta"]'),
+ randomButton: voiceModal.querySelector('[data-role="voice-modal-random"]'),
+ clearButton: voiceModal.querySelector('[data-role="voice-modal-clear"]'),
+ };
+
+ if (elements.searchInput) {
+ elements.searchInput.addEventListener("input", () => renderVoiceList(elements));
+ }
+ if (elements.languageSelect) {
+ elements.languageSelect.addEventListener("change", () => renderVoiceList(elements));
+ }
+ elements.genderButtons.forEach((button) => {
+ button.addEventListener("click", () => {
+ activeGenderFilter = button.dataset.value || "";
+ elements.genderButtons.forEach((btn) => btn.setAttribute("aria-pressed", btn === button ? "true" : "false"));
+ renderVoiceList(elements);
+ });
+ });
+ if (elements.list) {
+ elements.list.addEventListener("click", (event) => {
+ const target = event.target.closest('[data-role="voice-modal-item"]');
+ if (!target) return;
+ event.preventDefault();
+ const voiceId = target.dataset.voiceId;
+ if (!voiceId) return;
+ if (!modalState.mix.has(voiceId)) {
+ modalState.mix.set(voiceId, 0.5);
+ }
+ modalState.highlighted = voiceId;
+ renderMix(elements);
+ renderVoiceList(elements);
+ updateModalMeta(elements);
+ updateApplyState(elements);
+ });
+ }
+ if (elements.randomButton) {
+ elements.randomButton.addEventListener("click", () => {
+ const genderInput = modalState.speakerItem?.querySelector('[data-role="gender-input"]');
+ const gender = genderInput?.value || "unknown";
+ const mix = buildRandomMix(gender);
+ if (mix) {
+ modalState.mix = mix;
+ modalState.highlighted = Array.from(mix.keys())[0];
+ refreshModal(elements);
+ }
+ });
+ }
+ if (elements.clearButton) {
+ elements.clearButton.addEventListener("click", () => {
+ modalState.mix.clear();
+ modalState.highlighted = "";
+ refreshModal(elements);
+ });
+ }
+ if (elements.applyButton) {
+ elements.applyButton.addEventListener("click", (event) => {
+ event.preventDefault();
+ if (!modalState.speakerItem) return;
+ const formula = getMixFormula();
+ if (!formula) return;
+ applyFormulaToSpeaker(modalState.speakerItem, formula);
+ closeVoiceBrowser();
+ });
+ }
+ voiceModal.addEventListener("click", (event) => {
+ if (event.target.closest('[data-role="voice-modal-close"]')) {
+ event.preventDefault();
+ closeVoiceBrowser();
+ }
+ });
+ if (elements.samplesContainer) {
+ elements.samplesContainer.addEventListener("click", (event) => {
+ const sample = event.target.closest(".voice-browser__sample");
+ if (!sample) return;
+ elements.samplesContainer
+ .querySelectorAll(".voice-browser__sample")
+ .forEach((node) => node.removeAttribute("data-active"));
+ sample.dataset.active = "true";
+ });
+ }
+ document.addEventListener("keydown", (event) => {
+ if (event.key === "Escape" && !voiceModal.hidden) {
+ closeVoiceBrowser();
+ }
+ });
+
+ renderVoiceList(elements);
+ }
+
+ const entitySummaryData = parseJSONScript("entity-summary-data") || {};
+ const entityCacheKeyData = parseJSONScript("entity-cache-key");
+ const manualOverridesSeed = parseJSONScript("manual-overrides-data") || [];
+ const pronunciationOverridesSeed = parseJSONScript("pronunciation-overrides-data") || [];
+ const heteronymOverridesSeed = parseJSONScript("heteronym-overrides-data") || [];
+
+ const entityTabs = form.querySelector('[data-role="entity-tabs"]');
+ const entitiesUrl = form.dataset.entitiesUrl || "";
+ const manualUpsertUrl = form.dataset.manualUpsertUrl || "";
+ const manualDeleteUrlTemplate = form.dataset.manualDeleteUrlTemplate || "";
+ const manualSearchUrl = form.dataset.manualSearchUrl || "";
+ const baseVoice = form.dataset.baseVoice || form.dataset.voice || "";
+ const languageCode = form.dataset.language || "en";
+ const defaultSpeed = form.dataset.speed || "1.0";
+ const useGpuDefault = form.dataset.useGpu || "true";
+ let entitiesEnabled = form.dataset.entitiesEnabled !== "false";
+
+ const entityState = {
+ summary: entitySummaryData && typeof entitySummaryData === "object" ? entitySummaryData : {},
+ cacheKey: typeof entityCacheKeyData === "string" ? entityCacheKeyData : "",
+ manualOverrides: Array.isArray(manualOverridesSeed) ? [...manualOverridesSeed] : [],
+ pronunciationOverrides: Array.isArray(pronunciationOverridesSeed) ? [...pronunciationOverridesSeed] : [],
+ heteronymOverrides: Array.isArray(heteronymOverridesSeed) ? [...heteronymOverridesSeed] : [],
+ filters: {
+ people: 0,
+ entities: 0,
+ entitiesKind: "all",
+ },
+ };
+
+ let highlightedOverrideId = "";
+ let highlightMode = "manual";
+ const dirtyOverrideIds = new Set();
+ let activeEntityPanel = "";
+ let overrideFlushPromise = null;
+ let markOverrideDirty = () => {};
+ let flushManualOverrides = () => null;
+ let hasTriggeredEntitiesRefresh = false;
+
+ if (entityTabs) {
+ const tabButtons = Array.from(entityTabs.querySelectorAll('[data-role="entity-tab"]'));
+ const tabPanels = new Map(
+ Array.from(entityTabs.querySelectorAll('[data-role="entity-panel"]')).map((panel) => [panel.dataset.panel || "", panel])
+ );
+
+ const peopleSummaryContainer = entityTabs.querySelector('[data-role="people-summary"]');
+ const peopleStatsNode = peopleSummaryContainer?.querySelector('[data-role="people-stats"]');
+ const peopleListNode = peopleSummaryContainer?.querySelector('[data-role="entity-list-people"]');
+ const peopleFilterNode = peopleSummaryContainer?.querySelector('[data-role="entity-filter-people"]');
+
+ const entitySummaryContainer = entityTabs.querySelector('[data-role="entities-summary"]');
+ const entityStatsNode = entitySummaryContainer?.querySelector('[data-role="entity-stats"]');
+ const entityListNode = entitySummaryContainer?.querySelector('[data-role="entity-list-entities"]');
+ const entitiesFilterNode = entitySummaryContainer?.querySelector('[data-role="entity-filter-entities"]');
+ const entitiesKindFilterNode = entitySummaryContainer?.querySelector('[data-role="entity-filter-kind"]');
+ const entityRowTemplate = entityTabs.querySelector('template[data-role="entity-row-template"]');
+ const entitiesRefreshButton = entitySummaryContainer?.querySelector('[data-role="entities-refresh"]');
+ const entitySpinner = entitySummaryContainer?.querySelector('[data-role="entities-spinner"]');
+ const globalEntitySpinner = entityTabs.querySelector('[data-role="global-entity-spinner"]');
+
+ const manualOverridesRoot = entityTabs.querySelector('[data-role="manual-overrides"]');
+ const manualOverrideList = manualOverridesRoot?.querySelector('[data-role="manual-override-list"]');
+ const manualOverrideTemplate = manualOverridesRoot?.querySelector('template[data-role="manual-override-template"]');
+ const manualOverrideResultsList = manualOverridesRoot?.querySelector('[data-role="manual-override-results"]');
+ const manualOverrideQueryInput = manualOverridesRoot?.querySelector('[data-role="manual-override-query"]');
+ const manualOverrideSearchButton = manualOverridesRoot?.querySelector('[data-role="manual-override-search"]');
+ const manualOverrideAddCustomButton = manualOverridesRoot?.querySelector('[data-role="manual-override-add-custom"]');
+ const manualOverridesEmpty = manualOverridesRoot?.querySelector('[data-role="manual-overrides-empty"]');
+ const manualOverrideSaveButton = manualOverridesRoot?.querySelector('[data-role="manual-override-save-all"]');
+ const manualOverrideStatusNode = manualOverridesRoot?.querySelector('[data-role="manual-override-status"]');
+ const heteronymOverridesRoot = manualOverridesRoot?.querySelector('[data-role="heteronym-overrides"]');
+ const heteronymOverrideList = heteronymOverridesRoot?.querySelector('[data-role="heteronym-override-list"]');
+ const heteronymOverrideTemplate = heteronymOverridesRoot?.querySelector('template[data-role="heteronym-override-template"]');
+ const heteronymOverridesEmpty = heteronymOverridesRoot?.querySelector('[data-role="heteronym-overrides-empty"]');
+ let manualOverrideStatusTimer = null;
+ let manualOverrideStatusNonce = 0;
+
+ const setManualOverrideStatus = (message, state = "") => {
+ if (!manualOverrideStatusNode) return;
+ manualOverrideStatusNonce += 1;
+ const nonce = manualOverrideStatusNonce;
+ if (manualOverrideStatusTimer) {
+ window.clearTimeout(manualOverrideStatusTimer);
+ manualOverrideStatusTimer = null;
+ }
+ manualOverrideStatusNode.textContent = message || "";
+ if (state) {
+ manualOverrideStatusNode.dataset.state = state;
+ } else {
+ manualOverrideStatusNode.removeAttribute("data-state");
+ }
+ if (state === "success" && message) {
+ manualOverrideStatusTimer = window.setTimeout(() => {
+ if (manualOverrideStatusNonce !== nonce) {
+ return;
+ }
+ manualOverrideStatusNode.textContent = "";
+ manualOverrideStatusNode.removeAttribute("data-state");
+ manualOverrideStatusTimer = null;
+ }, 4000);
+ }
+ };
+
+ if (entitiesRefreshButton) {
+ entitiesRefreshButton.disabled = !entitiesEnabled;
+ entitiesRefreshButton.setAttribute("aria-disabled", entitiesEnabled ? "false" : "true");
+ }
+
+ const parseThreshold = (value) => {
+ const parsed = Number.parseInt(value, 10);
+ return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+ };
+
+ if (peopleFilterNode) {
+ peopleFilterNode.addEventListener("change", () => {
+ entityState.filters.people = parseThreshold(peopleFilterNode.value);
+ renderEntitySummary();
+ });
+ }
+
+ if (entitiesFilterNode) {
+ entitiesFilterNode.addEventListener("change", () => {
+ entityState.filters.entities = parseThreshold(entitiesFilterNode.value);
+ renderEntitySummary();
+ });
+ }
+
+ if (entitiesKindFilterNode) {
+ entitiesKindFilterNode.addEventListener("change", () => {
+ const value = (entitiesKindFilterNode.value || "all").trim();
+ entityState.filters.entitiesKind = value || "all";
+ renderEntitySummary();
+ });
+ }
+
+ const cloneTemplate = (template) => {
+ if (!template) return null;
+ if (template.content && template.content.firstElementChild) {
+ return template.content.firstElementChild.cloneNode(true);
+ }
+ return template.cloneNode(true);
+ };
+
+ const formatMentions = (value) => {
+ const count = Number(value || 0);
+ return `${count.toLocaleString()} mention${count === 1 ? "" : "s"}`;
+ };
+
+ const formatEntityKindLabel = (value) => {
+ if (!value) {
+ return "Unknown";
+ }
+ if (/^[A-Z0-9_]+$/.test(value) && value.length <= 4) {
+ return value.replace(/_/g, " ");
+ }
+ const lowerParts = value.toLowerCase().split("_");
+ return lowerParts
+ .map((part, index) => {
+ if (index > 0 && ["of", "and", "the", "in", "on", "at"].includes(part)) {
+ return part;
+ }
+ return part.charAt(0).toUpperCase() + part.slice(1);
+ })
+ .join(" ");
+ };
+
+ const buildOverrideLookup = () => {
+ const map = new Map();
+ const register = (entry, origin) => {
+ if (!entry || typeof entry !== "object") return;
+ const normalizedToken = entry.normalized || entry.token || "";
+ const canonical = canonicalizeEntityKey(normalizedToken);
+ const tokenLabel = entry.token || entry.normalized || "";
+ const pronunciation = entry.pronunciation || "";
+ if (!canonical || !tokenLabel) return;
+ map.set(canonical, {
+ ...entry,
+ origin,
+ token: tokenLabel,
+ normalized: normalizedToken,
+ pronunciation,
+ });
+ };
+
+ const pronunciationOverrides = Array.isArray(entityState.pronunciationOverrides)
+ ? entityState.pronunciationOverrides
+ : [];
+ pronunciationOverrides.forEach((entry) => register(entry, entry?.source || "history"));
+
+ const manualOverrides = Array.isArray(entityState.manualOverrides) ? entityState.manualOverrides : [];
+ manualOverrides.forEach((entry) => register(entry, "manual"));
+
+ return map;
+ };
+
+ const buildPossessivePreviewSamples = (pronText, tokenLabel) => {
+ const samples = new Set();
+ const base = (pronText || "").trim();
+ const fallback = (tokenLabel || "").trim();
+ if (base) {
+ samples.add(base);
+ } else if (fallback) {
+ samples.add(fallback);
+ }
+ const reference = (fallback || base).trim();
+ if (!reference) {
+ return Array.from(samples);
+ }
+ const root = (base || reference).trim();
+ if (!root) {
+ return Array.from(samples);
+ }
+ const lowerReference = reference.toLowerCase();
+ const lowerRoot = root.toLowerCase();
+ const endsWithApostrophe = lowerRoot.endsWith("'") || lowerRoot.endsWith("’");
+ const endsWithApostropheS = lowerRoot.endsWith("'s") || lowerRoot.endsWith("’s");
+ if (!endsWithApostropheS) {
+ const possessive = `${root}'s`;
+ const altPossessive = `${root}’s`;
+ samples.add(possessive);
+ samples.add(altPossessive);
+ }
+ if ((lowerReference.endsWith("s") || lowerRoot.endsWith("s")) && !endsWithApostrophe) {
+ samples.add(`${root}'`);
+ samples.add(`${root}’`);
+ }
+ return Array.from(samples);
+ };
+
+ const joinPossessivePreviewSamples = (pronText, tokenLabel) => {
+ const variants = buildPossessivePreviewSamples(pronText, tokenLabel);
+ return variants.join("\n").trim();
+ };
+
+ const setEntitiesLoading = (isLoading) => {
+ if (globalEntitySpinner) {
+ globalEntitySpinner.hidden = !isLoading;
+ }
+ if (!entitySummaryContainer) {
+ return;
+ }
+ if (isLoading) {
+ entitySummaryContainer.dataset.loading = "true";
+ } else {
+ delete entitySummaryContainer.dataset.loading;
+ }
+ if (entitySpinner) {
+ entitySpinner.hidden = !isLoading;
+ entitySpinner.setAttribute("aria-hidden", isLoading ? "false" : "true");
+ }
+ if (entitiesRefreshButton) {
+ const disabled = isLoading || !entitiesEnabled;
+ entitiesRefreshButton.disabled = disabled;
+ entitiesRefreshButton.setAttribute("aria-disabled", disabled ? "true" : "false");
+ }
+ if (entityStatsNode && isLoading) {
+ entityStatsNode.textContent = "Updating entity analysis…";
+ }
+ };
+
+ function triggerEntitiesRefresh(force = false) {
+ if (!entitiesEnabled) {
+ return;
+ }
+ if (force) {
+ hasTriggeredEntitiesRefresh = true;
+ performEntitiesRefresh(true);
+ return;
+ }
+ if (!hasTriggeredEntitiesRefresh) {
+ hasTriggeredEntitiesRefresh = true;
+ performEntitiesRefresh(true);
+ }
+ }
+
+ function activateEntityTab(panelKey) {
+ if (activeEntityPanel === "manual" && panelKey !== activeEntityPanel) {
+ void flushManualOverrides();
+ }
+ tabButtons.forEach((button) => {
+ const isActive = button.dataset.panel === panelKey;
+ button.classList.toggle("is-active", isActive);
+ button.setAttribute("aria-selected", isActive ? "true" : "false");
+ });
+ tabPanels.forEach((panel, key) => {
+ if (!panel) return;
+ const isActive = key === panelKey;
+ panel.classList.toggle("is-active", isActive);
+ panel.hidden = !isActive;
+ panel.setAttribute("aria-hidden", isActive ? "false" : "true");
+ });
+ activeEntityPanel = panelKey;
+ if (panelKey === "entities") {
+ triggerEntitiesRefresh();
+ }
+ }
+
+ function populateVoiceOptions(select, selectedVoice) {
+ if (!select) return;
+ const narratorLabel = baseVoice ? `Use narrator voice (${baseVoice})` : "Use narrator voice";
+ select.innerHTML = "";
+ const narratorOption = document.createElement("option");
+ narratorOption.value = "";
+ narratorOption.textContent = narratorLabel;
+ if (!selectedVoice) {
+ narratorOption.selected = true;
+ }
+ select.appendChild(narratorOption);
+ voiceCatalog.forEach((voice) => {
+ const option = document.createElement("option");
+ option.value = voice.id;
+ option.textContent = `${voice.display_name} · ${voice.language_label} · ${voice.gender}`;
+ if (selectedVoice === voice.id) {
+ option.selected = true;
+ }
+ select.appendChild(option);
+ });
+ if (selectedVoice) {
+ const hasMatch = Array.from(select.options).some((option) => option.value === selectedVoice);
+ if (!hasMatch) {
+ const fallback = document.createElement("option");
+ fallback.value = selectedVoice;
+ fallback.textContent = selectedVoice;
+ fallback.selected = true;
+ select.appendChild(fallback);
+ }
+ }
+ }
+
+ function renderEntitySummary() {
+ const summary = entityState.summary || {};
+ const stats = summary.stats || {};
+ const errors = Array.isArray(summary.errors) ? summary.errors : [];
+ const peopleEntries = Array.isArray(summary.people) ? summary.people : [];
+ const entityEntries = Array.isArray(summary.entities) ? summary.entities : [];
+ const overrideLookup = buildOverrideLookup();
+ const peopleThreshold = Number.parseInt(entityState.filters?.people, 10) || 0;
+ const entityThreshold = Number.parseInt(entityState.filters?.entities, 10) || 0;
+ const entityKindSelection = (entityState.filters?.entitiesKind || "all").toLowerCase();
+
+ const ensureSelectValue = (node, value) => {
+ if (!node) return;
+ const target = String(value);
+ if (node.value !== target) {
+ node.value = target;
+ }
+ };
+
+ ensureSelectValue(peopleFilterNode, peopleThreshold);
+ ensureSelectValue(entitiesFilterNode, entityThreshold);
+ ensureSelectValue(entitiesKindFilterNode, entityKindSelection || "all");
+
+ if (entitiesKindFilterNode) {
+ const seenKinds = new Set();
+ const existingValue = entitiesKindFilterNode.value || "all";
+ const options = Array.from(entityEntries || [])
+ .map((entry) => String(entry?.kind || ""))
+ .filter((kind) => kind && kind !== "PERSON");
+ entitiesKindFilterNode.innerHTML = "";
+ const addOption = (value, label) => {
+ if (seenKinds.has(value)) return;
+ const opt = document.createElement("option");
+ opt.value = value;
+ opt.textContent = label;
+ entitiesKindFilterNode.appendChild(opt);
+ seenKinds.add(value);
+ };
+ addOption("all", "All");
+ addOption("proper_noun", "Proper nouns");
+ options.forEach((kind) => {
+ const normalized = kind.toLowerCase();
+ addOption(normalized, formatEntityKindLabel(kind));
+ });
+ if (!seenKinds.has(existingValue)) {
+ entityState.filters.entitiesKind = "all";
+ }
+ ensureSelectValue(entitiesKindFilterNode, entityState.filters.entitiesKind || "all");
+ }
+
+ const renderDisabled = (listNode, message) => {
+ if (!listNode) return;
+ listNode.innerHTML = "";
+ const emptyItem = document.createElement("li");
+ emptyItem.className = "entity-summary__empty";
+ emptyItem.textContent = message;
+ listNode.appendChild(emptyItem);
+ };
+
+ if (!entitiesEnabled) {
+ const disabledMessage = "Entity recognition is turned off in Settings.";
+ if (entityStatsNode) {
+ entityStatsNode.textContent = disabledMessage;
+ }
+ if (peopleStatsNode) {
+ peopleStatsNode.textContent = disabledMessage;
+ }
+ if (peopleFilterNode) {
+ peopleFilterNode.disabled = true;
+ }
+ if (entitiesFilterNode) {
+ entitiesFilterNode.disabled = true;
+ }
+ if (entitiesKindFilterNode) {
+ entitiesKindFilterNode.disabled = true;
+ entitiesKindFilterNode.value = "all";
+ }
+ renderDisabled(peopleListNode, disabledMessage);
+ renderDisabled(entityListNode, "Enable entity recognition to populate detected entities.");
+ return;
+ }
+
+ if (peopleFilterNode) {
+ peopleFilterNode.disabled = false;
+ }
+ if (entitiesFilterNode) {
+ entitiesFilterNode.disabled = false;
+ }
+ if (entitiesKindFilterNode) {
+ entitiesKindFilterNode.disabled = false;
+ }
+
+ if (entityStatsNode) {
+ if (errors.length) {
+ entityStatsNode.textContent = errors.join(" · ");
+ } else if (stats.processed) {
+ const parts = [];
+ if (typeof stats.chapters === "number") {
+ parts.push(`${stats.chapters} chapter${stats.chapters === 1 ? "" : "s"}`);
+ }
+ if (typeof stats.tokens === "number") {
+ parts.push(`${stats.tokens.toLocaleString()} tokens processed`);
+ }
+ if (typeof stats.people === "number") {
+ parts.push(`${stats.people} character${stats.people === 1 ? "" : "s"}`);
+ }
+ if (typeof stats.entities === "number") {
+ parts.push(`${stats.entities} ${stats.entities === 1 ? "entity" : "entities"}`);
+ }
+ entityStatsNode.textContent = parts.length ? parts.join(" · ") : "Entity analysis up to date.";
+ } else {
+ entityStatsNode.textContent = "Entity analysis will populate once you continue from chapters.";
+ }
+ }
+
+ const renderGroup = (listNode, entries, threshold, options) => {
+ if (!listNode) {
+ return { visible: 0, total: entries.length };
+ }
+ listNode.innerHTML = "";
+ let filtered = entries.filter((entry) => Number(entry?.count || 0) >= threshold);
+ if (options.kindFilter) {
+ filtered = filtered.filter((entry) => options.kindFilter(entry));
+ }
+ if (!filtered.length) {
+ const emptyItem = document.createElement("li");
+ emptyItem.className = "entity-summary__empty";
+ emptyItem.textContent = entries.length ? options.filteredEmptyText : options.emptyText;
+ listNode.appendChild(emptyItem);
+ return { visible: 0, total: entries.length };
+ }
+ filtered.forEach((entity) => {
+ const item = cloneTemplate(entityRowTemplate);
+ if (!item) return;
+ const normalized = entity.normalized || entity.label || entity.token || "";
+ const tokenLabel = entity.label || entity.token || normalized || "Untitled entity";
+ item.dataset.entityId = entity.id || normalized || tokenLabel;
+ item.dataset.entityCategory = options.groupKey;
+ item.dataset.normalized = normalized.toLowerCase();
+ if (entity.kind) {
+ item.dataset.entityKind = entity.kind;
+ }
+
+ const labelEl = item.querySelector('[data-role="entity-label"]');
+ if (labelEl) {
+ labelEl.textContent = tokenLabel;
+ }
+
+ const kindEl = item.querySelector('[data-role="entity-kind"]');
+ if (kindEl) {
+ const kind = entity.kind || entity.category || "";
+ if (options.hideKind || !kind) {
+ kindEl.textContent = "";
+ kindEl.hidden = true;
+ } else {
+ kindEl.hidden = false;
+ kindEl.textContent = formatEntityKindLabel(kind);
+ }
+ }
+
+ const countEl = item.querySelector('[data-role="entity-count"]');
+ if (countEl) {
+ countEl.textContent = formatMentions(entity.count);
+ }
+
+ const samplesContainer = item.querySelector('[data-role="entity-samples"]');
+ if (samplesContainer) {
+ samplesContainer.innerHTML = "";
+ const samples = Array.isArray(entity.samples) ? entity.samples : [];
+ if (!samples.length) {
+ const hint = document.createElement("p");
+ hint.className = "hint";
+ hint.textContent = "No sample sentences captured yet.";
+ samplesContainer.appendChild(hint);
+ } else {
+ const list = document.createElement("ul");
+ list.className = "entity-summary__samples-list";
+ samples.slice(0, 3).forEach((sample) => {
+ const text = typeof sample === "string" ? sample : sample?.excerpt;
+ if (!text) return;
+ const entry = document.createElement("li");
+ entry.textContent = text;
+ list.appendChild(entry);
+ });
+ samplesContainer.appendChild(list);
+ }
+ }
+
+ const normalizedKey = canonicalizeEntityKey(normalized || tokenLabel);
+ const overrideMeta = normalizedKey ? overrideLookup.get(normalizedKey) : null;
+
+ const overrideButton = item.querySelector('[data-role="entity-add-override"]');
+ if (overrideButton) {
+ overrideButton.dataset.entityToken = entity.label || entity.token || "";
+ overrideButton.dataset.entityNormalized = normalized;
+ overrideButton.dataset.entityCategory = options.groupKey;
+ overrideButton.dataset.entityCount = String(entity.count || 0);
+ const sampleContext = Array.isArray(entity.samples) && entity.samples.length
+ ? typeof entity.samples[0] === "string"
+ ? entity.samples[0]
+ : entity.samples[0]?.excerpt || ""
+ : "";
+ if (sampleContext) {
+ overrideButton.dataset.entityContext = sampleContext;
+ }
+ if (entity.kind) {
+ overrideButton.dataset.entityKind = entity.kind;
+ }
+ overrideButton.textContent = overrideMeta
+ ? overrideMeta.origin === "manual"
+ ? "Edit manual override"
+ : "Edit pronunciation override"
+ : "Add manual override";
+ if (overrideMeta) {
+ item.dataset.hasOverride = "true";
+ } else {
+ delete item.dataset.hasOverride;
+ }
+ }
+
+ const inlineOverride = item.querySelector('[data-role="inline-override"]');
+ if (inlineOverride) {
+ const override = overrideMeta;
+ if (override) {
+ inlineOverride.hidden = false;
+ item.dataset.hasOverride = "true";
+ item.dataset.overrideId = override.id || override.normalized || override.token || "";
+ if (override.origin) {
+ item.dataset.overrideSource = override.origin;
+ } else {
+ delete item.dataset.overrideSource;
+ }
+ inlineOverride.dataset.pendingToken = override.token || tokenLabel;
+ inlineOverride.dataset.pendingNormalized = override.normalized || normalized;
+ inlineOverride.dataset.pendingContext = override.context || inlineOverride.dataset.pendingContext || "";
+ inlineOverride.dataset.pendingCategory = options.groupKey;
+ inlineOverride.dataset.pendingKind = entity.kind || "";
+ const pronInput = inlineOverride.querySelector('[data-role="manual-override-pronunciation"]');
+ if (pronInput) {
+ pronInput.value = override.pronunciation || "";
+ pronInput.placeholder = override.token || tokenLabel;
+ }
+ const voiceSelect = inlineOverride.querySelector('[data-role="manual-override-voice"]');
+ if (voiceSelect) {
+ populateVoiceOptions(voiceSelect, override.voice || "");
+ }
+ const previewButton = inlineOverride.querySelector('[data-role="speaker-preview"]');
+ if (previewButton) {
+ const previewValue = joinPossessivePreviewSamples(override.pronunciation, override.token || tokenLabel);
+ previewButton.dataset.previewText = previewValue || override.token || tokenLabel;
+ previewButton.dataset.voice = override.voice || override.voice_profile || baseVoice || "";
+ previewButton.dataset.language = languageCode;
+ previewButton.dataset.speed = defaultSpeed;
+ previewButton.dataset.useGpu = useGpuDefault;
+ }
+ if (
+ highlightMode === "inline" &&
+ highlightedOverrideId &&
+ (override.id === highlightedOverrideId || override.normalized === highlightedOverrideId || override.token === highlightedOverrideId)
+ ) {
+ item.classList.add("is-highlighted");
+ inlineOverride.hidden = false;
+ setTimeout(() => item.classList.remove("is-highlighted"), 2200);
+ highlightedOverrideId = "";
+ }
+ } else {
+ inlineOverride.hidden = true;
+ delete item.dataset.overrideId;
+ delete item.dataset.overrideSource;
+ }
+ }
+
+ const previewButton = item.querySelector('[data-entity-preview="true"]');
+ if (previewButton) {
+ const previewVoice = overrideMeta?.voice || baseVoice || "";
+ const previewText = Array.isArray(entity.samples) && entity.samples.length
+ ? typeof entity.samples[0] === "string"
+ ? entity.samples[0]
+ : entity.samples[0]?.excerpt || tokenLabel
+ : tokenLabel;
+ previewButton.hidden = !previewText;
+ if (previewText) {
+ previewButton.dataset.previewText = previewText;
+ previewButton.dataset.voice = previewVoice;
+ previewButton.dataset.language = languageCode;
+ previewButton.dataset.speed = defaultSpeed;
+ previewButton.dataset.useGpu = useGpuDefault;
+ previewButton.dataset.previewSource = "entity";
+ }
+ }
+
+ listNode.appendChild(item);
+ });
+ return { visible: filtered.length, total: entries.length };
+ };
+
+ const peopleRender = renderGroup(peopleListNode, peopleEntries, peopleThreshold, {
+ groupKey: "people",
+ hideKind: true,
+ emptyText: "No characters detected yet.",
+ filteredEmptyText: "No characters match the selected mention filter.",
+ });
+
+ if (peopleFilterNode && !peopleEntries.length) {
+ peopleFilterNode.value = "0";
+ }
+
+ if (peopleStatsNode) {
+ if (errors.length) {
+ peopleStatsNode.textContent = errors.join(" · ");
+ } else if (!peopleEntries.length) {
+ peopleStatsNode.textContent = "No characters detected yet.";
+ } else if (!peopleRender.visible) {
+ peopleStatsNode.textContent = "Adjust the mention filter to see additional characters.";
+ } else {
+ let label = "all mentions";
+ if (peopleThreshold > 1) {
+ label = `${peopleThreshold}+ mentions`;
+ } else if (peopleThreshold === 1) {
+ label = "1+ mention";
+ }
+ peopleStatsNode.textContent = `Showing ${peopleRender.visible} of ${peopleRender.total} characters (${label}).`;
+ }
+ }
+
+ const entitiesRender = renderGroup(entityListNode, entityEntries, entityThreshold, {
+ groupKey: "entities",
+ hideKind: false,
+ emptyText: "No entities detected yet.",
+ filteredEmptyText: "No entities match the selected mention filter.",
+ kindFilter: (entry) => {
+ if (!entityKindSelection || entityKindSelection === "all") {
+ return true;
+ }
+ const kind = (entry.kind || "").toLowerCase();
+ if (entityKindSelection === "proper_noun") {
+ return !kind || kind === "propn" || kind === "noun" || kind === "proper_noun";
+ }
+ return kind === entityKindSelection;
+ },
+ });
+
+ if (entitiesFilterNode && !entityEntries.length) {
+ entitiesFilterNode.value = "0";
+ }
+
+ if (
+ entityStatsNode &&
+ !errors.length &&
+ stats.processed &&
+ typeof stats.entities === "number" &&
+ entityThreshold > 0 &&
+ stats.entities > entitiesRender.visible
+ ) {
+ const filterLabel = entityThreshold > 1 ? `${entityThreshold}+ mentions` : "1+ mention";
+ entityStatsNode.textContent += ` · Filter hiding ${stats.entities - entitiesRender.visible} entries (${filterLabel})`;
+ }
+ }
+
+ function renderManualOverrides() {
+ if (!manualOverrideList) return;
+ manualOverrideList.innerHTML = "";
+ const overrides = Array.isArray(entityState.manualOverrides) ? entityState.manualOverrides : [];
+ if (!overrides.length) {
+ if (manualOverridesEmpty) {
+ manualOverridesEmpty.hidden = false;
+ }
+ return;
+ }
+
+ if (manualOverridesEmpty) {
+ manualOverridesEmpty.hidden = true;
+ }
+
+ overrides.forEach((override) => {
+ const node = cloneTemplate(manualOverrideTemplate);
+ if (!node) return;
+ const overrideId = override.id || override.normalized || override.token || "";
+ node.dataset.overrideId = overrideId;
+ node.dataset.token = override.token || "";
+ node.dataset.normalized = override.normalized || "";
+ node.dataset.context = override.context || "";
+
+ const labelEl = node.querySelector('[data-role="override-label"]');
+ if (labelEl) {
+ labelEl.textContent = override.token || override.normalized || "Manual override";
+ }
+
+ const notesEl = node.querySelector('[data-role="override-notes"]');
+ if (notesEl) {
+ const notes = override.notes || override.context || "";
+ if (notes) {
+ notesEl.textContent = notes;
+ } else {
+ notesEl.hidden = true;
+ }
+ }
+
+ const pronInput = node.querySelector('[data-role="manual-override-pronunciation"]');
+ if (pronInput) {
+ pronInput.value = override.pronunciation || "";
+ pronInput.placeholder = override.token || override.normalized || "";
+ pronInput.dataset.overrideId = overrideId;
+ }
+
+ const voiceSelect = node.querySelector('[data-role="manual-override-voice"]');
+ if (voiceSelect) {
+ populateVoiceOptions(voiceSelect, override.voice || "");
+ voiceSelect.dataset.overrideId = overrideId;
+ }
+
+ const previewButton = node.querySelector('[data-role="speaker-preview"]');
+ if (previewButton) {
+ const previewVoice = override.voice || voiceSelect?.value || baseVoice || "";
+ const previewText = joinPossessivePreviewSamples(override.pronunciation, override.token || override.normalized || "");
+ previewButton.dataset.overrideId = overrideId;
+ previewButton.dataset.previewText = previewText || override.pronunciation || override.token || "";
+ previewButton.dataset.voice = previewVoice;
+ previewButton.dataset.language = languageCode;
+ previewButton.dataset.speed = defaultSpeed;
+ previewButton.dataset.useGpu = useGpuDefault;
+ }
+
+ const deleteButton = node.querySelector('[data-role="manual-override-delete"]');
+ if (deleteButton) {
+ deleteButton.dataset.overrideId = overrideId;
+ }
+
+ const metaEl = node.querySelector('[data-role="manual-override-meta"]');
+ if (metaEl) {
+ const parts = [];
+ if (override.source) {
+ parts.push(`Source: ${override.source}`);
+ }
+ if (override.updated_at) {
+ const timestamp = Number(override.updated_at) * 1000;
+ if (!Number.isNaN(timestamp)) {
+ parts.push(`Updated ${new Date(timestamp).toLocaleString()}`);
+ }
+ }
+ metaEl.textContent = parts.join(" · ");
+ }
+
+ manualOverrideList.appendChild(node);
+ if (highlightedOverrideId && highlightedOverrideId === overrideId) {
+ node.classList.add("is-highlighted");
+ setTimeout(() => node.classList.remove("is-highlighted"), 2400);
+ node.scrollIntoView({ behavior: "smooth", block: "center" });
+ highlightedOverrideId = "";
+ }
+ });
+ }
+
+ const escapeRegExp = (value) => String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+ const resolveHeteronymTooltip = (entry) => {
+ if (!entry || typeof entry !== "object") return "";
+ const options = Array.isArray(entry.options) ? entry.options : [];
+ if (options.length < 2) return "";
+ const parts = [];
+ options.slice(0, 2).forEach((opt) => {
+ const label = String(opt?.label || "").trim();
+ const example = String(opt?.example_sentence || "").trim();
+ if (label && example) {
+ parts.push(`${label}: ${example}`);
+ } else if (example) {
+ parts.push(example);
+ }
+ });
+ return parts.join("\n");
+ };
+
+ const fillHighlightedSentence = (container, sentence, token, tooltip) => {
+ if (!container) return;
+ container.textContent = "";
+ const rawSentence = String(sentence || "");
+ const rawToken = String(token || "");
+ if (!rawSentence) {
+ return;
+ }
+ if (!rawToken) {
+ container.textContent = rawSentence;
+ return;
+ }
+
+ const pattern = new RegExp(`\\b${escapeRegExp(rawToken)}\\b`, "i");
+ const match = pattern.exec(rawSentence);
+ if (!match) {
+ container.textContent = rawSentence;
+ return;
+ }
+
+ const before = rawSentence.slice(0, match.index);
+ const hit = rawSentence.slice(match.index, match.index + match[0].length);
+ const after = rawSentence.slice(match.index + match[0].length);
+
+ if (before) {
+ container.appendChild(document.createTextNode(before));
+ }
+ const chip = document.createElement("span");
+ chip.className = "chip";
+ chip.textContent = hit;
+ if (tooltip) {
+ chip.title = tooltip;
+ }
+ container.appendChild(chip);
+ if (after) {
+ container.appendChild(document.createTextNode(after));
+ }
+ };
+
+ function renderHeteronymOverrides() {
+ if (!heteronymOverrideList) return;
+ heteronymOverrideList.innerHTML = "";
+ const entries = Array.isArray(entityState.heteronymOverrides) ? entityState.heteronymOverrides : [];
+ if (!entries.length) {
+ if (heteronymOverridesEmpty) {
+ heteronymOverridesEmpty.hidden = false;
+ }
+ return;
+ }
+
+ if (heteronymOverridesEmpty) {
+ heteronymOverridesEmpty.hidden = true;
+ }
+
+ entries.forEach((entry) => {
+ if (!entry || typeof entry !== "object") return;
+ const entryId = String(entry.entry_id || entry.id || "").trim();
+ if (!entryId) return;
+ const sentence = String(entry.sentence || "").trim();
+ if (!sentence) return;
+ const token = String(entry.token || "").trim();
+
+ const node = cloneTemplate(heteronymOverrideTemplate);
+ if (!node) return;
+ node.dataset.entryId = entryId;
+
+ const sentenceEl = node.querySelector('[data-role="heteronym-sentence"]');
+ if (sentenceEl) {
+ const tooltip = resolveHeteronymTooltip(entry);
+ fillHighlightedSentence(sentenceEl, sentence, token, tooltip);
+ }
+
+ const notesEl = node.querySelector('[data-role="heteronym-notes"]');
+ if (notesEl) {
+ const suggested = String(entry.default_choice || "").trim();
+ if (suggested) {
+ const options = Array.isArray(entry.options) ? entry.options : [];
+ const match = options.find((opt) => String(opt?.key || "").trim() === suggested);
+ const label = String(match?.label || "").trim();
+ notesEl.textContent = label ? `Suggested: ${label}` : "";
+ notesEl.hidden = !notesEl.textContent;
+ } else {
+ notesEl.hidden = true;
+ }
+ }
+
+ const optionsContainer = node.querySelector('[data-role="heteronym-options"]');
+ if (optionsContainer) {
+ optionsContainer.innerHTML = "";
+ const options = Array.isArray(entry.options) ? entry.options : [];
+ const selectedKey = String(entry.choice || entry.default_choice || "").trim();
+ options.slice(0, 2).forEach((opt, index) => {
+ if (!opt || typeof opt !== "object") return;
+ const key = String(opt.key || "").trim();
+ const label = String(opt.label || "Option").trim();
+ const previewSentence = String(opt.replacement_sentence || sentence).trim();
+ if (!key) return;
+
+ const wrapper = document.createElement("div");
+ wrapper.className = "entity-inline-override__actions";
+
+ const choiceLabel = document.createElement("label");
+ choiceLabel.className = "toggle-pill";
+ const input = document.createElement("input");
+ input.type = "radio";
+ input.name = `heteronym-${entryId}-choice`;
+ input.value = key;
+ if (selectedKey) {
+ input.checked = selectedKey === key;
+ } else {
+ input.checked = index === 0;
+ }
+ const span = document.createElement("span");
+ span.textContent = label;
+ choiceLabel.appendChild(input);
+ choiceLabel.appendChild(span);
+
+ const previewButton = document.createElement("button");
+ previewButton.type = "button";
+ previewButton.className = "button button--ghost button--small";
+ previewButton.dataset.role = "speaker-preview";
+ previewButton.dataset.previewText = previewSentence;
+ previewButton.dataset.voice = baseVoice || "";
+ previewButton.dataset.language = languageCode;
+ previewButton.dataset.speed = defaultSpeed;
+ previewButton.dataset.useGpu = useGpuDefault;
+ previewButton.textContent = "Preview";
+ previewButton.disabled = !previewButton.dataset.voice;
+ previewButton.setAttribute("aria-disabled", previewButton.disabled ? "true" : "false");
+
+ wrapper.appendChild(choiceLabel);
+ wrapper.appendChild(previewButton);
+ optionsContainer.appendChild(wrapper);
+ });
+ }
+
+ heteronymOverrideList.appendChild(node);
+ });
+ }
+
+ function applyEntityPayload(payload, options = {}) {
+ if (payload && typeof payload === "object") {
+ if (payload.summary) {
+ entityState.summary = payload.summary;
+ }
+ if (Array.isArray(payload.manual_overrides)) {
+ entityState.manualOverrides = payload.manual_overrides;
+ }
+ if (Array.isArray(payload.pronunciation_overrides)) {
+ entityState.pronunciationOverrides = payload.pronunciation_overrides;
+ }
+ if (Array.isArray(payload.heteronym_overrides)) {
+ entityState.heteronymOverrides = payload.heteronym_overrides;
+ }
+ if (typeof payload.cache_key === "string") {
+ entityState.cacheKey = payload.cache_key;
+ }
+ if (Object.prototype.hasOwnProperty.call(payload, "recognition_enabled")) {
+ entitiesEnabled = payload.recognition_enabled !== false;
+ form.dataset.entitiesEnabled = entitiesEnabled ? "true" : "false";
+ if (entitiesRefreshButton) {
+ entitiesRefreshButton.disabled = !entitiesEnabled;
+ entitiesRefreshButton.setAttribute("aria-disabled", entitiesEnabled ? "false" : "true");
+ }
+ }
+ }
+ if (options.highlightId) {
+ highlightedOverrideId = options.highlightId;
+ }
+ renderEntitySummary();
+ renderManualOverrides();
+ renderHeteronymOverrides();
+ }
+
+ const filterVoicesByGender = (voices, genderHint) => {
+ const normalized = (genderHint || "unknown").toLowerCase();
+ if (normalized === "female") {
+ return voices.filter((voice) => (voice.gender_code || "").toLowerCase() === "f");
+ }
+ if (normalized === "male") {
+ return voices.filter((voice) => (voice.gender_code || "").toLowerCase() === "m");
+ }
+ if (normalized === "either") {
+ return voices.filter((voice) => {
+ const code = (voice.gender_code || "").toLowerCase();
+ return code === "f" || code === "m";
+ });
+ }
+ return voices.slice();
+ };
+
+ const pickRandomVoiceForOverride = (genderHint) => {
+ if (!Array.isArray(voiceCatalog) || !voiceCatalog.length) {
+ return baseVoice || "";
+ }
+ const normalizedLanguage = (languageCode || "").trim().toLowerCase();
+ const languageCandidates = () => {
+ const keys = [];
+ if (normalizedLanguage) keys.push(normalizedLanguage);
+ if (languageCode && languageCode !== normalizedLanguage) {
+ keys.push(languageCode);
+ }
+ for (const key of keys) {
+ const mapped = languageMap?.[key];
+ if (Array.isArray(mapped) && mapped.length) {
+ const lookup = new Set(mapped);
+ const matches = voiceCatalog.filter((voice) => lookup.has(voice.id));
+ if (matches.length) {
+ return matches;
+ }
+ }
+ }
+ const direct = voiceCatalog.filter((voice) => (voice.language || "").toLowerCase() === normalizedLanguage);
+ return direct;
+ };
+
+ const preferred = languageCandidates();
+ let pool = filterVoicesByGender(preferred.length ? preferred : voiceCatalog, genderHint);
+ if (!pool.length) {
+ pool = voiceCatalog.slice();
+ }
+ if (!pool.length) {
+ return baseVoice || "";
+ }
+ const selected = pool[Math.floor(Math.random() * pool.length)];
+ return selected?.id || baseVoice || "";
+ };
+
+ const resolveOverrideVoice = (data) => {
+ const hasVoiceProp = Boolean(data && Object.prototype.hasOwnProperty.call(data, "voice"));
+ const voiceValueRaw = typeof data?.voice === "string" ? data.voice : "";
+ const voiceValue = voiceValueRaw.trim();
+ if (voiceValue) {
+ return voiceValue;
+ }
+ if (hasVoiceProp) {
+ return "";
+ }
+ const normalizedKey = canonicalizeEntityKey(data.normalized || data.token || "");
+ let genderHint = (data.gender || "").toLowerCase();
+ if (normalizedKey) {
+ const speakerHint = speakerHints.get(normalizedKey);
+ if (speakerHint) {
+ if (speakerHint.voice) {
+ return speakerHint.voice;
+ }
+ if (!genderHint || genderHint === "unknown") {
+ genderHint = speakerHint.gender || genderHint;
+ }
+ }
+ }
+ if (!genderHint || genderHint === "unknown") {
+ if (data.category === "people" || data.kind === "PERSON") {
+ genderHint = "either";
+ } else {
+ genderHint = "";
+ }
+ }
+ if (baseVoice) {
+ return "";
+ }
+ return pickRandomVoiceForOverride(genderHint);
+ };
+
+ function collectOverridePayload(overrideId) {
+ if (!overrideId || !manualOverrideList) return null;
+ const selectorId = typeof CSS !== "undefined" && CSS.escape ? CSS.escape(overrideId) : overrideId.replace(/["\\]/g, "\\$&");
+ const node = manualOverrideList.querySelector(`[data-override-id="${selectorId}"]`);
+ if (!node) return null;
+ const pronInput = node.querySelector('[data-role="manual-override-pronunciation"]');
+ const voiceSelect = node.querySelector('[data-role="manual-override-voice"]');
+ return {
+ id: overrideId,
+ token: node.dataset.token || "",
+ normalized: node.dataset.normalized || "",
+ pronunciation: pronInput?.value?.trim() || "",
+ voice: voiceSelect?.value || "",
+ notes: "",
+ context: node.dataset.context || "",
+ };
+ }
+
+ async function saveManualOverride(overrideId) {
+ const payload = collectOverridePayload(overrideId);
+ if (!payload || !manualUpsertUrl) return false;
+ try {
+ const response = await fetch(manualUpsertUrl, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ });
+ if (!response.ok) {
+ throw new Error(`Override save failed with status ${response.status}`);
+ }
+ const data = await response.json();
+ applyEntityPayload(data, { highlightId: data.override?.id || payload.id });
+ return true;
+ } catch (error) {
+ console.error("Failed to save manual override", error);
+ return false;
+ }
+ }
+
+ markOverrideDirty = (overrideId) => {
+ if (!overrideId) return;
+ dirtyOverrideIds.add(overrideId);
+ setManualOverrideStatus("Unsaved changes", "pending");
+ };
+
+ flushManualOverrides = (options = {}) => {
+ const { overrideId } = options || {};
+ const pendingIds = Array.isArray(overrideId) ? overrideId : overrideId ? [overrideId] : Array.from(dirtyOverrideIds);
+ const targetIds = pendingIds.filter((id) => dirtyOverrideIds.has(id));
+ if (!targetIds.length) return null;
+ setManualOverrideStatus("Saving overrides…", "pending");
+ targetIds.forEach((id) => dirtyOverrideIds.delete(id));
+ const runFlush = async () => {
+ if (overrideFlushPromise) {
+ try {
+ await overrideFlushPromise;
+ } catch (error) {
+ console.warn("Previous override flush failed", error);
+ }
+ }
+ const results = await Promise.all(targetIds.map((id) => saveManualOverride(id)));
+ let hasFailure = false;
+ results.forEach((ok, index) => {
+ if (!ok) {
+ hasFailure = true;
+ dirtyOverrideIds.add(targetIds[index]);
+ }
+ });
+ if (hasFailure) {
+ setManualOverrideStatus("Some overrides failed to save.", "error");
+ } else {
+ setManualOverrideStatus("Overrides saved.", "success");
+ }
+ };
+ overrideFlushPromise = runFlush()
+ .catch((error) => {
+ console.error("Failed flushing manual overrides", error);
+ setManualOverrideStatus("Failed to save overrides.", "error");
+ })
+ .finally(() => {
+ overrideFlushPromise = null;
+ });
+ return overrideFlushPromise;
+ };
+
+ async function deleteManualOverride(overrideId) {
+ if (!overrideId || !manualDeleteUrlTemplate) return;
+ dirtyOverrideIds.delete(overrideId);
+ const targetUrl = manualDeleteUrlTemplate.replace("__OVERRIDE_ID__", encodeURIComponent(overrideId));
+ try {
+ const response = await fetch(targetUrl, { method: "DELETE" });
+ if (!response.ok) {
+ throw new Error(`Override delete failed with status ${response.status}`);
+ }
+ const data = await response.json();
+ applyEntityPayload(data);
+ } catch (error) {
+ console.error("Failed to delete manual override", error);
+ }
+ }
+
+ async function performEntitiesRefresh(force = false) {
+ if (!entitiesUrl) return;
+ setEntitiesLoading(true);
+ try {
+ const url = new URL(entitiesUrl, window.location.origin);
+ if (force) {
+ url.searchParams.set("refresh", "1");
+ }
+ if (entityState.cacheKey) {
+ url.searchParams.set("cache_key", entityState.cacheKey);
+ }
+ const response = await fetch(url.toString(), { method: "GET" });
+ if (!response.ok) {
+ throw new Error(`Entity refresh failed with status ${response.status}`);
+ }
+ const data = await response.json();
+ applyEntityPayload(data);
+ } catch (error) {
+ console.error("Failed to refresh entity summary", error);
+ } finally {
+ setEntitiesLoading(false);
+ }
+ }
+
+ async function performManualOverrideSearch(query) {
+ if (!manualSearchUrl || !manualOverrideResultsList) return;
+ manualOverrideResultsList.innerHTML = "";
+ try {
+ const url = new URL(manualSearchUrl, window.location.origin);
+ if (query) {
+ url.searchParams.set("q", query);
+ }
+ const response = await fetch(url.toString(), { method: "GET" });
+ if (!response.ok) {
+ throw new Error(`Search failed with status ${response.status}`);
+ }
+ const data = await response.json();
+ const results = Array.isArray(data.results) ? data.results : [];
+ if (!results.length) {
+ const emptyItem = document.createElement("li");
+ emptyItem.className = "manual-overrides__results-empty";
+ emptyItem.textContent = query ? "No matches found." : "Start typing to search tokens.";
+ manualOverrideResultsList.appendChild(emptyItem);
+ return;
+ }
+ results.forEach((entry) => {
+ const item = document.createElement("li");
+ item.className = "manual-overrides__result";
+ const button = document.createElement("button");
+ button.type = "button";
+ button.className = "button button--ghost button--small";
+ button.dataset.role = "manual-override-result";
+ button.dataset.token = entry.token || entry.normalized || "";
+ if (entry.normalized) {
+ button.dataset.normalized = entry.normalized;
+ }
+ if (entry.context) {
+ button.dataset.context = entry.context;
+ } else if (Array.isArray(entry.samples) && entry.samples.length) {
+ const sample = entry.samples[0];
+ button.dataset.context = typeof sample === "string" ? sample : sample?.excerpt || "";
+ }
+ if (entry.pronunciation) {
+ button.dataset.pronunciation = entry.pronunciation;
+ }
+ if (entry.voice) {
+ button.dataset.voice = entry.voice;
+ }
+ button.dataset.source = entry.source || "search";
+ button.textContent = entry.token || entry.normalized || "Unnamed token";
+ item.appendChild(button);
+ manualOverrideResultsList.appendChild(item);
+ });
+ } catch (error) {
+ console.error("Failed to search manual override candidates", error);
+ }
+ }
+
+ async function createOverrideFromData(data) {
+ if (!data || !manualUpsertUrl) return false;
+ const token = (data.token || "").trim();
+ if (!token) return false;
+ const normalized = (data.normalized || "").trim();
+ const voiceChoice = resolveOverrideVoice({ ...data, token, normalized });
+ const payload = {
+ token,
+ normalized,
+ context: data.context || "",
+ pronunciation: data.pronunciation || "",
+ voice: voiceChoice || "",
+ source: data.source || "manual",
+ };
+ try {
+ const response = await fetch(manualUpsertUrl, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ });
+ if (!response.ok) {
+ throw new Error(`Override creation failed with status ${response.status}`);
+ }
+ const body = await response.json();
+ const highlighted = body.override?.id || payload.normalized || payload.token;
+ applyEntityPayload(body, { highlightId: highlighted });
+ if (highlightMode === "inline") {
+ highlightedOverrideId = highlighted;
+ const targetPanel = activeEntityPanel || "entities";
+ activateEntityTab(targetPanel);
+ } else {
+ activateEntityTab("manual");
+ if (manualOverrideResultsList) {
+ manualOverrideResultsList.innerHTML = "";
+ }
+ }
+ return true;
+ } catch (error) {
+ console.error("Failed to create manual override", error);
+ return false;
+ }
+ }
+
+ tabButtons.forEach((button) => {
+ button.addEventListener("click", () => {
+ highlightMode = button.dataset.panel === "manual" ? "manual" : "entities";
+ activateEntityTab(button.dataset.panel || "people");
+ });
+ });
+
+ if (entitiesRefreshButton) {
+ entitiesRefreshButton.addEventListener("click", () => {
+ void flushManualOverrides();
+ triggerEntitiesRefresh(true);
+ });
+ }
+
+ const extractInlineOverrideState = (inlineOverride, row) => {
+ if (!inlineOverride || inlineOverride.hidden) {
+ return null;
+ }
+ const container = row || inlineOverride.closest('[data-role="entity-row"]');
+ if (!container) {
+ return null;
+ }
+ const tokenLabel = inlineOverride.dataset.pendingToken || container.querySelector('[data-role="entity-label"]')?.textContent || "";
+ if (!tokenLabel) {
+ return null;
+ }
+ const normalized = (inlineOverride.dataset.pendingNormalized || container.dataset.normalized || tokenLabel || "").trim();
+ const context = (inlineOverride.dataset.pendingContext || "").trim();
+ const pronInput = inlineOverride.querySelector('[data-role="manual-override-pronunciation"]');
+ const voiceSelect = inlineOverride.querySelector('[data-role="manual-override-voice"]');
+ const pronunciationRaw = pronInput?.value ?? "";
+ const pronunciation = pronunciationRaw.trim();
+ const voiceRaw = voiceSelect?.value ?? "";
+ const voice = voiceRaw;
+ const previewVoice = voice || baseVoice || "";
+ const previewText = pronunciation || tokenLabel;
+ return {
+ token: tokenLabel,
+ normalized,
+ context,
+ pronunciation,
+ voice,
+ previewVoice,
+ previewText,
+ category: inlineOverride.dataset.pendingCategory || container.dataset.entityCategory || "",
+ kind: inlineOverride.dataset.pendingKind || container.dataset.entityKind || "",
+ };
+ };
+
+ const syncInlinePreviewUI = (row, inlineOverride, state, targetButton) => {
+ if (!state) {
+ return;
+ }
+ const previewText = state.previewText || state.token;
+ const previewVoice = state.previewVoice || baseVoice || "";
+ const applyDatasets = (button) => {
+ if (!button) return;
+ const previewValue = joinPossessivePreviewSamples(previewText, state.token);
+ button.dataset.previewText = previewValue || previewText || state.token || "";
+ button.dataset.voice = previewVoice;
+ button.dataset.language = languageCode;
+ button.dataset.speed = defaultSpeed;
+ button.dataset.useGpu = useGpuDefault;
+ if (!button.dataset.previewSource || button.dataset.previewSource === "entity") {
+ button.dataset.previewSource = "manual";
+ }
+ };
+
+ if (targetButton) {
+ applyDatasets(targetButton);
+ return;
+ }
+
+ if (inlineOverride) {
+ applyDatasets(inlineOverride.querySelector('[data-role="speaker-preview"]'));
+ }
+ if (row) {
+ applyDatasets(row.querySelector('[data-entity-preview="true"]'));
+ }
+ };
+
+ const persistInlineOverrideState = (state) => {
+ if (!state) {
+ return null;
+ }
+ highlightMode = "inline";
+ setManualOverrideStatus("Saving overrides…", "pending");
+ return createOverrideFromData({
+ token: state.token,
+ normalized: state.normalized,
+ context: state.context,
+ pronunciation: state.pronunciation,
+ voice: state.voice,
+ category: state.category,
+ kind: state.kind,
+ source: "entity-inline",
+ })
+ .then((ok) => {
+ if (ok) {
+ setManualOverrideStatus("Overrides saved.", "success");
+ } else {
+ setManualOverrideStatus("Failed to save overrides.", "error");
+ }
+ return ok;
+ })
+ .catch((error) => {
+ setManualOverrideStatus("Failed to save overrides.", "error");
+ throw error;
+ });
+ };
+
+ const handleEntityListClick = (event) => {
+ const addTrigger = event.target.closest('[data-role="entity-add-override"]');
+ if (addTrigger) {
+ event.preventDefault();
+ const row = addTrigger.closest('[data-role="entity-row"]');
+ if (!row) {
+ return;
+ }
+ const inlineOverride = row.querySelector('[data-role="inline-override"]');
+ if (!inlineOverride) {
+ highlightMode = "manual";
+ createOverrideFromData({
+ token: addTrigger.dataset.entityToken || "",
+ normalized: addTrigger.dataset.entityNormalized || "",
+ context: addTrigger.dataset.entityContext || "",
+ category: addTrigger.dataset.entityCategory || "",
+ kind: addTrigger.dataset.entityKind || "",
+ source: "entity",
+ });
+ return;
+ }
+
+ inlineOverride.hidden = false;
+ inlineOverride.setAttribute("aria-hidden", "false");
+ const pronInput = inlineOverride.querySelector('[data-role="manual-override-pronunciation"]');
+ const voiceSelect = inlineOverride.querySelector('[data-role="manual-override-voice"]');
+ const previewButton = inlineOverride.querySelector('[data-role="speaker-preview"]');
+ const token = addTrigger.dataset.entityToken || row.querySelector('[data-role="entity-label"]')?.textContent || "";
+ const normalized = addTrigger.dataset.entityNormalized || row.dataset.normalized || token;
+ const context = addTrigger.dataset.entityContext || "";
+
+ if (!row.dataset.hasOverride) {
+ if (pronInput) {
+ pronInput.value = "";
+ }
+ if (voiceSelect) {
+ populateVoiceOptions(voiceSelect, "");
+ }
+ }
+
+ inlineOverride.dataset.pendingToken = token;
+ inlineOverride.dataset.pendingNormalized = normalized;
+ inlineOverride.dataset.pendingContext = context;
+ inlineOverride.dataset.pendingCategory = addTrigger.dataset.entityCategory || row.dataset.entityCategory || "";
+ inlineOverride.dataset.pendingKind = addTrigger.dataset.entityKind || row.dataset.entityKind || "";
+
+ const inlineState = extractInlineOverrideState(inlineOverride, row);
+ syncInlinePreviewUI(row, inlineOverride, inlineState, previewButton);
+
+ highlightMode = "inline";
+ highlightedOverrideId = row.dataset.overrideId || "";
+ pronInput?.focus({ preventScroll: true });
+ return;
+ }
+
+ const saveTrigger = event.target.closest('[data-role="inline-override-save"]');
+ if (saveTrigger) {
+ event.preventDefault();
+ const inlineOverride = saveTrigger.closest('[data-role="inline-override"]');
+ const row = saveTrigger.closest('[data-role="entity-row"]');
+ if (!inlineOverride || !row) {
+ return;
+ }
+ const inlineState = extractInlineOverrideState(inlineOverride, row);
+ syncInlinePreviewUI(row, inlineOverride, inlineState);
+ void persistInlineOverrideState(inlineState);
+ return;
+ }
+
+ const removeTrigger = event.target.closest('[data-role="inline-override-remove"]');
+ if (removeTrigger) {
+ event.preventDefault();
+ const row = removeTrigger.closest('[data-role="entity-row"]');
+ if (!row) {
+ return;
+ }
+ const overrideId = row.dataset.overrideId;
+ if (overrideId) {
+ deleteManualOverride(overrideId);
+ } else {
+ const inlineOverride = removeTrigger.closest('[data-role="inline-override"]');
+ if (inlineOverride) {
+ inlineOverride.hidden = true;
+ inlineOverride.setAttribute("aria-hidden", "true");
+ }
+ }
+ }
+ };
+
+ [peopleListNode, entityListNode].forEach((list) => {
+ if (!list) return;
+ list.addEventListener("click", handleEntityListClick);
+ });
+
+ if (manualOverrideSearchButton) {
+ manualOverrideSearchButton.addEventListener("click", () => {
+ const query = manualOverrideQueryInput?.value?.trim() || "";
+ performManualOverrideSearch(query);
+ });
+ }
+
+ if (manualOverrideQueryInput) {
+ manualOverrideQueryInput.addEventListener("keydown", (event) => {
+ if (event.key === "Enter") {
+ event.preventDefault();
+ performManualOverrideSearch(manualOverrideQueryInput.value.trim());
+ }
+ });
+ }
+
+ if (manualOverrideAddCustomButton) {
+ manualOverrideAddCustomButton.addEventListener("click", () => {
+ const token = window.prompt("Enter the token to override:");
+ if (!token) return;
+ highlightMode = "manual";
+ createOverrideFromData({ token: token.trim(), source: "manual" });
+ });
+ }
+
+ if (manualOverrideResultsList) {
+ manualOverrideResultsList.addEventListener("click", (event) => {
+ const resultButton = event.target.closest('[data-role="manual-override-result"]');
+ if (!resultButton) return;
+ event.preventDefault();
+ highlightMode = "manual";
+ createOverrideFromData({
+ token: resultButton.dataset.token || "",
+ normalized: resultButton.dataset.normalized || "",
+ context: resultButton.dataset.context || "",
+ pronunciation: resultButton.dataset.pronunciation || "",
+ voice: resultButton.dataset.voice || "",
+ source: resultButton.dataset.source || "search",
+ });
+ });
+ }
+
+ if (manualOverrideList) {
+ manualOverrideList.addEventListener("input", (event) => {
+ const input = event.target.closest('[data-role="manual-override-pronunciation"]');
+ if (!input) return;
+ const overrideId = input.dataset.overrideId || input.closest('[data-override-id]')?.dataset.overrideId;
+ const container = input.closest(".manual-override");
+ const previewButton = container?.querySelector('[data-role="speaker-preview"]');
+ if (previewButton) {
+ const fallback = container?.dataset.token || input.placeholder || "";
+ const previewValue = joinPossessivePreviewSamples(input.value.trim(), fallback);
+ previewButton.dataset.previewText = previewValue || input.value.trim() || fallback;
+ }
+ if (overrideId) {
+ markOverrideDirty(overrideId);
+ }
+ });
+
+ manualOverrideList.addEventListener("change", (event) => {
+ const select = event.target.closest('[data-role="manual-override-voice"]');
+ if (!select) return;
+ const overrideId = select.dataset.overrideId || select.closest('[data-override-id]')?.dataset.overrideId;
+ const container = select.closest(".manual-override");
+ const previewButton = container?.querySelector('[data-role="speaker-preview"]');
+ if (previewButton) {
+ previewButton.dataset.voice = select.value || baseVoice || select.dataset.defaultVoice || "";
+ }
+ if (overrideId) {
+ markOverrideDirty(overrideId);
+ }
+ });
+
+ manualOverrideList.addEventListener("click", (event) => {
+ const previewButton = event.target.closest('[data-role="speaker-preview"]');
+ if (previewButton?.dataset.overrideId) {
+ void flushManualOverrides({ overrideId: previewButton.dataset.overrideId });
+ }
+ const deleteButton = event.target.closest('[data-role="manual-override-delete"]');
+ if (!deleteButton) return;
+ event.preventDefault();
+ const overrideId = deleteButton.dataset.overrideId;
+ if (!overrideId) return;
+ deleteManualOverride(overrideId);
+ });
+ }
+
+ const initialTab = tabButtons.find((button) => button.classList.contains("is-active"));
+ activateEntityTab(initialTab?.dataset.panel || "people");
+ renderEntitySummary();
+ renderManualOverrides();
+ renderHeteronymOverrides();
+ triggerEntitiesRefresh();
+ }
+
+ const handleDeferredSubmit = (event) => {
+ const hasDirty = dirtyOverrideIds.size > 0;
+ const hasPendingFlush = Boolean(overrideFlushPromise);
+ if (!hasDirty && !hasPendingFlush) return;
+ if (form.dataset.skipDirtyFlush === "true") {
+ delete form.dataset.skipDirtyFlush;
+ return;
+ }
+ event.preventDefault();
+ const submitter = event.submitter || null;
+ const resumeSubmission = () => {
+ form.dataset.skipDirtyFlush = "true";
+ if (typeof form.requestSubmit === "function") {
+ form.requestSubmit(submitter || undefined);
+ } else if (submitter && typeof submitter.click === "function") {
+ submitter.click();
+ } else if (typeof form.submit === "function") {
+ form.submit();
+ }
+ };
+
+ const flushPromise = overrideFlushPromise || flushManualOverrides();
+ if (!flushPromise) {
+ resumeSubmission();
+ return;
+ }
+ flushPromise.finally(resumeSubmission);
+ };
+
+ form.addEventListener("submit", handleDeferredSubmit);
+
+ form.addEventListener("click", (event) => {
+ const previewFromOverride = event.target.closest('[data-role="speaker-preview"]');
+ if (previewFromOverride) {
+ const entityRow = previewFromOverride.closest('[data-role="entity-row"]');
+ const inlineOverride = entityRow?.querySelector('[data-role="inline-override"]');
+ if (inlineOverride && !inlineOverride.hidden) {
+ const inlineState = extractInlineOverrideState(inlineOverride, entityRow);
+ syncInlinePreviewUI(entityRow, inlineOverride, inlineState, previewFromOverride);
+ void persistInlineOverrideState(inlineState);
+ }
+ }
+ if (previewFromOverride?.dataset.overrideId) {
+ void flushManualOverrides({ overrideId: previewFromOverride.dataset.overrideId });
+ }
+ const genderMenu = event.target.closest('[data-role="gender-menu"]');
+ const genderPill = event.target.closest('[data-role="gender-pill"]');
+ if (!genderMenu && !genderPill) {
+ hideGenderMenus();
+ }
+
+ if (genderPill) {
+ event.preventDefault();
+ const menu = genderPill.parentElement?.querySelector('[data-role="gender-menu"]');
+ const isOpen = menu && !menu.hidden;
+ hideGenderMenus();
+ if (menu && !isOpen) {
+ menu.hidden = false;
+ menu.setAttribute("aria-hidden", "false");
+ genderPill.classList.add("is-open");
+ }
+ return;
+ }
+
+ const genderOption = event.target.closest('[data-role="gender-option"]');
+ if (genderOption) {
+ event.preventDefault();
+ const container = genderOption.closest('[data-role="speaker-gender"]');
+ setGenderForSpeaker(container, genderOption.dataset.value);
+ hideGenderMenus();
+ return;
+ }
+
+ const nextSampleButton = event.target.closest('[data-role="speaker-next-sample"]');
+ if (nextSampleButton) {
+ event.preventDefault();
+ const container = nextSampleButton.closest(".speaker-list__item");
+ if (!container) return;
+ const currentIndex = sampleIndexState.get(container) || 0;
+ setSpeakerSample(container, currentIndex + 1);
+ return;
+ }
+
+ const clearMixButton = event.target.closest('[data-role="clear-mix"]');
+ if (clearMixButton) {
+ event.preventDefault();
+ const container = clearMixButton.closest(".speaker-list__item");
+ applyFormulaToSpeaker(container, "");
+ return;
+ }
+
+ const generateButton = event.target.closest('[data-role="generate-voice"]');
+ if (generateButton) {
+ event.preventDefault();
+ const container = generateButton.closest(".speaker-list__item");
+ if (!container) return;
+ const genderInput = container.querySelector('[data-role="gender-input"]');
+ const genderValue = genderInput?.value || "unknown";
+ const mix = buildRandomMix(genderValue);
+ if (!mix) {
+ console.warn("No voices available to generate a mix for", genderValue);
+ return;
+ }
+ const formula = formatMix(normaliseMix(mix));
+ applyFormulaToSpeaker(container, formula);
+ return;
+ }
+
+ const modalTrigger = event.target.closest('[data-role="open-voice-browser"]');
+ if (modalTrigger) {
+ event.preventDefault();
+ const container = modalTrigger.closest(".speaker-list__item");
+ if (!container) return;
+ const sampleIndex = Number.parseInt(modalTrigger.dataset.sampleIndex || "0", 10);
+ openVoiceBrowser(container, Number.isNaN(sampleIndex) ? 0 : sampleIndex);
+ return;
+ }
+
+ const chip = event.target.closest('[data-role="recommended-voice"]');
+ if (!chip) return;
+ event.preventDefault();
+ const container = chip.closest(".speaker-list__item");
+ if (!container) return;
+ const select = container.querySelector('[data-role="speaker-voice"]');
+ if (!select) return;
+ select.value = chip.dataset.voice || "";
+ select.dispatchEvent(new Event("change", { bubbles: true }));
+ select.dataset.prevManual = select.value || "";
+ });
+
+ form.addEventListener("input", (event) => {
+ const inlineOverride = event.target.closest('[data-role="inline-override"]');
+ if (!inlineOverride || inlineOverride.hidden) {
+ return;
+ }
+ const entityRow = inlineOverride.closest('[data-role="entity-row"]');
+ const inlineState = extractInlineOverrideState(inlineOverride, entityRow);
+ syncInlinePreviewUI(entityRow, inlineOverride, inlineState);
+ if (inlineState) {
+ setManualOverrideStatus("Unsaved changes", "pending");
+ }
+ });
+
+ form.addEventListener("change", (event) => {
+ const inlineOverride = event.target.closest('[data-role="inline-override"]');
+ if (!inlineOverride || inlineOverride.hidden) {
+ return;
+ }
+ const entityRow = inlineOverride.closest('[data-role="entity-row"]');
+ const inlineState = extractInlineOverrideState(inlineOverride, entityRow);
+ syncInlinePreviewUI(entityRow, inlineOverride, inlineState);
+ if (inlineState) {
+ setManualOverrideStatus("Unsaved changes", "pending");
+ }
+ });
+
+ document.addEventListener("click", (event) => {
+ if (!form.contains(event.target)) {
+ hideGenderMenus();
+ }
+ });
+};
+
+window.AbogenPrepare = window.AbogenPrepare || {};
+window.AbogenPrepare.init = initPrepare;
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", () => initPrepare());
+} else {
+ initPrepare();
+}
diff --git a/abogen/webui/static/queue.js b/abogen/webui/static/queue.js
new file mode 100644
index 0000000..184467a
--- /dev/null
+++ b/abogen/webui/static/queue.js
@@ -0,0 +1,45 @@
+import { initReaderUI } from "./reader.js";
+
+const queueState = (window.AbogenQueueState = window.AbogenQueueState || {
+ boundOverwritePrompt: false,
+});
+
+const handleOverwritePrompt = (event) => {
+ const detail = event?.detail || {};
+ const title = detail.title || "this item";
+ const message = detail.message || `Audiobookshelf already has "${title}". Overwrite?`;
+ if (!window.confirm(message)) {
+ return;
+ }
+
+ const url = detail.url;
+ if (!url || typeof htmx === "undefined") {
+ return;
+ }
+
+ const target = detail.target || "#jobs-panel";
+ const values = { overwrite: "true" };
+ if (detail.values && typeof detail.values === "object") {
+ Object.assign(values, detail.values);
+ }
+
+ htmx.ajax("POST", url, {
+ target,
+ swap: "innerHTML",
+ values,
+ });
+};
+
+const initQueuePage = () => {
+ initReaderUI();
+ if (!queueState.boundOverwritePrompt) {
+ queueState.boundOverwritePrompt = true;
+ document.addEventListener("audiobookshelf-overwrite-prompt", handleOverwritePrompt);
+ }
+};
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", initQueuePage, { once: true });
+} else {
+ initQueuePage();
+}
diff --git a/abogen/webui/static/reader.js b/abogen/webui/static/reader.js
new file mode 100644
index 0000000..fd26820
--- /dev/null
+++ b/abogen/webui/static/reader.js
@@ -0,0 +1,221 @@
+const readerButtonRegistry = new WeakSet();
+let initialized = false;
+let readerModal = null;
+let readerFrame = null;
+let readerHint = null;
+let readerTitle = null;
+let readerTrigger = null;
+let defaultReaderHint = "";
+
+const resolveEventMatch = (event, selector) => {
+ const target = event.target;
+ if (target instanceof Element) {
+ const match = target.closest(selector);
+ if (match) {
+ return match;
+ }
+ }
+ const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+ for (const node of path) {
+ if (node instanceof Element) {
+ if (node.matches(selector)) {
+ return node;
+ }
+ const match = node.closest(selector);
+ if (match) {
+ return match;
+ }
+ }
+ }
+ return null;
+};
+
+const closeReaderModal = () => {
+ if (!readerModal) {
+ return;
+ }
+ if (readerModal.hidden) {
+ return;
+ }
+ readerModal.hidden = true;
+ readerModal.removeAttribute("data-open");
+ document.body.classList.remove("modal-open");
+ if (readerFrame) {
+ const frameWindow = readerFrame.contentWindow;
+ if (frameWindow) {
+ try {
+ frameWindow.postMessage({ type: "abogen:reader:pause", currentTime: 0 }, window.location.origin);
+ } catch (error) {
+ // Ignore cross-origin messaging errors.
+ }
+ }
+ window.setTimeout(() => {
+ readerFrame.src = "about:blank";
+ }, 75);
+ }
+ if (readerHint && defaultReaderHint) {
+ readerHint.textContent = defaultReaderHint;
+ }
+ if (readerTitle) {
+ readerTitle.textContent = "Read & listen";
+ }
+ if (readerTrigger instanceof HTMLElement) {
+ try {
+ readerTrigger.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus errors.
+ }
+ }
+ readerTrigger = null;
+};
+
+const createBindReaderButtons = (openReaderModal) => {
+ return (root) => {
+ const context = root instanceof Element ? root : document;
+ const buttons = context.querySelectorAll('[data-role="open-reader"]');
+ buttons.forEach((button) => {
+ if (!(button instanceof HTMLElement)) {
+ return;
+ }
+ if (readerButtonRegistry.has(button)) {
+ return;
+ }
+ button.addEventListener("click", (event) => {
+ event.preventDefault();
+ openReaderModal(button);
+ });
+ readerButtonRegistry.add(button);
+ });
+ };
+};
+
+export const initReaderUI = (options = {}) => {
+ if (initialized) {
+ return {
+ bindReaderButtons: createBindReaderButtons((trigger) => {
+ if (typeof options.onBeforeOpen === "function") {
+ options.onBeforeOpen();
+ }
+ openReader(trigger, options);
+ }),
+ closeReaderModal,
+ };
+ }
+
+ readerModal = document.querySelector('[data-role="reader-modal"]');
+ readerFrame = readerModal?.querySelector('[data-role="reader-frame"]') || null;
+ readerHint = readerModal?.querySelector('[data-role="reader-modal-hint"]') || null;
+ readerTitle = readerModal?.querySelector('#reader-modal-title') || null;
+ defaultReaderHint = readerHint?.textContent || "";
+
+ const openReaderModal = (trigger) => {
+ if (typeof options.onBeforeOpen === "function") {
+ options.onBeforeOpen();
+ }
+ if (!(trigger instanceof HTMLElement)) {
+ return;
+ }
+ const url = trigger.dataset.readerUrl || "";
+ if (!url) {
+ return;
+ }
+ if (!readerModal || !readerFrame) {
+ window.open(url, "_blank", "noopener,noreferrer");
+ return;
+ }
+ readerTrigger = trigger;
+ const bookTitle = trigger.dataset.bookTitle || "";
+ if (readerTitle) {
+ readerTitle.textContent = bookTitle ? `${bookTitle} · reader` : "Read & listen";
+ }
+ if (readerHint) {
+ readerHint.textContent = bookTitle
+ ? `Preview ${bookTitle} directly in your browser.`
+ : defaultReaderHint;
+ }
+ readerModal.hidden = false;
+ readerModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ readerFrame.src = url;
+ try {
+ readerFrame.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus errors.
+ }
+ };
+
+ const bindReaderButtons = createBindReaderButtons(openReaderModal);
+ bindReaderButtons();
+
+ document.addEventListener("click", (event) => {
+ const closeButton = resolveEventMatch(event, '[data-role="reader-modal-close"]');
+ if (closeButton) {
+ event.preventDefault();
+ closeReaderModal();
+ return;
+ }
+ const trigger = resolveEventMatch(event, '[data-role="open-reader"]');
+ if (trigger instanceof HTMLElement) {
+ event.preventDefault();
+ openReaderModal(trigger);
+ }
+ });
+
+ document.addEventListener("keydown", (event) => {
+ if (event.key === "Escape") {
+ closeReaderModal();
+ }
+ });
+
+ document.addEventListener("htmx:afterSwap", (event) => {
+ const fragment = event?.detail?.target;
+ if (fragment instanceof Element) {
+ bindReaderButtons(fragment);
+ } else {
+ bindReaderButtons();
+ }
+ });
+
+ initialized = true;
+
+ return {
+ bindReaderButtons,
+ closeReaderModal,
+ };
+};
+
+const openReader = (trigger, options) => {
+ if (typeof options.onBeforeOpen === "function") {
+ options.onBeforeOpen();
+ }
+ if (!(trigger instanceof HTMLElement)) {
+ return;
+ }
+ const url = trigger.dataset.readerUrl || "";
+ if (!url) {
+ return;
+ }
+ if (!readerModal || !readerFrame) {
+ window.open(url, "_blank", "noopener,noreferrer");
+ return;
+ }
+ readerTrigger = trigger;
+ const bookTitle = trigger.dataset.bookTitle || "";
+ if (readerTitle) {
+ readerTitle.textContent = bookTitle ? `${bookTitle} · reader` : "Read & listen";
+ }
+ if (readerHint) {
+ readerHint.textContent = bookTitle
+ ? `Preview ${bookTitle} directly in your browser.`
+ : defaultReaderHint;
+ }
+ readerModal.hidden = false;
+ readerModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ readerFrame.src = url;
+ try {
+ readerFrame.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus errors.
+ }
+};
diff --git a/abogen/webui/static/settings.js b/abogen/webui/static/settings.js
new file mode 100644
index 0000000..4a3e187
--- /dev/null
+++ b/abogen/webui/static/settings.js
@@ -0,0 +1,882 @@
+const form = document.querySelector('.settings__form');
+const navButtons = Array.from(document.querySelectorAll('.settings-nav__item'));
+const panels = Array.from(document.querySelectorAll('.settings-panel'));
+const llmNavButton = navButtons.find((button) => button.dataset.section === 'llm');
+
+const statusSelectors = {
+ llm: document.querySelector('[data-role="llm-preview-status"]'),
+ normalization: document.querySelector('[data-role="normalization-preview-status"]'),
+ calibre: document.querySelector('[data-role="calibre-test-status"]'),
+ audiobookshelf: document.querySelector('[data-role="audiobookshelf-test-status"]'),
+};
+
+const outputAreas = {
+ llm: document.querySelector('[data-role="llm-preview-output"]'),
+ normalization: document.querySelector('[data-role="normalization-preview-output"]'),
+};
+
+const normalizationAudio = document.querySelector('[data-role="normalization-preview-audio"]');
+
+const folderModal = document.querySelector('[data-role="audiobookshelf-folder-modal"]');
+const folderModalOverlay = folderModal ? folderModal.querySelector('[data-role="audiobookshelf-folder-overlay"]') : null;
+const folderList = folderModal ? folderModal.querySelector('[data-role="audiobookshelf-folder-list"]') : null;
+const folderStatusMessage = folderModal ? folderModal.querySelector('[data-role="audiobookshelf-folder-status"]') : null;
+const folderFilter = folderModal ? folderModal.querySelector('[data-role="audiobookshelf-folder-filter"]') : null;
+const folderEmptyState = folderModal ? folderModal.querySelector('[data-role="audiobookshelf-folder-empty"]') : null;
+const defaultFolderEmptyMessage = folderEmptyState ? folderEmptyState.textContent : 'No folders match your filter.';
+let folderModalOpener = null;
+let folderModalPreviousFocus = null;
+let audiobookshelfFolderSource = [];
+
+const contractionModal = document.querySelector('[data-role="contraction-modal"]');
+const contractionModalOverlay = contractionModal ? contractionModal.querySelector('[data-role="contraction-modal-overlay"]') : null;
+let contractionModalOpener = null;
+let contractionModalPreviousFocus = null;
+
+function setStatus(target, message, state) {
+ if (!target) {
+ return;
+ }
+ target.textContent = message || '';
+ if (state) {
+ target.dataset.state = state;
+ } else {
+ delete target.dataset.state;
+ }
+}
+
+function clearStatus(target) {
+ setStatus(target, '', null);
+}
+
+function activatePanel(section) {
+ if (!section) {
+ return;
+ }
+ navButtons.forEach((button) => {
+ const isActive = button.dataset.section === section;
+ button.classList.toggle('is-active', isActive);
+ });
+ let activePanel = null;
+ panels.forEach((panel) => {
+ const isActive = panel.dataset.section === section;
+ panel.classList.toggle('is-active', isActive);
+ if (isActive) {
+ activePanel = panel;
+ }
+ });
+ if (activePanel) {
+ const focusable = activePanel.querySelector('input, select, textarea');
+ if (focusable) {
+ window.requestAnimationFrame(() => {
+ focusable.focus({ preventScroll: false });
+ });
+ }
+ }
+}
+
+function initNavigation() {
+ if (!navButtons.length || !panels.length) {
+ return;
+ }
+ navButtons.forEach((button) => {
+ button.addEventListener('click', () => {
+ activatePanel(button.dataset.section);
+ if (button.dataset.section) {
+ window.history.replaceState(null, '', `#${button.dataset.section}`);
+ }
+ });
+ });
+ const hash = window.location.hash.replace('#', '');
+ if (hash && panels.some((panel) => panel.dataset.section === hash)) {
+ activatePanel(hash);
+ } else {
+ const current = navButtons.find((button) => button.classList.contains('is-active'));
+ if (current) {
+ activatePanel(current.dataset.section);
+ }
+ }
+ window.addEventListener('hashchange', () => {
+ const section = window.location.hash.replace('#', '');
+ if (section) {
+ activatePanel(section);
+ }
+ });
+}
+
+function parseNumber(value, fallback) {
+ const parsed = Number.parseFloat(value);
+ return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function normalizeFolderToken(value) {
+ return String(value || '').trim().toLowerCase();
+}
+
+function setFolderModalStatus(message, state) {
+ if (!folderStatusMessage) {
+ return;
+ }
+ folderStatusMessage.textContent = message || '';
+ if (state) {
+ folderStatusMessage.dataset.state = state;
+ folderStatusMessage.hidden = false;
+ } else {
+ delete folderStatusMessage.dataset.state;
+ folderStatusMessage.hidden = !message;
+ }
+}
+
+function clearFolderModalContents() {
+ if (folderList) {
+ folderList.innerHTML = '';
+ }
+ if (folderEmptyState) {
+ folderEmptyState.textContent = defaultFolderEmptyMessage;
+ folderEmptyState.hidden = true;
+ }
+}
+
+function openFolderModal(opener) {
+ if (!folderModal) {
+ return;
+ }
+ folderModalOpener = opener || null;
+ folderModalPreviousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+ folderModal.hidden = false;
+ folderModal.dataset.open = 'true';
+ document.body.classList.add('modal-open');
+ if (folderFilter) {
+ folderFilter.value = '';
+ folderFilter.disabled = true;
+ }
+ clearFolderModalContents();
+ setFolderModalStatus('Loading folders...', 'loading');
+}
+
+function closeFolderModal(event) {
+ if (event) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ if (!folderModal || folderModal.hidden) {
+ return;
+ }
+ folderModal.dataset.open = 'false';
+ folderModal.hidden = true;
+ document.body.classList.remove('modal-open');
+ audiobookshelfFolderSource = [];
+ if (folderFilter) {
+ folderFilter.value = '';
+ folderFilter.disabled = false;
+ }
+ clearFolderModalContents();
+ setFolderModalStatus('', null);
+ const focusTarget = folderModalPreviousFocus && typeof folderModalPreviousFocus.focus === 'function'
+ ? folderModalPreviousFocus
+ : folderModalOpener;
+ if (focusTarget && typeof focusTarget.focus === 'function') {
+ focusTarget.focus({ preventScroll: false });
+ }
+ folderModalPreviousFocus = null;
+ folderModalOpener = null;
+}
+
+function openContractionModal(opener) {
+ if (!contractionModal) {
+ return;
+ }
+ contractionModalOpener = opener || null;
+ contractionModalPreviousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+ contractionModal.hidden = false;
+ contractionModal.dataset.open = 'true';
+ document.body.classList.add('modal-open');
+ const focusTarget = contractionModal.querySelector('input, button, select, textarea');
+ if (focusTarget instanceof HTMLElement) {
+ focusTarget.focus({ preventScroll: true });
+ }
+}
+
+function closeContractionModal(event) {
+ if (event) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ if (!contractionModal || contractionModal.hidden) {
+ return;
+ }
+ contractionModal.dataset.open = 'false';
+ contractionModal.hidden = true;
+ document.body.classList.remove('modal-open');
+ const focusTarget =
+ (contractionModalPreviousFocus && typeof contractionModalPreviousFocus.focus === 'function'
+ ? contractionModalPreviousFocus
+ : contractionModalOpener) || null;
+ if (focusTarget && typeof focusTarget.focus === 'function') {
+ focusTarget.focus({ preventScroll: true });
+ }
+ contractionModalPreviousFocus = null;
+ contractionModalOpener = null;
+}
+
+function initContractionModal() {
+ if (!contractionModal) {
+ return;
+ }
+ const openButton = document.querySelector('[data-action="contraction-modal-open"]');
+ if (openButton) {
+ openButton.addEventListener('click', () => openContractionModal(openButton));
+ }
+ const closeButtons = contractionModal.querySelectorAll('[data-action="contraction-modal-close"]');
+ closeButtons.forEach((button) => {
+ button.addEventListener('click', closeContractionModal);
+ });
+ if (contractionModalOverlay) {
+ contractionModalOverlay.addEventListener('click', closeContractionModal);
+ }
+ contractionModal.addEventListener('keydown', (event) => {
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ closeContractionModal(event);
+ }
+ });
+}
+
+function renderFolderList(query) {
+ if (!folderList) {
+ return;
+ }
+ folderList.innerHTML = '';
+ const normalizedQuery = normalizeFolderToken(query);
+ const matches = audiobookshelfFolderSource.filter((entry) => {
+ const tokens = [
+ normalizeFolderToken(entry.name),
+ normalizeFolderToken(entry.path),
+ normalizeFolderToken(entry.id),
+ ];
+ return !normalizedQuery || tokens.some((token) => token.includes(normalizedQuery));
+ });
+ if (!matches.length) {
+ if (folderEmptyState) {
+ folderEmptyState.textContent = normalizedQuery ? defaultFolderEmptyMessage : 'No folders found for this library.';
+ folderEmptyState.hidden = false;
+ }
+ return;
+ }
+ if (folderEmptyState) {
+ folderEmptyState.textContent = defaultFolderEmptyMessage;
+ folderEmptyState.hidden = true;
+ }
+ matches.forEach((entry) => {
+ const button = document.createElement('button');
+ button.type = 'button';
+ button.className = 'folder-picker__item';
+ button.setAttribute('role', 'option');
+ if (entry.id) {
+ button.dataset.folderId = entry.id;
+ }
+ const displayName = entry.name || entry.path || entry.id || 'Unnamed folder';
+ const nameEl = document.createElement('span');
+ nameEl.className = 'folder-picker__item-name';
+ nameEl.textContent = displayName;
+ button.appendChild(nameEl);
+ if (entry.path && (!entry.name || entry.path.toLowerCase() !== entry.name.toLowerCase())) {
+ const pathEl = document.createElement('span');
+ pathEl.className = 'folder-picker__item-path';
+ pathEl.textContent = entry.path;
+ button.appendChild(pathEl);
+ }
+ if (entry.id) {
+ const idEl = document.createElement('span');
+ idEl.className = 'folder-picker__item-id';
+ idEl.textContent = entry.id;
+ button.appendChild(idEl);
+ }
+ button.addEventListener('click', () => handleFolderSelection(entry));
+ folderList.appendChild(button);
+ });
+}
+
+function populateFolderPicker(entries) {
+ audiobookshelfFolderSource = Array.isArray(entries) ? entries : [];
+ if (!audiobookshelfFolderSource.length) {
+ if (folderFilter) {
+ folderFilter.value = '';
+ folderFilter.disabled = true;
+ }
+ setFolderModalStatus('No folders found for this library.', 'info');
+ if (folderEmptyState) {
+ folderEmptyState.textContent = 'No folders found for this library.';
+ folderEmptyState.hidden = false;
+ }
+ return;
+ }
+ if (folderFilter) {
+ folderFilter.disabled = false;
+ folderFilter.value = '';
+ folderFilter.focus({ preventScroll: true });
+ }
+ setFolderModalStatus('', null);
+ if (folderEmptyState) {
+ folderEmptyState.textContent = defaultFolderEmptyMessage;
+ folderEmptyState.hidden = true;
+ }
+ renderFolderList('');
+}
+
+function handleFolderSelection(entry) {
+ const folderInput = form ? form.querySelector('#audiobookshelf_folder_id') : null;
+ if (folderInput) {
+ folderInput.value = entry.id || '';
+ folderInput.dispatchEvent(new Event('input', { bubbles: true }));
+ }
+ closeFolderModal();
+ const status = statusSelectors.audiobookshelf;
+ if (status) {
+ const label = entry.name || entry.path || entry.id || 'selected folder';
+ setStatus(status, `Selected folder '${label}'.`, 'success');
+ }
+}
+
+function initFolderPicker() {
+ if (!folderModal) {
+ return;
+ }
+ const closeButtons = folderModal.querySelectorAll('[data-action="audiobookshelf-folder-close"]');
+ closeButtons.forEach((button) => {
+ button.addEventListener('click', closeFolderModal);
+ });
+ if (folderModalOverlay) {
+ folderModalOverlay.addEventListener('click', closeFolderModal);
+ }
+ if (folderFilter) {
+ folderFilter.addEventListener('input', () => renderFolderList(folderFilter.value));
+ }
+ folderModal.addEventListener('keydown', (event) => {
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ closeFolderModal();
+ }
+ });
+}
+
+function collectLLMFields() {
+ const baseUrl = form.querySelector('#llm_base_url');
+ const apiKey = form.querySelector('#llm_api_key');
+ const model = form.querySelector('#llm_model');
+ const prompt = form.querySelector('#llm_prompt');
+ const timeout = form.querySelector('#llm_timeout');
+ const context = form.querySelector('input[name="llm_context_mode"]:checked');
+ return {
+ base_url: baseUrl ? baseUrl.value.trim() : '',
+ api_key: apiKey ? apiKey.value.trim() : '',
+ model: model ? model.value.trim() : '',
+ prompt: prompt ? prompt.value : '',
+ context_mode: context ? context.value : 'sentence',
+ timeout: timeout ? parseNumber(timeout.value, 30) : 30,
+ };
+}
+
+function updateModelOptions(models) {
+ const select = form.querySelector('#llm_model');
+ if (!select) {
+ return;
+ }
+ const current = select.dataset.currentModel || select.value;
+ select.innerHTML = '';
+ if (!Array.isArray(models) || !models.length) {
+ const option = document.createElement('option');
+ option.value = '';
+ option.textContent = 'No models found';
+ select.appendChild(option);
+ select.dataset.currentModel = '';
+ select.disabled = true;
+ return;
+ }
+ const fragment = document.createDocumentFragment();
+ let matchedCurrent = false;
+ models.forEach((entry) => {
+ let identifier = '';
+ let label = '';
+ if (typeof entry === 'string') {
+ identifier = entry;
+ label = entry;
+ } else if (entry && typeof entry === 'object') {
+ identifier = String(entry.id || entry.name || entry.label || '').trim();
+ label = String(entry.label || entry.name || identifier || '').trim();
+ }
+ if (!identifier) {
+ return;
+ }
+ if (!label) {
+ label = identifier;
+ }
+ const option = document.createElement('option');
+ option.value = identifier;
+ option.textContent = label;
+ if (identifier === current) {
+ option.selected = true;
+ matchedCurrent = true;
+ }
+ fragment.appendChild(option);
+ });
+ select.appendChild(fragment);
+ if (!matchedCurrent && select.options.length) {
+ select.selectedIndex = 0;
+ }
+ select.dataset.currentModel = select.value || '';
+ select.disabled = false;
+}
+
+async function refreshModels(button) {
+ const status = statusSelectors.llm;
+ const llmFields = collectLLMFields();
+ if (!llmFields.base_url) {
+ setStatus(status, 'Enter a base URL before refreshing models.', 'error');
+ return;
+ }
+ clearStatus(status);
+ setStatus(status, 'Fetching models…');
+ button.disabled = true;
+ try {
+ const response = await fetch('/api/llm/models', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ base_url: llmFields.base_url,
+ api_key: llmFields.api_key,
+ timeout: llmFields.timeout,
+ }),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Unable to load models.');
+ }
+ updateModelOptions(payload.models || []);
+ const count = Array.isArray(payload.models) ? payload.models.length : 0;
+ if (count) {
+ setStatus(status, `Loaded ${count} model${count === 1 ? '' : 's'}.`, 'success');
+ } else {
+ setStatus(status, 'No models were returned.', 'error');
+ }
+ } catch (error) {
+ setStatus(status, error instanceof Error ? error.message : 'Failed to load models.', 'error');
+ } finally {
+ button.disabled = false;
+ }
+}
+
+async function previewLLM(button) {
+ const status = statusSelectors.llm;
+ const output = outputAreas.llm;
+ const previewText = document.querySelector('#llm_preview_text');
+ if (!previewText) {
+ return;
+ }
+ const llmFields = collectLLMFields();
+ if (!llmFields.base_url) {
+ setStatus(status, 'Enter a base URL to preview.', 'error');
+ return;
+ }
+ if (!llmFields.model) {
+ setStatus(status, 'Select a model to preview.', 'error');
+ return;
+ }
+ const sample = previewText.value.trim();
+ if (!sample) {
+ setStatus(status, 'Add some sample text first.', 'error');
+ return;
+ }
+ clearStatus(status);
+ if (output) {
+ output.textContent = '';
+ }
+ setStatus(status, 'Generating preview…');
+ button.disabled = true;
+ try {
+ const response = await fetch('/api/llm/preview', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ text: sample,
+ base_url: llmFields.base_url,
+ api_key: llmFields.api_key,
+ model: llmFields.model,
+ prompt: llmFields.prompt,
+ context_mode: llmFields.context_mode,
+ timeout: llmFields.timeout,
+ }),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Preview failed.');
+ }
+ if (output) {
+ output.textContent = payload.normalized_text || '';
+ }
+ setStatus(status, 'Preview ready.', 'success');
+ } catch (error) {
+ if (output) {
+ output.textContent = '';
+ }
+ setStatus(status, error instanceof Error ? error.message : 'Preview failed.', 'error');
+ } finally {
+ button.disabled = false;
+ }
+}
+
+function collectNormalizationSettings() {
+ if (!form) {
+ return null;
+ }
+ const normalization = {
+ normalization_numbers: Boolean(form.querySelector('input[name="normalization_numbers"]')?.checked),
+ normalization_currency: Boolean(form.querySelector('input[name="normalization_currency"]')?.checked),
+ normalization_titles: Boolean(form.querySelector('input[name="normalization_titles"]')?.checked),
+ normalization_footnotes: Boolean(form.querySelector('input[name="normalization_footnotes"]')?.checked),
+ normalization_terminal: Boolean(form.querySelector('input[name="normalization_terminal"]')?.checked),
+ normalization_caps_quotes: Boolean(form.querySelector('input[name="normalization_caps_quotes"]')?.checked),
+ normalization_phoneme_hints: Boolean(form.querySelector('input[name="normalization_phoneme_hints"]')?.checked),
+ normalization_apostrophes_contractions: Boolean(form.querySelector('input[name="normalization_apostrophes_contractions"]')?.checked),
+ normalization_apostrophes_plural_possessives: Boolean(form.querySelector('input[name="normalization_apostrophes_plural_possessives"]')?.checked),
+ normalization_apostrophes_sibilant_possessives: Boolean(form.querySelector('input[name="normalization_apostrophes_sibilant_possessives"]')?.checked),
+ normalization_apostrophes_decades: Boolean(form.querySelector('input[name="normalization_apostrophes_decades"]')?.checked),
+ normalization_apostrophes_leading_elisions: Boolean(form.querySelector('input[name="normalization_apostrophes_leading_elisions"]')?.checked),
+ normalization_contraction_aux_be: Boolean(form.querySelector('input[name="normalization_contraction_aux_be"]')?.checked),
+ normalization_contraction_aux_have: Boolean(form.querySelector('input[name="normalization_contraction_aux_have"]')?.checked),
+ normalization_contraction_modal_will: Boolean(form.querySelector('input[name="normalization_contraction_modal_will"]')?.checked),
+ normalization_contraction_modal_would: Boolean(form.querySelector('input[name="normalization_contraction_modal_would"]')?.checked),
+ normalization_contraction_negation_not: Boolean(form.querySelector('input[name="normalization_contraction_negation_not"]')?.checked),
+ normalization_contraction_let_us: Boolean(form.querySelector('input[name="normalization_contraction_let_us"]')?.checked),
+ normalization_apostrophe_mode: form.querySelector('input[name="normalization_apostrophe_mode"]:checked')?.value || 'spacy',
+ };
+ return normalization;
+}
+
+function collectCalibreFields() {
+ if (!form) {
+ return {};
+ }
+ const enabled = Boolean(form.querySelector('input[name="calibre_opds_enabled"]')?.checked);
+ const baseUrl = form.querySelector('#calibre_opds_base_url')?.value?.trim() || '';
+ const username = form.querySelector('#calibre_opds_username')?.value?.trim() || '';
+ const passwordInput = form.querySelector('#calibre_opds_password');
+ const password = passwordInput ? passwordInput.value : '';
+ const hasSecret = passwordInput?.dataset.hasSecret === 'true';
+ const clearSaved = Boolean(form.querySelector('input[name="calibre_opds_password_clear"]')?.checked);
+ const useSavedPassword = !password && hasSecret && !clearSaved;
+ const verify = Boolean(form.querySelector('input[name="calibre_opds_verify_ssl"]')?.checked);
+ return {
+ enabled,
+ base_url: baseUrl,
+ username,
+ password,
+ verify_ssl: verify,
+ use_saved_password: useSavedPassword,
+ clear_saved_password: clearSaved,
+ };
+}
+
+function collectAudiobookshelfFields() {
+ if (!form) {
+ return {};
+ }
+ const baseUrl = form.querySelector('#audiobookshelf_base_url')?.value?.trim() || '';
+ const libraryId = form.querySelector('#audiobookshelf_library_id')?.value?.trim() || '';
+ const collectionId = form.querySelector('#audiobookshelf_collection_id')?.value?.trim() || '';
+ const folderId = form.querySelector('#audiobookshelf_folder_id')?.value?.trim() || '';
+ const tokenInput = form.querySelector('#audiobookshelf_api_token');
+ const apiToken = tokenInput?.value?.trim() || '';
+ const hasSecret = tokenInput?.dataset.hasSecret === 'true';
+ const clearToken = Boolean(form.querySelector('input[name="audiobookshelf_api_token_clear"]')?.checked);
+ const useSavedToken = !apiToken && hasSecret && !clearToken;
+ const timeoutInput = form.querySelector('#audiobookshelf_timeout');
+ const timeout = parseNumber(timeoutInput?.value, 30);
+ return {
+ enabled: Boolean(form.querySelector('input[name="audiobookshelf_enabled"]')?.checked),
+ auto_send: Boolean(form.querySelector('input[name="audiobookshelf_auto_send"]')?.checked),
+ verify_ssl: Boolean(form.querySelector('input[name="audiobookshelf_verify_ssl"]')?.checked),
+ base_url: baseUrl,
+ library_id: libraryId,
+ collection_id: collectionId,
+ folder_id: folderId,
+ api_token: apiToken,
+ use_saved_token: useSavedToken,
+ clear_saved_token: clearToken,
+ timeout,
+ send_cover: Boolean(form.querySelector('input[name="audiobookshelf_send_cover"]')?.checked),
+ send_chapters: Boolean(form.querySelector('input[name="audiobookshelf_send_chapters"]')?.checked),
+ send_subtitles: Boolean(form.querySelector('input[name="audiobookshelf_send_subtitles"]')?.checked),
+ };
+}
+
+function updateLLMNavState() {
+ if (!llmNavButton) {
+ return;
+ }
+ const fields = collectLLMFields();
+ if (fields.base_url && fields.api_key) {
+ llmNavButton.classList.remove('is-disabled');
+ } else {
+ llmNavButton.classList.add('is-disabled');
+ }
+}
+
+async function testCalibre(button) {
+ const status = statusSelectors.calibre;
+ const fields = collectCalibreFields();
+ if (!status) {
+ return;
+ }
+ if (!fields.base_url) {
+ setStatus(status, 'Enter a Calibre OPDS base URL to test.', 'error');
+ return;
+ }
+ clearStatus(status);
+ setStatus(status, 'Testing connection…');
+ button.disabled = true;
+ try {
+ const response = await fetch('/api/integrations/calibre-opds/test', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(fields),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Calibre test failed.');
+ }
+ setStatus(status, payload.message || 'Connection successful.', 'success');
+ } catch (error) {
+ setStatus(status, error instanceof Error ? error.message : 'Calibre test failed.', 'error');
+ } finally {
+ button.disabled = false;
+ }
+}
+
+async function testAudiobookshelf(button) {
+ const status = statusSelectors.audiobookshelf;
+ const fields = collectAudiobookshelfFields();
+ if (!status) {
+ return;
+ }
+ const hasToken = Boolean(fields.api_token) || Boolean(fields.use_saved_token);
+ if (!fields.base_url || !hasToken || !fields.library_id || !fields.folder_id) {
+ setStatus(status, 'Enter the base URL, API token, library ID, and folder name or ID to test.', 'error');
+ return;
+ }
+ clearStatus(status);
+ setStatus(status, 'Testing connection…');
+ button.disabled = true;
+ try {
+ const response = await fetch('/api/integrations/audiobookshelf/test', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(fields),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Audiobookshelf test failed.');
+ }
+ setStatus(status, payload.message || 'Connection successful.', 'success');
+ } catch (error) {
+ setStatus(status, error instanceof Error ? error.message : 'Audiobookshelf test failed.', 'error');
+ } finally {
+ button.disabled = false;
+ }
+}
+
+async function browseAudiobookshelfFolders(button) {
+ const status = statusSelectors.audiobookshelf;
+ const fields = collectAudiobookshelfFields();
+ if (!status) {
+ return;
+ }
+ const hasToken = Boolean(fields.api_token) || Boolean(fields.use_saved_token);
+ if (!fields.base_url || !hasToken || !fields.library_id) {
+ setStatus(status, 'Enter the base URL, API token, and library ID before browsing folders.', 'error');
+ return;
+ }
+ clearStatus(status);
+ openFolderModal(button);
+ if (!folderModal) {
+ setStatus(status, 'Folder picker is unavailable in this view.', 'error');
+ return;
+ }
+ button.disabled = true;
+ try {
+ const response = await fetch('/api/integrations/audiobookshelf/folders', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(fields),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Folder lookup failed.');
+ }
+ const folders = Array.isArray(payload.folders) ? payload.folders : [];
+ const modalActive = folderModal && !folderModal.hidden;
+ if (!folders.length) {
+ const message = payload.message || 'No folders found for this library.';
+ setStatus(status, message, 'info');
+ if (modalActive) {
+ clearFolderModalContents();
+ setFolderModalStatus(message, 'info');
+ }
+ return;
+ }
+ if (!modalActive) {
+ setStatus(status, 'Folders loaded.', 'info');
+ return;
+ }
+ populateFolderPicker(folders);
+ setStatus(status, 'Choose a folder below.', 'info');
+ } catch (error) {
+ const message = error instanceof Error ? error.message : 'Folder lookup failed.';
+ setStatus(status, message, 'error');
+ if (folderModal && !folderModal.hidden) {
+ clearFolderModalContents();
+ setFolderModalStatus(message, 'error');
+ }
+ } finally {
+ button.disabled = false;
+ }
+}
+
+async function previewNormalization(button) {
+ const status = statusSelectors.normalization;
+ const output = outputAreas.normalization;
+ const textArea = document.querySelector('#normalization_sample_text');
+ const voiceSelect = document.querySelector('#normalization_sample_voice');
+ if (!textArea) {
+ return;
+ }
+ const sample = textArea.value.trim();
+ if (!sample) {
+ setStatus(status, 'Enter some text to preview.', 'error');
+ return;
+ }
+ clearStatus(status);
+ if (output) {
+ output.textContent = '';
+ }
+ if (normalizationAudio) {
+ normalizationAudio.hidden = true;
+ normalizationAudio.removeAttribute('src');
+ }
+ setStatus(status, 'Building preview…');
+ const normalization = collectNormalizationSettings();
+ if (!normalization) {
+ setStatus(status, 'Unable to gather normalization settings.', 'error');
+ return;
+ }
+ const llmFields = collectLLMFields();
+ try {
+ const response = await fetch('/api/normalization/preview', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ text: sample,
+ voice: voiceSelect ? voiceSelect.value : undefined,
+ normalization,
+ llm: {
+ llm_base_url: llmFields.base_url,
+ llm_api_key: llmFields.api_key,
+ llm_model: llmFields.model,
+ llm_prompt: llmFields.prompt,
+ llm_context_mode: llmFields.context_mode,
+ llm_timeout: llmFields.timeout,
+ },
+ max_seconds: 8,
+ }),
+ });
+ const payload = await response.json();
+ if (!response.ok) {
+ throw new Error(payload.error || 'Preview failed.');
+ }
+ if (output) {
+ output.textContent = payload.normalized_text || '';
+ }
+ if (payload.audio_base64 && normalizationAudio) {
+ normalizationAudio.src = `data:audio/wav;base64,${payload.audio_base64}`;
+ normalizationAudio.hidden = false;
+ normalizationAudio.load();
+ normalizationAudio.play().catch(() => {
+ /* autoplay can fail; ignore */
+ });
+ }
+ setStatus(status, 'Preview updated.', 'success');
+ } catch (error) {
+ if (output) {
+ output.textContent = '';
+ }
+ if (normalizationAudio) {
+ normalizationAudio.hidden = true;
+ normalizationAudio.removeAttribute('src');
+ }
+ setStatus(status, error instanceof Error ? error.message : 'Preview failed.', 'error');
+ } finally {
+ button.disabled = false;
+ }
+}
+
+function initSampleSelector() {
+ const select = document.querySelector('#normalization_sample_select');
+ const textArea = document.querySelector('#normalization_sample_text');
+ if (!select || !textArea) {
+ return;
+ }
+ select.addEventListener('change', () => {
+ const option = select.selectedOptions[0];
+ if (option) {
+ textArea.value = option.value;
+ }
+ });
+}
+
+function initActions() {
+ const refreshButton = document.querySelector('[data-action="llm-refresh-models"]');
+ if (refreshButton) {
+ refreshButton.addEventListener('click', () => refreshModels(refreshButton));
+ }
+ const llmPreviewButton = document.querySelector('[data-action="llm-preview"]');
+ if (llmPreviewButton) {
+ llmPreviewButton.addEventListener('click', () => previewLLM(llmPreviewButton));
+ }
+ const normalizationButton = document.querySelector('[data-action="normalization-preview"]');
+ if (normalizationButton) {
+ normalizationButton.addEventListener('click', () => previewNormalization(normalizationButton));
+ }
+ const calibreTestButton = document.querySelector('[data-action="calibre-test"]');
+ if (calibreTestButton) {
+ calibreTestButton.addEventListener('click', () => testCalibre(calibreTestButton));
+ }
+ const audiobookshelfTestButton = document.querySelector('[data-action="audiobookshelf-test"]');
+ if (audiobookshelfTestButton) {
+ audiobookshelfTestButton.addEventListener('click', () => testAudiobookshelf(audiobookshelfTestButton));
+ }
+ const audiobookshelfBrowseButton = document.querySelector('[data-action="audiobookshelf-list-folders"]');
+ if (audiobookshelfBrowseButton) {
+ audiobookshelfBrowseButton.addEventListener('click', () => browseAudiobookshelfFolders(audiobookshelfBrowseButton));
+ }
+}
+
+function initLLMStateWatchers() {
+ const baseUrlInput = form.querySelector('#llm_base_url');
+ const apiKeyInput = form.querySelector('#llm_api_key');
+ if (!baseUrlInput || !apiKeyInput) {
+ return;
+ }
+ const handler = () => updateLLMNavState();
+ baseUrlInput.addEventListener('input', handler);
+ apiKeyInput.addEventListener('input', handler);
+ updateLLMNavState();
+}
+
+if (form) {
+ initNavigation();
+ initSampleSelector();
+ initActions();
+ initFolderPicker();
+ initContractionModal();
+ initLLMStateWatchers();
+}
diff --git a/abogen/webui/static/speaker-configs.js b/abogen/webui/static/speaker-configs.js
new file mode 100644
index 0000000..4185f21
--- /dev/null
+++ b/abogen/webui/static/speaker-configs.js
@@ -0,0 +1,97 @@
+const initSpeakerConfigsPage = () => {
+ const form = document.getElementById("speaker-config-form");
+ if (!form) return;
+
+ const rowsContainer = form.querySelector('[data-role="speaker-rows"]');
+ const template = document.getElementById("speaker-row-template");
+ const addButtons = form.querySelectorAll('[data-action="add-speaker"]');
+
+ const ensureEmptyState = () => {
+ if (!rowsContainer) return;
+ const hasRows = rowsContainer.querySelector('[data-role="speaker-row"]');
+ let emptyState = rowsContainer.querySelector('[data-role="empty-state"]');
+ if (hasRows && emptyState) {
+ emptyState.remove();
+ emptyState = null;
+ }
+ if (!hasRows && !emptyState) {
+ const placeholder = document.createElement("div");
+ placeholder.className = "speaker-config-rows__empty";
+ placeholder.dataset.role = "empty-state";
+ placeholder.textContent = "No speakers yet. Add your first character.";
+ rowsContainer.appendChild(placeholder);
+ }
+ };
+
+ const hydrateRow = (fragment, key) => {
+ const elements = fragment.querySelectorAll("[name], [id], label[for], [data-row-id]");
+ elements.forEach((el) => {
+ if (el.name) {
+ el.name = el.name.replace(/__ROW__/g, key);
+ }
+ if (el.id) {
+ el.id = el.id.replace(/__ROW__/g, key);
+ }
+ if (el.tagName === "LABEL") {
+ const forValue = el.getAttribute("for");
+ if (forValue) {
+ el.setAttribute("for", forValue.replace(/__ROW__/g, key));
+ }
+ }
+ if (el.dataset && el.dataset.rowId) {
+ el.dataset.rowId = key;
+ }
+ });
+
+ const hiddenId = fragment.querySelector(`input[name="speaker-${key}-id"]`);
+ if (hiddenId && !hiddenId.value) {
+ hiddenId.value = key;
+ }
+ const rowMarkers = fragment.querySelectorAll('input[name="speaker_rows"]');
+ rowMarkers.forEach((marker) => {
+ marker.value = key;
+ });
+ };
+
+ const addRow = () => {
+ if (!template || !rowsContainer) return;
+ const key = `row-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+ const fragment = template.content.cloneNode(true);
+ hydrateRow(fragment, key);
+ rowsContainer.appendChild(fragment);
+ ensureEmptyState();
+ const newRow = rowsContainer.querySelector(`[data-row-id="${key}"]`);
+ if (newRow) {
+ const input = newRow.querySelector("input[type=text]");
+ if (input) {
+ input.focus();
+ }
+ }
+ };
+
+ addButtons.forEach((button) => {
+ button.addEventListener("click", (event) => {
+ event.preventDefault();
+ addRow();
+ });
+ });
+
+ rowsContainer?.addEventListener("click", (event) => {
+ const removeButton = event.target.closest('[data-action="remove-speaker"]');
+ if (!removeButton) return;
+ event.preventDefault();
+ const row = removeButton.closest('[data-role="speaker-row"]');
+ if (row) {
+ row.remove();
+ ensureEmptyState();
+ }
+ });
+
+ ensureEmptyState();
+};
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", initSpeakerConfigsPage, { once: true });
+} else {
+ initSpeakerConfigsPage();
+}
diff --git a/abogen/webui/static/speakers.js b/abogen/webui/static/speakers.js
new file mode 100644
index 0000000..23affcb
--- /dev/null
+++ b/abogen/webui/static/speakers.js
@@ -0,0 +1,121 @@
+const audioElement = new Audio();
+let activeButton = null;
+let activeUrl = null;
+
+const setLoadingState = (button, isLoading) => {
+ if (!button) return;
+ button.disabled = isLoading;
+ if (isLoading) {
+ button.setAttribute("data-loading", "true");
+ } else {
+ button.removeAttribute("data-loading");
+ }
+};
+
+const stopCurrentPlayback = () => {
+ if (audioElement && !audioElement.paused) {
+ audioElement.pause();
+ }
+ if (activeUrl) {
+ URL.revokeObjectURL(activeUrl);
+ activeUrl = null;
+ }
+ if (activeButton) {
+ setLoadingState(activeButton, false);
+ activeButton = null;
+ }
+};
+
+const resolvePreviewText = (button) => {
+ const source = (button.dataset.previewSource || "").toLowerCase();
+ if (source === "pronunciation") {
+ const container = button.closest(".speaker-list__item");
+ if (container) {
+ const input = container.querySelector('[data-role="speaker-pronunciation"]');
+ const fallback = (container.dataset.defaultPronunciation || "").trim();
+ const value = (input?.value || "").trim() || fallback;
+ button.dataset.previewText = value;
+ return value;
+ }
+ }
+ return (button.dataset.previewText || "").trim();
+};
+
+audioElement.addEventListener("ended", () => {
+ stopCurrentPlayback();
+});
+
+audioElement.addEventListener("pause", () => {
+ if (audioElement.currentTime === 0 || audioElement.currentTime >= audioElement.duration) {
+ stopCurrentPlayback();
+ }
+});
+
+const playPreview = async (button) => {
+ const text = resolvePreviewText(button);
+ const voice = (button.dataset.voice || "").trim();
+ const language = (button.dataset.language || "a").trim() || "a";
+ const speedRaw = button.dataset.speed || "1";
+ const useGpu = (button.dataset.useGpu || "true") !== "false";
+ const speed = Number.parseFloat(speedRaw);
+
+ if (!text) {
+ console.warn("Skipping speaker preview: no text provided");
+ return;
+ }
+ if (!voice) {
+ console.warn("Skipping speaker preview: no voice provided");
+ return;
+ }
+
+ const payload = {
+ text,
+ voice,
+ language,
+ speed: Number.isFinite(speed) ? speed : 1.0,
+ use_gpu: useGpu,
+ max_seconds: 8,
+ };
+
+ const pendingId =
+ button.dataset.pendingId ||
+ button.closest("[data-pending-id]")?.dataset.pendingId ||
+ document.querySelector('[data-role="prepare-form"]')?.dataset.pendingId ||
+ "";
+ if (pendingId) {
+ payload.pending_id = pendingId;
+ }
+
+ stopCurrentPlayback();
+ activeButton = button;
+ setLoadingState(button, true);
+
+ try {
+ const response = await fetch("/api/speaker-preview", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ });
+ if (!response.ok) {
+ const message = await response.text();
+ throw new Error(message || `Preview failed with status ${response.status}`);
+ }
+ const blob = await response.blob();
+ activeUrl = URL.createObjectURL(blob);
+ audioElement.src = activeUrl;
+ await audioElement.play();
+ } catch (error) {
+ console.error("Failed to play speaker preview", error);
+ stopCurrentPlayback();
+ } finally {
+ setLoadingState(button, false);
+ }
+};
+
+document.addEventListener("click", (event) => {
+ const trigger = event.target.closest('[data-role="speaker-preview"]');
+ if (!trigger) return;
+ event.preventDefault();
+ if (trigger.disabled) return;
+ playPreview(trigger);
+});
diff --git a/abogen/webui/static/styles.css b/abogen/webui/static/styles.css
new file mode 100644
index 0000000..bc29982
--- /dev/null
+++ b/abogen/webui/static/styles.css
@@ -0,0 +1,4263 @@
+:root {
+ color-scheme: dark light;
+ --bg: #0f172a;
+ --bg-alt: #111c30;
+ --panel: rgba(255, 255, 255, 0.04);
+ --panel-border: rgba(148, 163, 184, 0.12);
+ --text: #e2e8f0;
+ --muted: #94a3b8;
+ --accent: #38bdf8;
+ --accent-strong: #0ea5e9;
+ --success: #34d399;
+ --danger: #f87171;
+ --warning: #fbbf24;
+ font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+body {
+ margin: 0;
+ min-height: 100vh;
+ background: radial-gradient(circle at 0% 0%, rgba(56, 189, 248, 0.12), transparent 40%),
+ radial-gradient(circle at 100% 0%, rgba(244, 114, 182, 0.08), transparent 45%),
+ var(--bg);
+ color: var(--text);
+ display: flex;
+ flex-direction: column;
+}
+
+.notice {
+ margin: 0 0 1.5rem;
+ padding: 0.9rem 1.1rem;
+ border-radius: 16px;
+ border: 1px solid rgba(56, 189, 248, 0.32);
+ background: rgba(14, 165, 233, 0.18);
+ color: var(--text);
+ font-size: 0.95rem;
+ box-shadow: 0 12px 30px rgba(8, 15, 32, 0.22);
+}
+
+.notice--success {
+ border-color: rgba(52, 211, 153, 0.42);
+ background: rgba(34, 197, 94, 0.18);
+}
+
+.notice--error {
+ border-color: rgba(248, 113, 113, 0.48);
+ background: rgba(248, 113, 113, 0.18);
+}
+
+.top-bar {
+ backdrop-filter: blur(20px);
+ background: linear-gradient(90deg, rgba(15, 23, 42, 0.9), rgba(30, 41, 59, 0.7));
+ padding: 1.25rem 3rem;
+ border-bottom: 1px solid var(--panel-border);
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ position: sticky;
+ top: 0;
+ z-index: 100;
+}
+
+.brand {
+ display: flex;
+ align-items: center;
+ gap: 1rem;
+}
+
+.brand__mark {
+ font-size: 1.75rem;
+}
+
+.brand__name {
+ font-size: 1.5rem;
+ font-weight: 600;
+ letter-spacing: 0.04em;
+}
+
+.brand__tagline {
+ color: var(--muted);
+ font-size: 0.9rem;
+ font-family: "Georgia", "Times New Roman", serif;
+ font-style: italic;
+}
+
+.top-actions .btn {
+ color: var(--accent);
+ text-decoration: none;
+ border: 1px solid transparent;
+ padding: 0.5rem 1rem;
+ border-radius: 999px;
+ transition: all 0.2s ease;
+}
+
+.top-actions .btn:hover {
+ border-color: var(--accent);
+ background: rgba(56, 189, 248, 0.1);
+}
+
+.top-actions .btn.is-active {
+ border-color: var(--accent);
+ background: rgba(56, 189, 248, 0.18);
+ color: #fff;
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.12);
+}
+
+.main {
+ flex: 1;
+ padding: 2.5rem 3rem 3.5rem;
+ max-width: 1100px;
+ width: 100%;
+ margin: 0 auto;
+ display: grid;
+ gap: 2rem;
+}
+
+.footer {
+ padding: 1.5rem 3rem;
+ display: flex;
+ justify-content: center;
+ gap: 0.75rem;
+ color: var(--muted);
+ border-top: 1px solid var(--panel-border);
+ background: rgba(15, 23, 42, 0.8);
+}
+
+.footer a {
+ color: var(--accent);
+ text-decoration: none;
+}
+
+.card {
+ background: var(--panel);
+ border: 1px solid var(--panel-border);
+ border-radius: 28px;
+ padding: 2rem;
+ box-shadow: 0 20px 50px rgba(8, 15, 32, 0.35);
+ position: relative;
+ overflow: hidden;
+ z-index: 0;
+}
+
+.card::before {
+ content: "";
+ position: absolute;
+ inset: 0;
+ background: radial-gradient(circle at 0% 0%, rgba(56, 189, 248, 0.15), transparent 55%);
+ pointer-events: none;
+ z-index: -1;
+}
+
+.card--workflow {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.upload-card__dropzone {
+ border: 1.5px dashed rgba(148, 163, 184, 0.3);
+ border-radius: 24px;
+ background: rgba(15, 23, 42, 0.28);
+ padding: 2.75rem 2rem;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ text-align: center;
+ cursor: pointer;
+ transition: border-color 0.2s ease, background 0.2s ease, box-shadow 0.2s ease;
+ outline: none;
+}
+
+.upload-card__dropzone:hover,
+.upload-card__dropzone:focus-visible {
+ border-color: rgba(56, 189, 248, 0.6);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.12);
+}
+
+.upload-card__dropzone.is-dragging {
+ border-color: rgba(56, 189, 248, 0.85);
+ background: rgba(15, 23, 42, 0.45);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.18);
+}
+
+.upload-card__dropzone-content {
+ display: grid;
+ gap: 0.75rem;
+ justify-items: center;
+ max-width: 420px;
+}
+
+.upload-card__icon {
+ font-size: 2rem;
+ line-height: 1;
+ padding: 0.55rem 0.7rem;
+ border-radius: 999px;
+ background: rgba(56, 189, 248, 0.12);
+ color: var(--accent);
+}
+
+.upload-card__headline {
+ margin: 0;
+ font-size: 1.1rem;
+ font-weight: 600;
+}
+
+.upload-card__hint {
+ margin: 0;
+ color: var(--muted);
+}
+
+.upload-card__filename {
+ margin: 0;
+ color: var(--accent);
+ font-weight: 500;
+}
+
+.upload-card__filename[data-state="error"] {
+ color: var(--danger);
+}
+
+.upload-card__dropzone .button {
+ margin-top: 0.25rem;
+}
+
+.card__actions {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+}
+
+.card__actions .button {
+ padding: 0.7rem 1.1rem;
+ font-size: 0.95rem;
+ border-radius: 12px;
+ box-shadow: 0 8px 22px rgba(56, 189, 248, 0.18);
+}
+
+.card__actions .button:hover {
+ box-shadow: 0 12px 26px rgba(14, 165, 233, 0.24);
+}
+
+.card--modal {
+ padding: 0;
+ border-radius: 28px;
+ overflow: hidden;
+}
+
+.modal {
+ position: fixed;
+ inset: 0;
+ padding: 2rem;
+ display: none;
+ align-items: center;
+ justify-content: center;
+ z-index: 300;
+ overflow-y: auto;
+}
+
+.modal[data-open="true"] {
+ display: flex;
+}
+
+.modal[hidden] {
+ display: none !important;
+}
+
+/* Ensure the HTML hidden attribute always wins over component display rules. */
+[hidden] {
+ display: none !important;
+}
+
+.modal__overlay {
+ position: absolute;
+ inset: 0;
+ background: rgba(15, 23, 42, 0.74);
+ backdrop-filter: blur(8px);
+}
+
+.modal__content {
+ position: relative;
+ width: min(95vw, 1120px);
+ max-height: 90vh;
+ display: flex;
+ flex-direction: column;
+ box-shadow: 0 30px 70px rgba(7, 14, 32, 0.55);
+ border-radius: 24px;
+ overflow: hidden;
+}
+
+.modal__header {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 1.5rem;
+ padding: 1.75rem 2rem 0;
+}
+
+.modal__heading {
+ display: grid;
+ gap: 0.5rem;
+}
+
+.modal__eyebrow {
+ margin: 0;
+ text-transform: uppercase;
+ letter-spacing: 0.12em;
+ font-size: 0.75rem;
+ color: var(--muted);
+}
+
+.modal__title {
+ margin: 0;
+ font-size: 1.6rem;
+ font-weight: 600;
+}
+
+.modal__body {
+ padding: 1.5rem 2rem 2rem;
+ overflow-y: auto;
+ display: flex;
+ flex-direction: column;
+ gap: 1.5rem;
+ flex: 1 1 auto;
+ min-height: 0;
+}
+
+.modal__footer {
+ display: flex;
+ justify-content: flex-end;
+ gap: 0.75rem;
+ padding: 1.25rem 2rem 2.75rem;
+ border-top: 1px solid rgba(148, 163, 184, 0.12);
+ background: linear-gradient(180deg, transparent, rgba(15, 23, 42, 0.3));
+}
+
+.modal-open {
+ overflow: hidden;
+}
+
+.modal__content.voice-browser {
+ padding: 0;
+ border-radius: 28px;
+}
+
+.modal__content.folder-picker-modal {
+ width: min(600px, 95vw);
+}
+
+.folder-picker {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.folder-picker__controls {
+ display: flex;
+ align-items: center;
+}
+
+.folder-picker__controls input {
+ width: 100%;
+}
+
+.folder-picker__status {
+ margin: 0;
+ font-size: 0.9rem;
+ color: var(--muted);
+}
+
+.folder-picker__status[data-state="loading"] {
+ color: var(--muted);
+}
+
+.folder-picker__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.folder-picker__status[data-state="info"],
+.folder-picker__status[data-state="success"] {
+ color: var(--accent);
+}
+
+.folder-picker__list {
+ display: flex;
+ flex-direction: column;
+ gap: 0.65rem;
+ max-height: 20rem;
+ overflow-y: auto;
+ padding-right: 0.25rem;
+}
+
+.folder-picker__item {
+ display: flex;
+ flex-direction: column;
+ align-items: flex-start;
+ gap: 0.25rem;
+ width: 100%;
+ border: 1px solid rgba(148, 163, 184, 0.22);
+ border-radius: 16px;
+ background: rgba(15, 23, 42, 0.6);
+ padding: 0.8rem 1rem;
+ color: var(--text);
+ cursor: pointer;
+ transition: border-color 0.2s ease, box-shadow 0.2s ease, transform 0.2s ease;
+}
+
+.folder-picker__item:hover,
+.folder-picker__item:focus-visible {
+ border-color: rgba(56, 189, 248, 0.5);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.12);
+ outline: none;
+ transform: translateY(-1px);
+}
+
+.folder-picker__item-name {
+ font-weight: 600;
+ font-size: 1rem;
+}
+
+.folder-picker__item-path {
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.folder-picker__item-id {
+ font-size: 0.75rem;
+ color: var(--muted);
+ background: rgba(148, 163, 184, 0.18);
+ padding: 0.15rem 0.4rem;
+ border-radius: 999px;
+}
+
+.folder-picker__empty {
+ margin: 0;
+ font-size: 0.9rem;
+ color: var(--muted);
+}
+
+.reader-modal {
+ width: min(960px, 95vw);
+ height: min(90vh, 720px);
+ display: flex;
+ flex-direction: column;
+}
+
+.visually-hidden {
+ position: absolute;
+ width: 1px;
+ height: 1px;
+ padding: 0;
+ margin: -1px;
+ overflow: hidden;
+ clip: rect(0, 0, 0, 0);
+ white-space: nowrap;
+ border: 0;
+}
+
+.find-books__body {
+ display: grid;
+ gap: 1.75rem;
+}
+
+@media (min-width: 960px) {
+ .find-books__body {
+ grid-template-columns: 1fr 320px;
+ align-items: start;
+ }
+}
+
+.find-books__resources {
+ display: grid;
+ gap: 1.5rem;
+}
+
+.resource-tile {
+ background: rgba(15, 23, 42, 0.32);
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 20px;
+ padding: 1.5rem;
+ display: grid;
+ gap: 0.85rem;
+ box-shadow: 0 18px 40px rgba(8, 15, 32, 0.28);
+}
+
+.resource-tile h2 {
+ margin: 0;
+ font-size: 1.1rem;
+ font-weight: 600;
+}
+
+.resource-tile p {
+ margin: 0;
+ color: var(--muted);
+ line-height: 1.55;
+}
+
+.resource-tile .button {
+ align-self: start;
+}
+
+.resource-tile .hint {
+ font-size: 0.85rem;
+}
+
+.find-books__opds {
+ border: 1px dashed rgba(148, 163, 184, 0.22);
+ border-radius: 20px;
+ padding: 1.5rem;
+ display: grid;
+ gap: 0.9rem;
+ background: rgba(15, 23, 42, 0.22);
+}
+
+.find-books__opds h2 {
+ margin: 0;
+ font-size: 1.05rem;
+ font-weight: 600;
+}
+
+.find-books__opds .hint {
+ margin: 0;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.find-books__opds .button {
+ justify-self: start;
+}
+
+.opds-modal {
+ width: min(1020px, 95vw);
+ max-height: 88vh;
+}
+
+.opds-modal__header {
+ align-items: center;
+ flex-wrap: wrap;
+ gap: 1.25rem;
+}
+
+.opds-modal__search {
+ flex: 1 1 auto;
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+ align-items: center;
+}
+
+.opds-search__field {
+ position: relative;
+ flex: 1 1 280px;
+ display: flex;
+ align-items: center;
+ gap: 0.65rem;
+ background: rgba(15, 23, 42, 0.45);
+ border: 1px solid rgba(148, 163, 184, 0.22);
+ border-radius: 14px;
+ padding: 0.65rem 0.85rem;
+}
+
+.opds-search__field input[type="search"] {
+ flex: 1 1 auto;
+ background: transparent;
+ border: none;
+ color: var(--text);
+ font-size: 0.95rem;
+ outline: none;
+}
+
+.opds-search__field input[type="search"]::placeholder {
+ color: rgba(148, 163, 184, 0.7);
+}
+
+.opds-search__icon {
+ width: 18px;
+ height: 18px;
+ fill: rgba(148, 163, 184, 0.7);
+}
+
+.opds-search__actions {
+ display: flex;
+ gap: 0.5rem;
+}
+
+.opds-modal__close {
+ align-self: flex-start;
+}
+
+.opds-modal__tabs {
+ display: flex;
+ align-items: center;
+ gap: 0.6rem;
+ padding: 0 2rem 0.75rem;
+}
+
+.opds-modal__tabs.is-empty {
+ display: none;
+}
+
+.opds-tab {
+ border: 1px solid transparent;
+ border-radius: 999px;
+ padding: 0.4rem 0.95rem;
+ background: rgba(148, 163, 184, 0.12);
+ color: var(--text);
+ font-size: 0.9rem;
+ cursor: pointer;
+ transition: all 0.2s ease;
+}
+
+.opds-tab:hover {
+ border-color: rgba(56, 189, 248, 0.4);
+ background: rgba(56, 189, 248, 0.12);
+}
+
+.opds-tab.is-active {
+ border-color: rgba(56, 189, 248, 0.6);
+ background: rgba(56, 189, 248, 0.18);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.12);
+}
+
+.opds-tab--search {
+ background: rgba(79, 70, 229, 0.16);
+ border-color: rgba(129, 140, 248, 0.45);
+}
+
+.opds-modal__body {
+ gap: 1rem;
+ padding-top: 0;
+}
+
+.opds-modal__status {
+ font-size: 0.92rem;
+ min-height: 1.25rem;
+ color: var(--muted);
+}
+
+.opds-modal__status[data-state="loading"] {
+ color: var(--accent);
+}
+
+.opds-modal__status[data-state="success"] {
+ color: var(--success);
+}
+
+.opds-modal__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.opds-modal__status[data-state="info"] {
+ color: var(--muted);
+}
+
+.opds-modal__nav {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.opds-modal__alpha {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.35rem;
+ margin: 0;
+ padding: 0.75rem 0 1rem;
+ position: sticky;
+ top: 0;
+ z-index: 20;
+ background: var(--bg);
+ box-shadow: 0 10px 20px -5px rgba(0, 0, 0, 0.2);
+ margin-bottom: 1rem;
+ border-bottom: 1px solid var(--panel-border);
+}
+
+.opds-modal__nav--bottom {
+ margin-top: 1rem;
+ padding-top: 1.5rem;
+ border-top: 1px solid var(--panel-border);
+ justify-content: center;
+}
+
+.opds-alpha-picker__button {
+ border: 1px solid rgba(148, 163, 184, 0.3);
+ border-radius: 999px;
+ background: rgba(15, 23, 42, 0.35);
+ color: rgba(226, 232, 240, 0.88);
+ padding: 0.3rem 0.65rem;
+ font-size: 0.82rem;
+ letter-spacing: 0.02em;
+ text-transform: uppercase;
+ cursor: pointer;
+ transition: background 0.15s ease, color 0.15s ease, border-color 0.15s ease;
+}
+
+.opds-alpha-picker__button:hover {
+ border-color: rgba(148, 163, 184, 0.55);
+ color: #f8fafc;
+}
+
+.opds-alpha-picker__button.is-active {
+ background: rgba(56, 189, 248, 0.2);
+ border-color: rgba(56, 189, 248, 0.65);
+ color: #f0f9ff;
+ box-shadow: 0 0 0 1px rgba(14, 165, 233, 0.25);
+}
+
+.opds-alpha-picker__button:disabled,
+.opds-alpha-picker__button[aria-disabled="true"] {
+ opacity: 0.45;
+ cursor: default;
+}
+
+.opds-alpha-picker__button[data-empty="true"] {
+ opacity: 0.6;
+}
+
+.opds-modal__results-wrap {
+ flex: 1 1 auto;
+ min-height: 0;
+ overflow-y: auto;
+}
+
+.opds-modal__results {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 1rem;
+}
+
+.opds-browser__entry {
+ border: 1px solid rgba(148, 163, 184, 0.16);
+ border-radius: 18px;
+ padding: 1.25rem 1.5rem;
+ background: rgba(15, 23, 42, 0.35);
+ display: grid;
+ gap: 0.85rem;
+ box-shadow: 0 14px 30px rgba(7, 14, 32, 0.32);
+}
+
+.opds-browser__entry--navigation {
+ border-style: dashed;
+ background: rgba(56, 189, 248, 0.08);
+}
+
+.opds-browser__entry-head {
+ display: grid;
+ gap: 0.35rem;
+}
+
+.opds-browser__title {
+ margin: 0;
+ font-size: 1.05rem;
+ font-weight: 600;
+}
+
+.opds-browser__meta {
+ margin: 0;
+ color: rgba(148, 163, 184, 0.85);
+ font-size: 0.9rem;
+}
+
+.opds-browser__summary {
+ margin: 0;
+ color: var(--muted);
+ font-size: 0.9rem;
+ line-height: 1.55;
+}
+
+.opds-browser__actions {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.6rem;
+}
+
+.opds-browser__hint {
+ color: rgba(148, 163, 184, 0.75);
+ font-size: 0.85rem;
+}
+
+.opds-browser__empty {
+ border: 1px dashed rgba(148, 163, 184, 0.24);
+ border-radius: 16px;
+ padding: 1.2rem;
+ text-align: center;
+ color: rgba(148, 163, 184, 0.85);
+}
+
+.reader-modal__body {
+ padding: 0;
+ flex: 1 1 auto;
+ display: flex;
+ flex-direction: column;
+ background: rgba(15, 23, 42, 0.75);
+}
+
+.reader-modal__frame {
+ width: 100%;
+ height: 100%;
+ border: none;
+ border-radius: 18px;
+ background: #0f172a;
+}
+
+.voice-browser__header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ padding: 1.75rem 1.75rem 1.25rem;
+ border-bottom: 1px solid rgba(148, 163, 184, 0.16);
+}
+
+.voice-browser__body {
+ display: grid;
+ grid-template-columns: 260px 1fr 320px;
+ gap: 1.5rem;
+ padding: 1.5rem 1.75rem 1.75rem;
+ overflow-y: auto;
+ max-height: calc(90vh - 150px);
+ flex: 1 1 auto;
+}
+
+.voice-browser__filters,
+.voice-browser__catalog,
+.voice-browser__mix {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.voice-browser__filters .field {
+ gap: 0.35rem;
+}
+
+.voice-browser__filters .button {
+ width: 100%;
+}
+
+.voice-browser__gender {
+ display: grid;
+ gap: 0.5rem;
+}
+
+.voice-browser__list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 0.75rem;
+}
+
+.voice-browser__entry {
+ width: 100%;
+ display: flex;
+ flex-direction: column;
+ align-items: flex-start;
+ padding: 0.85rem 1rem;
+ border-radius: 16px;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ background: rgba(15, 23, 42, 0.35);
+ color: inherit;
+ text-align: left;
+}
+
+.voice-browser__entry:hover,
+.voice-browser__entry[aria-current="true"],
+.voice-browser__entry[data-in-mix="true"] {
+ border-color: rgba(56, 189, 248, 0.55);
+ box-shadow: 0 0 0 2px rgba(56, 189, 248, 0.18);
+}
+
+.voice-browser__entry-name {
+ font-weight: 600;
+}
+
+.voice-browser__entry-meta {
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.voice-browser__mix {
+ border: 1px dashed rgba(148, 163, 184, 0.25);
+ border-radius: 18px;
+ padding: 1.25rem;
+ background: rgba(15, 23, 42, 0.25);
+ gap: 1.25rem;
+}
+
+.voice-browser__mix-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+}
+
+.voice-browser__mix-list {
+ display: grid;
+ gap: 1rem;
+}
+
+.voice-browser__mix-item {
+ display: grid;
+ gap: 0.75rem;
+ padding: 1rem;
+ border-radius: 16px;
+ border: 1px solid rgba(148, 163, 184, 0.16);
+ background: rgba(15, 23, 42, 0.3);
+}
+
+.voice-browser__mix-header h3,
+.voice-browser__mix-name {
+ margin: 0;
+ font-size: 1rem;
+ font-weight: 600;
+}
+
+.voice-browser__mix-remove {
+ appearance: none;
+ border: none;
+ background: none;
+ color: var(--muted);
+ font-size: 1.15rem;
+ cursor: pointer;
+}
+
+.voice-browser__mix-remove:hover {
+ color: var(--danger);
+}
+
+.voice-browser__mix-weight {
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.voice-browser__preview {
+ display: grid;
+ gap: 1rem;
+}
+
+.voice-browser__samples {
+ display: grid;
+ gap: 0.75rem;
+}
+
+.voice-browser__sample {
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 16px;
+ padding: 0.85rem 1rem;
+ background: rgba(15, 23, 42, 0.28);
+}
+
+.voice-browser__actions {
+ display: flex;
+ justify-content: flex-end;
+}
+
+.voice-browser__empty {
+ margin: 0;
+ text-align: center;
+ color: var(--muted);
+}
+
+@media (max-width: 1100px) {
+ .voice-browser__body {
+ grid-template-columns: 1fr;
+ }
+
+ .voice-browser__mix {
+ order: 3;
+ }
+}
+
+@media (max-width: 768px) {
+ .modal {
+ padding: 1rem;
+ }
+
+ .modal__header,
+ .modal__body,
+ .modal__footer {
+ padding-left: 1.25rem;
+ padding-right: 1.25rem;
+ }
+}
+
+ .wizard-page {
+ display: flex;
+ justify-content: center;
+ padding: 3rem 0 5rem;
+ }
+
+ .wizard-page--modal {
+ padding: 0;
+ min-height: 100vh;
+ }
+
+ .wizard-card {
+ width: min(1100px, calc(100% - 2.5rem));
+ margin: 0 auto;
+ }
+
+ .wizard-card__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: flex-start;
+ gap: 2rem;
+ }
+
+ .wizard-card__aside {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+ align-items: flex-end;
+ text-align: right;
+ max-width: 320px;
+ }
+
+ .wizard-card__links {
+ display: flex;
+ gap: 0.75rem;
+ flex-wrap: wrap;
+ justify-content: flex-end;
+ }
+
+ .wizard-card__filename {
+ font-size: 0.85rem;
+ color: var(--muted);
+ max-width: 100%;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ }
+
+ .wizard-card__body {
+ display: flex;
+ flex-direction: column;
+ gap: 2rem;
+ }
+
+ .wizard-card__stage {
+ flex: 1 1 auto;
+ display: flex;
+ flex-direction: column;
+ min-height: 0;
+ position: relative;
+ }
+
+ .wizard-card__stage > form[data-wizard-form="true"] {
+ display: flex;
+ flex-direction: column;
+ flex: 1 1 auto;
+ min-height: 0;
+ }
+
+ .wizard-card__footer {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ gap: 1rem;
+ flex-wrap: wrap;
+ }
+
+ .wizard-card__footer-actions {
+ display: flex;
+ gap: 0.75rem;
+ align-items: center;
+ }
+
+ .wizard-hidden-inputs {
+ display: none;
+ }
+
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage::after,
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage::before {
+ content: "";
+ position: absolute;
+ }
+
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage::after {
+ inset: 0;
+ background: rgba(15, 23, 42, 0.55);
+ border-radius: 24px;
+ pointer-events: auto;
+ }
+
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage::before {
+ left: 50%;
+ top: 50%;
+ width: 2.75rem;
+ height: 2.75rem;
+ margin: -1.375rem;
+ border-radius: 50%;
+ border: 3px solid rgba(56, 189, 248, 0.25);
+ border-top-color: rgba(56, 189, 248, 0.85);
+ animation: spin 0.85s linear infinite;
+ pointer-events: none;
+ }
+
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage > * {
+ pointer-events: none;
+ user-select: none;
+ opacity: 0.75;
+ }
+
+ @media (max-width: 900px) {
+ .wizard-card__header {
+ flex-direction: column;
+ align-items: stretch;
+ }
+
+ .wizard-card__aside {
+ align-items: flex-start;
+ text-align: left;
+ }
+
+ .wizard-card__links {
+ justify-content: flex-start;
+ }
+ }
+
+.step-indicator {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+ margin-bottom: 1.5rem;
+ align-items: center;
+}
+
+.step-indicator__item {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.5rem;
+ padding: 0.4rem 0.85rem;
+ border-radius: 999px;
+ background: rgba(148, 163, 184, 0.12);
+ color: var(--muted);
+ font-size: 0.85rem;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+}
+
+button.step-indicator__item {
+ cursor: pointer;
+ font: inherit;
+}
+
+button.step-indicator__item:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+
+.step-indicator__index {
+ width: 1.75rem;
+ height: 1.75rem;
+ border-radius: 50%;
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ font-weight: 600;
+ border: 1px solid rgba(148, 163, 184, 0.35);
+ background: rgba(15, 23, 42, 0.65);
+}
+
+.step-indicator__label {
+ font-weight: 500;
+ letter-spacing: 0.02em;
+}
+
+.step-indicator__item.is-active {
+ background: rgba(56, 189, 248, 0.18);
+ color: #fff;
+ border-color: rgba(56, 189, 248, 0.35);
+}
+
+.step-indicator__item.is-active .step-indicator__index {
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ border-color: transparent;
+ color: #fff;
+}
+
+.step-indicator__item.is-complete {
+ background: rgba(56, 189, 248, 0.12);
+ color: var(--accent);
+ border-color: rgba(56, 189, 248, 0.25);
+}
+
+.step-indicator__item.is-complete .step-indicator__index {
+ border-color: rgba(56, 189, 248, 0.35);
+}
+
+.step-indicator__item[data-state="clickable"] {
+ cursor: pointer;
+ color: rgba(148, 163, 184, 0.95);
+}
+
+.step-indicator__item[data-state="clickable"]:hover {
+ color: var(--accent);
+ background: rgba(56, 189, 248, 0.12);
+}
+
+.card__title {
+ font-size: 1.4rem;
+ font-weight: 600;
+ margin-bottom: 1rem;
+}
+
+.card__title-row {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 1rem;
+ flex-wrap: wrap;
+ margin-bottom: 1rem;
+}
+
+.card__title-row .card__title {
+ margin: 0;
+}
+
+.card__title-row .button {
+ margin-left: auto;
+}
+
+.grid {
+ display: grid;
+ gap: 1.5rem;
+}
+
+.grid--two {
+ grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+}
+
+.form-grid {
+ align-items: start;
+}
+
+.form-grid {
+ grid-template-columns: minmax(0, 420px) minmax(0, 1fr);
+ align-items: start;
+ gap: 2rem;
+}
+
+.form-grid > .grid {
+ align-items: start;
+ max-width: none;
+ width: 100%;
+ justify-self: stretch;
+}
+
+.form-grid > .grid:last-child {
+ width: min(100%, 540px);
+}
+
+.button {
+ appearance: none;
+ border: none;
+ border-radius: 16px;
+ padding: 0.85rem 1.2rem;
+ font-size: 1rem;
+ font-weight: 600;
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ color: #fff;
+ cursor: pointer;
+ transition: transform 0.15s ease, box-shadow 0.15s ease;
+ box-shadow: 0 12px 30px rgba(56, 189, 248, 0.2);
+}
+
+.button:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 16px 30px rgba(14, 165, 233, 0.28);
+}
+
+.button--ghost {
+ background: transparent;
+ border: 1px solid var(--panel-border);
+ color: var(--muted);
+ box-shadow: none;
+}
+
+.button--ghost:hover {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+.button[data-loading="true"]:not([data-role="preview-button"]) {
+ position: relative;
+ padding-left: 2.75rem;
+ pointer-events: none;
+ color: rgba(255, 255, 255, 0.88);
+ opacity: 0.92;
+}
+
+.button[data-loading="true"]:not([data-role="preview-button"])::after {
+ content: "";
+ position: absolute;
+ left: 1.15rem;
+ top: 50%;
+ width: 1.1rem;
+ height: 1.1rem;
+ margin-top: -0.55rem;
+ border-radius: 50%;
+ border: 2px solid rgba(255, 255, 255, 0.3);
+ border-right-color: rgba(255, 255, 255, 0.9);
+ animation: spin 0.85s linear infinite;
+}
+
+.log-copy {
+ margin-top: 1.5rem;
+}
+
+.log-copy > summary {
+ cursor: pointer;
+ font-weight: 600;
+ margin-bottom: 0.75rem;
+}
+
+.log-copy__textarea {
+ display: block;
+ width: 100%;
+ min-height: 240px;
+ padding: 1rem;
+ border-radius: 12px;
+ border: 1px solid rgba(148, 163, 184, 0.32);
+ background: rgba(15, 23, 42, 0.35);
+ color: inherit;
+ font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+ font-size: 0.95rem;
+ line-height: 1.5;
+ resize: vertical;
+}
+
+.log-copy__textarea:focus {
+ outline: 2px solid rgba(56, 189, 248, 0.55);
+ outline-offset: 2px;
+}
+
+.upload-form {
+ display: flex;
+ flex-direction: column;
+ flex: 1 1 auto;
+ min-height: 0;
+}
+
+.upload-form__sections {
+ display: flex;
+ flex-direction: column;
+ gap: 1.5rem;
+ flex: 1 1 auto;
+ min-height: 0;
+}
+
+.form-section {
+ display: flex;
+ flex-direction: column;
+ gap: 1.25rem;
+ padding: 1.5rem;
+ border-radius: 24px;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ background: rgba(15, 23, 42, 0.45);
+}
+
+.form-section__title {
+ margin: 0;
+ font-size: 1.1rem;
+ font-weight: 600;
+ color: var(--text);
+}
+
+.form-section__layout {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.form-section__layout--split {
+ grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+}
+
+.form-section__group {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.field-grid {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.field-grid--compact {
+ grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+ align-items: start;
+}
+
+.field-grid--compact .field {
+ max-width: none;
+}
+
+.field-grid--two {
+ grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+}
+
+.field-grid--two > .field {
+ max-width: none;
+}
+
+.field--span-2 {
+ grid-column: span 2;
+}
+
+.field-grid--two input[type="text"],
+.field-grid--two input[type="number"],
+.field-grid--two input[type="file"],
+.field-grid--two input[type="range"],
+.field-grid--two select,
+.field-grid--two textarea {
+ max-width: 100%;
+}
+
+.field--stack {
+ display: flex;
+ flex-direction: column;
+ gap: 0.65rem;
+}
+
+.field--with-action .field__label-row {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+}
+
+.field__label-row .field__label,
+.field__label-row label {
+ font-weight: 500;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.field__status {
+ margin: 0;
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.field__status[data-state="loading"] {
+ color: var(--accent);
+}
+
+.field__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.field__status[data-state="success"] {
+ color: var(--success);
+}
+
+.voice-preview__audio {
+ width: min(100%, 360px);
+ margin-top: 0.75rem;
+ border-radius: 14px;
+ background: rgba(15, 23, 42, 0.4);
+}
+
+.field {
+ display: flex;
+ flex-direction: column;
+ gap: 0.4rem;
+}
+
+.field__caption {
+ font-weight: 500;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.field[hidden],
+.field[data-state="hidden"] {
+ display: none !important;
+}
+
+.field--full {
+ max-width: none;
+}
+
+.field--full textarea {
+ min-height: 260px;
+}
+
+.field--actions {
+ display: flex;
+ justify-content: flex-end;
+ align-items: center;
+}
+
+.field label {
+ font-weight: 500;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.field input,
+.field select,
+.field textarea {
+ width: 100%;
+ box-sizing: border-box;
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ background: rgba(15, 23, 42, 0.45);
+ padding: 0.75rem 1rem;
+ color: var(--text);
+ font-size: 1rem;
+ transition: border 0.2s ease, box-shadow 0.2s ease;
+}
+
+.field input[type="text"],
+.field input[type="file"],
+.field input[type="number"],
+.field select {
+ max-width: 420px;
+ width: min(100%, 420px);
+}
+
+.field input[type="range"] {
+ max-width: 420px;
+ width: min(100%, 420px);
+ padding: 0;
+ margin-inline: 0;
+ align-self: flex-start;
+}
+
+.field input[type="number"] {
+ max-width: 200px;
+}
+
+.field input:focus,
+.field select:focus,
+.field textarea:focus {
+ outline: none;
+ border-color: var(--accent);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.15);
+}
+
+.split {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+ gap: 1rem;
+}
+
+.tag {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ border-radius: 999px;
+ padding: 0.35rem 0.8rem;
+ font-size: 0.8rem;
+ background: rgba(148, 163, 184, 0.12);
+ color: var(--muted);
+}
+
+.badge {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.35rem;
+ padding: 0.4rem 0.85rem;
+ border-radius: 999px;
+ font-size: 0.75rem;
+ font-weight: 600;
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+}
+
+.badge--pending {
+ background: rgba(148, 163, 184, 0.12);
+ color: var(--muted);
+}
+
+.badge--running {
+ background: rgba(56, 189, 248, 0.12);
+ color: var(--accent);
+}
+
+.badge--completed {
+ background: rgba(52, 211, 153, 0.15);
+ color: var(--success);
+}
+
+.badge--failed,
+.badge--cancelled {
+ background: rgba(248, 113, 113, 0.15);
+ color: var(--danger);
+}
+
+.badge--info {
+ background: rgba(56, 189, 248, 0.18);
+ color: var(--accent);
+}
+
+.badge--muted {
+ background: rgba(148, 163, 184, 0.15);
+ color: var(--muted);
+}
+
+.log-list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 0.65rem;
+ max-height: 260px;
+ overflow-y: auto;
+}
+
+.log-item {
+ padding: 0.75rem 0.95rem;
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.12);
+ background: rgba(15, 23, 42, 0.3);
+ font-size: 0.9rem;
+ line-height: 1.4;
+}
+
+.log-item--success {
+ border-color: rgba(52, 211, 153, 0.4);
+ color: var(--success);
+}
+
+.log-item--error {
+ border-color: rgba(248, 113, 113, 0.45);
+ color: var(--danger);
+}
+
+.log-item--warning {
+ border-color: rgba(251, 191, 36, 0.45);
+ color: var(--warning);
+}
+
+.jobs-table {
+ width: 100%;
+ border-collapse: collapse;
+ overflow: hidden;
+ border-radius: 20px;
+}
+
+.jobs-table thead {
+ background: rgba(148, 163, 184, 0.12);
+ text-transform: uppercase;
+ letter-spacing: 0.04em;
+ font-size: 0.75rem;
+}
+
+.jobs-table th,
+.jobs-table td {
+ padding: 0.9rem 1.15rem;
+ text-align: left;
+}
+
+.jobs-table tbody tr {
+ border-bottom: 1px solid rgba(148, 163, 184, 0.12);
+}
+
+.jobs-table tbody tr:hover {
+ background: rgba(56, 189, 248, 0.08);
+}
+
+
+.entity-table-tools {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 1rem;
+ align-items: flex-end;
+ margin-bottom: 1.5rem;
+}
+
+.entity-table-tools__filter {
+ flex: 1 1 240px;
+ max-width: 360px;
+}
+
+.entity-table-tools__filter input {
+ max-width: none;
+}
+
+.entity-table-tools__clear {
+ align-self: center;
+}
+
+.entity-create {
+ gap: 1.25rem;
+}
+
+.entity-create__description {
+ margin: 0;
+ color: var(--muted);
+ font-size: 0.95rem;
+}
+
+.entity-create__actions {
+ display: flex;
+ justify-content: flex-end;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+}
+
+.entity-preview {
+ display: grid;
+ gap: 0.6rem;
+ align-items: flex-start;
+}
+
+.entity-preview__controls {
+ display: flex;
+ align-items: center;
+ gap: 0.6rem;
+ flex-wrap: wrap;
+}
+
+.entity-preview__audio {
+ width: min(100%, 220px);
+ border-radius: 14px;
+ background: rgba(15, 23, 42, 0.45);
+}
+
+.entity-preview__status {
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.entity-preview__status[data-state="success"] {
+ color: var(--success);
+}
+
+.entity-preview__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.overrides-table__token {
+ font-weight: 600;
+ letter-spacing: 0.02em;
+}
+
+.overrides-table__input,
+.overrides-table__select {
+ width: 100%;
+ box-sizing: border-box;
+ border-radius: 12px;
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ background: rgba(15, 23, 42, 0.45);
+ color: var(--text);
+ padding: 0.6rem 0.75rem;
+ font-size: 0.95rem;
+ transition: border 0.2s ease, box-shadow 0.2s ease;
+}
+
+.overrides-table__input:focus,
+.overrides-table__select:focus {
+ outline: none;
+ border-color: rgba(56, 189, 248, 0.55);
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.18);
+}
+
+.overrides-table__select {
+ appearance: none;
+}
+
+.overrides-table__actions-heading {
+ text-align: right;
+}
+
+.overrides-table__actions {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: flex-end;
+ gap: 0.5rem;
+}
+
+.overrides-table__form {
+ margin: 0;
+}
+
+.button[data-loading="true"][data-role="preview-button"] {
+ position: relative;
+ padding-left: 2.3rem;
+ pointer-events: none;
+}
+
+.button[data-loading="true"][data-role="preview-button"]::after {
+ content: "";
+ position: absolute;
+ left: 0.9rem;
+ top: 50%;
+ width: 1rem;
+ height: 1rem;
+ margin-top: -0.5rem;
+ border-radius: 50%;
+ border: 2px solid rgba(148, 163, 184, 0.4);
+ border-right-color: rgba(56, 189, 248, 0.8);
+ animation: spin 0.85s linear infinite;
+}
+
+.progress-bar {
+ width: 100%;
+ height: 9px;
+ border-radius: 999px;
+ background: rgba(148, 163, 184, 0.15);
+ overflow: hidden;
+ --progress: 0%;
+}
+
+.progress-bar__fill {
+ height: 100%;
+ background: linear-gradient(90deg, var(--accent), var(--accent-strong));
+ border-radius: inherit;
+ transition: width 0.35s ease;
+ width: var(--progress);
+}
+
+.list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 1rem;
+}
+
+.list__item {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 18px;
+ padding: 1rem 1.25rem;
+ background: rgba(15, 23, 42, 0.35);
+ gap: 1rem;
+}
+
+.queue-section {
+ display: grid;
+ gap: 1rem;
+ margin-bottom: 1.75rem;
+}
+
+.queue-section:last-of-type {
+ margin-bottom: 0;
+}
+
+.queue-section__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ gap: 1rem;
+}
+
+.queue-section__header h3 {
+ margin: 0;
+ font-size: 1.1rem;
+ font-weight: 600;
+}
+
+.job-cards {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 1rem;
+}
+
+.job-card {
+ border: 1px solid rgba(148, 163, 184, 0.16);
+ border-radius: 20px;
+ padding: 1rem 1.25rem;
+ background: rgba(15, 23, 42, 0.35);
+ box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.03);
+ display: grid;
+ gap: 0.75rem;
+}
+
+.job-card[data-status="paused"] {
+ border-color: rgba(251, 191, 36, 0.45);
+ background: rgba(251, 191, 36, 0.08);
+}
+
+.job-card__title {
+ font-size: 1.05rem;
+ font-weight: 600;
+ margin: 0;
+}
+
+.job-card__title a {
+ color: inherit;
+ text-decoration: none;
+}
+
+.job-card__title a:hover {
+ color: var(--accent);
+}
+
+.job-card__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: flex-start;
+ gap: 1rem;
+}
+
+.job-card__meta {
+ color: var(--muted);
+ font-size: 0.85rem;
+ margin-top: 0.35rem;
+}
+
+.job-card__meta--warning {
+ color: var(--warning);
+}
+
+.job-card__progress {
+ display: grid;
+ gap: 0.4rem;
+}
+
+.job-card__progress small {
+ color: var(--muted);
+}
+
+.job-card__progress-meta {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+}
+
+.job-card__eta {
+ color: var(--muted);
+ font-variant-numeric: tabular-nums;
+}
+
+.job-card__footer {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.job-card__footer .button--ghost {
+ padding: 0.6rem 0.95rem;
+}
+
+.job-cards--compact .job-card {
+ background: rgba(15, 23, 42, 0.28);
+}
+
+.job-cards--compact .job-card__meta {
+ margin-top: 0.25rem;
+}
+
+.job-card--info {
+ border-style: dashed;
+ border-color: rgba(148, 163, 184, 0.25);
+ background: rgba(15, 23, 42, 0.2);
+ text-align: center;
+}
+
+.job-card--info .job-card__meta {
+ margin-top: 0;
+}
+
+.queue-empty {
+ color: var(--muted);
+}
+
+.field--file input[type="file"] {
+ width: min(100%, 420px);
+ max-width: 420px;
+ align-self: flex-start;
+ border-radius: 14px;
+ border: 1px dashed rgba(148, 163, 184, 0.35);
+ background: rgba(15, 23, 42, 0.45);
+ padding: 0.85rem 1rem;
+ font-size: 0.95rem;
+ color: var(--muted);
+ cursor: pointer;
+ transition: border 0.2s ease, box-shadow 0.2s ease, background 0.2s ease;
+}
+
+.field--file input[type="file"]:hover,
+.field--file input[type="file"]:focus {
+ border-color: var(--accent);
+ background: rgba(56, 189, 248, 0.1);
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.12);
+}
+
+.field--file input[type="file"]::file-selector-button,
+.field--file input[type="file"]::-webkit-file-upload-button {
+ border: none;
+ border-radius: 12px;
+ background: rgba(56, 189, 248, 0.2);
+ color: var(--accent);
+ font-weight: 600;
+ padding: 0.55rem 1.05rem;
+ margin-right: 1rem;
+ cursor: pointer;
+ transition: background 0.2s ease, color 0.2s ease;
+}
+.prepare-wizard[data-speaker-step="disabled"] [data-step-key="speakers"] {
+ display: none;
+}
+.prepare-wizard[data-speaker-step="disabled"] [data-speaker-panel="true"] {
+ display: none !important;
+}
+.prepare-wizard[data-speaker-step="enabled"] [data-chapter-action="finalize"] {
+ display: none;
+}
+.prepare-wizard[data-speaker-step="disabled"] [data-chapter-action="continue"] {
+ display: none;
+}
+.prepare-wizard[data-speaker-step="disabled"] [data-chapter-action="finalize"] {
+ display: inline-flex;
+}
+
+.field--file input[type="file"]:hover::file-selector-button,
+.field--file input[type="file"]:focus::file-selector-button,
+.field--file input[type="file"]:hover::-webkit-file-upload-button,
+.field--file input[type="file"]:focus::-webkit-file-upload-button {
+ background: rgba(56, 189, 248, 0.35);
+ color: #fff;
+}
+
+.alert {
+ margin: 1rem 0;
+ padding: 0.75rem 1rem;
+ border-radius: 14px;
+ font-size: 0.95rem;
+}
+
+.alert--success {
+ background: rgba(52, 211, 153, 0.12);
+ border: 1px solid rgba(52, 211, 153, 0.35);
+ color: var(--success);
+}
+
+.alert--error {
+ background: rgba(248, 113, 113, 0.12);
+ border: 1px solid rgba(248, 113, 113, 0.35);
+ color: var(--danger);
+}
+
+.button--danger {
+ background: rgba(248, 113, 113, 0.16);
+ color: var(--danger);
+ border: 1px solid rgba(248, 113, 113, 0.45);
+ box-shadow: 0 10px 24px rgba(248, 113, 113, 0.18);
+}
+
+.button--danger:hover {
+ background: linear-gradient(135deg, rgba(248, 113, 113, 0.85), #ef4444);
+ color: #fff;
+ border-color: rgba(248, 113, 113, 0.65);
+ box-shadow: 0 16px 36px rgba(248, 113, 113, 0.32);
+}
+
+
+.settings-layout {
+ display: grid;
+ grid-template-columns: 220px minmax(0, 1fr);
+ gap: 2rem;
+ align-items: start;
+}
+
+.settings-nav {
+ display: flex;
+ flex-direction: column;
+ gap: 0.5rem;
+ position: sticky;
+ top: 100px;
+}
+
+.settings-nav__item {
+ display: inline-flex;
+ justify-content: flex-start;
+ align-items: center;
+ padding: 0.65rem 0.9rem;
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ background: rgba(15, 23, 42, 0.55);
+ color: var(--muted);
+ font-size: 0.95rem;
+ cursor: pointer;
+ transition: border 0.2s ease, color 0.2s ease, background 0.2s ease, box-shadow 0.2s ease;
+}
+
+.settings-nav__item:hover,
+.settings-nav__item:focus-visible {
+ border-color: rgba(56, 189, 248, 0.5);
+ color: var(--accent);
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.1);
+}
+
+.settings-nav__item.is-active {
+ background: rgba(56, 189, 248, 0.18);
+ border-color: rgba(56, 189, 248, 0.28);
+ color: #fff;
+ box-shadow: 0 10px 20px rgba(56, 189, 248, 0.18);
+}
+
+.settings-nav__item.is-disabled {
+ opacity: 0.6;
+ cursor: pointer;
+}
+
+.settings__form {
+ display: grid;
+ gap: 1.75rem;
+}
+
+.settings-panels {
+ display: grid;
+}
+
+.settings-panel {
+ display: none;
+ gap: 1.75rem;
+}
+
+.settings-panel.is-active {
+ display: grid;
+ gap: 1.75rem;
+}
+
+.settings__section {
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ border-radius: 18px;
+ padding: 1.25rem 1.4rem;
+ display: grid;
+ gap: 1.1rem 1.4rem;
+ grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+}
+
+.settings__section legend {
+ font-weight: 600;
+ padding: 0 0.5rem;
+ color: var(--muted);
+ grid-column: 1 / -1;
+}
+
+.settings__section .field {
+ align-items: flex-start;
+}
+
+.settings__section .field input,
+.settings__section .field select,
+.settings__section .field textarea {
+ max-width: 100%;
+}
+
+.settings__section .field input[type="text"],
+.settings__section .field input[type="file"],
+.settings__section .field select {
+ max-width: 100%;
+}
+
+.settings__section .field--wide {
+ grid-column: 1 / -1;
+}
+
+.settings__section .field--wide input,
+.settings__section .field--wide select,
+.settings__section .field--wide textarea {
+ max-width: 100%;
+}
+
+.field--choices {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+ gap: 0.85rem;
+}
+
+.toggle-pill {
+ position: relative;
+ display: inline-flex;
+ align-items: center;
+ gap: 0.65rem;
+ cursor: pointer;
+}
+
+.toggle-pill input {
+ position: absolute;
+ opacity: 0;
+ inset: 0;
+ cursor: pointer;
+}
+
+.toggle-pill span {
+ display: inline-flex;
+ align-items: center;
+ justify-content: flex-start;
+ width: 100%;
+ padding: 0.65rem 0.95rem;
+ border-radius: 16px;
+ border: 1px solid rgba(148, 163, 184, 0.25);
+ background: rgba(15, 23, 42, 0.45);
+ color: var(--muted);
+ transition: border 0.2s ease, background 0.2s ease, color 0.2s ease, box-shadow 0.2s ease;
+}
+
+.toggle-pill:hover span {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+.toggle-pill input:focus-visible + span {
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.18);
+}
+
+.choices {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.choices--inline {
+ display: inline-flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.radio-pill {
+ position: relative;
+ display: inline-flex;
+ align-items: center;
+ cursor: pointer;
+}
+
+.radio-pill input {
+ position: absolute;
+ opacity: 0;
+ inset: 0;
+ cursor: pointer;
+}
+
+.radio-pill span {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ padding: 0.55rem 0.9rem;
+ border-radius: 999px;
+ border: 1px solid rgba(148, 163, 184, 0.25);
+ background: rgba(15, 23, 42, 0.4);
+ color: var(--muted);
+ transition: border 0.2s ease, background 0.2s ease, color 0.2s ease, box-shadow 0.2s ease;
+}
+
+.radio-pill:hover span {
+ border-color: rgba(56, 189, 248, 0.5);
+ color: var(--accent);
+}
+
+.radio-pill input:checked + span {
+ border-color: rgba(56, 189, 248, 0.45);
+ background: rgba(56, 189, 248, 0.16);
+ color: #fff;
+ box-shadow: 0 8px 18px rgba(56, 189, 248, 0.18);
+}
+
+.radio-pill input:focus-visible + span {
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.18);
+}
+
+.field__group {
+ display: flex;
+ flex-direction: column;
+ gap: 0.35rem;
+}
+
+.field__input-with-button {
+ display: flex;
+ align-items: center;
+ gap: 0.65rem;
+ flex-wrap: wrap;
+}
+
+.field__input-with-button > input {
+ flex: 1 1 16rem;
+ min-width: 12rem;
+}
+
+.preview-card {
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 16px;
+ padding: 1rem 1.1rem;
+ background: rgba(15, 23, 42, 0.52);
+ display: grid;
+ gap: 0.75rem;
+}
+
+.preview-card__actions {
+ display: flex;
+ align-items: center;
+ gap: 0.85rem;
+ flex-wrap: wrap;
+}
+
+.preview-card__status {
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.preview-card__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.preview-card__status[data-state="success"] {
+ color: var(--success);
+}
+
+.preview-card__output {
+ border-radius: 12px;
+ background: rgba(15, 23, 42, 0.7);
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ padding: 0.9rem 1rem;
+ font-family: "JetBrains Mono", "Fira Code", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+ font-size: 0.9rem;
+ line-height: 1.5;
+ color: var(--text);
+ min-height: 3.5rem;
+ white-space: pre-wrap;
+}
+
+.preview-card__output:empty {
+ display: none;
+}
+
+.preview-card__audio {
+ width: 100%;
+ margin-top: 0.25rem;
+}
+
+.hint--warning {
+ color: var(--warning);
+}
+
+@media (max-width: 860px) {
+ .settings-layout {
+ grid-template-columns: 1fr;
+ }
+
+ .settings-nav {
+ position: static;
+ flex-direction: row;
+ flex-wrap: wrap;
+ gap: 0.65rem;
+ }
+
+ .settings-nav__item {
+ flex: 1 1 calc(50% - 0.65rem);
+ justify-content: center;
+ text-align: center;
+ }
+}
+
+.prepare-summary {
+ display: grid;
+ grid-template-columns: minmax(0, 320px) minmax(0, 1fr);
+ gap: 2rem;
+ margin-bottom: 2rem;
+ align-items: start;
+}
+.form-section__title-row {
+ display: flex;
+ justify-content: space-between;
+ align-items: flex-end;
+ gap: 1rem;
+ flex-wrap: wrap;
+ margin-bottom: 1rem;
+}
+.form-section__title-row .form-section__title {
+ margin-bottom: 0;
+}
+
+.prepare-summary__stats dl {
+ margin: 0;
+ display: grid;
+ gap: 0.6rem;
+ grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+}
+
+.prepare-summary__stats dt {
+ font-size: 0.75rem;
+ letter-spacing: 0.04em;
+ text-transform: uppercase;
+ color: var(--muted);
+}
+
+.prepare-summary__stats dd {
+ margin: 0;
+ font-weight: 500;
+}
+
+.prepare-summary__insights {
+ display: grid;
+ gap: 1.25rem;
+ align-content: start;
+}
+
+.prepare-summary__stats dl > div {
+ display: grid;
+ gap: 0.25rem;
+}
+
+.prepare-summary__insights > .prepare-analysis,
+.prepare-summary__insights > .prepare-metadata {
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ background: rgba(15, 23, 42, 0.35);
+ border-radius: 18px;
+ padding: 1rem 1.25rem;
+}
+
+.prepare-speakers {
+ margin-top: 2rem;
+ border-top: 1px solid var(--panel-border);
+ padding-top: 1.5rem;
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.prepare-speaker-config {
+ margin-top: 2rem;
+ border-top: 1px solid var(--panel-border);
+ padding-top: 1.5rem;
+ display: grid;
+ gap: 1rem;
+}
+
+.prepare-speaker-config__header {
+ display: flex;
+ flex-direction: column;
+ gap: 0.35rem;
+}
+
+.prepare-speaker-config__grid {
+ display: grid;
+ gap: 1.25rem;
+ grid-template-columns: minmax(0, 360px) minmax(0, 1fr);
+ align-items: center;
+}
+
+.prepare-speaker-config__actions {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+ align-items: center;
+ justify-content: flex-end;
+}
+
+.prepare-speaker-config__actions .button {
+ white-space: nowrap;
+}
+
+.prepare-speaker-config__field .hint {
+ margin-top: 0.2rem;
+}
+
+@media (max-width: 900px) {
+ .prepare-speaker-config__grid {
+ grid-template-columns: minmax(0, 1fr);
+ align-items: stretch;
+ }
+ .prepare-speaker-config__actions {
+ justify-content: flex-start;
+ }
+}
+
+.entity-tabs {
+ display: flex;
+ flex-direction: column;
+ gap: 1.75rem;
+}
+
+.entity-tabs__notice {
+ margin-bottom: 0.5rem;
+}
+
+.entity-tabs__nav {
+ display: flex;
+ gap: 0.75rem;
+ padding: 0.45rem;
+ border-radius: 999px;
+ background: rgba(15, 23, 42, 0.62);
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ box-shadow: 0 18px 38px rgba(15, 23, 42, 0.35);
+ backdrop-filter: blur(4px);
+ position: sticky;
+ top: max(env(safe-area-inset-top), 0.5rem);
+ z-index: 25;
+}
+
+.entity-tabs__tab {
+ flex: 1 1 0;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ gap: 0.6rem;
+ padding: 0.65rem 1rem 0.65rem 2.45rem;
+ border-radius: 999px;
+ border: 1px solid transparent;
+ background: transparent;
+ color: var(--muted);
+ font-weight: 600;
+ position: relative;
+ transition: color 0.2s ease, border-color 0.2s ease, background 0.2s ease, transform 0.2s ease;
+}
+
+.entity-tabs__tab::before {
+ content: "";
+ position: absolute;
+ left: 1.1rem;
+ width: 0.95rem;
+ height: 0.95rem;
+ border-radius: 50%;
+ background: rgba(148, 163, 184, 0.5);
+ box-shadow: 0 0 0 4px rgba(148, 163, 184, 0.16);
+ transition: transform 0.2s ease, box-shadow 0.2s ease, background 0.2s ease;
+}
+
+.entity-tabs__tab[data-panel="people"]::before {
+ background: linear-gradient(135deg, rgba(37, 99, 235, 0.7), rgba(56, 189, 248, 0.85));
+}
+
+.entity-tabs__tab[data-panel="entities"]::before {
+ background: linear-gradient(135deg, rgba(236, 72, 153, 0.45), rgba(244, 114, 182, 0.75));
+}
+
+.entity-tabs__tab[data-panel="manual"]::before {
+ background: linear-gradient(135deg, rgba(248, 189, 32, 0.55), rgba(248, 113, 113, 0.7));
+}
+
+.entity-tabs__tab:hover,
+.entity-tabs__tab:focus-visible {
+ color: #fff;
+ border-color: rgba(56, 189, 248, 0.45);
+}
+
+.entity-tabs__tab:focus-visible {
+ outline: none;
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.22);
+}
+
+.entity-tabs__tab.is-active {
+ color: #fff;
+ border-color: rgba(56, 189, 248, 0.6);
+ background: linear-gradient(135deg, rgba(30, 64, 175, 0.3), rgba(56, 189, 248, 0.4));
+ box-shadow: 0 20px 34px rgba(14, 165, 233, 0.35);
+}
+
+.entity-tabs__tab.is-active::before {
+ transform: scale(1.15);
+ box-shadow: 0 0 0 6px rgba(56, 189, 248, 0.28);
+}
+
+.entity-tabs__panels {
+ background: rgba(15, 23, 42, 0.55);
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 28px;
+ padding: 1.9rem;
+ box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.02);
+ backdrop-filter: blur(6px);
+}
+
+.entity-tabs__panel {
+ display: flex;
+ flex-direction: column;
+ gap: 1.75rem;
+}
+
+.entity-summary {
+ display: flex;
+ flex-direction: column;
+ gap: 1.5rem;
+}
+
+.entity-summary__header {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: space-between;
+ align-items: center;
+ gap: 1rem;
+}
+
+.entity-summary__filters {
+ display: flex;
+ flex-wrap: wrap;
+ align-items: center;
+ gap: 0.75rem;
+}
+
+.entity-summary__filters .field,
+.entity-summary__filters .button {
+ margin: 0;
+}
+
+.field--inline {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.85rem;
+ align-items: flex-end;
+}
+
+.entity-summary__titles h2 {
+ margin: 0;
+}
+
+.entity-summary__titles .hint {
+ margin-top: 0.35rem;
+}
+
+.entity-summary__stats {
+ display: grid;
+ gap: 1rem;
+ grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+}
+
+.entity-summary__list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 1.1rem;
+}
+
+.entity-summary__empty {
+ border: 1px dashed rgba(148, 163, 184, 0.3);
+ border-radius: 18px;
+ padding: 1.1rem;
+ text-align: center;
+ color: rgba(148, 163, 184, 0.9);
+ background: rgba(15, 23, 42, 0.4);
+}
+
+.entity-summary__item {
+ background: rgba(15, 23, 42, 0.62);
+ border: 1px solid rgba(148, 163, 184, 0.16);
+ border-radius: 20px;
+ padding: 1.25rem;
+ box-shadow: 0 22px 40px rgba(15, 23, 42, 0.4);
+}
+
+.entity-summary__item-header {
+ display: flex;
+ justify-content: space-between;
+ gap: 1rem;
+ align-items: flex-start;
+}
+
+.entity-summary__label {
+ margin: 0;
+ font-size: 1.05rem;
+ letter-spacing: 0.01em;
+}
+
+.entity-summary__kind {
+ margin: 0.25rem 0 0;
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.entity-summary__actions {
+ display: flex;
+ gap: 0.75rem;
+ align-items: center;
+}
+
+.entity-summary__samples {
+ margin-top: 1rem;
+ display: grid;
+ gap: 0.6rem;
+}
+
+.entity-summary__samples p {
+ margin: 0;
+ color: rgba(226, 232, 240, 0.9);
+ line-height: 1.55;
+}
+
+.manual-overrides__header {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 1rem;
+}
+
+.manual-overrides__copy {
+ display: flex;
+ flex-direction: column;
+ gap: 0.35rem;
+}
+
+.manual-overrides__header h2 {
+ margin: 0;
+}
+
+.manual-overrides__header-actions {
+ display: flex;
+ align-items: center;
+ gap: 0.65rem;
+}
+
+.manual-overrides__status {
+ font-size: 0.85rem;
+ color: var(--muted);
+ min-height: 1.2em;
+}
+
+.manual-overrides__status[data-state="success"] {
+ color: var(--success);
+}
+
+.manual-overrides__status[data-state="error"] {
+ color: var(--danger);
+}
+
+.manual-overrides__status[data-state="pending"] {
+ color: var(--accent);
+}
+
+.manual-overrides__search {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.manual-overrides__search-actions {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+}
+
+.manual-overrides__results,
+.manual-overrides__list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 1rem;
+}
+
+.entity-tabs [hidden] {
+ display: none !important;
+}
+
+@media (max-width: 820px) {
+ .field--span-2 {
+ grid-column: span 1;
+ }
+
+ .manual-overrides__header {
+ flex-direction: column;
+ align-items: stretch;
+ }
+
+ .manual-overrides__header-actions {
+ justify-content: flex-start;
+ flex-wrap: wrap;
+ }
+
+ .entity-tabs__nav {
+ flex-direction: column;
+ padding: 0.35rem;
+ }
+
+ .entity-tabs__tab {
+ width: 100%;
+ justify-content: flex-start;
+ padding: 0.6rem 1rem 0.6rem 2.3rem;
+ }
+}
+
+.speaker-list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.speaker-list__item {
+ background: rgba(148, 163, 184, 0.05);
+ border: 1px solid var(--panel-border);
+ border-radius: 18px;
+ padding: 1rem 1.25rem;
+ display: flex;
+ flex-direction: column;
+ gap: 0.65rem;
+}
+
+.speaker-line {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+}
+
+.speaker-list__name {
+ font-weight: 600;
+ font-size: 1rem;
+}
+
+.speaker-list__preview {
+ font-size: 1.1rem;
+ line-height: 1;
+ width: 2.4rem;
+ height: 2.4rem;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ border-radius: 999px;
+ border: 1px solid var(--panel-border);
+ color: var(--accent);
+ background: rgba(56, 189, 248, 0.08);
+ transition: transform 0.15s ease, box-shadow 0.15s ease, border-color 0.15s ease;
+}
+
+.speaker-list__preview:hover {
+ border-color: var(--accent);
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.15);
+ transform: translateY(-1px);
+}
+
+.speaker-list__preview .spinner {
+ display: none;
+}
+
+.speaker-list__preview[data-loading="true"] .spinner {
+ display: inline-block;
+}
+
+.speaker-list__preview[data-loading="true"] .icon-button__glyph {
+ display: none;
+}
+
+.speaker-list__preview[data-loading="true"] {
+ cursor: progress;
+ box-shadow: none;
+ color: transparent;
+}
+
+.speaker-list__field {
+ display: flex;
+ flex-direction: column;
+ gap: 0.35rem;
+}
+
+.speaker-list__field input {
+ border-radius: 12px;
+ border: 1px solid var(--panel-border);
+ background: rgba(15, 23, 42, 0.6);
+ padding: 0.6rem 0.8rem;
+ color: var(--text);
+ font-size: 0.95rem;
+}
+
+.speaker-list__field input:focus {
+ outline: none;
+ border-color: var(--accent);
+ box-shadow: 0 0 0 2px rgba(56, 189, 248, 0.2);
+}
+
+.speaker-list__field select {
+ border-radius: 12px;
+ border: 1px solid var(--panel-border);
+ background: rgba(15, 23, 42, 0.6);
+ padding: 0.55rem 0.75rem;
+ color: var(--text);
+}
+
+.speaker-list__field select[multiple] {
+ min-height: 6rem;
+}
+
+.speaker-list__meta {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+ font-size: 0.8rem;
+ margin-bottom: 0.3rem;
+ align-items: center;
+}
+
+.speaker-gender {
+ position: relative;
+ display: inline-flex;
+ align-items: center;
+}
+
+.speaker-gender__pill {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ gap: 0.35rem;
+ padding: 0.32rem 0.8rem;
+ min-width: 8.5rem;
+ border-radius: 999px;
+ border: 1px solid rgba(56, 189, 248, 0.35);
+ background: rgba(56, 189, 248, 0.12);
+ color: var(--accent);
+ cursor: pointer;
+ transition: transform 0.15s ease, border-color 0.15s ease, box-shadow 0.15s ease;
+}
+
+.speaker-gender__pill:hover,
+.speaker-gender__pill.is-open {
+ border-color: var(--accent);
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.18);
+}
+
+.speaker-gender__menu {
+ position: absolute;
+ top: calc(100% + 0.45rem);
+ left: 0;
+ z-index: 40;
+ min-width: 220px;
+ padding: 0.75rem;
+ border-radius: 16px;
+ border: 1px solid var(--panel-border);
+ background: rgba(15, 23, 42, 0.96);
+ box-shadow: 0 18px 40px rgba(7, 14, 32, 0.55);
+}
+
+.speaker-gender__menu[hidden] {
+ display: none !important;
+}
+
+.speaker-gender__options {
+ display: grid;
+ gap: 0.35rem;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.speaker-gender__options .chip {
+ width: 100%;
+ justify-content: center;
+}
+
+.speaker-list__controls {
+ display: grid;
+ gap: 1rem;
+}
+
+.speaker-list__inline {
+ display: flex;
+ align-items: center;
+}
+
+.speaker-list__recommendations {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+ align-items: center;
+ margin-top: 0.25rem;
+}
+
+.chip {
+ border: 1px solid rgba(56, 189, 248, 0.35);
+ background: rgba(56, 189, 248, 0.12);
+ color: var(--accent);
+ border-radius: 999px;
+ padding: 0.3rem 0.7rem;
+ font-size: 0.8rem;
+ cursor: pointer;
+ transition: transform 0.15s ease, border-color 0.15s ease;
+}
+
+.chip:hover {
+ border-color: var(--accent);
+ transform: translateY(-1px);
+}
+
+.speaker-list__stats {
+ margin: 0;
+ color: var(--muted);
+ font-size: 0.85rem;
+}
+
+.prepare-metadata h2 {
+ font-size: 1rem;
+ margin: 0 0 0.6rem;
+ color: var(--muted);
+}
+
+.prepare-metadata ul {
+ margin: 0;
+ padding-left: 1.1rem;
+ display: grid;
+ gap: 0.35rem;
+ font-size: 0.95rem;
+}
+
+.prepare-form {
+ display: grid;
+ gap: 2rem;
+}
+
+.prepare-step {
+ display: grid;
+ gap: 2rem;
+}
+
+.prepare-step__header {
+ display: grid;
+ gap: 0.5rem;
+ margin-bottom: 1.5rem;
+}
+
+.chapter-grid {
+ display: grid;
+ gap: 1.25rem;
+ margin-top: 1.5rem;
+}
+
+.prepare-options {
+ display: grid;
+ gap: 1.5rem;
+ margin-top: 1.75rem;
+}
+
+@media (min-width: 880px) {
+ .prepare-options {
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ }
+ .prepare-options .field {
+ max-width: none;
+ }
+}
+
+.prepare-step__actions {
+ margin-top: 0;
+ padding-top: 1.5rem;
+ padding-bottom: 0.5rem;
+ display: flex;
+ justify-content: flex-end;
+ border-top: 1px solid rgba(148, 163, 184, 0.22);
+}
+
+.chapter-card {
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 22px;
+ padding: 1.25rem 1.5rem;
+ background: rgba(15, 23, 42, 0.32);
+ display: grid;
+ gap: 1.1rem;
+}
+
+.chapter-card[data-disabled="true"] {
+ opacity: 0.5;
+}
+
+.chapter-card__summary {
+ display: flex;
+ justify-content: space-between;
+ align-items: flex-start;
+ gap: 1.25rem;
+}
+
+.chapter-card__summary:focus-within {
+ outline: none;
+}
+
+.chapter-card__toggle {
+ border: none;
+ background: rgba(148, 163, 184, 0.1);
+ color: var(--muted);
+ width: 32px;
+ height: 32px;
+ border-radius: 50%;
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ cursor: pointer;
+ transition: background 0.2s ease, color 0.2s ease, transform 0.2s ease;
+}
+
+.chapter-card__toggle:hover,
+.chapter-card__toggle:focus-visible {
+ background: rgba(148, 163, 184, 0.2);
+ color: #fff;
+}
+
+.chapter-card__toggle[disabled] {
+ opacity: 0.45;
+ cursor: not-allowed;
+ pointer-events: none;
+}
+
+.chapter-card__toggle:focus-visible {
+ outline: 2px solid rgba(56, 189, 248, 0.45);
+ outline-offset: 2px;
+}
+
+.chapter-card__toggle-icon {
+ display: inline-flex;
+ font-size: 1rem;
+ transition: transform 0.2s ease;
+}
+
+.chapter-card[data-expanded="true"] .chapter-card__toggle-icon {
+ transform: rotate(180deg);
+}
+
+.chapter-card__details {
+ display: grid;
+ gap: 1rem;
+}
+
+.chapter-card__snippet {
+ margin: 0;
+ font-size: 0.95rem;
+ line-height: 1.5;
+ color: var(--muted);
+}
+
+.chapter-card__title {
+ font-weight: 600;
+ display: flex;
+ align-items: center;
+ gap: 0.6rem;
+}
+
+.chapter-card__checkbox {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.6rem;
+}
+
+.chapter-card__checkbox input {
+ width: 1rem;
+ height: 1rem;
+ accent-color: var(--accent);
+}
+
+.speaker-configs__layout {
+ display: grid;
+ gap: 2rem;
+ grid-template-columns: minmax(220px, 280px) minmax(0, 1fr);
+ align-items: start;
+}
+
+.speaker-configs__sidebar {
+ display: grid;
+ gap: 1rem;
+}
+
+.speaker-configs__sidebar-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 1rem;
+}
+
+.speaker-configs__list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 0.75rem;
+}
+
+.speaker-configs__entry {
+ border: 1px solid var(--panel-border);
+ border-radius: 18px;
+ padding: 0.9rem 1rem;
+ background: rgba(15, 23, 42, 0.35);
+ display: grid;
+ gap: 0.35rem;
+}
+
+.speaker-configs__entry.is-active {
+ border-color: rgba(56, 189, 248, 0.45);
+ background: rgba(56, 189, 248, 0.12);
+}
+
+.speaker-configs__entry a {
+ color: #fff;
+ font-weight: 600;
+ text-decoration: none;
+}
+
+.speaker-configs__entry a:hover {
+ color: var(--accent);
+}
+
+.speaker-configs__meta {
+ color: var(--muted);
+ font-size: 0.85rem;
+}
+
+.speaker-configs__delete {
+ margin: 0;
+ justify-self: flex-start;
+}
+
+.speaker-configs__empty {
+ padding: 0.75rem 0;
+ color: var(--muted);
+ font-style: italic;
+}
+
+.speaker-config-form__grid {
+ display: grid;
+ gap: 1rem;
+ grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+}
+
+.speaker-config-form .field--full {
+ grid-column: 1 / -1;
+}
+
+.speaker-config-rows {
+ margin-top: 2rem;
+ display: grid;
+ gap: 1rem;
+}
+
+.speaker-config-rows__header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 1rem;
+}
+
+.speaker-config-rows__list {
+ display: grid;
+ gap: 1rem;
+}
+
+.speaker-config-rows__empty {
+ border: 1px dashed rgba(148, 163, 184, 0.35);
+ border-radius: 16px;
+ padding: 1rem;
+ color: var(--muted);
+ font-style: italic;
+}
+
+.speaker-config-row {
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ border-radius: 18px;
+ background: rgba(15, 23, 42, 0.4);
+ padding: 1rem 1.25rem;
+ display: grid;
+ gap: 1rem;
+}
+
+.speaker-config-row__grid {
+ display: grid;
+ gap: 1rem;
+ grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}
+
+.speaker-config-row__footer {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ gap: 1rem;
+ flex-wrap: wrap;
+}
+
+.speaker-configs__actions {
+ margin-top: 2rem;
+ display: flex;
+ flex-wrap: wrap;
+ gap: 1rem;
+ align-items: center;
+}
+
+.button--small {
+ padding: 0.5rem 0.85rem;
+ font-size: 0.85rem;
+}
+
+.chapter-card__field label {
+ font-size: 0.85rem;
+ color: var(--muted);
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+}
+
+.chapter-card__field input,
+.chapter-card__field select {
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.22);
+ background: rgba(15, 23, 42, 0.45);
+ padding: 0.7rem 0.9rem;
+ color: var(--text);
+ font-size: 0.95rem;
+}
+
+.chapter-card__preview summary {
+ cursor: pointer;
+ color: var(--accent);
+ font-weight: 500;
+}
+
+.chapter-card__preview pre {
+ margin: 0.35rem 0 0;
+ padding: 0.75rem 0.9rem;
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ background: rgba(15, 23, 42, 0.55);
+ max-height: 200px;
+ overflow-y: auto;
+ font-size: 0.85rem;
+ line-height: 1.45;
+ white-space: pre-wrap;
+}
+
+.chapter-card__formula {
+ max-width: 420px;
+}
+
+.prepare-actions {
+ display: flex;
+ justify-content: flex-end;
+ align-items: center;
+ gap: 1rem;
+ padding-top: 1.25rem;
+}
+
+.prepare-actions .button {
+ min-width: 200px;
+ padding-left: 1.75rem;
+ padding-right: 1.75rem;
+}
+
+.prepare-actions .button--ghost {
+ border-color: rgba(148, 163, 184, 0.35);
+}
+
+.toggle-pill input:checked + span {
+ background: rgba(56, 189, 248, 0.15);
+ border-color: rgba(56, 189, 248, 0.4);
+ color: var(--accent);
+}
+
+@media (max-width: 1024px) {
+ .prepare-summary {
+ grid-template-columns: 1fr;
+ }
+
+ .prepare-summary__stats dl {
+ grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+ }
+}
+
+@media (max-width: 880px) {
+ .form-grid {
+ grid-template-columns: 1fr;
+ }
+
+ .voice-preview {
+ width: 100%;
+ }
+}
+
+.hint {
+ margin: 0;
+ font-size: 0.8rem;
+ color: var(--muted);
+}
+
+.settings__actions {
+ display: flex;
+ justify-content: flex-end;
+}
+
+.pill-grid {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.pill {
+ border-radius: 999px;
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ padding: 0.35rem 0.75rem;
+ font-size: 0.8rem;
+ color: var(--muted);
+ background: rgba(15, 23, 42, 0.4);
+}
+
+.text-preview {
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ border-radius: 18px;
+ background: rgba(15, 23, 42, 0.35);
+ padding: 1.1rem 1.25rem;
+ display: grid;
+ gap: 0.85rem;
+ min-height: 220px;
+}
+
+.text-preview__header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+}
+
+.text-preview__header h2 {
+ margin: 0;
+ font-size: 1rem;
+ font-weight: 600;
+}
+
+.text-preview__meta {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.35rem;
+ font-size: 0.85rem;
+ color: var(--muted);
+}
+
+.text-preview__body {
+ margin: 0;
+ white-space: pre-wrap;
+ word-break: break-word;
+ font-family: inherit;
+ font-size: 0.95rem;
+ line-height: 1.5;
+ color: var(--text);
+}
+
+.text-preview[data-state="empty"] .text-preview__body {
+ color: var(--muted);
+}
+
+progress.progress {
+ width: 100%;
+ height: 0.6rem;
+ border-radius: 999px;
+ overflow: hidden;
+ background: rgba(148, 163, 184, 0.15);
+}
+
+progress.progress::-webkit-progress-bar {
+ background: rgba(148, 163, 184, 0.15);
+ border-radius: 999px;
+}
+
+progress.progress::-webkit-progress-value {
+ background: linear-gradient(90deg, var(--accent), var(--accent-strong));
+ border-radius: 999px;
+}
+
+progress.progress::-moz-progress-bar {
+ background: linear-gradient(90deg, var(--accent), var(--accent-strong));
+ border-radius: 999px;
+}
+
+.voice-mixer__header {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: 1.5rem;
+ margin-bottom: 1.5rem;
+}
+
+.voice-mixer__header-actions {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+}
+
+.voice-mixer__layout {
+ display: grid;
+ grid-template-columns: minmax(260px, 300px) 1fr;
+ gap: 2.25rem;
+ align-items: start;
+}
+
+.voice-mixer__profiles {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+ border-right: 1px solid var(--panel-border);
+ padding-right: 1.5rem;
+}
+
+.voice-list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: grid;
+ gap: 0.75rem;
+}
+
+.voice-list__header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+}
+
+.voice-list__item {
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 16px;
+ padding: 0.75rem 1rem;
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+ background: rgba(15, 23, 42, 0.35);
+ transition: border 0.2s ease, background 0.2s ease;
+}
+
+.voice-list__item.is-selected {
+ border-color: var(--accent);
+ background: rgba(56, 189, 248, 0.1);
+}
+
+.voice-list__select {
+ all: unset;
+ display: flex;
+ flex-direction: column;
+ gap: 0.25rem;
+ cursor: pointer;
+}
+
+.voice-list__select:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 3px;
+}
+
+.voice-list__name {
+ font-weight: 600;
+}
+
+.voice-list__meta {
+ font-size: 0.78rem;
+ color: var(--muted);
+}
+
+.voice-list__actions {
+ display: flex;
+ gap: 0.5rem;
+}
+
+.voice-list__action {
+ border: none;
+ border-radius: 999px;
+ padding: 0.35rem 0.65rem;
+ font-size: 0.75rem;
+ cursor: pointer;
+ background: rgba(148, 163, 184, 0.15);
+ color: var(--muted);
+ transition: background 0.2s ease, color 0.2s ease;
+}
+
+.voice-list__action:hover {
+ background: rgba(56, 189, 248, 0.18);
+ color: var(--accent);
+}
+
+.voice-list__action--danger:hover {
+ background: rgba(248, 113, 113, 0.2);
+ color: var(--danger);
+}
+
+.voice-editor {
+ display: flex;
+ flex-direction: column;
+ gap: 1.5rem;
+}
+
+.voice-editor__meta {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.voice-editor__identity {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ gap: 0.75rem 1rem;
+ align-items: end;
+}
+
+.voice-editor__name-field {
+ min-width: 200px;
+}
+
+.voice-editor__toolbar {
+ display: inline-flex;
+ align-items: center;
+ justify-content: flex-end;
+ gap: 0.65rem;
+ min-height: 2.6rem;
+}
+
+.voice-editor__language {
+ max-width: 260px;
+ width: min(100%, 260px);
+}
+
+.voice-editor__summary {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+ flex-wrap: wrap;
+}
+
+.voice-editor__canvas {
+ display: grid;
+ grid-template-columns: minmax(280px, 340px) minmax(320px, 1fr);
+ gap: 2rem;
+ align-items: start;
+}
+
+.voice-available,
+.voice-mix {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.voice-available__header,
+.voice-mix__header {
+ display: flex;
+ align-items: flex-end;
+ justify-content: space-between;
+ gap: 1rem;
+ flex-wrap: wrap;
+}
+
+.voice-available__title {
+ display: flex;
+ flex-direction: column;
+ gap: 0.25rem;
+}
+
+.voice-filter {
+ display: flex;
+ flex-direction: column;
+ gap: 0.35rem;
+ min-width: 180px;
+}
+
+.voice-filter__label {
+ font-size: 0.75rem;
+ font-weight: 600;
+ letter-spacing: 0.04em;
+ text-transform: uppercase;
+ color: var(--muted);
+}
+
+.voice-filter__controls {
+ display: flex;
+ align-items: center;
+ gap: 0.75rem;
+ flex-wrap: wrap;
+}
+
+.voice-filter select {
+ border-radius: 12px;
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ background: rgba(15, 23, 42, 0.55);
+ padding: 0.55rem 0.75rem;
+ color: var(--text);
+ font-size: 0.95rem;
+ min-width: 0;
+ flex: 1 1 200px;
+}
+
+.voice-filter select:focus {
+ outline: none;
+ border-color: var(--accent);
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.15);
+}
+
+.voice-gender-filter {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.35rem;
+ flex: 0 0 auto;
+}
+
+.voice-gender-filter__button {
+ border: 1px solid rgba(148, 163, 184, 0.3);
+ background: rgba(15, 23, 42, 0.45);
+ color: var(--muted);
+ font-size: 1.05rem;
+ line-height: 1;
+ width: 2.25rem;
+ height: 2.25rem;
+ border-radius: 999px;
+ cursor: pointer;
+ transition: border 0.2s ease, background 0.2s ease, color 0.2s ease;
+}
+
+.voice-gender-filter__button:hover {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+.voice-gender-filter__button[aria-pressed="true"] {
+ background: rgba(56, 189, 248, 0.16);
+ border-color: var(--accent);
+ color: #fff;
+ box-shadow: 0 0 0 3px rgba(56, 189, 248, 0.15);
+}
+
+.voice-available__list {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+ gap: 0.85rem;
+ max-height: 55vh;
+ overflow-y: auto;
+ padding-right: 0.5rem;
+}
+
+.voice-available__empty {
+ margin: 0;
+ padding: 1.25rem 1rem;
+ text-align: center;
+ border: 1px dashed rgba(148, 163, 184, 0.25);
+ border-radius: 16px;
+ color: var(--muted);
+ background: rgba(15, 23, 42, 0.3);
+}
+
+.voice-available__card {
+ border: 1px solid rgba(148, 163, 184, 0.18);
+ border-radius: 18px;
+ background: rgba(15, 23, 42, 0.33);
+ padding: 0.9rem 1rem;
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 0.75rem;
+ cursor: grab;
+ transition: border 0.2s ease, transform 0.2s ease, background 0.2s ease;
+}
+
+.voice-available__card:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 3px;
+}
+
+.voice-available__card:hover {
+ border-color: var(--accent);
+ transform: translateY(-1px);
+}
+
+.voice-available__card.is-active {
+ border-color: rgba(56, 189, 248, 0.35);
+ background: rgba(56, 189, 248, 0.12);
+ cursor: default;
+}
+
+.voice-available__info {
+ display: flex;
+ flex-direction: column;
+ gap: 0.25rem;
+}
+
+.voice-available__name {
+ font-weight: 600;
+}
+
+.voice-available__meta {
+ font-size: 0.78rem;
+ color: var(--muted);
+}
+
+.voice-available__add {
+ border: none;
+ border-radius: 12px;
+ padding: 0.4rem 0.85rem;
+ cursor: pointer;
+ background: rgba(56, 189, 248, 0.15);
+ color: var(--accent);
+ font-weight: 600;
+ transition: background 0.2s ease, color 0.2s ease;
+}
+
+.voice-available__add:hover:not(:disabled) {
+ background: rgba(56, 189, 248, 0.25);
+ color: #fff;
+}
+
+.voice-available__add:disabled {
+ cursor: default;
+ background: rgba(148, 163, 184, 0.2);
+ color: var(--muted);
+}
+
+.voice-mix__dropzone {
+ border: 2px dashed rgba(148, 163, 184, 0.25);
+ border-radius: 20px;
+ padding: 1.5rem;
+ min-height: 320px;
+ background: rgba(15, 23, 42, 0.25);
+ transition: border 0.2s ease, background 0.2s ease;
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.voice-mix__dropzone.is-hovered {
+ border-color: var(--accent);
+ background: rgba(56, 189, 248, 0.08);
+}
+
+.voice-mix__empty {
+ margin: 0;
+ text-align: center;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.voice-mix__list {
+ display: flex;
+ flex-direction: column;
+ gap: 1rem;
+}
+
+.mix-voice {
+ border: 1px solid rgba(148, 163, 184, 0.2);
+ border-radius: 18px;
+ background: rgba(15, 23, 42, 0.4);
+ padding: 1.1rem 1.2rem;
+ display: flex;
+ flex-direction: column;
+ gap: 0.9rem;
+}
+
+.mix-voice__header {
+ display: flex;
+ align-items: center;
+ gap: 0.75rem;
+}
+
+.mix-voice__info {
+ display: flex;
+ flex-direction: column;
+ gap: 0.25rem;
+}
+
+.mix-voice__title {
+ font-weight: 600;
+}
+
+.mix-voice__meta {
+ font-size: 0.78rem;
+ color: var(--muted);
+}
+
+.mix-voice__weight {
+ margin-left: auto;
+ font-size: 0.85rem;
+ font-weight: 600;
+ color: var(--accent);
+}
+
+.mix-voice__remove {
+ border: none;
+ border-radius: 12px;
+ width: 28px;
+ height: 28px;
+ background: rgba(248, 113, 113, 0.2);
+ color: #fca5a5;
+ font-size: 1.1rem;
+ cursor: pointer;
+ line-height: 1;
+ display: grid;
+ place-items: center;
+ transition: background 0.2s ease, color 0.2s ease;
+}
+
+.mix-voice__remove:hover {
+ background: rgba(248, 113, 113, 0.35);
+ color: #fff;
+}
+
+.mix-slider {
+ width: 100%;
+ appearance: none;
+ height: 8px;
+ border-radius: 999px;
+ background: rgba(148, 163, 184, 0.25);
+ outline: none;
+ cursor: pointer;
+ transition: box-shadow 0.2s ease;
+}
+
+.mix-slider:focus-visible {
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.2);
+}
+
+.mix-slider::-webkit-slider-thumb {
+ appearance: none;
+ width: 18px;
+ height: 18px;
+ border-radius: 50%;
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ box-shadow: 0 6px 15px rgba(14, 165, 233, 0.4);
+ border: none;
+}
+
+.mix-slider::-moz-range-thumb {
+ width: 18px;
+ height: 18px;
+ border-radius: 50%;
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ border: none;
+ box-shadow: 0 6px 15px rgba(14, 165, 233, 0.4);
+}
+
+.voice-editor__actions {
+ display: grid;
+ gap: 1.25rem;
+}
+
+.voice-preview {
+ display: grid;
+ gap: 0.9rem;
+ padding: 1rem 1.25rem;
+ border-radius: 18px;
+ border: 1px solid rgba(148, 163, 184, 0.22);
+ background: rgba(15, 23, 42, 0.6);
+ box-shadow: 0 16px 40px rgba(8, 15, 32, 0.45);
+ width: min(100%, 520px);
+}
+
+.field--slider {
+ display: flex;
+ flex-direction: column;
+ gap: 0.65rem;
+ align-items: flex-start;
+ width: min(100%, 420px);
+}
+
+.field--slider label {
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+}
+
+#preview-speed {
+ width: 100%;
+ appearance: none;
+ height: 8px;
+ border-radius: 999px;
+ background: rgba(148, 163, 184, 0.25);
+ outline: none;
+ transition: box-shadow 0.2s ease;
+}
+
+#preview-speed:focus-visible {
+ box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.2);
+}
+
+#preview-speed::-webkit-slider-thumb {
+ appearance: none;
+ width: 18px;
+ height: 18px;
+ border-radius: 50%;
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ border: none;
+ box-shadow: 0 6px 15px rgba(14, 165, 233, 0.4);
+}
+
+#preview-speed::-moz-range-thumb {
+ width: 18px;
+ height: 18px;
+ border-radius: 50%;
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ border: none;
+ box-shadow: 0 6px 15px rgba(14, 165, 233, 0.4);
+}
+
+.voice-preview__controls {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.75rem;
+ justify-content: flex-start;
+ width: min(100%, 420px);
+}
+
+.voice-preview audio {
+ width: min(100%, 420px);
+ border-radius: 12px;
+ background: rgba(15, 23, 42, 0.45);
+ border: 1px solid rgba(148, 163, 184, 0.18);
+}
+
+.voice-preview textarea {
+ border-radius: 14px;
+ border: 1px solid rgba(148, 163, 184, 0.25);
+ background: rgba(11, 18, 34, 0.85);
+ min-height: 140px;
+ width: min(100%, 420px);
+ max-width: 420px;
+ align-self: flex-start;
+}
+
+.voice-status {
+ min-height: 1.2rem;
+ font-size: 0.9rem;
+}
+
+.voice-status--info {
+ color: var(--accent);
+}
+
+.voice-status--success {
+ color: var(--success);
+}
+
+.voice-status--warning {
+ color: var(--warning);
+}
+
+.voice-status--danger {
+ color: var(--danger);
+}
+
+.voice-mixer[data-state="loading"] .voice-editor {
+ opacity: 0.6;
+ pointer-events: none;
+}
+
+[data-state="locked"] {
+ cursor: not-allowed;
+}
+
+select[data-state="locked"],
+input[data-state="locked"] {
+ background: rgba(15, 23, 42, 0.35);
+ color: rgba(148, 163, 184, 0.8);
+ border-color: rgba(148, 163, 184, 0.2);
+}
+
+.icon-button {
+ appearance: none;
+ border-radius: 16px;
+ width: 2.6rem;
+ height: 2.6rem;
+ display: grid;
+ place-items: center;
+ border: 1px solid rgba(148, 163, 184, 0.25);
+ background: rgba(15, 23, 42, 0.4);
+ color: var(--muted);
+ cursor: pointer;
+ transition: color 0.2s ease, border 0.2s ease, background 0.2s ease, box-shadow 0.2s ease;
+}
+
+.voice-editor__identity > .voice-editor__toolbar {
+ align-self: end;
+}
+
+.icon-button svg {
+ width: 1.15rem;
+ height: 1.15rem;
+}
+
+.icon-button:hover {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+.icon-button:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+
+.icon-button:disabled {
+ opacity: 0.45;
+ cursor: not-allowed;
+ box-shadow: none;
+}
+
+.icon-button--borderless {
+ background: transparent;
+ border-color: transparent;
+}
+
+.icon-button--borderless:hover {
+ background: rgba(148, 163, 184, 0.1);
+ border-color: rgba(148, 163, 184, 0.3);
+}
+
+.icon-button--borderless:focus-visible {
+ border-color: var(--accent);
+}
+
+.icon-button--primary {
+ background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+ border: none;
+ color: #fff;
+ box-shadow: 0 10px 25px rgba(56, 189, 248, 0.32);
+}
+
+.icon-button--primary:hover {
+ box-shadow: 0 14px 28px rgba(14, 165, 233, 0.4);
+}
+
+.icon-button--danger {
+ background: linear-gradient(135deg, var(--danger), #ef4444);
+ border: none;
+ color: #fff;
+ box-shadow: 0 10px 25px rgba(239, 68, 68, 0.28);
+}
+
+.icon-button--danger:hover {
+ box-shadow: 0 14px 30px rgba(248, 113, 113, 0.35);
+}
+
+.icon-button--danger:disabled {
+ background: rgba(248, 113, 113, 0.2);
+ color: rgba(248, 113, 113, 0.65);
+ border: 1px solid rgba(248, 113, 113, 0.25);
+}
+
+.icon-button--primary:disabled {
+ background: rgba(56, 189, 248, 0.25);
+ border: 1px solid rgba(56, 189, 248, 0.2);
+ color: rgba(255, 255, 255, 0.8);
+ box-shadow: none;
+}
+
+.spinner {
+ display: inline-block;
+ width: 1.1rem;
+ height: 1.1rem;
+ border-radius: 50%;
+ border: 2px solid rgba(148, 163, 184, 0.28);
+ border-top-color: var(--accent);
+ animation: spin 0.8s linear infinite;
+}
+
+.spinner--sm {
+ width: 0.85rem;
+ height: 0.85rem;
+}
+
+.spinner--lg {
+ width: 1.5rem;
+ height: 1.5rem;
+ border-width: 3px;
+}
+
+.spinner--muted {
+ border-color: rgba(148, 163, 184, 0.2);
+ border-top-color: rgba(148, 163, 184, 0.6);
+}
+
+.button[data-role="preview-button"] {
+ position: relative;
+}
+
+.button[data-role="preview-button"][data-loading="true"] {
+ padding-left: 2.8rem;
+ color: rgba(255, 255, 255, 0.8);
+}
+
+.button[data-role="preview-button"][data-loading="true"]::after {
+ content: "";
+ position: absolute;
+ left: 1.1rem;
+ top: 50%;
+ width: 1rem;
+ height: 1rem;
+ margin-top: -0.5rem;
+ border-radius: 50%;
+ border: 2px solid rgba(255, 255, 255, 0.35);
+ border-right-color: rgba(255, 255, 255, 0.85);
+ animation: spin 0.8s linear infinite;
+}
+
+@media (prefers-reduced-motion: reduce) {
+ .button[data-role="preview-button"][data-loading="true"]::after,
+ .button[data-loading="true"]:not([data-role="preview-button"])::after,
+ [data-role="new-job-modal"][data-submitting="true"] .wizard-card__stage::before,
+ .spinner {
+ animation-duration: 1.6s;
+ }
+}
+
+@media (max-width: 980px) {
+ .voice-mixer__layout {
+ grid-template-columns: 1fr;
+ }
+
+ .voice-mixer__profiles {
+ border-right: none;
+ border-bottom: 1px solid var(--panel-border);
+ padding-right: 0;
+ padding-bottom: 1.5rem;
+ margin-bottom: 1.5rem;
+ }
+
+ .voice-editor__canvas {
+ grid-template-columns: 1fr;
+ }
+
+ .voice-available__list {
+ max-height: none;
+ padding-right: 0;
+ }
+
+ .voice-available__header,
+ .voice-mix__header {
+ align-items: stretch;
+ }
+
+ .voice-filter {
+ width: 100%;
+ }
+
+ .voice-mix__dropzone {
+ min-height: 220px;
+ }
+
+ .field--slider label {
+ flex-direction: column;
+ align-items: flex-start;
+ }
+}
+
+@media (max-width: 720px) {
+ .voice-editor__identity {
+ grid-template-columns: 1fr;
+ }
+
+ .voice-editor__toolbar {
+ justify-content: flex-start;
+ }
+
+ .settings__section {
+ grid-template-columns: 1fr;
+ }
+
+ .field--choices {
+ grid-template-columns: 1fr;
+ }
+}
+
+@keyframes spin {
+ 0% {
+ transform: rotate(0deg);
+ }
+ 100% {
+ transform: rotate(360deg);
+ }
+}
+
+.entity-tabs__status {
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+ margin-left: auto;
+ color: var(--muted);
+ font-size: 0.875rem;
+ padding-right: 1rem;
+}
+
+.entity-tabs__status-text {
+ font-weight: 500;
+ animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+ 0%, 100% { opacity: 1; }
+ 50% { opacity: 0.6; }
+}
diff --git a/abogen/webui/static/voices.js b/abogen/webui/static/voices.js
new file mode 100644
index 0000000..5341c56
--- /dev/null
+++ b/abogen/webui/static/voices.js
@@ -0,0 +1,1206 @@
+const setupVoiceMixer = () => {
+ const data = window.ABOGEN_VOICE_MIXER_DATA || {};
+ const languages = data.languages || {};
+ const voiceCatalog = Array.isArray(data.voice_catalog) ? data.voice_catalog : [];
+ const samples = data.sample_voice_texts || {};
+ let profiles = data.voice_profiles_data || {};
+
+ const app = document.getElementById("voice-mixer-app");
+ if (!app) {
+ return;
+ }
+
+ const profileListEl = app.querySelector('[data-role="profile-list"]');
+ const statusEl = app.querySelector('[data-role="status"]');
+ const saveBtn = app.querySelector('[data-role="save-profile"]');
+ const duplicateBtn = app.querySelector('[data-role="duplicate-profile"]');
+ const deleteBtn = app.querySelector('[data-role="delete-profile"]');
+ const previewBtn = app.querySelector('[data-role="preview-button"]');
+ const loadSampleBtn = app.querySelector('[data-role="load-sample"]');
+ const previewTextEl = app.querySelector('[data-role="preview-text"]');
+ const previewAudio = app.querySelector('[data-role="preview-audio"]');
+ const previewSpeedLabel = app.querySelector('[data-role="preview-speed-display"]');
+ const profileSummaryEl = app.querySelector('[data-role="profile-summary"]');
+ const mixTotalEl = app.querySelector('[data-role="mix-total"]');
+ const nameInput = document.getElementById("profile-name");
+ const languageSelect = document.getElementById("profile-language");
+ const languageField = app.querySelector(".voice-editor__language");
+ const providerSelect = document.getElementById("profile-provider");
+ const kokoroMixerEl = app.querySelector('[data-role="kokoro-mixer"]');
+ const supertonicPanelEl = app.querySelector('[data-role="supertonic-panel"]');
+ const supertonicVoiceSelect = app.querySelector('[data-role="supertonic-voice"]');
+ const supertonicStepsInput = app.querySelector('[data-role="supertonic-steps"]');
+ const supertonicSpeedInput = app.querySelector('[data-role="supertonic-speed"]');
+ const supertonicStepsLabel = app.querySelector('[data-role="supertonic-steps-display"]');
+ const supertonicSpeedLabel = app.querySelector('[data-role="supertonic-speed-display"]');
+ const speedInput = document.getElementById("preview-speed");
+ const importInput = document.getElementById("voice-import-input");
+ const headerActions = document.querySelector(".voice-mixer__header-actions");
+ const availableListEl = app.querySelector('[data-role="available-voices"]');
+ const selectedListEl = app.querySelector('[data-role="selected-voices"]');
+ const dropzoneEl = app.querySelector('[data-role="dropzone"]');
+ const emptyStateEl = app.querySelector('[data-role="mix-empty"]');
+ const voiceFilterSelect = app.querySelector('[data-role="voice-filter"]');
+ const genderFilterEl = app.querySelector('[data-role="gender-filter"]');
+
+ const providerPickerModal = document.querySelector('[data-role="provider-picker-modal"]');
+ const providerPickerOverlay = document.querySelector('[data-role="provider-picker-overlay"]');
+ const providerPickerClose = document.querySelector('[data-role="provider-picker-close"]');
+ const providerPickerCancel = document.querySelector('[data-role="provider-picker-cancel"]');
+ const providerPickerConfirm = document.querySelector('[data-role="provider-picker-confirm"]');
+ const providerPickerOptions = document.querySelector('[data-role="provider-picker-options"]');
+
+ if (previewBtn && !previewBtn.dataset.label) {
+ previewBtn.dataset.label = previewBtn.textContent.trim();
+ }
+
+ if (!profileListEl || !availableListEl || !selectedListEl) {
+ return;
+ }
+
+ const voiceLookup = new Map();
+ voiceCatalog.forEach((voice) => {
+ if (voice && voice.id) {
+ voiceLookup.set(voice.id, voice);
+ }
+ });
+
+ const availableCards = new Map();
+ const selectedControls = new Map();
+
+ const state = {
+ selectedProfile: null,
+ originalName: null,
+ dirty: false,
+ previewUrl: null,
+ draft: {
+ name: "",
+ provider: "kokoro",
+ language: "a",
+ voices: new Map(),
+ supertonic: {
+ voice: "M1",
+ total_steps: 5,
+ speed: 1.0,
+ },
+ },
+ languageFilter: voiceFilterSelect ? voiceFilterSelect.value : "",
+ genderFilter: "",
+ };
+
+ let statusTimeout = null;
+
+ const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+ const formatWeight = (value) => value.toFixed(2);
+
+ const setSliderFill = (slider, weight) => {
+ const percent = Math.round(clamp(weight, 0, 1) * 100);
+ slider.style.background = `linear-gradient(90deg, var(--accent) 0%, var(--accent) ${percent}%, rgba(148, 163, 184, 0.25) ${percent}%, rgba(148, 163, 184, 0.25) 100%)`;
+ };
+
+ const setRangeFill = (slider) => {
+ if (!slider) return;
+ const min = parseFloat(slider.min || "0");
+ const max = parseFloat(slider.max || "1");
+ const value = parseFloat(slider.value || String(min));
+ const percent = max === min ? 0 : Math.round(((value - min) / (max - min)) * 100);
+ slider.style.background = `linear-gradient(90deg, var(--accent) 0%, var(--accent) ${percent}%, rgba(148, 163, 184, 0.25) ${percent}%, rgba(148, 163, 184, 0.25) 100%)`;
+ };
+
+ const voiceGenderIcon = (gender) => {
+ if (!gender) return "•";
+ const initial = gender[0].toLowerCase();
+ if (initial === "f") return "♀";
+ if (initial === "m") return "♂";
+ return "•";
+ };
+
+ const voiceLanguageLabel = (code) => languages[code] || code?.toUpperCase() || "";
+
+ const clearStatus = () => {
+ if (statusTimeout) {
+ clearTimeout(statusTimeout);
+ statusTimeout = null;
+ }
+ if (statusEl) {
+ statusEl.textContent = "";
+ statusEl.className = "voice-status";
+ }
+ };
+
+ const setStatus = (message, tone = "info", timeout = 4000) => {
+ if (!statusEl) return;
+ clearStatus();
+ statusEl.textContent = message;
+ statusEl.className = `voice-status voice-status--${tone}`;
+ if (timeout > 0) {
+ statusTimeout = window.setTimeout(() => {
+ clearStatus();
+ }, timeout);
+ }
+ };
+
+ const mixTotal = () => {
+ let total = 0;
+ state.draft.voices.forEach((weight) => {
+ total += weight;
+ });
+ return total;
+ };
+
+ const normalizeProvider = (value) => {
+ const candidate = String(value || "").trim().toLowerCase();
+ return candidate === "supertonic" ? "supertonic" : "kokoro";
+ };
+
+ const getProviderCatalog = () => {
+ if (!providerSelect) {
+ return [
+ { id: "kokoro", label: "Kokoro" },
+ { id: "supertonic", label: "Supertonic" },
+ ];
+ }
+ return Array.from(providerSelect.options || []).map((option) => ({
+ id: normalizeProvider(option.value),
+ label: option.textContent?.trim() || option.value,
+ }));
+ };
+
+ const providerDescription = (providerId) => {
+ const provider = normalizeProvider(providerId);
+ if (provider === "supertonic") {
+ return "Voice selection + quality/speed per speaker.";
+ }
+ return "Voice mixing supported via the Kokoro mixer.";
+ };
+
+ const openProviderPicker = (defaultProvider = "kokoro") => {
+ if (!providerPickerModal || !providerPickerOptions || !providerPickerConfirm) {
+ return Promise.resolve(normalizeProvider(defaultProvider));
+ }
+
+ providerPickerOptions.innerHTML = "";
+ const catalog = getProviderCatalog();
+ const normalizedDefault = normalizeProvider(defaultProvider);
+
+ catalog.forEach((item) => {
+ const label = document.createElement("label");
+ label.className = "toggle-pill";
+
+ const input = document.createElement("input");
+ input.type = "radio";
+ input.name = "provider-picker";
+ input.value = item.id;
+ input.checked = item.id === normalizedDefault;
+
+ const span = document.createElement("span");
+ const title = document.createElement("strong");
+ title.textContent = item.label;
+ const detail = document.createElement("span");
+ detail.className = "muted";
+ detail.textContent = ` — ${providerDescription(item.id)}`;
+ span.appendChild(title);
+ span.appendChild(detail);
+
+ label.appendChild(input);
+ label.appendChild(span);
+ providerPickerOptions.appendChild(label);
+ });
+
+ const selectedRadio = providerPickerOptions.querySelector('input[name="provider-picker"]:checked');
+ providerPickerConfirm.disabled = !selectedRadio;
+
+ return new Promise((resolve) => {
+ let resolved = false;
+ const teardown = () => {
+ providerPickerModal.dataset.open = "false";
+ providerPickerModal.hidden = true;
+ document.body.classList.remove("modal-open");
+ document.removeEventListener("keydown", onKeydown);
+ providerPickerOptions.removeEventListener("change", onChange);
+ providerPickerOverlay?.removeEventListener("click", onCancel);
+ providerPickerClose?.removeEventListener("click", onCancel);
+ providerPickerCancel?.removeEventListener("click", onCancel);
+ providerPickerConfirm?.removeEventListener("click", onConfirm);
+ };
+
+ const finish = (value) => {
+ if (resolved) return;
+ resolved = true;
+ teardown();
+ resolve(value);
+ };
+
+ const onCancel = () => finish(null);
+ const onConfirm = () => {
+ const selected = providerPickerOptions.querySelector('input[name="provider-picker"]:checked');
+ finish(selected ? normalizeProvider(selected.value) : null);
+ };
+ const onChange = () => {
+ const selected = providerPickerOptions.querySelector('input[name="provider-picker"]:checked');
+ providerPickerConfirm.disabled = !selected;
+ };
+ const onKeydown = (event) => {
+ if (event.key === "Escape") {
+ event.preventDefault();
+ onCancel();
+ }
+ };
+
+ providerPickerModal.hidden = false;
+ providerPickerModal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ document.addEventListener("keydown", onKeydown);
+ providerPickerOptions.addEventListener("change", onChange);
+ providerPickerOverlay?.addEventListener("click", onCancel);
+ providerPickerClose?.addEventListener("click", onCancel);
+ providerPickerCancel?.addEventListener("click", onCancel);
+ providerPickerConfirm?.addEventListener("click", onConfirm);
+
+ const focusTarget = providerPickerOptions.querySelector('input[name="provider-picker"]:checked')
+ || providerPickerOptions.querySelector('input[name="provider-picker"]');
+ if (focusTarget instanceof HTMLElement) {
+ focusTarget.focus();
+ }
+ });
+ };
+
+ const applyProviderToUI = () => {
+ const provider = normalizeProvider(state.draft.provider);
+ const isSupertonic = provider === "supertonic";
+ if (providerSelect) {
+ providerSelect.value = provider;
+ }
+ if (languageField) {
+ languageField.hidden = isSupertonic;
+ }
+ if (kokoroMixerEl) {
+ kokoroMixerEl.hidden = isSupertonic;
+ }
+ if (supertonicPanelEl) {
+ supertonicPanelEl.hidden = !isSupertonic;
+ }
+ if (mixTotalEl) {
+ mixTotalEl.hidden = isSupertonic;
+ }
+ if (previewBtn) {
+ previewBtn.dataset.label = isSupertonic ? "Preview speaker" : (previewBtn.dataset.label || "Preview speaker");
+ }
+
+ // Keep preview speed aligned with the Supertonic speaker speed.
+ if (isSupertonic && speedInput) {
+ const desired = Number(state.draft.supertonic?.speed ?? 1.0);
+ if (!Number.isNaN(desired)) {
+ speedInput.value = String(desired);
+ setRangeFill(speedInput);
+ }
+ }
+ };
+
+ const updateMixSummary = () => {
+ const provider = normalizeProvider(state.draft.provider);
+ const isSupertonic = provider === "supertonic";
+ if (mixTotalEl && !isSupertonic) {
+ mixTotalEl.textContent = `Total weight: ${formatWeight(mixTotal())}`;
+ }
+ if (profileSummaryEl) {
+ const voiceCount = state.draft.voices.size;
+ if (!state.draft.name && !voiceCount) {
+ profileSummaryEl.textContent = "Select or create a speaker to begin.";
+ } else {
+ const profileLabel = state.draft.name ? `Editing: ${state.draft.name}` : "Unsaved speaker";
+ if (isSupertonic) {
+ profileSummaryEl.textContent = `${profileLabel} · Supertonic`;
+ } else {
+ profileSummaryEl.textContent = `${profileLabel} · ${voiceCount} voice${voiceCount === 1 ? "" : "s"}`;
+ }
+ }
+ }
+ };
+
+ const markDirty = () => {
+ state.dirty = true;
+ if (saveBtn) {
+ saveBtn.disabled = false;
+ }
+ };
+
+ const resetDirty = () => {
+ state.dirty = false;
+ if (saveBtn) {
+ saveBtn.disabled = true;
+ }
+ };
+
+ const ensureEmptyState = () => {
+ if (!emptyStateEl) return;
+ emptyStateEl.hidden = state.draft.voices.size > 0;
+ };
+
+ const updateAvailableState = () => {
+ availableCards.forEach(({ card, addButton }, voiceId) => {
+ const isActive = state.draft.voices.has(voiceId);
+ card.classList.toggle("is-active", isActive);
+ if (addButton) {
+ addButton.disabled = isActive;
+ addButton.textContent = isActive ? "Added" : "Add";
+ }
+ });
+ };
+
+ const updateGenderFilterButtons = () => {
+ if (!genderFilterEl) return;
+ const buttons = genderFilterEl.querySelectorAll("[data-value]");
+ buttons.forEach((button) => {
+ const value = button.getAttribute("data-value") || "";
+ const pressed = value === state.genderFilter;
+ button.setAttribute("aria-pressed", pressed ? "true" : "false");
+ });
+ };
+
+ const setSliderFocus = (voiceId) => {
+ const control = selectedControls.get(voiceId);
+ if (control?.slider) {
+ control.slider.focus({ preventScroll: false });
+ }
+ };
+
+ const renderSelectedVoices = () => {
+ selectedControls.clear();
+ selectedListEl.innerHTML = "";
+
+ state.draft.voices.forEach((weight, voiceId) => {
+ const meta = voiceLookup.get(voiceId) || {};
+ const card = document.createElement("div");
+ card.className = "mix-voice";
+ card.dataset.voiceId = voiceId;
+
+ const header = document.createElement("div");
+ header.className = "mix-voice__header";
+
+ const titleWrap = document.createElement("div");
+ titleWrap.className = "mix-voice__info";
+
+ const title = document.createElement("div");
+ title.className = "mix-voice__title";
+ title.textContent = meta.display_name || meta.name || voiceId;
+
+ const metaLabel = document.createElement("div");
+ metaLabel.className = "mix-voice__meta";
+ const languageCode = meta.language || voiceId.charAt(0) || "a";
+ metaLabel.textContent = `${voiceLanguageLabel(languageCode)} · ${voiceGenderIcon(meta.gender)}`;
+
+ titleWrap.appendChild(title);
+ titleWrap.appendChild(metaLabel);
+
+ const weightLabel = document.createElement("span");
+ weightLabel.className = "mix-voice__weight";
+ weightLabel.textContent = formatWeight(weight);
+
+ const removeBtn = document.createElement("button");
+ removeBtn.type = "button";
+ removeBtn.className = "mix-voice__remove";
+ removeBtn.setAttribute("aria-label", `Remove ${title.textContent} from mix`);
+ removeBtn.innerHTML = "×";
+ removeBtn.addEventListener("click", () => {
+ state.draft.voices.delete(voiceId);
+ renderSelectedVoices();
+ updateAvailableState();
+ updateMixSummary();
+ markDirty();
+ });
+
+ header.appendChild(titleWrap);
+ header.appendChild(weightLabel);
+ header.appendChild(removeBtn);
+
+ const slider = document.createElement("input");
+ slider.type = "range";
+ slider.min = "5";
+ slider.max = "100";
+ slider.step = "1";
+ slider.className = "mix-slider";
+ const normalizedWeight = clamp(weight, 0.05, 1);
+ slider.value = String(Math.round(normalizedWeight * 100));
+ setSliderFill(slider, normalizedWeight);
+ slider.addEventListener("input", () => {
+ const value = clamp(Number(slider.value) / 100, 0.05, 1);
+ slider.value = String(Math.round(value * 100));
+ state.draft.voices.set(voiceId, value);
+ weightLabel.textContent = formatWeight(value);
+ setSliderFill(slider, value);
+ updateMixSummary();
+ markDirty();
+ });
+
+ card.appendChild(header);
+ card.appendChild(slider);
+ selectedListEl.appendChild(card);
+
+ selectedControls.set(voiceId, { slider, weightLabel });
+ });
+
+ ensureEmptyState();
+ };
+
+ const renderAvailableVoices = () => {
+ availableCards.clear();
+ availableListEl.innerHTML = "";
+
+ const sortedVoices = voiceCatalog
+ .slice()
+ .sort((a, b) => (a.display_name || a.id).localeCompare(b.display_name || b.id));
+
+ const filteredVoices = sortedVoices.filter((voice) => {
+ const languageCode = voice.language || voice.id?.charAt(0) || "a";
+ const languageMatch = !state.languageFilter || state.languageFilter === languageCode;
+ const genderCode = (voice.gender || "").charAt(0).toLowerCase();
+ const genderMatch = !state.genderFilter || state.genderFilter === genderCode;
+ return languageMatch && genderMatch;
+ });
+
+ if (!filteredVoices.length) {
+ const empty = document.createElement("p");
+ empty.className = "voice-available__empty";
+ const filters = [];
+ if (state.languageFilter) {
+ filters.push(voiceLanguageLabel(state.languageFilter) || state.languageFilter.toUpperCase());
+ }
+ if (state.genderFilter) {
+ filters.push(state.genderFilter === "f" ? "♀ Female" : "♂ Male");
+ }
+ if (filters.length) {
+ empty.innerHTML = `No voices match ${filters.join(" · ")}.`;
+ } else {
+ empty.textContent = "No voices available.";
+ }
+ availableListEl.appendChild(empty);
+ updateAvailableState();
+ updateGenderFilterButtons();
+ return;
+ }
+
+ filteredVoices.forEach((voice) => {
+ if (!voice?.id) {
+ return;
+ }
+ const card = document.createElement("article");
+ card.className = "voice-available__card";
+ card.draggable = true;
+ card.dataset.voiceId = voice.id;
+ card.tabIndex = 0;
+
+ card.addEventListener("dragstart", (event) => {
+ card.classList.add("is-dragging");
+ if (event.dataTransfer) {
+ event.dataTransfer.effectAllowed = "copy";
+ event.dataTransfer.setData("text/plain", voice.id);
+ }
+ });
+
+ card.addEventListener("dragend", () => {
+ card.classList.remove("is-dragging");
+ });
+
+ card.addEventListener("dblclick", () => {
+ addVoiceToDraft(voice.id);
+ });
+
+ card.addEventListener("keydown", (event) => {
+ if (event.key === "Enter" || event.key === " ") {
+ event.preventDefault();
+ addVoiceToDraft(voice.id);
+ }
+ });
+
+ const info = document.createElement("div");
+ info.className = "voice-available__info";
+
+ const name = document.createElement("div");
+ name.className = "voice-available__name";
+ name.textContent = voice.display_name || voice.id;
+
+ const meta = document.createElement("div");
+ meta.className = "voice-available__meta";
+ const languageCode = voice.language || voice.id.charAt(0) || "a";
+ meta.textContent = `${voiceLanguageLabel(languageCode)} · ${voiceGenderIcon(voice.gender)}`;
+
+ info.appendChild(name);
+ info.appendChild(meta);
+
+ const addButton = document.createElement("button");
+ addButton.type = "button";
+ addButton.className = "voice-available__add";
+ addButton.textContent = "Add";
+ addButton.addEventListener("click", (event) => {
+ event.stopPropagation();
+ addVoiceToDraft(voice.id);
+ });
+
+ card.appendChild(info);
+ card.appendChild(addButton);
+ availableListEl.appendChild(card);
+
+ availableCards.set(voice.id, { card, addButton });
+ });
+
+ updateAvailableState();
+ updateGenderFilterButtons();
+ availableListEl.scrollTop = 0;
+ };
+
+ const addVoiceToDraft = (voiceId, weight = 0.6) => {
+ if (!voiceLookup.has(voiceId)) {
+ return;
+ }
+ if (state.draft.voices.has(voiceId)) {
+ setSliderFocus(voiceId);
+ return;
+ }
+ state.draft.voices.set(voiceId, clamp(weight, 0.05, 1));
+ renderSelectedVoices();
+ updateAvailableState();
+ updateMixSummary();
+ markDirty();
+ setSliderFocus(voiceId);
+ };
+
+ const buildProfilePayload = () =>
+ Array.from(state.draft.voices.entries()).map(([voiceId, weight]) => ({
+ id: voiceId,
+ weight,
+ enabled: weight > 0,
+ }));
+
+ const updateActionButtons = () => {
+ const hasSelection = Boolean(state.selectedProfile && profiles[state.selectedProfile]);
+ if (duplicateBtn) {
+ duplicateBtn.disabled = !hasSelection;
+ }
+ if (deleteBtn) {
+ deleteBtn.disabled = !hasSelection;
+ }
+ };
+
+ const applyDraftToControls = () => {
+ if (nameInput) {
+ nameInput.value = state.draft.name || "";
+ }
+ if (languageSelect) {
+ languageSelect.value = state.draft.language || "a";
+ }
+ if (supertonicVoiceSelect) {
+ supertonicVoiceSelect.value = state.draft.supertonic?.voice || "M1";
+ }
+ if (supertonicStepsInput) {
+ supertonicStepsInput.value = String(state.draft.supertonic?.total_steps ?? 5);
+ setRangeFill(supertonicStepsInput);
+ }
+ if (supertonicSpeedInput) {
+ supertonicSpeedInput.value = String(state.draft.supertonic?.speed ?? 1.0);
+ setRangeFill(supertonicSpeedInput);
+ }
+ if (supertonicStepsLabel) {
+ supertonicStepsLabel.textContent = String(state.draft.supertonic?.total_steps ?? 5);
+ }
+ if (supertonicSpeedLabel) {
+ const speed = Number(state.draft.supertonic?.speed ?? 1.0);
+ supertonicSpeedLabel.textContent = `${(Number.isFinite(speed) ? speed : 1.0).toFixed(2)}×`;
+ }
+ applyProviderToUI();
+ renderSelectedVoices();
+ updateMixSummary();
+ updateAvailableState();
+ updateActionButtons();
+ resetDirty();
+ };
+
+ const renderProfileList = () => {
+ profileListEl.innerHTML = "";
+
+ const header = document.createElement("div");
+ header.className = "voice-list__header";
+ const heading = document.createElement("h2");
+ heading.textContent = "Saved speakers";
+ header.appendChild(heading);
+ profileListEl.appendChild(header);
+
+ const names = Object.keys(profiles).sort((a, b) => a.localeCompare(b));
+ if (!names.length) {
+ const empty = document.createElement("p");
+ empty.className = "tag";
+ empty.textContent = "No speakers yet. Create one on the right.";
+ profileListEl.appendChild(empty);
+ return;
+ }
+
+ const list = document.createElement("ul");
+ list.className = "voice-list";
+
+ names.forEach((name) => {
+ const li = document.createElement("li");
+ li.className = "voice-list__item";
+ if (state.selectedProfile === name) {
+ li.classList.add("is-selected");
+ }
+
+ const selectBtn = document.createElement("button");
+ selectBtn.type = "button";
+ selectBtn.className = "voice-list__select";
+ selectBtn.dataset.name = name;
+ const profile = profiles[name] || {};
+ const provider = normalizeProvider(profile.provider);
+ const providerLabel = provider === "supertonic" ? "Supertonic" : "Kokoro";
+ selectBtn.innerHTML = `
+ ${name}
+
+ `;
+ selectBtn.addEventListener("click", () => selectProfile(name));
+
+ const actions = document.createElement("div");
+ actions.className = "voice-list__actions";
+
+ const duplicateAction = document.createElement("button");
+ duplicateAction.type = "button";
+ duplicateAction.className = "voice-list__action";
+ duplicateAction.textContent = "Duplicate";
+ duplicateAction.addEventListener("click", (event) => {
+ event.stopPropagation();
+ runDuplicate(name);
+ });
+
+ const deleteAction = document.createElement("button");
+ deleteAction.type = "button";
+ deleteAction.className = "voice-list__action voice-list__action--danger";
+ deleteAction.textContent = "Delete";
+ deleteAction.addEventListener("click", (event) => {
+ event.stopPropagation();
+ runDelete(name);
+ });
+
+ actions.appendChild(duplicateAction);
+ actions.appendChild(deleteAction);
+
+ li.appendChild(selectBtn);
+ li.appendChild(actions);
+ list.appendChild(li);
+ });
+
+ profileListEl.appendChild(list);
+ };
+
+ const selectProfile = (name) => {
+ state.selectedProfile = name;
+ state.originalName = name;
+ const profile = profiles[name];
+ const provider = normalizeProvider(profile?.provider);
+ state.draft = {
+ name,
+ provider,
+ language: profile?.language || "a",
+ voices: new Map(),
+ supertonic: {
+ voice: profile?.voice || "M1",
+ total_steps: Number(profile?.total_steps ?? 5),
+ speed: Number(profile?.speed ?? 1.0),
+ },
+ };
+ if (provider === "kokoro" && Array.isArray(profile?.voices)) {
+ profile.voices.forEach((entry) => {
+ if (Array.isArray(entry) && entry.length >= 2) {
+ const [voiceId, weight] = entry;
+ const value = clamp(parseFloat(weight), 0, 1);
+ if (!Number.isNaN(value) && value > 0) {
+ const normalized = clamp(value, 0.05, 1);
+ state.draft.voices.set(String(voiceId), normalized);
+ }
+ }
+ });
+ }
+ applyDraftToControls();
+ renderProfileList();
+ loadSampleText();
+ setStatus(`Loaded speaker “${name}”.`, "info", 2500);
+ };
+
+ const startNewProfile = (provider = "kokoro") => {
+ state.selectedProfile = null;
+ state.originalName = null;
+ state.draft = {
+ name: "",
+ provider: normalizeProvider(provider),
+ language: languageSelect ? languageSelect.value || "a" : "a",
+ voices: new Map(),
+ supertonic: {
+ voice: "M1",
+ total_steps: 5,
+ speed: 1.0,
+ },
+ };
+ applyDraftToControls();
+ renderProfileList();
+ loadSampleText();
+ };
+
+ const requestNewProfile = async () => {
+ const chosen = await openProviderPicker(normalizeProvider(state.draft.provider));
+ if (!chosen) {
+ return;
+ }
+ startNewProfile(chosen);
+ setStatus("New speaker ready.", "info");
+ };
+
+ const refreshProfiles = (nextProfiles, selectedName = null) => {
+ profiles = nextProfiles || {};
+ renderProfileList();
+ if (selectedName && profiles[selectedName]) {
+ selectProfile(selectedName);
+ } else if (state.selectedProfile && profiles[state.selectedProfile]) {
+ selectProfile(state.selectedProfile);
+ } else {
+ const names = Object.keys(profiles);
+ if (names.length) {
+ selectProfile(names[0]);
+ } else {
+ startNewProfile("kokoro");
+ }
+ }
+ updateActionButtons();
+ };
+
+ const loadSampleText = () => {
+ if (!previewTextEl || !languageSelect) return;
+ const lang = languageSelect.value || "a";
+ previewTextEl.value = samples[lang] || samples.a || "This is a sample of the selected voice.";
+ };
+
+ const withJson = async (response) => {
+ if (response.ok) {
+ return response.json();
+ }
+ let message = "Unexpected error";
+ try {
+ const data = await response.json();
+ message = data.error || data.message || message;
+ } catch (err) {
+ message = await response.text();
+ }
+ throw new Error(message);
+ };
+
+ const runSave = async () => {
+ if (!nameInput) return;
+ const name = nameInput.value.trim();
+ if (!name) {
+ setStatus("Give your profile a name first.", "warning");
+ return;
+ }
+ const payload = {
+ name,
+ originalName: state.originalName,
+ provider: normalizeProvider(state.draft.provider),
+ language: normalizeProvider(state.draft.provider) === "kokoro" ? (languageSelect ? languageSelect.value : "a") : "a",
+ voices: normalizeProvider(state.draft.provider) === "kokoro" ? buildProfilePayload() : [],
+ voice: state.draft.supertonic?.voice,
+ total_steps: state.draft.supertonic?.total_steps,
+ speed: state.draft.supertonic?.speed,
+ };
+ try {
+ const response = await fetch("/api/voice-profiles", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ });
+ const result = await withJson(response);
+ refreshProfiles(result.profiles, result.profile);
+ resetDirty();
+ setStatus(`Saved speaker “${result.profile}”.`, "success");
+ } catch (error) {
+ setStatus(error.message || "Failed to save profile", "danger", 7000);
+ }
+ };
+
+ const runDelete = async (targetName = null) => {
+ const name = targetName || state.selectedProfile;
+ if (!name) {
+ setStatus("Select a profile to delete.", "warning");
+ return;
+ }
+ const confirmed = window.confirm(`Delete speaker “${name}”?`);
+ if (!confirmed) return;
+ try {
+ const response = await fetch(`/api/voice-profiles/${encodeURIComponent(name)}`, {
+ method: "DELETE",
+ });
+ const result = await withJson(response);
+ refreshProfiles(result.profiles);
+ setStatus(`Deleted speaker “${name}”.`, "info");
+ } catch (error) {
+ setStatus(error.message || "Failed to delete profile", "danger", 7000);
+ }
+ };
+
+ const runDuplicate = async (targetName = null) => {
+ const name = targetName || state.selectedProfile;
+ if (!name) {
+ setStatus("Select a profile to duplicate.", "warning");
+ return;
+ }
+ const newName = window.prompt("Duplicate speaker as…", `${name} copy`);
+ if (!newName) return;
+ try {
+ const response = await fetch(`/api/voice-profiles/${encodeURIComponent(name)}/duplicate`, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ name: newName }),
+ });
+ const result = await withJson(response);
+ refreshProfiles(result.profiles, result.profile);
+ setStatus(`Duplicated to “${result.profile}”.`, "success");
+ } catch (error) {
+ setStatus(error.message || "Failed to duplicate profile", "danger", 7000);
+ }
+ };
+
+ const runImport = async (file) => {
+ try {
+ const text = await file.text();
+ const parsed = JSON.parse(text);
+ const replace = window.confirm("Replace existing speakers if duplicates are found?");
+ const response = await fetch("/api/voice-profiles/import", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ data: parsed, replace_existing: replace }),
+ });
+ const result = await withJson(response);
+ refreshProfiles(result.profiles);
+ setStatus(`Imported ${result.imported.length} speaker${result.imported.length === 1 ? "" : "s"}.`, "success");
+ } catch (error) {
+ setStatus(error.message || "Import failed", "danger", 7000);
+ } finally {
+ importInput.value = "";
+ }
+ };
+
+ const runExport = async () => {
+ const name = state.selectedProfile;
+ const query = name ? `?names=${encodeURIComponent(name)}` : "";
+ try {
+ const response = await fetch(`/api/voice-profiles/export${query}`);
+ if (!response.ok) {
+ throw new Error("Export failed");
+ }
+ const blob = await response.blob();
+ const url = URL.createObjectURL(blob);
+ const anchor = document.createElement("a");
+ anchor.href = url;
+ anchor.download = name ? `${name}.json` : "voice_profiles.json";
+ document.body.appendChild(anchor);
+ anchor.click();
+ document.body.removeChild(anchor);
+ URL.revokeObjectURL(url);
+ setStatus("Export complete.", "success");
+ } catch (error) {
+ setStatus(error.message || "Export failed", "danger", 7000);
+ }
+ };
+
+ const runPreview = async () => {
+ if (!previewBtn) return;
+ const provider = normalizeProvider(state.draft.provider);
+ const payload = {
+ provider,
+ language: languageSelect ? languageSelect.value : "a",
+ voices: provider === "kokoro" ? buildProfilePayload() : [],
+ voice: state.draft.supertonic?.voice,
+ total_steps: state.draft.supertonic?.total_steps,
+ text: previewTextEl ? previewTextEl.value : "",
+ speed: speedInput ? parseFloat(speedInput.value || "1") : 1,
+ max_seconds: 8,
+ };
+ if (provider === "kokoro") {
+ const enabledVoices = payload.voices.filter((entry) => entry.enabled && entry.weight > 0);
+ if (!enabledVoices.length) {
+ setStatus("Enable at least one voice to preview.", "warning");
+ return;
+ }
+ } else {
+ if (!payload.voice) {
+ setStatus("Select a Supertonic voice to preview.", "warning");
+ return;
+ }
+ payload.supertonic_total_steps = payload.total_steps;
+ payload.tts_provider = "supertonic";
+ }
+ previewBtn.disabled = true;
+ previewBtn.dataset.loading = "true";
+ previewBtn.setAttribute("aria-busy", "true");
+ previewBtn.textContent = "Previewing…";
+ setStatus("Generating preview…", "info", 0);
+ try {
+ const response = await fetch("/api/voice-profiles/preview", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(payload),
+ });
+ if (!response.ok) {
+ throw new Error(await response.text());
+ }
+ const blob = await response.blob();
+ if (state.previewUrl) {
+ URL.revokeObjectURL(state.previewUrl);
+ }
+ state.previewUrl = URL.createObjectURL(blob);
+ if (previewAudio) {
+ previewAudio.src = state.previewUrl;
+ previewAudio.play().catch(() => {});
+ }
+ setStatus("Preview ready.", "success");
+ } catch (error) {
+ setStatus(error.message || "Preview failed", "danger", 7000);
+ } finally {
+ previewBtn.disabled = false;
+ previewBtn.dataset.loading = "false";
+ previewBtn.textContent = previewBtn.dataset.label || "Preview speaker";
+ previewBtn.removeAttribute("aria-busy");
+ }
+ };
+
+ if (saveBtn) {
+ const form = saveBtn.closest("form");
+ if (form) {
+ form.addEventListener("submit", (event) => {
+ event.preventDefault();
+ runSave();
+ });
+ }
+ }
+
+ if (duplicateBtn) {
+ duplicateBtn.addEventListener("click", () => runDuplicate());
+ }
+
+ if (deleteBtn) {
+ deleteBtn.addEventListener("click", () => runDelete());
+ }
+
+ if (previewBtn) {
+ previewBtn.addEventListener("click", () => runPreview());
+ }
+
+ if (loadSampleBtn) {
+ loadSampleBtn.addEventListener("click", loadSampleText);
+ }
+
+ if (languageSelect) {
+ languageSelect.addEventListener("change", () => {
+ state.draft.language = languageSelect.value;
+ markDirty();
+ loadSampleText();
+ });
+ }
+
+ if (providerSelect) {
+ providerSelect.addEventListener("change", () => {
+ state.draft.provider = normalizeProvider(providerSelect.value);
+ // When switching to Supertonic, clear Kokoro mix.
+ if (state.draft.provider === "supertonic") {
+ state.draft.voices = new Map();
+ }
+ applyDraftToControls();
+ markDirty();
+ loadSampleText();
+ setStatus("Provider updated.", "info", 1500);
+ });
+ }
+
+ if (supertonicVoiceSelect) {
+ supertonicVoiceSelect.addEventListener("change", () => {
+ state.draft.supertonic.voice = supertonicVoiceSelect.value;
+ markDirty();
+ updateMixSummary();
+ });
+ }
+
+ if (supertonicStepsInput) {
+ supertonicStepsInput.addEventListener("input", () => {
+ const value = Number(supertonicStepsInput.value || "5");
+ state.draft.supertonic.total_steps = clamp(value, 2, 15);
+ supertonicStepsInput.value = String(Math.round(state.draft.supertonic.total_steps));
+ if (supertonicStepsLabel) {
+ supertonicStepsLabel.textContent = supertonicStepsInput.value;
+ }
+ setRangeFill(supertonicStepsInput);
+ markDirty();
+ });
+ setRangeFill(supertonicStepsInput);
+ }
+
+ if (supertonicSpeedInput) {
+ supertonicSpeedInput.addEventListener("input", () => {
+ const value = parseFloat(supertonicSpeedInput.value || "1");
+ const normalized = clamp(value, 0.7, 2.0);
+ state.draft.supertonic.speed = normalized;
+ supertonicSpeedInput.value = normalized.toFixed(2);
+ if (supertonicSpeedLabel) {
+ supertonicSpeedLabel.textContent = `${normalized.toFixed(2)}×`;
+ }
+ setRangeFill(supertonicSpeedInput);
+ if (speedInput) {
+ speedInput.value = String(normalized);
+ setRangeFill(speedInput);
+ }
+ markDirty();
+ });
+ setRangeFill(supertonicSpeedInput);
+ }
+
+ if (voiceFilterSelect) {
+ voiceFilterSelect.addEventListener("change", () => {
+ state.languageFilter = voiceFilterSelect.value;
+ renderAvailableVoices();
+ });
+ }
+
+ if (speedInput) {
+ const updatePreviewSpeedLabel = () => {
+ const speed = parseFloat(speedInput.value || "1");
+ if (previewSpeedLabel) {
+ previewSpeedLabel.textContent = `${speed.toFixed(2)}×`;
+ }
+ setRangeFill(speedInput);
+
+ if (normalizeProvider(state.draft.provider) === "supertonic") {
+ state.draft.supertonic.speed = clamp(speed, 0.7, 2.0);
+ if (supertonicSpeedInput) {
+ supertonicSpeedInput.value = state.draft.supertonic.speed.toFixed(2);
+ setRangeFill(supertonicSpeedInput);
+ }
+ if (supertonicSpeedLabel) {
+ supertonicSpeedLabel.textContent = `${state.draft.supertonic.speed.toFixed(2)}×`;
+ }
+ }
+ };
+ speedInput.addEventListener("input", updatePreviewSpeedLabel);
+ updatePreviewSpeedLabel();
+ }
+
+ if (genderFilterEl) {
+ genderFilterEl.addEventListener("click", (event) => {
+ const target = event.target;
+ if (!(target instanceof HTMLButtonElement)) return;
+ const value = (target.getAttribute("data-value") || "").toLowerCase();
+ if (!value) return;
+ state.genderFilter = state.genderFilter === value ? "" : value;
+ renderAvailableVoices();
+ });
+ updateGenderFilterButtons();
+ }
+
+ if (nameInput) {
+ nameInput.addEventListener("input", () => {
+ state.draft.name = nameInput.value;
+ markDirty();
+ updateMixSummary();
+ });
+ }
+
+ if (importInput) {
+ importInput.addEventListener("change", () => {
+ const [file] = importInput.files || [];
+ if (file) {
+ runImport(file);
+ }
+ });
+ }
+
+ if (headerActions) {
+ headerActions.addEventListener("click", (event) => {
+ const target = event.target;
+ if (!(target instanceof HTMLElement)) return;
+ const actionEl = target.closest("[data-action]");
+ const action = actionEl instanceof HTMLElement ? actionEl.dataset.action : null;
+ if (!action) return;
+ if (action === "new-profile") {
+ requestNewProfile();
+ } else if (action === "import-profiles") {
+ importInput?.click();
+ } else if (action === "export-profiles") {
+ runExport();
+ }
+ });
+ }
+
+ if (dropzoneEl) {
+ const setHover = (hovered) => {
+ dropzoneEl.classList.toggle("is-hovered", hovered);
+ };
+ [dropzoneEl, selectedListEl].forEach((target) => {
+ target.addEventListener("dragover", (event) => {
+ event.preventDefault();
+ setHover(true);
+ });
+ target.addEventListener("dragenter", (event) => {
+ event.preventDefault();
+ setHover(true);
+ });
+ target.addEventListener("dragleave", (event) => {
+ if (!event.currentTarget.contains(event.relatedTarget)) {
+ setHover(false);
+ }
+ });
+ target.addEventListener("drop", (event) => {
+ event.preventDefault();
+ const voiceId = event.dataTransfer?.getData("text/plain");
+ if (voiceId) {
+ addVoiceToDraft(voiceId);
+ }
+ setHover(false);
+ });
+ });
+
+ dropzoneEl.addEventListener("click", (event) => {
+ if (!(event.target instanceof HTMLElement)) {
+ return;
+ }
+ if (event.target.closest(".mix-voice")) {
+ return;
+ }
+ if (event.target.closest(".mix-slider")) {
+ return;
+ }
+ const firstInactive = Array.from(availableCards.entries()).find(
+ ([voiceId]) => !state.draft.voices.has(voiceId),
+ );
+ if (firstInactive) {
+ addVoiceToDraft(firstInactive[0]);
+ }
+ });
+ }
+
+ renderAvailableVoices();
+ renderProfileList();
+ startNewProfile("kokoro");
+
+ if (Object.keys(profiles).length) {
+ const first = Object.keys(profiles).sort((a, b) => a.localeCompare(b))[0];
+ selectProfile(first);
+ }
+
+ loadSampleText();
+ updateActionButtons();
+ app.dataset.state = "ready";
+
+ window.addEventListener("beforeunload", () => {
+ if (state.previewUrl) {
+ URL.revokeObjectURL(state.previewUrl);
+ }
+ });
+};
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", setupVoiceMixer, { once: true });
+} else {
+ setupVoiceMixer();
+}
diff --git a/abogen/webui/static/wizard.js b/abogen/webui/static/wizard.js
new file mode 100644
index 0000000..eae3a2f
--- /dev/null
+++ b/abogen/webui/static/wizard.js
@@ -0,0 +1,514 @@
+const STEP_ORDER = ["book", "chapters", "entities"];
+const STEP_META = {
+ book: {
+ index: 1,
+ title: "Book parameters",
+ hint: "Choose your source file or paste text, then set the defaults used for chapter analysis and speaker casting.",
+ },
+ chapters: {
+ index: 2,
+ title: "Select chapters",
+ hint: "Choose which chapters to convert. We'll analyse entities automatically when you continue.",
+ },
+ entities: {
+ index: 3,
+ title: "Review entities",
+ hint: "Assign pronunciations, voices, and manual overrides before queueing the conversion.",
+ },
+};
+
+const wizardState = (window.AbogenWizardState = window.AbogenWizardState || {
+ initialized: false,
+ modal: null,
+ stage: null,
+ submitting: false,
+ initialStep: "book",
+ initialStageMarkup: "",
+});
+
+const normalizeStep = (step) => {
+ let value = (step || "book").toLowerCase();
+ if (value === "speakers") {
+ value = "entities";
+ }
+ if (value === "settings" || value === "upload" || value === "") {
+ value = "book";
+ }
+ if (!STEP_ORDER.includes(value)) {
+ return "book";
+ }
+ return value;
+};
+
+const setButtonLoading = (button, isLoading) => {
+ if (!button) {
+ return;
+ }
+ if (isLoading) {
+ if (!button.dataset.originalDisabled) {
+ button.dataset.originalDisabled = button.disabled ? "true" : "false";
+ }
+ button.disabled = true;
+ button.dataset.loading = "true";
+ button.setAttribute("aria-busy", "true");
+ } else {
+ if (button.dataset.loading) {
+ delete button.dataset.loading;
+ }
+ button.removeAttribute("aria-busy");
+ const original = button.dataset.originalDisabled;
+ if (original !== undefined) {
+ button.disabled = original === "true";
+ delete button.dataset.originalDisabled;
+ } else {
+ button.disabled = false;
+ }
+ }
+};
+
+const setSubmitting = (modal, isSubmitting, button) => {
+ if (!modal) return;
+ wizardState.submitting = isSubmitting;
+ if (isSubmitting) {
+ modal.dataset.submitting = "true";
+ modal.setAttribute("aria-busy", "true");
+ } else {
+ delete modal.dataset.submitting;
+ modal.removeAttribute("aria-busy");
+ }
+ setButtonLoading(button, isSubmitting);
+};
+
+const resetWizardToInitial = () => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ wizardState.submitting = false;
+ delete modal.dataset.submitting;
+ modal.removeAttribute("aria-busy");
+ modal.dataset.pendingId = "";
+ const step = normalizeStep(wizardState.initialStep || modal.dataset.step || "book");
+ modal.dataset.step = step;
+ updateHeaderCopy(modal, step);
+ updateFilenameLabel(modal, "");
+ const stage = modal.querySelector('[data-role="wizard-stage"]');
+ if (stage) {
+ wizardState.stage = stage;
+ destroyTransientAlerts(stage);
+ if (typeof wizardState.initialStageMarkup === "string" && wizardState.initialStageMarkup) {
+ stage.innerHTML = wizardState.initialStageMarkup;
+ reinitializeStageModules(stage);
+ }
+ }
+};
+
+const findModal = () => document.querySelector('[data-role="new-job-modal"]');
+
+const ensureModalRef = () => {
+ if (wizardState.modal && wizardState.modal.isConnected) {
+ return wizardState.modal;
+ }
+ wizardState.modal = findModal();
+ return wizardState.modal;
+};
+
+const dispatchWizardEvent = (modal, type, detail = {}) => {
+ if (!modal) return;
+ const event = new CustomEvent(`wizard:${type}`, { bubbles: true, detail });
+ modal.dispatchEvent(event);
+};
+
+const destroyTransientAlerts = (stage) => {
+ if (!stage) {
+ return;
+ }
+ const alerts = stage.querySelectorAll('[data-role="wizard-error"]');
+ alerts.forEach((alert) => alert.remove());
+};
+
+const displayTransientError = (modal, message) => {
+ if (!modal) return;
+ const stage = modal.querySelector('[data-role="wizard-stage"]');
+ if (!stage) return;
+ const existing = stage.querySelector('[data-role="wizard-error"]');
+ if (existing) {
+ existing.textContent = message;
+ return;
+ }
+ const alert = document.createElement("div");
+ alert.className = "alert alert--error";
+ alert.dataset.role = "wizard-error";
+ alert.textContent = message;
+ stage.prepend(alert);
+};
+
+const updateStepIndicators = (modal, activeStep, payload) => {
+ const indicators = modal.querySelectorAll('[data-role="wizard-step-indicator"]');
+ const activeIndex = STEP_ORDER.indexOf(activeStep);
+ const completedList = Array.isArray(payload?.completed_steps) ? payload.completed_steps : [];
+ const completedSet = new Set(completedList.map((step) => normalizeStep(step)));
+ indicators.forEach((indicator) => {
+ const step = normalizeStep(indicator.dataset.step || "book");
+ indicator.classList.remove("is-active", "is-complete");
+ const index = STEP_ORDER.indexOf(step);
+ const isActive = index === activeIndex;
+ const visited = completedSet.has(step);
+ const isComplete = !isActive && (visited || (index > -1 && index < activeIndex));
+ indicator.classList.toggle("is-complete", isComplete);
+ indicator.classList.toggle("is-active", isActive);
+ if (indicator instanceof HTMLButtonElement) {
+ const clickable = isComplete && !isActive;
+ indicator.disabled = !clickable;
+ indicator.setAttribute("aria-disabled", clickable ? "false" : "true");
+ indicator.setAttribute("aria-current", isActive ? "step" : "false");
+ if (clickable) {
+ indicator.dataset.state = "clickable";
+ } else {
+ delete indicator.dataset.state;
+ }
+ }
+ });
+};
+
+const updateHeaderCopy = (modal, step, payload) => {
+ const meta = STEP_META[step];
+ if (!meta) {
+ return;
+ }
+ const titleEl = modal.querySelector("#new-job-modal-title");
+ const hintEl = modal.querySelector('[data-role="wizard-hint"]');
+ if (titleEl) {
+ titleEl.textContent = payload?.title || meta.title;
+ }
+ if (hintEl) {
+ hintEl.textContent = payload?.hint || meta.hint;
+ }
+ updateStepIndicators(modal, step, payload);
+};
+
+const updateFilenameLabel = (modal, filename) => {
+ const label = modal.querySelector(".wizard-card__filename");
+ if (!label) return;
+ if (filename) {
+ label.hidden = false;
+ label.textContent = filename;
+ label.setAttribute("title", filename);
+ } else {
+ label.hidden = true;
+ label.textContent = "";
+ label.removeAttribute("title");
+ }
+};
+
+const reinitializeStageModules = (stage) => {
+ if (!stage) return;
+ if (window.AbogenDashboard?.init) {
+ window.AbogenDashboard.init();
+ }
+ if (window.AbogenPrepare?.init) {
+ window.AbogenPrepare.init(stage);
+ }
+};
+
+const focusFirstInteractive = (stage) => {
+ if (!stage) return;
+ const focusable = stage.querySelector(
+ 'input:not([type="hidden"]):not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled])'
+ );
+ if (focusable instanceof HTMLElement) {
+ try {
+ focusable.focus({ preventScroll: true });
+ } catch (error) {
+ // Ignore focus errors, browser may block programmatic focus
+ }
+ }
+};
+
+const applyWizardPayload = (payload) => {
+ const modal = ensureModalRef();
+ if (!modal) {
+ return;
+ }
+ if (payload.pending_id !== undefined) {
+ modal.dataset.pendingId = payload.pending_id || "";
+ }
+ const step = normalizeStep(payload.step || modal.dataset.step || "book");
+ modal.dataset.step = step;
+ modal.hidden = false;
+ modal.dataset.open = "true";
+ document.body.classList.add("modal-open");
+ updateHeaderCopy(modal, step, payload);
+ updateFilenameLabel(modal, payload.filename);
+
+ const stage = modal.querySelector('[data-role="wizard-stage"]');
+ if (stage) {
+ destroyTransientAlerts(stage);
+ stage.innerHTML = payload.html || "";
+ wizardState.stage = stage;
+ reinitializeStageModules(stage);
+ focusFirstInteractive(stage);
+ }
+
+ const stepDetail = {
+ step,
+ index: STEP_META[step]?.index || STEP_ORDER.indexOf(step) + 1,
+ total: STEP_ORDER.length,
+ pendingId: modal.dataset.pendingId || "",
+ notice: payload.notice || "",
+ error: payload.error || "",
+ };
+ dispatchWizardEvent(modal, "step", stepDetail);
+};
+
+const handleWizardRedirect = (payload) => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ modal.hidden = true;
+ delete modal.dataset.open;
+ document.body.classList.remove("modal-open");
+ resetWizardToInitial();
+ dispatchWizardEvent(modal, "done", { redirectUrl: payload.redirect_url });
+ if (payload.redirect_url) {
+ window.location.assign(payload.redirect_url);
+ }
+};
+
+const processResponsePayload = (payload, responseOk) => {
+ if (!payload) {
+ return;
+ }
+ if (payload.redirect_url) {
+ handleWizardRedirect(payload);
+ return;
+ }
+ if (!payload.html && !responseOk) {
+ const modal = ensureModalRef();
+ displayTransientError(modal, payload.error || "Something went wrong. Try again.");
+ return;
+ }
+ applyWizardPayload(payload);
+};
+
+const requestWizardStep = async (url, { method = "GET", body = undefined } = {}) => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ try {
+ const response = await fetch(url, {
+ method,
+ body,
+ headers: { Accept: "application/json" },
+ credentials: "same-origin",
+ });
+ const text = await response.text();
+ const payload = text ? JSON.parse(text) : null;
+ processResponsePayload(payload, response.ok);
+ } catch (error) {
+ console.error("Wizard request failed", error);
+ displayTransientError(modal, error?.message || "Unable to update the wizard. Try again.");
+ }
+};
+
+const submitWizardForm = async (form, submitter) => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ if (wizardState.submitting) {
+ return;
+ }
+ const action = submitter?.getAttribute("formaction") || form.getAttribute("action") || window.location.href;
+ const method = (submitter?.getAttribute("formmethod") || form.getAttribute("method") || "GET").toUpperCase();
+ const stepTarget = submitter?.dataset?.stepTarget || "";
+ const normalizedStepTarget = stepTarget ? stepTarget.toLowerCase() : "";
+ if (normalizedStepTarget) {
+ const activeInput = form.querySelector('[data-role="active-step-input"]');
+ if (activeInput) {
+ activeInput.value = normalizedStepTarget;
+ }
+ }
+ const formData = new FormData(form);
+ if (normalizedStepTarget) {
+ formData.set("active_step", normalizedStepTarget);
+ formData.set("next_step", normalizedStepTarget);
+ }
+ if (submitter && submitter.name && !formData.has(submitter.name)) {
+ formData.append(submitter.name, submitter.value ?? "");
+ }
+
+ // Ensure pending_id is included if available in modal state but missing from form
+ if (!formData.get("pending_id") && modal && modal.dataset.pendingId) {
+ formData.set("pending_id", modal.dataset.pendingId);
+ }
+
+ const allowValidation = !submitter?.hasAttribute("formnovalidate") && !form.noValidate;
+ if (allowValidation && typeof form.reportValidity === "function" && !form.reportValidity()) {
+ return;
+ }
+
+ destroyTransientAlerts(modal.querySelector('[data-role="wizard-stage"]'));
+ setSubmitting(modal, true, submitter);
+ try {
+ const response = await fetch(action, {
+ method,
+ body: formData,
+ headers: { Accept: "application/json" },
+ credentials: "same-origin",
+ });
+ const text = await response.text();
+ let payload = null;
+ try {
+ payload = text ? JSON.parse(text) : null;
+ } catch (parseError) {
+ console.error("Failed to parse wizard response", parseError);
+ displayTransientError(modal, "Received an invalid response. Try again.");
+ return;
+ }
+ processResponsePayload(payload, response.ok);
+ if (!response.ok && (!payload || !payload.html)) {
+ displayTransientError(modal, payload?.error || `Request failed (${response.status})`);
+ }
+ } catch (networkError) {
+ console.error("Wizard submission failed", networkError);
+ displayTransientError(modal, networkError?.message || "Unable to submit form. Check your connection and try again.");
+ } finally {
+ setSubmitting(modal, false, submitter);
+ }
+};
+
+const handleCancel = async (button) => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ const pendingId = button?.dataset.pendingId || modal.dataset.pendingId;
+ const template = modal.dataset.cancelUrlTemplate || "";
+ if (!pendingId || !template) {
+ modal.hidden = true;
+ delete modal.dataset.open;
+ document.body.classList.remove("modal-open");
+ dispatchWizardEvent(modal, "cancel", { pendingId });
+ return;
+ }
+ const url = template.replace("__pending__", encodeURIComponent(pendingId));
+ try {
+ const response = await fetch(url, {
+ method: "POST",
+ headers: { Accept: "application/json" },
+ credentials: "same-origin",
+ });
+ if (response.ok) {
+ const text = await response.text();
+ const payload = text ? JSON.parse(text) : null;
+ if (payload?.redirect_url) {
+ handleWizardRedirect(payload);
+ return;
+ }
+ }
+ } catch (error) {
+ console.error("Cancel request failed", error);
+ }
+ modal.hidden = true;
+ delete modal.dataset.open;
+ document.body.classList.remove("modal-open");
+ dispatchWizardEvent(modal, "cancel", { pendingId });
+ resetWizardToInitial();
+};
+
+const navigateToWizardStep = (targetStep, pendingOverride) => {
+ const modal = ensureModalRef();
+ if (!modal || wizardState.submitting) {
+ return;
+ }
+ const normalizedTarget = normalizeStep(targetStep || "book");
+ const currentStep = modal.dataset.step ? normalizeStep(modal.dataset.step) : "book";
+ if (normalizedTarget === currentStep) {
+ return;
+ }
+ const pendingId = pendingOverride || modal.dataset.pendingId || "";
+ const template = modal.dataset.prepareUrlTemplate || "";
+ if (!pendingId || !template) {
+ return;
+ }
+ const url = new URL(template.replace("__pending__", encodeURIComponent(pendingId)), window.location.origin);
+ url.searchParams.set("step", normalizedTarget);
+ url.searchParams.set("format", "json");
+ requestWizardStep(url.toString(), { method: "GET" });
+};
+
+const handleBackToStep = (button) => {
+ const targetStep = normalizeStep(button.dataset.targetStep || "book");
+ navigateToWizardStep(targetStep, button.dataset.pendingId);
+};
+
+const handleWizardClick = (event) => {
+ const modal = ensureModalRef();
+ if (!modal) return;
+ const closeTarget = event.target.closest('[data-role="new-job-modal-close"]');
+ if (closeTarget) {
+ event.preventDefault();
+ event.stopPropagation();
+ handleCancel(closeTarget);
+ return;
+ }
+ const cancelButton = event.target.closest('[data-role="wizard-cancel"]');
+ if (cancelButton) {
+ event.preventDefault();
+ event.stopPropagation();
+ handleCancel(cancelButton);
+ return;
+ }
+ const backButton = event.target.closest('[data-role="wizard-back"]');
+ if (backButton) {
+ const targetStep = normalizeStep(backButton.dataset.targetStep || "book");
+ event.preventDefault();
+ event.stopPropagation();
+ handleBackToStep(backButton);
+ return;
+ }
+ const indicator = event.target.closest('[data-role="wizard-step-indicator"]');
+ if (indicator instanceof HTMLButtonElement) {
+ if (indicator.classList.contains("is-complete")) {
+ event.preventDefault();
+ event.stopPropagation();
+ navigateToWizardStep(indicator.dataset.step || "book");
+ }
+ }
+};
+
+const handleWizardSubmit = (event) => {
+ const form = event.target;
+ if (!(form instanceof HTMLFormElement)) {
+ return;
+ }
+ if (form.dataset.wizardForm !== "true") {
+ return;
+ }
+ const submitter = event.submitter || form.querySelector('button[type="submit"]');
+ if (!submitter) {
+ return;
+ }
+ event.preventDefault();
+ submitWizardForm(form, submitter);
+};
+
+const initWizard = () => {
+ if (wizardState.initialized) {
+ return;
+ }
+ const modal = ensureModalRef();
+ if (!modal) {
+ return;
+ }
+ wizardState.initialized = true;
+ wizardState.modal = modal;
+ wizardState.stage = modal.querySelector('[data-role="wizard-stage"]');
+ const initialStep = normalizeStep(modal.dataset.step || "book");
+ if (!wizardState.initialStageMarkup && wizardState.stage) {
+ wizardState.initialStageMarkup = wizardState.stage.innerHTML;
+ wizardState.initialStep = initialStep;
+ }
+ modal.addEventListener("submit", handleWizardSubmit, true);
+ modal.addEventListener("click", handleWizardClick);
+};
+
+window.AbogenWizard = window.AbogenWizard || {};
+window.AbogenWizard.init = initWizard;
+window.AbogenWizard.requestStep = requestWizardStep;
+window.AbogenWizard.applyPayload = applyWizardPayload;
+
+export { initWizard };
diff --git a/abogen/webui/templates/base.html b/abogen/webui/templates/base.html
new file mode 100644
index 0000000..194f394
--- /dev/null
+++ b/abogen/webui/templates/base.html
@@ -0,0 +1,37 @@
+
+
+
+
+
+ {% block title %}abogen{% endblock %}
+
+
+
+
+
+
+
+ 🔊
+ abogen
+ Verba audiuntur
+
+
+
+
+ {% block content %}{% endblock %}
+
+
+ {% block scripts %}{% endblock %}
+
+
diff --git a/abogen/webui/templates/debug_wavs.html b/abogen/webui/templates/debug_wavs.html
new file mode 100644
index 0000000..2b2e451
--- /dev/null
+++ b/abogen/webui/templates/debug_wavs.html
@@ -0,0 +1,37 @@
+{% extends "base.html" %}
+
+{% block title %}abogen · Debug WAVs{% endblock %}
+
+{% block content %}
+
+ Debug WAVs
+ Run ID: {{ run_id }}
+
+ Each clip reads: ID, one second pause, then the reference text.
+
+ {% if artifacts %}
+
+
+
+ {% for item in artifacts %}
+ -
+
+
+ {{ item.label }}
+ {% if item.text %}
+ — {{ item.text }}
+ {% endif %}
+
+
+
+
+ {% endfor %}
+
+
+ {% endif %}
+
+
+ Back to Settings
+
+
+{% endblock %}
diff --git a/abogen/webui/templates/entities.html b/abogen/webui/templates/entities.html
new file mode 100644
index 0000000..ea4f3a9
--- /dev/null
+++ b/abogen/webui/templates/entities.html
@@ -0,0 +1,275 @@
+{% extends "base.html" %}
+
+{% block title %}abogen · TTS Overrides{% endblock %}
+
+{% block content %}
+
+ TTS Overrides & Pronunciation
+ Review and refine stored pronunciations so recurring names sound right in every project.
+
+ Looking for saved speaker rosters instead? Manage speaker presets.
+
+
+
+
+ Overrides for {{ language_label }}
+
+ Showing {{ stats.filtered }} of {{ stats.total }} stored overrides ·
+ {{ stats.with_pronunciation }} with pronunciations · {{ stats.with_voice }} with assigned voices
+
+
+ {% if status_message or status_error %}
+
+ {{ status_error or status_message }}
+
+ {% endif %}
+
+
+
+
+
+ {% if overrides %}
+
+
+
+
+ Token
+ Pronunciation
+ Voice
+ Usage
+ Last updated
+ Preview
+ Actions
+
+
+
+ {% for override in overrides %}
+ {% set form_id = "override-form-" ~ loop.index %}
+
+ {{ override.token }}
+
+
+
+
+ {% set current_voice = override.voice or '' %}
+ {% set known_voice = namespace(value=False) %}
+ {% if current_voice %}
+ {% if current_voice in options.voice_catalog_map %}
+ {% set known_voice.value = True %}
+ {% else %}
+ {% for profile in options.voice_profile_options %}
+ {% if current_voice == 'profile:' ~ profile.name %}
+ {% set known_voice.value = True %}
+ {% endif %}
+ {% endfor %}
+ {% endif %}
+ {% endif %}
+
+
+ {{ override.usage_count }}
+ {{ override.updated_at_label }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {% endfor %}
+
+
+
+ No overrides match your current filter.
+ {% else %}
+ No overrides matched your filters. Try adjusting the search or create overrides from the Entities step while preparing a job.
+ {% endif %}
+
+{% endblock %}
+
+{% block scripts %}
+ {{ super() }}
+
+{% endblock %}
diff --git a/abogen/webui/templates/find_books.html b/abogen/webui/templates/find_books.html
new file mode 100644
index 0000000..1e79651
--- /dev/null
+++ b/abogen/webui/templates/find_books.html
@@ -0,0 +1,100 @@
+{% extends "base.html" %}
+
+{% block title %}abogen · Find Books{% endblock %}
+
+{% block content %}
+
+ Find Books
+ Browse trusted public-domain libraries or drill into your Calibre catalog without leaving abogen.
+
+
+
+ Standard Ebooks
+ Discover meticulously produced public-domain ebooks with consistent typography, metadata, and clean EPUB sources.
+
+
+ Visit standardebooks.org
+
+
+ Opens in a new tab so you can grab EPUB downloads and drag them into abogen.
+
+
+
+ Project Gutenberg
+ The world’s largest public-domain ebook library, offering thousands of EPUB and plain-text editions sourced from volunteer transcriptions.
+
+ Download the EPUB version for best results, then import it into abogen.
+
+
+
+
+ Calibre catalog
+ Wire abogen to your Calibre OPDS server to browse, search, and import titles without leaving the app.
+ {% if not opds_available %}
+ Enable the Calibre OPDS integration in settings to browse your library here.
+ {% else %}
+
+ {% endif %}
+
+
+
+
+{% if opds_available %}
+
+
+
+
+
+ Calibre OPDS
+ Browse your catalog
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endif %}
+{% with pending=None, readonly=False, active_step='settings' %}
+ {% include "partials/upload_modal.html" %}
+{% endwith %}
+{% include "partials/reader_modal.html" %}
+{% endblock %}
+
+{% block scripts %}
+ {{ super() }}
+
+
+
+
+ {% if opds_available %}
+
+ {% endif %}
+{% endblock %}
diff --git a/abogen/webui/templates/index.html b/abogen/webui/templates/index.html
new file mode 100644
index 0000000..b32c5ba
--- /dev/null
+++ b/abogen/webui/templates/index.html
@@ -0,0 +1,97 @@
+{% extends "base.html" %}
+
+{% block title %}abogen · Dashboard{% endblock %}
+
+{% block content %}
+
+
+
+
+ {{ stats.total }}
+ Total Jobs
+
+
+ {{ stats.completed }}
+ Converted
+
+
+ {{ stats.running }}
+ Converting
+
+
+ {{ stats.pending }}
+ Pending
+
+
+ {{ stats.failed }}
+ Failed
+
+
+
+
+ Create a New Audiobook
+ Kick off a fresh conversion with your manuscript or pasted text. You can fine-tune chapters and entities in the next steps.
+
+
+
+ Drop your manuscript to begin
+ Drag & drop a supported file here, or click to choose one in the next step.
+
+
+ {% if opds_available %}
+
+ Upload an EPUB or text file to begin.
+ Browse Calibre library
+
+ {% endif %}
+
+
+
+
+{% with pending=None, readonly=False, active_step='settings' %}
+ {% include "partials/upload_modal.html" %}
+{% endwith %}
+
+{% include "partials/reader_modal.html" %}
+
+{% endblock %}
+
+{% block scripts %}
+ {{ super() }}
+
+
+
+
+{% endblock %}
diff --git a/abogen/webui/templates/job_detail.html b/abogen/webui/templates/job_detail.html
new file mode 100644
index 0000000..6c45261
--- /dev/null
+++ b/abogen/webui/templates/job_detail.html
@@ -0,0 +1,158 @@
+{% extends "base.html" %}
+
+{% block title %}Job · {{ job.original_filename }}{% endblock %}
+
+{% block content %}
+
+ {{ job.original_filename }}
+
+
+ Settings
+
+ - Voice: {{ job.voice }}
+ - Language: {{ options.languages.get(job.language, job.language) }}
+ {% if job.voice_profile %}
+ - Voice profile: {{ job.voice_profile }}
+ {% endif %}
+ - Speed: {{ '%.2f' | format(job.speed) }}×
+ - Subtitle mode: {{ job.subtitle_mode }}
+ - Audio format: {{ job.output_format }}
+ - Subtitle format: {{ job.subtitle_format }}
+ - GPU: {{ 'Yes' if job.use_gpu else 'No' }}
+ - Save chapters separately: {{ 'Yes' if job.save_chapters_separately else 'No' }}
+ - Merge at end: {{ 'Yes' if job.merge_chapters_at_end else 'No' }}
+ - Separate chapter format: {{ job.separate_chapters_format|upper }}
+ - Silence between chapters: {{ '%.1f'|format(job.silence_between_chapters) }}s
+ - Chapter intro delay: {{ '%.1f'|format(job.chapter_intro_delay) }}s
+ - Title intro: {{ 'Yes' if job.read_title_intro else 'No' }}
+ - Closing outro: {{ 'Yes' if job.read_closing_outro else 'No' }}
+ - Normalize chapter openings: {{ 'Yes' if job.normalize_chapter_opening_caps else 'No' }}
+ - Prefix chapter titles: {{ 'Yes' if job.auto_prefix_chapter_titles else 'No' }}
+ - Max words per subtitle: {{ job.max_subtitle_words }}
+ - Project folder: {{ 'Yes' if job.save_as_project else 'No' }}
+ - Chunk granularity: {{ job.chunk_level|replace('_', ' ')|title }}
+ - Speaker analysis threshold: {{ job.speaker_analysis_threshold }}
+ - Generate EPUB 3: {{ 'Yes' if job.generate_epub3 else 'No' }}
+
+
+
+ Status
+ {{ job.status.value|title }}
+ Created: {{ job.created_at|datetimeformat }}
+ Started: {{ job.started_at|datetimeformat }}
+ Finished: {{ job.finished_at|datetimeformat }}
+ Characters: {{ job.processed_characters }} / {{ job.total_characters or '—' }}
+ {% set flags = downloads or {} %}
+ {% if flags.get('m4b') %}
+
+ {% elif flags.get('audio') %}
+
+ {% endif %}
+ {% if flags.get('epub3') %}
+
+ {% endif %}
+ {% if job.status in [JobStatus.PENDING, JobStatus.RUNNING, JobStatus.PAUSED] %}
+
+ {% elif job.status in [JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED] %}
+
+ {% endif %}
+
+
+
+
+{% set analysis = job.speaker_analysis or {} %}
+{% if analysis %}
+{% set preview_template = options.speaker_pronunciation_sentence or "This is {{name}} speaking." %}
+
+ Speaker analysis
+
+
+ Summary
+ {% set stats = analysis.get('stats', {}) %}
+
+ - Total chunks: {{ stats.get('total_chunks', '—') }}
+ - Explicit dialogue chunks: {{ stats.get('explicit_chunks', '—') }}
+ - Active speakers: {{ stats.get('active_speakers', '—') }}
+ - Unique speakers observed: {{ stats.get('unique_speakers', '—') }}
+ - Suppressed speakers: {{ stats.get('suppressed', 0) }}
+
+
+
+ Detected speakers
+ {% set speakers = analysis.get('speakers', {}) %}
+ {% set narrator_id = analysis.get('narrator', 'narrator') %}
+ {% if speakers %}
+
+ {% for speaker_id, payload in speakers.items() if speaker_id != narrator_id and not payload.get('suppressed') %}
+ {% set spoken_name = payload.get('pronunciation') or payload.get('label') or speaker_id|replace('_', ' ')|title %}
+ {% set preview_text = preview_template | replace("{{name}}", spoken_name) %}
+ -
+
+ {{ payload.get('label', speaker_id|replace('_', ' ')|title) }}
+
+
+
+ {% set quotes = payload.get('sample_quotes', []) %}
+ {% if quotes %}
+
+
Sample quotes
+
+ {% for quote in quotes %}
+ - {{ quote }}
+ {% endfor %}
+
+
+ {% endif %}
+
+ {% endfor %}
+
+ {% else %}
+ No additional speakers detected.
+ {% endif %}
+ {% set suppressed = analysis.get('suppressed_details') or analysis.get('suppressed', []) %}
+ {% if suppressed %}
+
+ Suppressed speakers:
+ {% if suppressed[0] is string %}
+ {{ suppressed | join(', ') }}
+ {% else %}
+ {{ suppressed | map(attribute='label') | join(', ') }}
+ {% endif %}
+
+ {% endif %}
+
+
+
+{% endif %}
+
+{% include "partials/logs_section.html" %}
+{% endblock %}
+
+{% block scripts %}
+ {{ super() }}
+
+{% endblock %}
diff --git a/abogen/webui/templates/job_logs_missing.html b/abogen/webui/templates/job_logs_missing.html
new file mode 100644
index 0000000..ad21254
--- /dev/null
+++ b/abogen/webui/templates/job_logs_missing.html
@@ -0,0 +1,13 @@
+{% extends "base.html" %}
+
+{% block title %}Job Not Found{% endblock %}
+
+{% block content %}
+
+
+ Job Not Found
+
+ This job no longer exists. It may have been deleted or the server was restarted.
+
+
+{% endblock %}
diff --git a/abogen/webui/templates/job_logs_static.html b/abogen/webui/templates/job_logs_static.html
new file mode 100644
index 0000000..a4a500c
--- /dev/null
+++ b/abogen/webui/templates/job_logs_static.html
@@ -0,0 +1,15 @@
+{% extends "base.html" %}
+
+{% block title %}Logs · {{ job.original_filename }}{% endblock %}
+
+{% block content %}
+
+ {% include "partials/logs.html" %}
+ {% if job.logs %}
+
+ Copy raw log output
+
+
+ {% endif %}
+
+{% endblock %}
diff --git a/abogen/webui/templates/job_not_found.html b/abogen/webui/templates/job_not_found.html
new file mode 100644
index 0000000..2c4afb6
--- /dev/null
+++ b/abogen/webui/templates/job_not_found.html
@@ -0,0 +1,13 @@
+{% extends "base.html" %}
+
+{% block title %}Job Not Found{% endblock %}
+
+{% block content %}
+
+
+ Job Not Found
+
+ This job no longer exists. It may have been deleted or the server was restarted.
+
+
+{% endblock %}
diff --git a/abogen/webui/templates/partials/jobs.html b/abogen/webui/templates/partials/jobs.html
new file mode 100644
index 0000000..a24a77c
--- /dev/null
+++ b/abogen/webui/templates/partials/jobs.html
@@ -0,0 +1,134 @@
+Queue
+
+
+
+ Active jobs
+
+ {% if active_jobs %}
+
+ {% for job in active_jobs %}
+ {% set progress_value = ((job.progress or 0) * 100)|round(1) %}
+ -
+
+
+ {{ job.original_filename }}
+
+ {% if job.pause_requested and job.status == JobStatus.RUNNING %}
+
+ {% endif %}
+
+ {{ job.status.value|title }}
+
+
+
+
+
+
+
+ {% endfor %}
+
+ {% else %}
+ No active jobs. Drop a file or paste text to get started.
+ {% endif %}
+
+
+
+
+ Recent results
+ {% if total_finished > 0 %}
+
+ {% endif %}
+
+ {% if finished_jobs %}
+
+ {% for job in finished_jobs %}
+ -
+
+
+ {{ job.status.value|title }}
+
+
+
+ {% endfor %}
+ {% if total_finished > finished_jobs|length %}
+ -
+
+
+ {% endif %}
+
+ {% else %}
+ Completed jobs will appear here.
+ {% endif %}
+
diff --git a/abogen/webui/templates/partials/logs.html b/abogen/webui/templates/partials/logs.html
new file mode 100644
index 0000000..cd8f983
--- /dev/null
+++ b/abogen/webui/templates/partials/logs.html
@@ -0,0 +1,21 @@
+{% set is_static = static_view if static_view is defined and static_view else False %}
+
+{% if job.logs %}
+
+ {% for entry in job.logs|reverse %}
+ -
+ {{ entry.timestamp|datetimeformat('%H:%M:%S') }}
+ {{ entry.message }}
+
+ {% endfor %}
+
+{% else %}
+ No log entries yet. Check back soon!
+{% endif %}
diff --git a/abogen/webui/templates/partials/logs_section.html b/abogen/webui/templates/partials/logs_section.html
new file mode 100644
index 0000000..fe68e90
--- /dev/null
+++ b/abogen/webui/templates/partials/logs_section.html
@@ -0,0 +1,7 @@
+
+ {% include "partials/logs.html" %}
+
diff --git a/abogen/webui/templates/partials/logs_section_missing.html b/abogen/webui/templates/partials/logs_section_missing.html
new file mode 100644
index 0000000..612014c
--- /dev/null
+++ b/abogen/webui/templates/partials/logs_section_missing.html
@@ -0,0 +1,6 @@
+
+
+ Live log
+
+ Job not found (it may have completed, been removed, or the server restarted). Refresh the page to load an active job.
+
diff --git a/abogen/webui/templates/partials/new_job_step_book.html b/abogen/webui/templates/partials/new_job_step_book.html
new file mode 100644
index 0000000..5bf14b4
--- /dev/null
+++ b/abogen/webui/templates/partials/new_job_step_book.html
@@ -0,0 +1,425 @@
+{% set pending = pending if pending is defined else None %}
+{% set metadata = pending.metadata_tags if pending else {} %}
+{% set readonly = readonly if readonly is defined else False %}
+{% set settings_dict = settings if settings is defined else {} %}
+{% set options = options if options is defined else {} %}
+{% set form_values = form_values if form_values is defined and form_values else {} %}
+{% set language_value = form_values.get('language') if form_values else None %}
+{% if not language_value %}
+ {% if pending and pending.language %}
+ {% set language_value = pending.language %}
+ {% else %}
+ {% set language_value = settings_dict.get('language', '') %}
+ {% endif %}
+{% endif %}
+{% if not language_value and options.languages %}
+ {% set sorted_languages = options.languages|dictsort %}
+ {% if sorted_languages %}
+ {% set language_value = sorted_languages[0][0] %}
+ {% endif %}
+{% endif %}
+{% set subtitle_value = form_values.get('subtitle_mode') if form_values else None %}
+{% if not subtitle_value %}
+ {% if pending and pending.subtitle_mode %}
+ {% set subtitle_value = pending.subtitle_mode %}
+ {% else %}
+ {% set subtitle_value = settings_dict.get('subtitle_mode', 'Disabled') %}
+ {% endif %}
+{% endif %}
+{% set generate_flag = form_values.get('generate_epub3') if form_values else None %}
+{% if generate_flag is not none %}
+ {% set generate_epub3 = True %}
+{% else %}
+ {% set generate_epub3 = pending.generate_epub3 if pending else settings_dict.get('generate_epub3', False) %}
+{% endif %}
+{% set chunk_level_value = form_values.get('chunk_level') if form_values else None %}
+{% if not chunk_level_value %}
+ {% if pending and pending.chunk_level %}
+ {% set chunk_level_value = pending.chunk_level %}
+ {% else %}
+ {% set chunk_level_value = settings_dict.get('chunk_level', 'paragraph') %}
+ {% endif %}
+{% endif %}
+{% set analysis_threshold_value = form_values.get('speaker_analysis_threshold') if form_values else None %}
+{% if not analysis_threshold_value %}
+ {% if pending and pending.speaker_analysis_threshold %}
+ {% set analysis_threshold_value = pending.speaker_analysis_threshold %}
+ {% else %}
+ {% set analysis_threshold_value = settings_dict.get('speaker_analysis_threshold', 3) %}
+ {% endif %}
+{% endif %}
+{% set chapter_delay_value = form_values.get('chapter_intro_delay') if form_values else None %}
+{% if not chapter_delay_value %}
+ {% if pending and pending.chapter_intro_delay is not none %}
+ {% set chapter_delay_value = pending.chapter_intro_delay %}
+ {% else %}
+ {% set chapter_delay_value = settings_dict.get('chapter_intro_delay', 0.5) %}
+ {% endif %}
+{% endif %}
+{% set read_intro_value = form_values.get('read_title_intro') if form_values else None %}
+{% if read_intro_value is not none %}
+ {% set read_title_intro = ((read_intro_value|string)|lower) in ['true', '1', 'yes', 'on'] %}
+{% else %}
+ {% if pending is not none %}
+ {% set read_title_intro = pending.read_title_intro %}
+ {% else %}
+ {% set read_title_intro = settings_dict.get('read_title_intro', False) %}
+ {% endif %}
+{% endif %}
+{% set read_outro_value = form_values.get('read_closing_outro') if form_values else None %}
+{% if read_outro_value is not none %}
+ {% set read_closing_outro = ((read_outro_value|string)|lower) in ['true', '1', 'yes', 'on'] %}
+{% else %}
+ {% if pending is not none %}
+ {% set read_closing_outro = pending.read_closing_outro %}
+ {% else %}
+ {% set read_closing_outro = settings_dict.get('read_closing_outro', True) %}
+ {% endif %}
+{% endif %}
+{% set normalize_caps_value = form_values.get('normalize_chapter_opening_caps') if form_values else None %}
+{% if normalize_caps_value is not none %}
+ {% set normalize_chapter_opening_caps = ((normalize_caps_value|string)|lower) in ['true', '1', 'yes', 'on'] %}
+{% else %}
+ {% if pending is not none %}
+ {% set normalize_chapter_opening_caps = pending.normalize_chapter_opening_caps %}
+ {% else %}
+ {% set normalize_chapter_opening_caps = settings_dict.get('normalize_chapter_opening_caps', True) %}
+ {% endif %}
+{% endif %}
+{% set selected_config = form_values.get('speaker_config') if form_values else None %}
+{% if selected_config is none %}
+ {% if pending and pending.applied_speaker_config %}
+ {% set selected_config = pending.applied_speaker_config %}
+ {% else %}
+ {% set selected_config = '' %}
+ {% endif %}
+{% endif %}
+{% set narrator_speed_value = form_values.get('speed') if form_values else None %}
+{% if narrator_speed_value is none %}
+ {% if pending and pending.speed %}
+ {% set narrator_speed_value = pending.speed %}
+ {% else %}
+ {% set narrator_speed_value = settings_dict.get('default_speed', 1.0) %}
+ {% endif %}
+{% endif %}
+{% set narrator_speed = narrator_speed_value|float if narrator_speed_value is not none else 1.0 %}
+{% set speed_display = '%.2f'|format(narrator_speed if narrator_speed else 1.0) %}
+{% set form_profile = form_values.get('voice_profile') if form_values else None %}
+{% set form_voice = form_values.get('voice') if form_values else None %}
+{% set form_formula = form_values.get('voice_formula') if form_values else None %}
+{% set narrator_profile = None %}
+{% if form_profile is not none and form_profile != '' %}
+ {% set narrator_profile = form_profile %}
+{% elif pending and pending.voice_profile %}
+ {% set narrator_profile = pending.voice_profile %}
+{% else %}
+ {% set narrator_profile = '' %}
+{% endif %}
+{% set narrator_voice = None %}
+{% if form_voice %}
+ {% set narrator_voice = form_voice %}
+{% elif pending and pending.voice %}
+ {% set narrator_voice = pending.voice %}
+{% else %}
+ {% set narrator_voice = settings_dict.get('default_voice', options.voices[0] if options.voices else '') %}
+{% endif %}
+{% if (not narrator_profile) and narrator_voice and narrator_voice[:8]|lower == 'profile:' %}
+ {% set narrator_profile = narrator_voice[8:]|trim %}
+ {% set narrator_voice = '' %}
+{% endif %}
+{% set normalization_overrides = pending.normalization_overrides if pending and pending.normalization_overrides else {} %}
+{% set voice_formula_value = '' %}
+{% set profile_value = narrator_profile if narrator_profile else '__standard' %}
+{% if profile_value == '__formula' %}
+ {% if form_formula %}
+ {% set voice_formula_value = form_formula %}
+ {% elif pending and pending.voice %}
+ {% set voice_formula_value = pending.voice %}
+ {% endif %}
+{% elif profile_value not in ['__standard', '', None] %}
+ {% set voice_formula_value = '' %}
+{% else %}
+ {% if form_formula %}
+ {% set profile_value = '__formula' %}
+ {% set voice_formula_value = form_formula %}
+ {% elif narrator_voice and ('+' in narrator_voice or '*' in narrator_voice) %}
+ {% set profile_value = '__formula' %}
+ {% set voice_formula_value = narrator_voice %}
+ {% else %}
+ {% set profile_value = '__standard' %}
+ {% set voice_formula_value = '' %}
+ {% endif %}
+{% endif %}
+{% if profile_value == '__formula' and not voice_formula_value %}
+ {% if pending and pending.voice %}
+ {% set voice_formula_value = pending.voice %}
+ {% endif %}
+{% endif %}
+{% if profile_value != '__standard' and profile_value != '__formula' %}
+ {% set narrator_voice = '' %}
+{% endif %}
+{% if not narrator_voice and options.voices %}
+ {% set narrator_voice = options.voices[0] %}
+{% endif %}
+
+{% if error %}
+ {{ error }}
+{% endif %}
+{% if notice %}
+ {{ notice }}
+{% endif %}
+
diff --git a/abogen/webui/templates/partials/new_job_step_chapters.html b/abogen/webui/templates/partials/new_job_step_chapters.html
new file mode 100644
index 0000000..ad3f2aa
--- /dev/null
+++ b/abogen/webui/templates/partials/new_job_step_chapters.html
@@ -0,0 +1,126 @@
+
diff --git a/abogen/webui/templates/partials/new_job_step_entities.html b/abogen/webui/templates/partials/new_job_step_entities.html
new file mode 100644
index 0000000..1177401
--- /dev/null
+++ b/abogen/webui/templates/partials/new_job_step_entities.html
@@ -0,0 +1,610 @@
+{% set embed_scripts = embed_scripts if embed_scripts is defined else True %}
+{% set recognition_enabled = settings.enable_entity_recognition if settings is defined and settings.enable_entity_recognition is not none else True %}
+
+
+
+
+
+
+ Choose a voice
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% if embed_scripts %}
+
+
+
+{% endif %}
diff --git a/abogen/webui/templates/partials/reader_modal.html b/abogen/webui/templates/partials/reader_modal.html
new file mode 100644
index 0000000..9421bd9
--- /dev/null
+++ b/abogen/webui/templates/partials/reader_modal.html
@@ -0,0 +1,19 @@
+
+
+
+
+
+ Read & listen
+ Preview synchronized narration directly in your browser.
+
+
+
+
+
+
+
+
diff --git a/abogen/webui/templates/partials/upload_modal.html b/abogen/webui/templates/partials/upload_modal.html
new file mode 100644
index 0000000..e4f05d1
--- /dev/null
+++ b/abogen/webui/templates/partials/upload_modal.html
@@ -0,0 +1,76 @@
+{% set pending = pending if pending is defined else None %}
+{% set readonly = readonly if readonly is defined else False %}
+{% set settings_dict = settings if settings is defined else {} %}
+{% set provided_step = step if step is defined else (active_step if active_step is defined else 'book') %}
+{% set current_step = provided_step %}
+{% if current_step in ['settings', 'upload', ''] %}{% set current_step = 'book' %}{% endif %}
+{% if current_step not in ['book', 'chapters', 'entities'] %}{% set current_step = 'book' %}{% endif %}
+{% set step_number = {'book': 1, 'chapters': 2, 'entities': 3} %}
+{% set step_titles = {
+ 'book': 'Book parameters',
+ 'chapters': 'Select chapters',
+ 'entities': 'Review entities'
+} %}
+{% set step_hints = {
+ 'book': 'Choose your source file or paste text, then set the defaults used for chapter analysis and speaker casting.',
+ 'chapters': "Choose which chapters to convert. We'll analyse entities automatically when you continue.",
+ 'entities': 'Assign pronunciations, voices, and manual overrides before queueing the conversion.'
+} %}
+{% set navigation_labels = {
+ 'book': 'Book parameters',
+ 'chapters': 'Chapters',
+ 'entities': 'Entities'
+} %}
+{% set total_steps = 3 %}
+{% set current_index = step_number[current_step] %}
+{% set is_open = open if open is defined else False %}
+{% set prepare_url_template = url_for('main.wizard_start', pending_id='__pending__') %}
+{% set cancel_url_template = url_for('main.wizard_cancel', pending_id='__pending__') %}
+{% set analyze_url_template = url_for('main.wizard_update', pending_id='__pending__') %}
+
+
+
+
+
+
+ {{ step_titles[current_step] }}
+ {{ step_hints[current_step] }}
+
+
+
+ {% if pending %}
+ {{ pending.original_filename }}
+ {% endif %}
+
+
+
+ {% if current_step == 'book' %}
+ {% include 'partials/new_job_step_book.html' %}
+ {% elif current_step == 'chapters' %}
+ {% include 'partials/new_job_step_chapters.html' %}
+ {% else %}
+ {% include 'partials/new_job_step_entities.html' %}
+ {% endif %}
+
+
+
diff --git a/abogen/webui/templates/prepare_chapters.html b/abogen/webui/templates/prepare_chapters.html
new file mode 100644
index 0000000..fc11972
--- /dev/null
+++ b/abogen/webui/templates/prepare_chapters.html
@@ -0,0 +1,190 @@
+{% extends "base.html" %}
+
+{% block title %}Prepare · {{ pending.original_filename }}{% endblock %}
+
+{% set is_multi_speaker = pending.speaker_mode == 'multi' %}
+{% set total_steps = 3 if is_multi_speaker else 2 %}
+
+{% block content %}
+
+
+
+
+
+
+
+ Select chapters
+ Choose which chapters to convert. We'll analyse entities automatically when you continue.
+
+
+ {{ pending.original_filename }}
+
+
+
+
+
+
+
+{% with pending=pending, readonly=True, active_step='chapters' %}
+ {% include "partials/upload_modal.html" %}
+{% endwith %}
+{% endblock %}
+
+{% block scripts %}
+ {{ super() }}
+
+
+
+
+
+
+{% endblock %}
diff --git a/abogen/webui/templates/prepare_job.html b/abogen/webui/templates/prepare_job.html
new file mode 100644
index 0000000..a349ad4
--- /dev/null
+++ b/abogen/webui/templates/prepare_job.html
@@ -0,0 +1,3 @@
+{# This template is intentionally left empty.
+ Step-specific templates now live in `prepare_chapters.html` and `prepare_entities.html`.
+ The file is kept as a placeholder to avoid breaking documentation references. #}
diff --git a/abogen/webui/templates/prepare_speakers.html b/abogen/webui/templates/prepare_speakers.html
new file mode 100644
index 0000000..bd6988f
--- /dev/null
+++ b/abogen/webui/templates/prepare_speakers.html
@@ -0,0 +1,172 @@
+ data-voice="{{ speaker.voice_formula or selected_voice or pending.voice }}"
+ data-speed="{{ '%.2f'|format(pending.speed) }}"
+ data-use-gpu="{{ 'true' if pending.use_gpu else 'false' }}"
+ {% if not speaker.voice_formula %}hidden{% endif %}>
+ Preview generated
+
+ {{ first_excerpt }}
+{{ first_hint }}
+No paragraphs captured yet. Continue from Step 2 to gather dialogue samples automatically.
+ {% endif %} +No additional speakers detected yet. The narrator voice will be used for all dialogue.
+ {% endif %} + + + + + + +Total weight: 0.00
+Settings apply to new jobs you queue from the dashboard.
+ + {% if saved %} +Store recurring casts and keep voices consistent between books.
+ + {% if message %} +Create and manage speakers for Kokoro and Supertonic.
+Speaker Studio
+Select which text-to-speech provider this speaker will use. You can create separate speakers per provider.
+ +]*>(.*?)", chapter_doc, re.DOTALL) + assert match is not None + original_text = html.unescape(match.group(1)) + assert "Second line\n\nThird paragraph." in original_text + + +def test_epub3_sentence_chunks_render_as_paragraphs(tmp_path) -> None: + extraction = ExtractionResult( + chapters=[ + ExtractedChapter( + title="Chapter 1", + text="First sentence. Second sentence in same paragraph.\n\nNew paragraph starts here.", + ) + ], + metadata={"title": "Sample", "artist": "Author", "language": "en"}, + ) + + chunks = [ + { + "id": "chap0000_p0000_s0000", + "chapter_index": 0, + "chunk_index": 0, + "text": "First sentence.", + "level": "sentence", + "speaker_id": "narrator", + }, + { + "id": "chap0000_p0000_s0001", + "chapter_index": 0, + "chunk_index": 1, + "text": "Second sentence in same paragraph.", + "level": "sentence", + "speaker_id": "narrator", + }, + { + "id": "chap0000_p0001_s0000", + "chapter_index": 0, + "chunk_index": 2, + "text": "New paragraph starts here.", + "level": "sentence", + "speaker_id": "narrator", + }, + ] + + chunk_markers = [ + {"id": chunk["id"], "chapter_index": 0, "chunk_index": chunk["chunk_index"], "start": None, "end": None} + for chunk in chunks + ] + + audio_path = tmp_path / "audio.mp3" + audio_path.write_bytes(b"ID3 audio") + output_path = tmp_path / "output.epub" + + build_epub3_package( + output_path=output_path, + book_id="job-paragraphs", + extraction=extraction, + metadata_tags={"title": "Sample", "artist": "Author", "language": "en"}, + chapter_markers=[], + chunk_markers=chunk_markers, + chunks=chunks, + audio_path=audio_path, + speaker_mode="single", + ) + + with zipfile.ZipFile(output_path) as archive: + chapter_doc = archive.read("OEBPS/text/chapter_0001.xhtml").decode("utf-8") + + assert '
Hello
" + book.add_item(chapter) + book.spine = ["nav", chapter] + book.add_item(epub.EpubNcx()) + book.add_item(epub.EpubNav()) + + path = tmp_path / "example.epub" + epub.write_epub(str(path), book) + + result = extract_from_path(path) + + assert result.metadata.get("series") == "Example Saga" + assert result.metadata.get("series_index") == "2" diff --git a/tests/test_text_normalization.py b/tests/test_text_normalization.py new file mode 100644 index 0000000..156fccf --- /dev/null +++ b/tests/test_text_normalization.py @@ -0,0 +1,343 @@ +from __future__ import annotations + +import pytest +from unittest.mock import patch + +from abogen.kokoro_text_normalization import ( + DEFAULT_APOSTROPHE_CONFIG, + normalize_for_pipeline, + normalize_roman_numeral_titles, +) +from abogen.normalization_settings import ( + apply_overrides as apply_normalization_overrides, + build_apostrophe_config, + get_runtime_settings, +) +from abogen.spacy_contraction_resolver import resolve_ambiguous_contractions + + +SPACY_RESOLVER_AVAILABLE = bool(resolve_ambiguous_contractions("It's been a long time.")) + + +def _normalize_text(text: str, *, normalization_overrides: dict[str, object] | None = None) -> str: + runtime_settings = get_runtime_settings() + if normalization_overrides: + runtime_settings = apply_normalization_overrides(runtime_settings, normalization_overrides) + config = build_apostrophe_config(settings=runtime_settings, base=DEFAULT_APOSTROPHE_CONFIG) + return normalize_for_pipeline(text, config=config, settings=runtime_settings) + + +def test_title_abbreviations_are_expanded(): + text = "Dr. Watson met Mr. Holmes and Ms. Hudson." + normalized = _normalize_text(text) + assert "Doctor" in normalized + assert "Mister" in normalized + assert "Miz" in normalized + + +def test_suffix_abbreviations_are_expanded_with_case_preserved(): + text = "John Doe Jr. spoke to JANE DOE SR. about the estate." + normalized = _normalize_text(text) + assert "John Doe Junior" in normalized + assert "JANE DOE SENIOR" in normalized + + +def test_missing_terminal_punctuation_is_added(): + normalized = _normalize_text("Chapter 1") + assert normalized.endswith(".") + + +def test_terminal_punctuation_respects_closing_quotes(): + normalized = _normalize_text('"Chapter 1"') + compact = normalized.replace(" ", "") + assert compact.endswith('."') + + +def test_normalization_preserves_spacing_around_quotes_and_hyphen(): + sample = "“Still,” said Château-Renaud, “Dr. d’Avrigny, who attends my mother, declares he is in despair about it." + normalized = _normalize_text(sample) + + assert normalized.startswith( + "“Still,” said Château-Renaud, “Doctor d'Avrigny, who attends my mother, declares he is in despair about it." + ) + assert " " not in normalized + assert "Château-Renaud" in normalized + assert "Doctor d'Avrigny" in normalized + + +def test_normalize_roman_titles_converts_when_majority() -> None: + titles = ["I: Opening", "II: Rising Action", "III: Climax"] + normalized = normalize_roman_numeral_titles(titles) + + assert normalized == ["1: Opening", "2: Rising Action", "3: Climax"] + + +def test_normalize_roman_titles_skips_when_not_majority() -> None: + titles = ["Preface", "I: Opening", "Acknowledgements"] + normalized = normalize_roman_numeral_titles(titles) + + assert normalized == titles + + +def test_normalize_roman_titles_preserves_separators() -> None: + titles = [" IV. The Trial", "V - The Verdict", "VI\nAftermath"] + normalized = normalize_roman_numeral_titles(titles) + + assert normalized[0] == " 4. The Trial" + assert normalized[1] == "5 - The Verdict" + assert normalized[2].startswith("6\nAftermath") + + +def test_grouped_numbers_are_spelled_out() -> None: + normalized = _normalize_text("The vault holds 35,000 credits") + assert "thirty-five thousand" in normalized.lower() + + +def test_numeric_ranges_are_spoken_with_to() -> None: + normalized = _normalize_text("Chapters 1-3") + assert "one to three" in normalized.lower() + + +def test_simple_fractions_are_spoken() -> None: + normalized = _normalize_text("Add 1/2 cup of sugar") + assert "one half" in normalized.lower() + + +def test_plain_numbers_are_spelled_out() -> None: + normalized = _normalize_text("He rolled a 42.") + assert "forty-two" in normalized.lower() + + +def test_decimal_numbers_include_point() -> None: + normalized = _normalize_text("Book 4.5 of the series.") + assert "four point five" in normalized.lower() + + +def test_space_separated_numbers_become_ranges() -> None: + normalized = _normalize_text("Read pages 12 14 tonight.") + assert "pages twelve to fourteen" in normalized.lower() + + +def test_year_like_numbers_use_common_pronunciation() -> None: + normalized = _normalize_text("In 1924 the journey began") + folded = normalized.lower().replace("-", " ") + assert "nineteen hundred" in folded + assert "twenty four" in folded + + +def test_early_century_years_use_hundred_format() -> None: + normalized = _normalize_text("In 1204 the city fell") + assert "twelve hundred" in normalized.lower() + assert "oh four" in normalized.lower() + + +def test_roman_numerals_in_titles_are_converted() -> None: + normalized = _normalize_text("Chapter IV begins now") + assert "chapter four" in normalized.lower() + + +def test_roman_numeral_suffixes_use_ordinals() -> None: + normalized = _normalize_text("Bob Smith II arrived late") + assert "bob smith the second" in normalized.lower() + + +def test_lowercase_roman_after_part_converts_to_cardinal() -> None: + normalized = _normalize_text("We studied part iii of the manuscript.") + assert "part three" in normalized.lower() + + +def test_hyphenated_phase_with_roman_is_converted() -> None: + normalized = _normalize_text("They executed phase-IV without delay.") + assert "phase four" in normalized.lower() + + +def test_all_caps_quotes_are_sentence_cased() -> None: + normalized = _normalize_text('"THIS IS A TEST."') + cleaned = normalized.replace('" ', '"') + assert '"This is a test."' in cleaned + + +def test_caps_quote_preserves_acronyms() -> None: + normalized = _normalize_text("“THE NASA TEAM ARRIVED.”") + assert "“The NASA team arrived.”" in normalized + + +def test_caps_quote_normalization_respects_override() -> None: + normalized = _normalize_text( + '"KEEP SHOUTING."', + normalization_overrides={"normalization_caps_quotes": False}, + ) + cleaned = normalized.replace('" ', '"') + assert '"KEEP SHOUTING."' in cleaned + + +def test_recent_years_split_twenty_style() -> None: + normalized = _normalize_text("In 2025 we planned ahead") + folded = normalized.lower().replace("-", " ") + assert "twenty twenty five" in folded + + +def test_two_thousands_use_two_thousand_prefix() -> None: + normalized = _normalize_text("In 2005 we celebrated") + assert "two thousand five" in normalized.lower() + + +def test_year_style_can_be_disabled() -> None: + normalized = _normalize_text( + "In 2025 we planned ahead", + normalization_overrides={"normalization_numbers_year_style": "off"}, + ) + folded = normalized.lower().replace("-", " ") + assert "twenty twenty five" not in folded + + +def test_contractions_can_be_kept_when_override_disabled() -> None: + normalized = _normalize_text( + "It's a good day.", + normalization_overrides={"normalization_apostrophes_contractions": False}, + ) + assert "It's" in normalized + + +def test_sibilant_possessives_remain_when_marking_disabled() -> None: + normalized = _normalize_text( + "The boss's chair wobbled.", + normalization_overrides={"normalization_apostrophes_sibilant_possessives": False}, + ) + assert "boss's" in normalized + assert "boss iz" not in normalized.lower() + + +def test_decades_can_skip_expansion_when_disabled() -> None: + normalized = _normalize_text( + "Classic hits from the '90s filled the hall.", + normalization_overrides={"normalization_apostrophes_decades": False}, + ) + assert "'90s" in normalized + + +def test_abbreviated_decades_expand_to_spoken_form() -> None: + normalized = _normalize_text("She loved music from the '80s.") + assert "eighties" in normalized.lower() + + +def test_currency_under_one_dollar_uses_cents() -> None: + normalized = _normalize_text("It cost $0.99.") + folded = normalized.lower().replace("-", " ") + assert "zero dollars" not in folded + assert "cents" in folded + + +def test_iso_dates_use_locale_order_and_ordinals(monkeypatch) -> None: + monkeypatch.setenv("LC_TIME", "en_US.UTF-8") + normalized = _normalize_text("The date is 2025/12/15.") + folded = normalized.lower().replace("-", " ") + assert "december" in folded + assert "fifteenth" in folded + + +def test_times_and_acronyms_do_not_say_dot() -> None: + normalized = _normalize_text("Meet at 5 p.m. near the U.S.A. border.") + folded = normalized.lower() + assert " dot " not in folded + + +def test_internet_slang_expansion_is_configurable() -> None: + normalized = _normalize_text( + "pls knock before entering.", + normalization_overrides={"normalization_internet_slang": True}, + ) + assert "please" in normalized.lower() + + +@pytest.mark.skipif(not SPACY_RESOLVER_AVAILABLE, reason="spaCy model unavailable") +def test_spacy_disambiguates_it_has_from_context() -> None: + normalized = _normalize_text("It's been a long time.") + assert "It has been a long time." == normalized + + +@pytest.mark.skipif(not SPACY_RESOLVER_AVAILABLE, reason="spaCy model unavailable") +def test_spacy_disambiguates_it_is_from_context() -> None: + normalized = _normalize_text("It's cold outside.") + assert "It is cold outside." == normalized + + +@pytest.mark.skipif(not SPACY_RESOLVER_AVAILABLE, reason="spaCy model unavailable") +def test_spacy_disambiguates_she_had() -> None: + normalized = _normalize_text("She'd left before dawn.") + assert "She had left before dawn." == normalized + + +@pytest.mark.skipif(not SPACY_RESOLVER_AVAILABLE, reason="spaCy model unavailable") +def test_spacy_disambiguates_she_would() -> None: + normalized = _normalize_text("She'd go if invited.") + assert "She would go if invited." == normalized + + +@pytest.mark.skipif(not SPACY_RESOLVER_AVAILABLE, reason="spaCy model unavailable") +def test_sample_sentence_handles_complex_contractions() -> None: + sample = "I've heard the captain'll arrive by dusk, but they'd said the same yesterday." + normalized = _normalize_text(sample) + assert ( + "I have heard the captain will arrive by dusk, but they had said the same yesterday." == normalized + ) + + +def test_modal_will_contractions_can_be_disabled() -> None: + sample = "The captain'll arrive at dawn." + normalized = _normalize_text( + sample, + normalization_overrides={"normalization_contraction_modal_will": False}, + ) + assert "captain'll" in normalized + + +@pytest.fixture(autouse=True) +def mock_settings(): + defaults = { + "normalization_numbers": True, + "normalization_titles": True, + "normalization_terminal": True, + "normalization_phoneme_hints": True, + "normalization_caps_quotes": True, + "normalization_apostrophes_contractions": True, + "normalization_apostrophes_plural_possessives": True, + "normalization_apostrophes_sibilant_possessives": True, + "normalization_apostrophes_decades": True, + "normalization_apostrophes_leading_elisions": True, + "normalization_apostrophe_mode": "spacy", + "normalization_contraction_aux_be": True, + "normalization_contraction_aux_have": True, + "normalization_contraction_modal_will": True, + "normalization_contraction_modal_would": True, + "normalization_contraction_negation_not": True, + "normalization_contraction_let_us": True, + "normalization_currency": True, + "normalization_footnotes": True, + "normalization_numbers_year_style": "american", + } + with patch("tests.test_text_normalization.get_runtime_settings", return_value=defaults): + yield + +def test_currency_magnitude(): + cases = [ + ("$2 million", "two million dollars"), + ("$2.5 million", "two point five million dollars"), + ("$100 billion", "one hundred billion dollars"), + ("$1.2 trillion", "one point two trillion dollars"), + ("$2.55 million", "two point five five million dollars"), + ("$1 million", "one million dollars"), + ("$0.5 million", "zero point five million dollars"), + ("$2.50", "two dollars, fifty cents"), + ("$100", "one hundred dollars"), + ] + + settings = { + "normalization_numbers": True, + "normalization_currency": True, + "normalization_apostrophe_mode": "spacy" + } + + for input_text, expected in cases: + normalized = _normalize_text(input_text, normalization_overrides=settings) + assert expected.lower() in normalized.lower(), f"Failed for {input_text}: got '{normalized}'" diff --git a/tests/test_tts_supertonic_unsupported_chars.py b/tests/test_tts_supertonic_unsupported_chars.py new file mode 100644 index 0000000..c08ca2c --- /dev/null +++ b/tests/test_tts_supertonic_unsupported_chars.py @@ -0,0 +1,53 @@ +import numpy as np + +from abogen.tts_supertonic import SupertonicPipeline + + +class _DummyTTS: + def get_voice_style(self, voice_name: str): + return {"voice": voice_name} + + def synthesize( + self, + *, + text: str, + voice_style, + total_steps: int, + speed: float, + max_chunk_length: int, + silence_duration: float, + verbose: bool, + ): + if "•" in text: + raise ValueError("Found 1 unsupported character(s): ['•']") + # Return 50ms of audio at 24kHz. + sr = 24000 + audio = np.zeros(int(0.05 * sr), dtype="float32") + return audio, 0.05 + + +def test_supertonic_pipeline_strips_unsupported_characters_and_retries(): + # Avoid importing/initializing real supertonic by manually constructing the pipeline. + pipeline = SupertonicPipeline.__new__(SupertonicPipeline) + pipeline.sample_rate = 24000 + pipeline.total_steps = 5 + pipeline.max_chunk_length = 1000 + pipeline._tts = _DummyTTS() + + segs = list(pipeline("Hello • world", voice="M1", speed=1.0)) + assert len(segs) == 1 + assert segs[0].graphemes == "Hello world" or segs[0].graphemes == "Hello world" + assert isinstance(segs[0].audio, np.ndarray) + assert segs[0].audio.dtype == np.float32 + assert segs[0].audio.size > 0 + + +def test_supertonic_pipeline_drops_chunk_if_only_unsupported_characters(): + pipeline = SupertonicPipeline.__new__(SupertonicPipeline) + pipeline.sample_rate = 24000 + pipeline.total_steps = 5 + pipeline.max_chunk_length = 1000 + pipeline._tts = _DummyTTS() + + segs = list(pipeline("•", voice="M1", speed=1.0)) + assert segs == [] diff --git a/tests/test_utils_cache.py b/tests/test_utils_cache.py new file mode 100644 index 0000000..2d35d18 --- /dev/null +++ b/tests/test_utils_cache.py @@ -0,0 +1,55 @@ +import os +import sys +from pathlib import Path +from typing import Iterable + +import pytest + + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) + + +@pytest.fixture(autouse=True) +def clear_utils_cache(): + import abogen.utils as utils + + getattr(utils.get_user_cache_root, "cache_clear")() + yield + getattr(utils.get_user_cache_root, "cache_clear")() + + +def _clear_env(monkeypatch: pytest.MonkeyPatch, keys: Iterable[str]) -> None: + for key in keys: + monkeypatch.delenv(key, raising=False) + + +def test_abogen_temp_dir_configures_hf_cache(monkeypatch, tmp_path): + import abogen.utils as utils + + cache_root = tmp_path / "cache-root" + home_dir = tmp_path / "home" + + monkeypatch.setenv("ABOGEN_TEMP_DIR", str(cache_root)) + monkeypatch.setenv("HOME", str(home_dir)) + _clear_env( + monkeypatch, + ( + "XDG_CACHE_HOME", + "HF_HOME", + "HUGGINGFACE_HUB_CACHE", + "TRANSFORMERS_CACHE", + "ABOGEN_INTERNAL_CACHE_ROOT", + ), + ) + + root = utils.get_user_cache_root() + + expected_root = os.path.abspath(str(cache_root)) + expected_hf = os.path.join(expected_root, "huggingface") + + assert root == expected_root + assert os.environ["XDG_CACHE_HOME"] == expected_root + assert os.environ["HF_HOME"] == expected_hf + assert os.environ["HUGGINGFACE_HUB_CACHE"] == expected_hf + assert os.environ["TRANSFORMERS_CACHE"] == expected_hf diff --git a/tests/test_voice_cache.py b/tests/test_voice_cache.py new file mode 100644 index 0000000..b0aa2ca --- /dev/null +++ b/tests/test_voice_cache.py @@ -0,0 +1,65 @@ +from types import SimpleNamespace +from typing import cast + +import pytest + +from abogen.constants import VOICES_INTERNAL +from abogen.voice_cache import LocalEntryNotFoundError, _CACHED_VOICES, ensure_voice_assets +from abogen.webui.conversion_runner import _collect_required_voice_ids +from abogen.webui.service import Job + + +@pytest.fixture(autouse=True) +def clear_voice_cache(): + _CACHED_VOICES.clear() + yield + _CACHED_VOICES.clear() + + +def test_ensure_voice_assets_downloads_missing(monkeypatch): + recorded = [] + + cached = set() + + def fake_download(**kwargs): + filename = kwargs["filename"] + if kwargs.get("local_files_only"): + if filename in cached: + return f"/tmp/{filename}" + raise LocalEntryNotFoundError(f"{filename} missing") + + recorded.append(filename) + cached.add(filename) + return f"/tmp/{filename}" + + monkeypatch.setattr("abogen.voice_cache.hf_hub_download", fake_download) + + downloaded, errors = ensure_voice_assets(["af_nova", "am_liam"]) + + assert downloaded == {"af_nova", "am_liam"} + assert errors == {} + assert set(recorded) == {"voices/af_nova.pt", "voices/am_liam.pt"} + + recorded.clear() + downloaded_again, errors_again = ensure_voice_assets(["af_nova"]) + + assert downloaded_again == set() + assert errors_again == {} + assert recorded == [] + + +def test_collect_required_voice_ids_includes_all(): + job = SimpleNamespace( + voice="af_nova", + chapters=[{"voice_formula": "af_nova*0.7+am_liam*0.3"}], + chunks=[{"voice": "am_michael"}], + speakers={ + "hero": {"voice_formula": "af_nova*0.6+am_liam*0.4"}, + "narrator": {"voice": "af_nova"}, + }, + ) + + voices = _collect_required_voice_ids(cast(Job, job)) + + assert {"af_nova", "am_liam", "am_michael"}.issubset(voices) + assert voices.issuperset(VOICES_INTERNAL) diff --git a/tests/test_voice_formula_resolution.py b/tests/test_voice_formula_resolution.py new file mode 100644 index 0000000..2bc3430 --- /dev/null +++ b/tests/test_voice_formula_resolution.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from abogen.webui.conversion_runner import _resolve_voice, _supertonic_voice_from_spec +from abogen.tts_supertonic import DEFAULT_SUPERTONIC_VOICES + + +def test_resolve_voice_formula_without_pipeline_does_not_crash() -> None: + # This can happen when a previously-saved Kokoro mix formula is present + # but the active provider is SuperTonic (no Kokoro pipeline object). + formula = "af_heart*0.5+af_sky*0.5" + resolved = _resolve_voice(None, formula, use_gpu=False) + assert resolved == formula + + +def test_supertonic_voice_from_formula_falls_back_to_valid_voice() -> None: + # When a stale Kokoro mix formula is present, SuperTonic should not receive it. + chosen = _supertonic_voice_from_spec("af_heart*0.5+af_sky*0.5", "af_heart*1.0") + assert chosen in DEFAULT_SUPERTONIC_VOICES