termux-tts 1.4.2 → 1.4.4

package/termux_tts/installer.py

@@ -9,10 +9,34 @@ import urllib.request
 import shutil
 from pathlib import Path
 
-VULKAN_BINARY_RELEASE_URL = (
-    "https://github.com/uno-km/termux-sherpa-ncnn/releases/download/"
-    "v1.0.0-vulkan/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz"
-)
+def get_candidate_vulkan_binary_urls():
+    """Generate dynamic candidate endpoints for Vulkan binary provisioner."""
+    try:
+        from . import __version__
+    except Exception:
+        __version__ = "1.4.4"
+
+    urls = []
+    custom_tag = os.environ.get("TERMUX_TTS_RELEASE_TAG", "").strip()
+    custom_base = os.environ.get("TERMUX_TTS_RELEASE_BASE", "").strip()
+
+    if custom_base:
+        urls.append(f"{custom_base.rstrip('/')}/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz")
+    if custom_tag:
+        tag = custom_tag if custom_tag.startswith("v") else f"v{custom_tag}"
+        urls.append(f"https://github.com/uno-km/termux-tts/releases/download/{tag}/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz")
+
+    # 1. termux-tts current version SSOT
+    current_tag = f"v{__version__}"
+    urls.append(f"https://github.com/uno-km/termux-tts/releases/download/{current_tag}/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz")
+
+    # 2. termux-tts latest release (verified HTTP 200)
+    urls.append("https://github.com/uno-km/termux-tts/releases/latest/download/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz")
+
+    # 3. Companion release fallback (verified HTTP 200)
+    urls.append("https://github.com/uno-km/termux-sherpa-ncnn/releases/download/v1.0.0-vulkan/sherpa-ncnn-offline-tts-vulkan-arm64.tar.gz")
+
+    return urls
 
 MODEL_REGISTRY = {
     "high": {
@@ -39,17 +63,90 @@ MODEL_REGISTRY = {
     }
 }
 
+OFFICIAL_NEURAL_MODELS = {
+    "ko": {
+        "name": "vits-mimic3-ko_KO-kss_low",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-mimic3-ko_KO-kss_low.tar.bz2",
+        "repo": "csukuangfj/vits-mimic3-ko_KO-kss_low",
+        "language_name": "Korean",
+        "description": "Korean VITS Mimic3 KSS Studio ONNX Model (~45MB)",
+    },
+    "en": {
+        "name": "vits-piper-en_US-lessac-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-en_US-lessac-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-en_US-lessac-medium",
+        "language_name": "English",
+        "description": "English VITS Piper Lessac Medium ONNX Model (~55MB)",
+    },
+    "ja": {
+        "name": "vits-piper-ja_JP-hina-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-ja_JP-hina-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-ja_JP-hina-medium",
+        "language_name": "Japanese",
+        "description": "Japanese VITS Piper Hina Medium ONNX Model (~50MB)",
+    },
+    "zh": {
+        "name": "vits-zh-aishell3",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-zh-aishell3.tar.bz2",
+        "repo": "csukuangfj/vits-zh-aishell3",
+        "language_name": "Chinese (Mandarin)",
+        "description": "Chinese VITS AISHELL-3 Multi-Speaker ONNX Model (~65MB)",
+    },
+    "hi": {
+        "name": "vits-piper-hi_IN-swara-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-hi_IN-swara-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-hi_IN-swara-medium",
+        "language_name": "Hindi",
+        "description": "Hindi VITS Piper Swara Medium ONNX Model (~55MB)",
+    },
+    "ru": {
+        "name": "vits-piper-ru_RU-dmitri-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-ru_RU-dmitri-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-ru_RU-dmitri-medium",
+        "language_name": "Russian",
+        "description": "Russian VITS Piper Dmitri Medium ONNX Model (~55MB)",
+    },
+    "es": {
+        "name": "vits-piper-es_ES-davefx-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-es_ES-davefx-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-es_ES-davefx-medium",
+        "language_name": "Spanish",
+        "description": "Spanish VITS Piper Davefx Medium ONNX Model (~50MB)",
+    },
+    "fr": {
+        "name": "vits-piper-fr_FR-siwis-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-fr_FR-siwis-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-fr_FR-siwis-medium",
+        "language_name": "French",
+        "description": "French VITS Piper Siwis Medium ONNX Model (~50MB)",
+    },
+    "de": {
+        "name": "vits-piper-de_DE-thorsten-medium",
+        "url": "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-de_DE-thorsten-medium.tar.bz2",
+        "repo": "csukuangfj/vits-piper-de_DE-thorsten-medium",
+        "language_name": "German",
+        "description": "German VITS Piper Thorsten Medium ONNX Model (~50MB)",
+    },
+}
+
 def get_install_paths():
-    home = Path.home()
-    bin_dir = home / ".local" / "bin"
-    cache_dir = home / ".cache" / "termux-tts" / "models"
+    home = Path.home().resolve()
+    bin_dir = (home / ".local" / "bin").resolve()
+    cache_dir = (home / ".cache" / "termux-tts" / "models").resolve()
+    models_tts_dir = (home / "models" / "tts").resolve()
     bin_dir.mkdir(parents=True, exist_ok=True)
     cache_dir.mkdir(parents=True, exist_ok=True)
+    models_tts_dir.mkdir(parents=True, exist_ok=True)
     return bin_dir, cache_dir
 
 def download_with_progress(url: str, dest_path: Path, label: str):
+    try:
+        from . import __version__
+    except Exception:
+        __version__ = "1.4.4"
+
     print(f"  [DOWNLOADING] {label}...")
-    req = urllib.request.Request(url, headers={"User-Agent": "termux-tts-installer/1.3.0"})
+    req = urllib.request.Request(url, headers={"User-Agent": f"termux-tts-installer/{__version__} (Android; ARM64)"})
     with urllib.request.urlopen(req) as resp, open(dest_path, "wb") as out_f:
         total = int(resp.headers.get("Content-Length", 0))
         downloaded = 0
@@ -69,13 +166,30 @@ def download_with_progress(url: str, dest_path: Path, label: str):
 def install_vulkan_binary(force: bool = False) -> Path:
     bin_dir, _ = get_install_paths()
     binary_path = bin_dir / "sherpa-ncnn-offline-tts"
+    prefix_bin = Path(os.environ.get("PREFIX", "/data/data/com.termux/files/usr")) / "bin"
     
     if binary_path.exists() and not force:
         print(f"  [OK] Pre-compiled Vulkan binary already exists: {binary_path}")
         return binary_path
 
     tar_path = bin_dir / "sherpa-vulkan.tar.gz"
-    download_with_progress(VULKAN_BINARY_RELEASE_URL, tar_path, "ARM64 Vulkan Binary (3.9MB)")
+    candidate_urls = get_candidate_vulkan_binary_urls()
+    download_success = False
+
+    for url in candidate_urls:
+        try:
+            download_with_progress(url, tar_path, f"ARM64 Vulkan Binary ({url})")
+            if tar_path.exists() and tar_path.stat().st_size > 500 * 1024:
+                download_success = True
+                break
+        except Exception as dl_err:
+            print(f"  [-] Candidate URL failed ({url}): {dl_err}")
+            if tar_path.exists():
+                tar_path.unlink(missing_ok=True)
+            continue
+
+    if not download_success:
+        raise RuntimeError("Failed to download sherpa-ncnn-offline-tts from any candidate endpoints.")
 
     print("  [EXTRACTING] Installing binary to ~/.local/bin...")
     with tarfile.open(tar_path, "r:gz") as tar:
@@ -83,6 +197,17 @@ def install_vulkan_binary(force: bool = False) -> Path:
 
     tar_path.unlink(missing_ok=True)
     binary_path.chmod(0o755)
+
+    # Dual-path installation to PREFIX/bin if writable
+    try:
+        if prefix_bin.exists() and os.access(prefix_bin, os.W_OK):
+            target_prefix_bin = prefix_bin / "sherpa-ncnn-offline-tts"
+            shutil.copy2(binary_path, target_prefix_bin)
+            target_prefix_bin.chmod(0o755)
+            print(f"  [SYMLINK/COPY] Linked to {target_prefix_bin}")
+    except OSError:
+        pass
+
     print(f"  [SUCCESS] Installed: {binary_path}")
     return binary_path
 
@@ -109,9 +234,68 @@ def install_vits_model(tier: str = "high", force: bool = False) -> Path:
     print(f"  [SUCCESS] Model installed at: {model_dir}")
     return model_dir
 
-def run_installation(tier: str = "high", force: bool = False, play: bool = True):
+def provision_neural_model_archive(language: str, force: bool = False) -> Path:
+    """
+    On-Demand Auto-Provisioner for official neural speech models.
+    Downloads official pre-compiled model archives (.tar.bz2) and extracts directly into cache.
+    """
+    from .script_classifier import normalize_language_code
+    lang = normalize_language_code(language)
+    if lang not in OFFICIAL_NEURAL_MODELS:
+        from .exceptions import TTSModelLoadError
+        raise TTSModelLoadError(
+            f"[FAIL-FAST] No official automated model package registered for language '{lang}'.\n"
+            f"Available automated packages: {list(OFFICIAL_NEURAL_MODELS.keys())}"
+        )
+
+    cfg = OFFICIAL_NEURAL_MODELS[lang]
+    _, cache_dir = get_install_paths()
+    target_dir = cache_dir / cfg["name"]
+    unified_tts_dir = Path.home() / "models" / "tts"
+
+    if target_dir.is_dir() and not force:
+        onnx_files = list(target_dir.glob("*.onnx"))
+        if onnx_files and (target_dir / "tokens.txt").exists() and (target_dir / "espeak-ng-data").exists():
+            # Ensure symlink in ~/models/tts/
+            try:
+                link_dest = unified_tts_dir / cfg["name"]
+                if not link_dest.exists() and not link_dest.is_symlink():
+                    link_dest.symlink_to(target_dir)
+            except OSError:
+                pass
+            return target_dir
+
+    print(f"\n[termux-tts runtime] Auto-provisioning {cfg['description']}...")
+    archive_path = cache_dir / f"{cfg['name']}.tar.bz2"
+
+    try:
+        download_with_progress(cfg["url"], archive_path, cfg["name"])
+        print(f"  [EXTRACTING] Unpacking model archive into {cache_dir}...")
+        with tarfile.open(archive_path, "r:bz2") as tar:
+            tar.extractall(path=cache_dir)
+        archive_path.unlink(missing_ok=True)
+
+        # Link to ~/models/tts/ as unified SSOT
+        try:
+            link_dest = unified_tts_dir / cfg["name"]
+            if not link_dest.exists() and not link_dest.is_symlink():
+                link_dest.symlink_to(target_dir)
+        except OSError:
+            pass
+
+        print(f"  [SUCCESS] Model provisioned: {target_dir}")
+        return target_dir
+    except Exception as err:
+        if archive_path.exists():
+            archive_path.unlink(missing_ok=True)
+        from .exceptions import TTSModelLoadError
+        raise TTSModelLoadError(
+            f"[FAIL-FAST] Failed to auto-provision neural model '{cfg['name']}': {err}"
+        ) from err
+
+def run_installation(tier: str = "high", models: str = "default", force: bool = False, play: bool = True):
     print("=" * 70)
-    print("   TERMUX-TTS VULKAN GPU AUTOMATED PROVISIONER (1-CLICK SETUP)")
+    print("   TERMUX-TTS AUTOMATED PROVISIONER (BATTERIES-INCLUDED RUNTIME)")
     print("=" * 70)
     
     # 1. Install pre-compiled Vulkan binary
@@ -119,6 +303,24 @@ def run_installation(tier: str = "high", force: bool = False, play: bool = True)
     
     # 2. Install VITS model
     model_path = install_vits_model(tier=tier, force=force)
+
+    # 2b. Install Multilingual VITS ONNX Models
+    # Default is ONLY Korean (ko) & English (en) for ultra-lightweight initial setup!
+    raw_models = models.strip().lower() if models else "default"
+    if raw_models in ("default", "base", "core"):
+        langs_to_install = ["ko", "en"]
+    elif raw_models == "all":
+        langs_to_install = list(OFFICIAL_NEURAL_MODELS.keys())
+    else:
+        # User specified specific language(s) like "hi" or "ja,zh"
+        langs_to_install = [l.strip() for l in raw_models.split(",") if l.strip()]
+
+    print(f"\n[MULTILINGUAL] Provisioning Neural Speech Models: {langs_to_install}...")
+    for lang in langs_to_install:
+        try:
+            provision_neural_model_archive(lang, force=force)
+        except Exception as e:
+            print(f"  [-] Multilingual {lang} provisioning note: {e}")
     
     # 3. Environment check
     vulkan_lib = Path("/system/lib64/libvulkan.so")

package/termux_tts/script_classifier.py

@@ -0,0 +1,253 @@
+"""
+Extensible Unicode Script Classifier and Multilingual Tokenizer.
+Supports Korean (ko), English/Latin (en), Japanese (ja), Chinese (zh),
+and dynamic extension for future languages.
+Adheres to strict Zero-Silent-Fallback and AOSF-ENG-STD-2026 Governance.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import List, Tuple, Optional, Set, Dict, Callable
+
+
+@dataclass
+class LanguageChunk:
+    text: str
+    language: str
+    pause_after: float
+    is_affix: bool = False
+
+    def __repr__(self) -> str:
+        return f"LanguageChunk(lang='{self.language}', text='{self.text}', pause={self.pause_after:.3f}s, affix={self.is_affix})"
+
+
+class ScriptRegistry:
+    """
+    Extensible Unicode Range Registry for multi-script linguistic detection.
+    Allows dynamic registration of new languages without modifying core dispatch logic.
+    """
+    _CUSTOM_MATCHERS: Dict[str, Callable[[int], bool]] = {}
+
+    @classmethod
+    def register_language(cls, lang_code: str, matcher: Callable[[int], bool]) -> None:
+        cls._CUSTOM_MATCHERS[lang_code.lower()] = matcher
+
+    @classmethod
+    def classify_code_point(cls, code: int) -> str:
+        # 1. Custom registered languages
+        for lang_code, matcher in cls._CUSTOM_MATCHERS.items():
+            if matcher(code):
+                return lang_code.lower()
+
+        # 2. Korean (Hangul Syllables, Jamo, Compatibility Jamo, Extended Jamo A/B)
+        if ((0xAC00 <= code <= 0xD7A3) or
+            (0x1100 <= code <= 0x11FF) or
+            (0x3130 <= code <= 0x318F) or
+            (0xA960 <= code <= 0xA97F) or
+            (0xD7B0 <= code <= 0xD7FF)):
+            return "ko"
+
+        # 3. Japanese Hiragana & Katakana (distinctly Japanese)
+        if ((0x3040 <= code <= 0x309F) or  # Hiragana
+            (0x30A0 <= code <= 0x30FF) or  # Katakana
+            (0x31F0 <= code <= 0x31FF)):   # Katakana Phonetic Extensions
+            return "ja"
+
+        # 4. English & Latin Alphabet (Basic Latin & Latin-1 Supplement)
+        if ((0x0041 <= code <= 0x005A) or  # A-Z
+            (0x0061 <= code <= 0x007A) or  # a-z
+            (0x00C0 <= code <= 0x024F)):   # Latin Extended-A & B
+            return "en"
+
+        # 5. CJK Unified Ideographs (Common Hanzi/Kanji/Hanja)
+        if ((0x4E00 <= code <= 0x9FFF) or
+            (0x3400 <= code <= 0x4DBF) or
+            (0x20000 <= code <= 0x2A6DF)):
+            return "cjk_ideograph"
+
+        # 6. Hindi (Devanagari script)
+        if 0x0900 <= code <= 0x097F:
+            return "hi"
+
+        # 7. Russian (Cyrillic script)
+        if (0x0400 <= code <= 0x04FF) or (0x0500 <= code <= 0x052F):
+            return "ru"
+
+        # 8. Arabic script
+        if (0x0600 <= code <= 0x06FF) or (0x0750 <= code <= 0x077F):
+            return "ar"
+
+        # 9. Spaces, Controls
+        if code in (0x20, 0x09, 0x0A, 0x0D):
+            return "space"
+
+        # 10. Punctuations
+        ch = chr(code)
+        if ch in ".?!":
+            return "punct_sentence"
+        elif ch in ",;:":
+            return "punct_clause"
+        elif ch in "\"'`-~…—()[]{}":
+            return "punct_inline"
+        elif 0x0030 <= code <= 0x0039:
+            return "digit"
+
+        return "other"
+
+
+def normalize_language_code(lang: Optional[str]) -> str:
+    """Normalizes various user language inputs (e.g. 'eng', 'kor', 'hindi', 'russian') to ISO 2-letter codes."""
+    if not lang:
+        return "auto"
+    cleaned = lang.strip().lower()
+    mapping = {
+        "ko": "ko", "kor": "ko", "korean": "ko", "한국어": "ko", "한글": "ko",
+        "en": "en", "eng": "en", "english": "en", "영어": "en",
+        "ja": "ja", "jpn": "ja", "japanese": "ja", "일본어": "ja", "일어": "ja",
+        "zh": "zh", "cmn": "zh", "chinese": "zh", "중국어": "zh", "중문": "zh",
+        "hi": "hi", "hin": "hi", "hindi": "hi", "힌디어": "hi",
+        "ru": "ru", "rus": "ru", "russian": "ru", "러시아어": "ru", "노어": "ru",
+        "es": "es", "spa": "es", "spanish": "es", "스페인어": "es",
+        "fr": "fr", "fra": "fr", "fre": "fr", "french": "fr", "프랑스어": "fr",
+        "de": "de", "deu": "de", "ger": "de", "german": "de", "독일어": "de",
+        "ar": "ar", "ara": "ar", "arabic": "ar", "아랍어": "ar",
+        "auto": "auto", "all": "auto", "multi": "auto", "multilingual": "auto",
+    }
+    return mapping.get(cleaned, cleaned)
+
+
+class MultilingualTokenizer:
+    """
+    Intelligent context-aware Code-Switching Tokenizer.
+    Partitions input text into language chunks and calculates optimal acoustic pauses
+    for seamless, artifact-free multi-speaker concatenation.
+    """
+
+    DEFAULT_PAUSE_SENTENCE = 0.250   # . ? ! (Sentence boundary breathing pause)
+    DEFAULT_PAUSE_CLAUSE = 0.150     # , ; : (Clause boundary short breath)
+    DEFAULT_PAUSE_AFFIX = 0.020      # Direct word+particle affix (e.g. 'parrot'+'이라고')
+    DEFAULT_PAUSE_WORD = 0.060       # Normal inter-word space
+
+    def __init__(self, default_language: str = "ko"):
+        self.default_language = default_language.lower()
+
+    @staticmethod
+    def detect_languages(text: str) -> Set[str]:
+        """Returns the set of natural languages detected in the text, ignoring expressive bracket markup."""
+        cleaned = re.sub(r"\[[a-zA-Z가-힣_]+\]", "", text)
+        detected = set()
+        for ch in cleaned:
+            script = ScriptRegistry.classify_code_point(ord(ch))
+            if script in ("ko", "en", "ja", "hi", "ru", "ar") or script in ScriptRegistry._CUSTOM_MATCHERS:
+                detected.add(script)
+            elif script == "cjk_ideograph":
+                detected.add("zh")
+        return detected
+
+    def tokenize(self, text: str, force_language: Optional[str] = None) -> List[LanguageChunk]:
+        """
+        Dynamically partitions mixed-script text into language chunks with
+        contextual silence duration.
+        If force_language is specified ('ko', 'en', etc.), the entire text is
+        routed to that language without multi-script splitting.
+        """
+        if not text or not text.strip():
+            return []
+
+        norm_forced = normalize_language_code(force_language)
+        if norm_forced != "auto":
+            clean_str = text.strip()
+            if any(clean_str.endswith(p) for p in (".", "?", "!")):
+                pause = self.DEFAULT_PAUSE_SENTENCE
+            elif any(clean_str.endswith(p) for p in (",", ";", ":")):
+                pause = self.DEFAULT_PAUSE_CLAUSE
+            else:
+                pause = self.DEFAULT_PAUSE_WORD
+
+            return [LanguageChunk(text=clean_str, language=norm_forced, pause_after=pause, is_affix=False)]
+
+        # Contextual disambiguation for CJK Ideographs (Kanji vs Hanzi vs Hanja)
+        has_kana = any(ScriptRegistry.classify_code_point(ord(c)) == "ja" for c in text)
+        has_hangul = any(ScriptRegistry.classify_code_point(ord(c)) == "ko" for c in text)
+
+        tokens: List[LanguageChunk] = []
+        current_lang: Optional[str] = None
+        buffer_chars: List[str] = []
+        has_trailing_space: bool = False
+
+        def flush_chunk(is_affix: bool = False):
+            nonlocal buffer_chars, current_lang
+            raw_chunk = "".join(buffer_chars).strip()
+            if raw_chunk and current_lang:
+                if any(raw_chunk.endswith(p) for p in (".", "?", "!")):
+                    pause = self.DEFAULT_PAUSE_SENTENCE
+                elif any(raw_chunk.endswith(p) for p in (",", ";", ":")):
+                    pause = self.DEFAULT_PAUSE_CLAUSE
+                elif is_affix:
+                    pause = self.DEFAULT_PAUSE_AFFIX
+                else:
+                    pause = self.DEFAULT_PAUSE_WORD
+
+                tokens.append(LanguageChunk(
+                    text=raw_chunk,
+                    language=current_lang,
+                    pause_after=pause,
+                    is_affix=is_affix
+                ))
+            buffer_chars = []
+
+        for ch in text:
+            script = ScriptRegistry.classify_code_point(ord(ch))
+
+            # Resolve effective language for ideographs
+            resolved_lang: Optional[str] = None
+            if script in ("ko", "en", "ja") or script in ScriptRegistry._CUSTOM_MATCHERS:
+                resolved_lang = script
+            elif script == "cjk_ideograph":
+                if has_kana and not has_hangul:
+                    resolved_lang = "ja"  # Japanese Kanji
+                elif has_hangul and not has_kana:
+                    resolved_lang = "ko"  # Korean Hanja context
+                else:
+                    resolved_lang = "zh"  # Chinese Hanzi
+
+            if resolved_lang is not None:
+                # Check sentence boundary even within same language (e.g., '알지? 뛰어난')
+                ends_with_sentence_punct = any("".join(buffer_chars).strip().endswith(p) for p in (".", "?", "!"))
+                
+                if current_lang is None:
+                    current_lang = resolved_lang
+                    buffer_chars.append(ch)
+                    has_trailing_space = False
+                elif current_lang != resolved_lang:
+                    # Language switch boundary!
+                    is_affix = not has_trailing_space
+                    flush_chunk(is_affix=is_affix)
+                    current_lang = resolved_lang
+                    buffer_chars.append(ch)
+                    has_trailing_space = False
+                elif ends_with_sentence_punct and has_trailing_space:
+                    # Sentence boundary split within same language!
+                    flush_chunk(is_affix=False)
+                    current_lang = resolved_lang
+                    buffer_chars.append(ch)
+                    has_trailing_space = False
+                else:
+                    buffer_chars.append(ch)
+                    has_trailing_space = False
+
+            elif script == "space":
+                if buffer_chars:
+                    buffer_chars.append(ch)
+                    has_trailing_space = True
+            else:
+                # Punctuation / digits / symbols belong to the active language chunk
+                if buffer_chars:
+                    buffer_chars.append(ch)
+
+        # Flush final chunk
+        if buffer_chars and current_lang:
+            flush_chunk(is_affix=False)
+
+        return tokens

package/termux_tts/tokenizer.py

@@ -125,9 +125,11 @@ def normalize_numbers_english(text: str) -> str:
 class PhoneticTokenizer:
     def __init__(self, language: str = "ko"):
         self.language = language.lower()
+        if self.language in ("auto", "multilingual"):
+            self.language = "ko"
         self.vocab = VOCAB
         if self.language not in ["ko", "korean", "en", "english"]:
-            raise TTSLanguageNotSupportedError(f"Language '{language}' is not supported. Supported: ['ko', 'en']")
+            raise TTSLanguageNotSupportedError(f"Language '{language}' is not supported. Supported: ['ko', 'en', 'auto', 'multilingual']")
 
     def normalize_text(self, text: str) -> str:
         if not text or not text.strip():