EchoScript : 1 & 2 - the static 4-language list was the real bug. 3 & 4 - already correct, verified by audit.

app.py

@@ -47,9 +47,9 @@ from services.subtitles import generate_srt, generate_vtt
 from services.transcription import SUPPORTED_LANGUAGES, TranscriptionService
 from services.translation import (
     ANTHROPIC_TARGET_LANGUAGES,
-    MARIAN_TARGET_LANGUAGES,
     TranslationError,
     TranslationService,
+    available_marian_targets,
 )
 
 # ---------------------------------------------------------------------------
@@ -103,11 +103,18 @@ _TRANSLATION_SECTION_ORDER = list(_TRANSLATION_LABEL_TO_CODE.keys())
 def _compute_translation_choices(has_key: bool, exclude_code: Optional[str]) -> list[str]:
     """The translate-to picker, cascaded from key presence + source language.
 
-    `exclude_code` removes "translate into the language it's already in"
-    -- always the actual transcript language at this point (this picker
-    only exists once a Transcript does), never a pre-detection guess.
+    `exclude_code` is the actual transcript language at this point (this
+    picker only exists once a Transcript does), never a pre-detection
+    guess. Without a key, the Marian options are checked for real against
+    the Hub for this specific source language -- not a fixed guess -- so
+    a source with no path to a given language (direct or English-pivot)
+    simply won't offer it, and one with good coverage offers everything
+    that's actually reachable (which can be more than four languages).
     """
-    pool = ANTHROPIC_TARGET_LANGUAGES if has_key else MARIAN_TARGET_LANGUAGES
+    if has_key:
+        pool = ANTHROPIC_TARGET_LANGUAGES
+    else:
+        pool = available_marian_targets(exclude_code) if exclude_code else {}
     return [f"{name} Translation" for code, name in pool.items() if code != exclude_code]
 
 
@@ -318,7 +325,7 @@ with gr.Blocks(title="EchoScript") as demo:
 **Upload Audio → Select Audio Window → Detect Language & Generate Transcript
 → Preview & Choose Languages → Generate Translations → Copy / Download**
 
-<sub>build: 2026-06-27 00:05 UTC &middot; two-stage workflow (transcript, then translations)</sub>
+<sub>build: 2026-06-27 00:24 UTC &middot; real per-source-language Marian availability (no more fixed 4-language guess)</sub>
         """
     )
 

requirements.txt

@@ -5,3 +5,4 @@ sentencepiece>=0.2
 sacremoses>=0.1
 torch>=2.0
 anthropic>=0.40
+huggingface_hub>=0.24

services/__init__.py

@@ -3,9 +3,9 @@ from services.subtitles import generate_srt, generate_vtt
 from services.transcription import SUPPORTED_LANGUAGES, TranscriptionService
 from services.translation import (
     ANTHROPIC_TARGET_LANGUAGES,
-    MARIAN_TARGET_LANGUAGES,
     TranslationError,
     TranslationService,
+    available_marian_targets,
 )
 
 __all__ = [
@@ -18,7 +18,7 @@ __all__ = [
     "SUPPORTED_LANGUAGES",
     "TranscriptionService",
     "ANTHROPIC_TARGET_LANGUAGES",
-    "MARIAN_TARGET_LANGUAGES",
+    "available_marian_targets",
     "TranslationError",
     "TranslationService",
 ]

services/translation.py

@@ -57,16 +57,9 @@ LANGUAGE_NAMES: dict[str, str] = {
     "ar": "Arabic",
     "ru": "Russian",
     "tr": "Turkish",
-}
-
-# Target languages offered in the "Outputs" checkboxes when NO Anthropic
-# API key is supplied -- restricted to the set MarianMT can reliably
-# reach (directly, or via an English pivot; see _resolve_marian_engines).
-MARIAN_TARGET_LANGUAGES: dict[str, str] = {
-    "en": "English",
-    "de": "German",
-    "fa": "Persian",
-    "es": "Spanish",
+    "ja": "Japanese",
+    "zh": "Chinese",
+    "ko": "Korean",
 }
 
 # Target languages offered once the person supplies their own Anthropic
@@ -74,9 +67,6 @@ MARIAN_TARGET_LANGUAGES: dict[str, str] = {
 # "every language EchoScript knows the name of".
 ANTHROPIC_TARGET_LANGUAGES: dict[str, str] = dict(LANGUAGE_NAMES)
 
-# Backwards-compatible alias (kept in case other modules import this name).
-SUPPORTED_TARGET_LANGUAGES = MARIAN_TARGET_LANGUAGES
-
 # Anthropic model used for translation -- Haiku is fast and inexpensive,
 # which fits well for what is otherwise a mechanical translation task.
 _ANTHROPIC_MODEL = "claude-haiku-4-5-20251001"
@@ -214,6 +204,59 @@ def _try_load_marian_engine(source_language: str, target_language: str):
     return tokenizer, model
 
 
+@lru_cache(maxsize=None)
+def _marian_model_exists(source_language: str, target_language: str) -> bool:
+    """Check (and cache) whether Helsinki-NLP publishes this exact pair.
+
+    This is a lightweight existence check (one small metadata request to
+    the Hub's model-info API), not a full model/tokenizer download --
+    deliberately kept separate from _try_load_marian_engine so the UI can
+    cheaply ask "what's actually available for this source language"
+    without paying the cost of downloading every candidate model.
+    Cached forever per pair: this is public catalog data, not something
+    that changes mid-session, and reusing it means the second person (or
+    the second transcript) asking about the same source language is
+    instant.
+    """
+    from huggingface_hub import HfApi
+    from huggingface_hub.utils import HfHubHTTPError
+
+    try:
+        HfApi().model_info(f"Helsinki-NLP/opus-mt-{source_language}-{target_language}")
+        return True
+    except HfHubHTTPError:
+        return False
+    except Exception:  # pragma: no cover - network hiccup, treat as unavailable
+        return False
+
+
+def _marian_path_exists(source_language: str, target_language: str) -> bool:
+    """Direct pair, or a source->en->target pivot, whichever is real."""
+    if source_language == target_language:
+        return False
+    if _marian_model_exists(source_language, target_language):
+        return True
+    if source_language != "en" and target_language != "en":
+        return _marian_model_exists(source_language, "en") and _marian_model_exists("en", target_language)
+    return False
+
+
+def available_marian_targets(source_language: str) -> dict[str, str]:
+    """Every language MarianMT can actually reach from `source_language`.
+
+    Checked for real against the Hub (direct pair or English pivot) for
+    each candidate in LANGUAGE_NAMES, rather than assumed from a fixed
+    list -- this is what makes the offered languages correct per source
+    language instead of a one-size-fits-all guess (e.g. Persian is only
+    offered for a source where a path genuinely exists).
+    """
+    return {
+        code: name
+        for code, name in LANGUAGE_NAMES.items()
+        if code != source_language and _marian_path_exists(source_language, code)
+    }
+
+
 def _resolve_marian_engines(source_language: str, target_language: str) -> list[tuple]:
     """Work out which model(s) to chain to get from source to target.