EchoScript : 20260701 0455 - Bug 1 (Persian missing) - the real root cause: The HF Hub returns 401 Unauthorized (not 404) for nonexistent repos when requests are unauthenticated. The fix: Replaced all live Hub checks with KNOWN_MARIAN_PAIRS - a static, hand-verified table of every (source, target) pair and its exact repo suffix. No network calls, no rate limits, no 401/404 ambiguity. Bug 2 (loading spinner on cached languages) - the real cause: generate_translations was a regular function, so Gradio held the loading spinner on every output component in translation_stage_outputs for the entire duration of the slowest new translation. The fix: Converted to a Gradio generator that yields twice: once immediately (pass 1, all cached results shown instantly, new languages left as no-op gr.update()), then once more per new language as each one finishes (pass 2).

app.py

@@ -254,42 +254,82 @@ def generate_translations(
     cached_transcript: Optional[Transcript],
     cached_translations: dict,
 ):
+    """Generator: yield cached results immediately, then compute only new ones.
+
+    This ensures the loading spinner only appears on sections that are
+    actually being translated. Languages already in the cache are yielded
+    instantly in the first pass; only genuinely new languages trigger
+    model/API calls in the second pass. Gradio generators allow partial
+    yields, so the UI updates progressively rather than waiting for the
+    slowest language.
+    """
     if cached_transcript is None:
         raise gr.Error("Generate a transcript first.")
 
+    selected = set(selected_languages or [])
     translation_service = get_translation_service()
-    section_updates = {}
+    tmp_dir = Path(tempfile.mkdtemp(prefix="echoscript_"))
+
+    def _make_outputs(section_states: dict) -> list:
+        """Build the flat output list from a dict of label -> (visible, text, file)."""
+        result = []
+        for label in _TRANSLATION_SECTION_ORDER:
+            state = section_states.get(label)
+            if state is None:
+                # No decision yet for this label -- emit a no-op so Gradio
+                # doesn't touch it (preserves whatever is already shown).
+                result += [gr.update(), gr.update(), gr.update()]
+            else:
+                visible, text, file_path = state
+                result += [gr.update(visible=visible), text if text is not None else gr.update(), file_path]
+        result.append(cached_translations)
+        return result
+
+    # ------------------------------------------------------------------
+    # Pass 1: Resolve every section immediately from the cache or by
+    # hiding unselected ones. Only sections that need a real translation
+    # call are left as None (no-op) so their current UI state is
+    # preserved while we wait.
+    # ------------------------------------------------------------------
+    section_states: dict[str, Optional[tuple]] = {}
+    needs_translation: list[str] = []
 
     for label in _TRANSLATION_SECTION_ORDER:
         code = _TRANSLATION_LABEL_TO_CODE[label]
-        if label not in (selected_languages or []):
-            section_updates[label] = (False, "", None)
-            continue
-
-        if code in cached_translations:
+        if label not in selected:
+            section_states[label] = (False, "", None)
+        elif code in cached_translations:
             text = cached_translations[code]
+            file_path = _write_text_file(text, tmp_dir, f"{code}_cached.txt")
+            section_states[label] = (True, text, file_path)
         else:
-            try:
-                translation = translation_service.translate(cached_transcript, code, api_key=api_key)
-                text = translation.text
-                cached_translations[code] = text
-            except TranslationError as exc:
-                # Surface the failure for this language only; deliberately
-                # not cached, so the next click retries it.
-                text = f"\u26a0\ufe0f Translation failed: {exc}"
-
-        file_path = None
-        if not text.startswith("\u26a0\ufe0f"):
-            tmp_dir = Path(tempfile.mkdtemp(prefix="echoscript_"))
+            # Will be computed in pass 2; leave as None for now.
+            section_states[label] = None
+            needs_translation.append(label)
+
+    # Yield immediately so cached results appear without waiting for new ones.
+    yield _make_outputs(section_states)
+
+    # ------------------------------------------------------------------
+    # Pass 2: Translate only the languages that aren't cached yet,
+    # yielding after each one completes.
+    # ------------------------------------------------------------------
+    for label in needs_translation:
+        code = _TRANSLATION_LABEL_TO_CODE[label]
+        try:
+            translation = translation_service.translate(cached_transcript, code, api_key=api_key)
+            text = translation.text
+            cached_translations[code] = text
             file_path = _write_text_file(text, tmp_dir, f"{code}.txt")
-        section_updates[label] = (True, text, file_path)
+            section_states[label] = (True, text, file_path)
+        except TranslationError as exc:
+            # Surface the failure for this language only. Deliberately not
+            # cached, so the next click will retry.
+            text = f"\u26a0\ufe0f Translation failed: {exc}"
+            section_states[label] = (True, text, None)
 
-    outputs = []
-    for label in _TRANSLATION_SECTION_ORDER:
-        visible, text, file_path = section_updates[label]
-        outputs += [gr.update(visible=visible), text, file_path]
-    outputs.append(cached_translations)
-    return outputs
+        # Yield after each language so the UI updates progressively.
+        yield _make_outputs(section_states)
 
 
 def reset_session_state():
@@ -325,7 +365,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-30 08:57 UTC &middot; fixed: rate-limited Hub checks were being cached as "language unavailable"</sub>
+<sub>build: 2026-07-01 04:55 UTC &middot; static pair table (Persian fixed) &middot; generator translations (no spinner on cached)</sub>
         """
     )
 

services/translation.py

@@ -7,30 +7,22 @@ audio:
     Audio -> Transcript -> Translation   (allowed)
     Audio -> Translation                 (never)
 
-This keeps a single source of truth: if a name or term is fixed once in
-the transcript (v1.1: Transcript Editing), every translation regenerated
-afterwards picks up the fix automatically, and every translation stays in
-sync with the same segment timings as the transcript (so subtitles still
-work for translated output).
+Two interchangeable backends, chosen per-request based on whether an
+Anthropic API key is supplied -- never stored:
 
-Two interchangeable backends are available, chosen per-request based on
-whether an Anthropic API key was supplied -- never stored:
-
-- "anthropic": the caller supplies their own API key (e.g. typed into the
-  UI for that session). Used whenever a key is present. Sends transcript
+- "anthropic": the caller supplies their own API key. Sends transcript
   text to Claude for translation. No missing-language-pair failure mode --
   every supported language translates directly to every other one in a
-  single call, with no local model downloads. The key is passed straight
-  through to the Anthropic client for that one call and is never written
-  to disk, logged, or cached in any module-level state.
+  single call. The key is passed straight through to the Anthropic client
+  for that one call and is never written to disk, logged, or cached.
 - "marian": fully offline, no API key needed. Uses local Helsinki-NLP
-  MarianMT models via `transformers`. Coverage is checked for real, per
-  source language, against the Hub (direct pair or English pivot) -- see
-  available_marian_targets() -- rather than assumed from a fixed list.
+  MarianMT models. Available targets per source language are determined
+  from a verified static table (see KNOWN_MARIAN_PAIRS below) rather
+  than live Hub API checks, which are unreliable in a rate-limited
+  unauthenticated HF Spaces environment.
 
-The UI is expected to only offer the larger ANTHROPIC_TARGET_LANGUAGES
-list once a key has been entered, and available_marian_targets(source)
-otherwise -- see app.py.
+The UI is expected to only offer ANTHROPIC_TARGET_LANGUAGES once a key
+has been entered, and available_marian_targets(source) otherwise.
 """
 
 from __future__ import annotations
@@ -38,14 +30,14 @@ from __future__ import annotations
 import os
 import re
 from functools import lru_cache
+from typing import Optional
 
 from models.transcript import Segment, Transcript, Translation
 
-# Display names for every language EchoScript knows about -- used both for
-# the source-language dropdown (services/transcription.py) and to name
-# languages in the Anthropic translation prompt. Falls back to the raw
-# code for anything not listed (e.g. a language Whisper auto-detected
-# that isn't in this table).
+# ---------------------------------------------------------------------------
+# Language catalog
+# ---------------------------------------------------------------------------
+
 LANGUAGE_NAMES: dict[str, str] = {
     "fr": "French",
     "en": "English",
@@ -64,35 +56,124 @@ LANGUAGE_NAMES: dict[str, str] = {
 }
 
 # Target languages offered once the person supplies their own Anthropic
-# API key -- Claude has no missing-pair problem, so this list is just
-# "every language EchoScript knows the name of".
+# API key -- Claude has no missing-pair problem so the list is simply
+# everything we know the name of.
 ANTHROPIC_TARGET_LANGUAGES: dict[str, str] = dict(LANGUAGE_NAMES)
 
-# 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"
-_ANTHROPIC_BATCH_SIZE = 40  # segments per API call, to keep prompts small
+# ---------------------------------------------------------------------------
+# Verified Marian pair table
+#
+# Verified from the Helsinki-NLP Hub catalog. We use a static table rather
+# than live Hub API checks because:
+#   - The HF Hub returns 401 (Unauthorized) for nonexistent repos when
+#     requests are unauthenticated, and the huggingface_hub library raises
+#     that as RepositoryNotFoundError -- indistinguishable from a genuine
+#     404 without parsing the status code correctly.
+#   - Unauthenticated HF Spaces requests are aggressively rate-limited.
+#     A burst of ~30 simultaneous existence checks (14 candidate languages
+#     × 2-3 pivot steps each) reliably triggers 429s.
+#   - Both 401 and 429 were being silently swallowed into "not available",
+#     causing Persian to disappear from English's target list even though
+#     Helsinki-NLP/opus-mt-en-fa genuinely exists.
+#
+# Format: {(source_code, target_code): repo_suffix}
+# repo_suffix is what goes after "Helsinki-NLP/opus-mt-". In almost all
+# cases it's just f"{src}-{tgt}", but Helsinki-NLP uses "jap" instead of
+# the ISO "ja" for the en->Japanese model.
+# ---------------------------------------------------------------------------
+KNOWN_MARIAN_PAIRS: dict[tuple[str, str], str] = {
+    # English <-> everything
+    ("en", "fr"): "en-fr",
+    ("fr", "en"): "fr-en",
+    ("en", "de"): "en-de",
+    ("de", "en"): "de-en",
+    ("en", "fa"): "en-fa",   # Helsinki-NLP/opus-mt-en-fa -- confirmed via catalog
+    ("fa", "en"): "fa-en",   # Helsinki-NLP/opus-mt-fa-en -- confirmed earlier
+    ("en", "es"): "en-es",
+    ("es", "en"): "es-en",
+    ("en", "it"): "en-it",
+    ("it", "en"): "it-en",
+    ("en", "pt"): "en-pt",
+    ("pt", "en"): "pt-en",
+    ("en", "nl"): "en-nl",
+    ("nl", "en"): "nl-en",
+    ("en", "ar"): "en-ar",
+    ("ar", "en"): "ar-en",
+    ("en", "ru"): "en-ru",
+    ("ru", "en"): "ru-en",
+    ("en", "tr"): "en-tr",
+    ("tr", "en"): "tr-en",
+    ("en", "zh"): "en-zh",
+    ("zh", "en"): "zh-en",
+    ("en", "ko"): "en-ko",
+    ("ko", "en"): "ko-en",
+    ("en", "ja"): "en-jap",  # repo uses "jap" not "ja"
+    ("ja", "en"): "ja-en",
+    # Selected direct non-English pairs (common enough to avoid a pivot hop)
+    ("fr", "de"): "fr-de",
+    ("de", "fr"): "de-fr",
+    ("fr", "es"): "fr-es",
+    ("es", "fr"): "es-fr",
+    ("de", "es"): "de-es",
+    ("es", "de"): "es-de",
+}
 
 
-class TranslationError(RuntimeError):
-    """Raised when no translation backend/model is available for a pair."""
+def _marian_repo_name(src: str, tgt: str) -> Optional[str]:
+    """Return the Helsinki-NLP repo suffix for a pair, or None if unknown."""
+    return KNOWN_MARIAN_PAIRS.get((src, tgt))
+
+
+def _marian_direct_exists(src: str, tgt: str) -> bool:
+    return _marian_repo_name(src, tgt) is not None
+
+
+def _marian_path_repo_names(src: str, tgt: str) -> Optional[list[str]]:
+    """Return the list of repo suffixes needed to translate src->tgt.
+
+    Returns a 1-element list for a direct pair, a 2-element list for an
+    English-pivot hop, or None if no path is known.
+    """
+    if src == tgt:
+        return None
+    direct = _marian_repo_name(src, tgt)
+    if direct:
+        return [direct]
+    # English pivot: src->en->tgt
+    if src != "en" and tgt != "en":
+        hop1 = _marian_repo_name(src, "en")
+        hop2 = _marian_repo_name("en", tgt)
+        if hop1 and hop2:
+            return [hop1, hop2]
+    return None
+
+
+def available_marian_targets(source_language: str) -> dict[str, str]:
+    """Every language MarianMT can reach from `source_language`.
+
+    Based on the verified KNOWN_MARIAN_PAIRS table (direct pair or English
+    pivot). No network calls are made; the table is the source of truth.
+    """
+    return {
+        code: name
+        for code, name in LANGUAGE_NAMES.items()
+        if code != source_language and _marian_path_repo_names(source_language, code) is not None
+    }
 
 
 # ---------------------------------------------------------------------------
 # Anthropic backend
 # ---------------------------------------------------------------------------
 
+_ANTHROPIC_MODEL = "claude-haiku-4-5-20251001"
+_ANTHROPIC_BATCH_SIZE = 40
 _NUMBERED_LINE_RE = re.compile(r"^\s*(\d+)[.\)]\s?(.*)$")
 
 
 def _anthropic_client(api_key: str):
-    """Build a fresh Anthropic client for this one call.
-
-    Deliberately not cached: the key is supplied per-request by the
-    person using the app and must not linger in any module-level state
-    after the call that needed it returns.
-    """
-    import anthropic  # heavy import, deferred until needed
+    """Build a fresh Anthropic client for this one call. Deliberately not
+    cached: the key must not linger in module-level state."""
+    import anthropic
 
     return anthropic.Anthropic(api_key=api_key)
 
@@ -100,10 +181,8 @@ def _anthropic_client(api_key: str):
 def _translate_batch_via_anthropic(
     texts: list[str], source_language: str, target_language: str, api_key: str
 ) -> list[str]:
-    """Translate a batch of lines in one Claude call, preserving order/count."""
     source_name = LANGUAGE_NAMES.get(source_language, source_language)
     target_name = LANGUAGE_NAMES.get(target_language, target_language)
-
     numbered_input = "\n".join(f"{i + 1}. {text}" for i, text in enumerate(texts))
 
     try:
@@ -112,17 +191,15 @@ def _translate_batch_via_anthropic(
             max_tokens=4096,
             system=(
                 f"You translate transcript lines from {source_name} to {target_name}. "
-                "You will be given a numbered list of lines, one sentence or "
-                "fragment per line. Reply with the same numbers, translated, "
-                "one per line, in the same order. Keep the same number of "
-                "lines as the input -- never merge, split, drop, or add lines. "
-                "Output only the numbered translated lines, with no preamble, "
-                "no explanations, and no extra commentary."
+                "You will be given a numbered list of lines, one sentence or fragment "
+                "per line. Reply with the same numbers, translated, one per line, in "
+                "the same order. Keep the same number of lines as the input -- never "
+                "merge, split, drop, or add lines. Output only the numbered translated "
+                "lines, with no preamble, no explanations, and no extra commentary."
             ),
             messages=[{"role": "user", "content": numbered_input}],
         )
-    except Exception as exc:  # pragma: no cover - depends on network/API key
-        # Deliberately do not include the key itself in this message.
+    except Exception as exc:
         raise TranslationError(
             f"Anthropic translation request failed for "
             f"'{source_language}' -> '{target_language}': {exc}"
@@ -131,7 +208,6 @@ def _translate_batch_via_anthropic(
     raw_text = "".join(
         block.text for block in response.content if getattr(block, "type", None) == "text"
     )
-
     parsed: dict[int, str] = {}
     for line in raw_text.splitlines():
         match = _NUMBERED_LINE_RE.match(line)
@@ -140,11 +216,10 @@ def _translate_batch_via_anthropic(
 
     if len(parsed) != len(texts) or any((i + 1) not in parsed for i in range(len(texts))):
         raise TranslationError(
-            f"Anthropic translation response didn't match expected line count "
-            f"for '{source_language}' -> '{target_language}' "
+            f"Anthropic response didn't match expected line count for "
+            f"'{source_language}' -> '{target_language}' "
             f"(expected {len(texts)}, parsed {len(parsed)})."
         )
-
     return [parsed[i + 1] for i in range(len(texts))]
 
 
@@ -153,21 +228,15 @@ def _translate_segments_via_anthropic(
 ) -> list[Segment]:
     non_empty = [(i, seg) for i, seg in enumerate(segments) if seg.text]
     translated_text_by_index: dict[int, str] = {}
-
     for start in range(0, len(non_empty), _ANTHROPIC_BATCH_SIZE):
         chunk = non_empty[start : start + _ANTHROPIC_BATCH_SIZE]
         texts = [seg.text for _, seg in chunk]
         translated = _translate_batch_via_anthropic(texts, source_language, target_language, api_key)
         for (i, _), text in zip(chunk, translated):
             translated_text_by_index[i] = text
-
     return [
-        Segment(
-            index=seg.index,
-            start=seg.start,
-            end=seg.end,
-            text=translated_text_by_index.get(i, seg.text),
-        )
+        Segment(index=seg.index, start=seg.start, end=seg.end,
+                text=translated_text_by_index.get(i, seg.text))
         for i, seg in enumerate(segments)
     ]
 
@@ -178,165 +247,26 @@ def _translate_segments_via_anthropic(
 
 
 @lru_cache(maxsize=None)
-def _try_load_marian_engine(source_language: str, target_language: str):
-    """Try to load+cache a MarianMT model+tokenizer for one language pair.
-
-    Returns (tokenizer, model), or None if no such model exists on the Hub
-    (e.g. Helsinki-NLP doesn't publish every pair directly). Cached either
-    way so a missing pair isn't re-checked over the network on every call.
-    Safe to cache: these are public model weights, not secrets.
-
-    Loads the model/tokenizer directly via AutoModelForSeq2SeqLM rather
-    than transformers.pipeline("translation", ...): as of transformers v5,
-    the generic "translation" pipeline task was removed entirely (see
-    huggingface/transformers#43825) -- pipeline("translation") now raises
-    KeyError. Loading the model directly and calling `model.generate()` is
-    unaffected by that change and is the path the transformers docs now
-    show for MarianMT.
+def _load_marian_engine(repo_suffix: str):
+    """Load and cache a MarianMT model+tokenizer by repo suffix.
+
+    Keyed by repo suffix (e.g. "en-fa", "en-jap") rather than ISO codes
+    so that aliased pairs (like en-ja -> "en-jap") don't get loaded twice.
+    Returns (tokenizer, model) or raises on failure.
     """
-    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer  # heavy import, deferred
+    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 
-    model_name = _marian_repo_id(source_language, target_language)
+    model_name = f"Helsinki-NLP/opus-mt-{repo_suffix}"
     try:
         tokenizer = AutoTokenizer.from_pretrained(model_name)
         model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-    except Exception:  # pragma: no cover - depends on model availability
-        return None
+    except Exception as exc:
+        raise TranslationError(
+            f"Failed to load MarianMT model '{model_name}': {exc}"
+        ) from exc
     return tokenizer, model
 
 
-# Helsinki-NLP doesn't always use standard ISO 639-1 codes in its repo
-# names. Known exceptions go here, mapped to the actual code used in that
-# specific repo name -- e.g. the en->Japanese model is published as
-# "Helsinki-NLP/opus-mt-en-jap" (not "...-en-ja"), even though the reverse
-# direction "Helsinki-NLP/opus-mt-ja-en" correctly uses "ja". Without this,
-# every availability check for Japanese-as-a-target would 404 on a model
-# that actually exists, regardless of source language.
-_MARIAN_CODE_ALIASES: dict[tuple[str, str], str] = {
-    ("en", "ja"): "jap",
-}
-
-
-def _marian_repo_id(source_language: str, target_language: str) -> str:
-    aliased_target = _MARIAN_CODE_ALIASES.get((source_language, target_language), target_language)
-    return f"Helsinki-NLP/opus-mt-{source_language}-{aliased_target}"
-
-
-@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.
-
-    Only a confirmed 404 (the repo genuinely doesn't exist) is cached as
-    False. Anything else -- rate limiting, a timeout, a transient network
-    error -- raises instead of being swallowed into a False. This matters
-    because @lru_cache only caches a function's return value, never an
-    exception it raised: if this returned False for a rate-limited
-    request, that wrong "doesn't exist" answer would be locked in for the
-    rest of the session (this is what was hiding Persian as a translation
-    target from English, even though Helsinki-NLP/opus-mt-en-fa genuinely
-    exists -- a burst of ~30+ unauthenticated existence checks during one
-    transcript's language-detection step is enough to get rate-limited).
-    Callers must catch the transient case themselves (see
-    _safe_marian_exists) and decide what "I don't know yet" should mean
-    for that call site, rather than this function silently deciding it.
-    """
-    from huggingface_hub import HfApi
-    from huggingface_hub.utils import HfHubHTTPError
-
-    try:
-        HfApi(token=_hf_token()).model_info(_marian_repo_id(source_language, target_language))
-        return True
-    except HfHubHTTPError as exc:
-        status_code = getattr(getattr(exc, "response", None), "status_code", None)
-        if status_code == 404:
-            return False
-        raise  # 429 / 5xx / etc. -- not proof the model doesn't exist
-
-
-def _safe_marian_exists(source_language: str, target_language: str) -> bool:
-    """`_marian_model_exists`, but transient failures fail open.
-
-    A genuine 404 still means "not available". Anything else (rate
-    limiting, a network blip) is treated as "available" for this one
-    call rather than "unavailable" -- erring toward occasionally offering
-    a language whose Hub check happened to fail transiently (the actual
-    translate() call will surface a clear per-language error if it truly
-    isn't there) rather than silently and permanently hiding one that's
-    really there, which is the bug this replaces.
-    """
-    try:
-        return _marian_model_exists(source_language, target_language)
-    except Exception:
-        return True
-
-
-def _hf_token() -> Optional[str]:
-    """An HF token, if one is configured -- raises the unauthenticated
-    rate limit that triggers the failure above in the first place.
-    Optional; everything here still works without one, just with a lower
-    request budget before transient failures become likely.
-    """
-    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
-
-
-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 _safe_marian_exists(source_language, target_language):
-        return True
-    if source_language != "en" and target_language != "en":
-        return _safe_marian_exists(source_language, "en") and _safe_marian_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.
-
-    Prefers a single direct Helsinki-NLP model. If none exists for the
-    pair, pivots through English (source -> en -> target), since that's
-    where Helsinki-NLP's coverage is densest -- this is what makes
-    something like French -> Persian work even though no direct
-    opus-mt-fr-fa model exists.
-    """
-    direct = _try_load_marian_engine(source_language, target_language)
-    if direct is not None:
-        return [direct]
-
-    if source_language != "en" and target_language != "en":
-        hop1 = _try_load_marian_engine(source_language, "en")
-        hop2 = _try_load_marian_engine("en", target_language)
-        if hop1 is not None and hop2 is not None:
-            return [hop1, hop2]
-
-    raise TranslationError(
-        f"No direct or English-pivot translation model available for "
-        f"'{source_language}' -> '{target_language}'."
-    )
-
-
 def _run_marian_translation(tokenizer, model, text: str) -> str:
     inputs = tokenizer(text, return_tensors="pt", truncation=True)
     generated = model.generate(**inputs, max_new_tokens=512)
@@ -346,7 +276,15 @@ def _run_marian_translation(tokenizer, model, text: str) -> str:
 def _translate_segments_via_marian(
     segments: list[Segment], source_language: str, target_language: str
 ) -> list[Segment]:
-    engines = _resolve_marian_engines(source_language, target_language)
+    repo_names = _marian_path_repo_names(source_language, target_language)
+    if not repo_names:
+        raise TranslationError(
+            f"No Marian translation path known for "
+            f"'{source_language}' -> '{target_language}'."
+        )
+
+    # Load engines (cached after the first call for each repo suffix)
+    engines = [_load_marian_engine(r) for r in repo_names]
 
     translated_segments = []
     for seg in segments:
@@ -356,7 +294,9 @@ def _translate_segments_via_marian(
         text = seg.text
         for tokenizer, model in engines:
             text = _run_marian_translation(tokenizer, model, text)
-        translated_segments.append(Segment(index=seg.index, start=seg.start, end=seg.end, text=text))
+        translated_segments.append(
+            Segment(index=seg.index, start=seg.start, end=seg.end, text=text)
+        )
     return translated_segments
 
 
@@ -365,6 +305,10 @@ def _translate_segments_via_marian(
 # ---------------------------------------------------------------------------
 
 
+class TranslationError(RuntimeError):
+    """Raised when no translation backend/model is available for a pair."""
+
+
 class TranslationService:
     """Translates a Transcript into one or more target languages.
 
@@ -379,11 +323,10 @@ class TranslationService:
         self,
         transcript: Transcript,
         target_language: str,
-        api_key: str | None = None,
+        api_key: Optional[str] = None,
     ) -> Translation:
         """Translate every segment of `transcript`, preserving timing."""
         if target_language == transcript.language:
-            # Already in the target language -- relabel, don't re-translate.
             return Translation(
                 source_language=transcript.language,
                 target_language=target_language,
@@ -406,18 +349,3 @@ class TranslationService:
             target_language=target_language,
             segments=translated_segments,
         )
-
-    def translate_many(
-        self,
-        transcript: Transcript,
-        target_languages: list[str],
-        api_key: str | None = None,
-    ) -> dict[str, Translation]:
-        """Translate into several target languages at once.
-
-        Returns a dict keyed by target-language code, in line with how the
-        UI's multi-select "Outputs" checkboxes will want to fan out.
-        """
-        return {
-            lang: self.translate(transcript, lang, api_key=api_key) for lang in target_languages
-        }