Upload 10 files

Dockerfile

@@ -1,8 +1,8 @@
-# Dockerfile — SubSync on Hugging Face Docker Space
 FROM python:3.11-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
         build-essential curl \
+        ffmpeg \
     && rm -rf /var/lib/apt/lists/*
 
 RUN useradd -m -u 1000 appuser
@@ -13,11 +13,13 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-# Write Streamlit config inline — no folder needed in project root
+# Create data dir for job storage
+RUN mkdir -p /app/_jobs && chown -R appuser:appuser /app
+
 RUN mkdir -p /home/appuser/.streamlit && \
     printf '[server]\nport = 7860\naddress = "0.0.0.0"\nheadless = true\nenableCORS = false\nenableXsrfProtection = false\nmaxUploadSize = 500\n\n[browser]\ngatherUsageStats = false\n\n[theme]\nbase = "dark"\n' \
     > /home/appuser/.streamlit/config.toml && \
-    chown -R appuser:appuser /home/appuser/.streamlit /app
+    chown -R appuser:appuser /home/appuser/.streamlit
 
 EXPOSE 7860
 USER appuser

app.py

@@ -16,7 +16,19 @@ import traceback
 import pandas as pd
 import streamlit as st
 
+import time
 from auth import is_authenticated, render_login_page, logout
+from job_store import (create_job, update_job, save_result, load_result,
+                       load_job, list_jobs, delete_job, clear_all_jobs,
+                       job_age_str, status_icon, status_color,
+                       save_glossary, load_glossary,
+                       get_latest_translate_job_with_glossary)
+from audio_transcriber import (run_transcription_bg, SUPPORTED_LANGUAGES,
+                               MODEL)
+from translation import (extract_glossary, translate_all,
+                         TranslationPaused, load_checkpoint,
+                         clear_checkpoint, checkpoint_progress,
+                         run_translation_bg)
 from api_handler import fetch_models, validate_api_key, call_ai
 from subtitle_parser import (
     parse_subtitle,
@@ -27,9 +39,6 @@ from subtitle_parser import (
     clean_workspace,
     workspace_size_mb,
 )
-from translation import (extract_glossary, translate_all,
-                         TranslationPaused, load_checkpoint,
-                         clear_checkpoint, checkpoint_progress)
 
 # ── Page config ───────────────────────────────────────────────────────────────
 st.set_page_config(
@@ -222,6 +231,13 @@ def _init_session() -> None:
         "translation_done":    False,
         "wizard_step":         1,
         "active_page":         "translate",
+        "current_job_id":      None,     # active job being processed
+        "audio_job_id":        None,     # current audio transcription job
+        "audio_srt_result":    None,
+        "audio_srt_filename":  None,
+        "audio_srt_to_translate": None,
+        "audio_srt_orig_name": None,
+        "tx_checkpoint":       None,
         "last_error":          None,
     }
     for k, v in defaults.items():
@@ -287,19 +303,27 @@ def _render_header(title: str, sub: str = "") -> None:
         # Push buttons to the right by using nested columns
         # Row 1: main nav buttons
         st.markdown('<div class="hdr-btn">', unsafe_allow_html=True)
-        b1, b2, b3 = st.columns(3)
+        b1, b2, b3, b4, b5 = st.columns(5)
         with b1:
+            if st.button("🎬 Translate", key="hb_home", use_container_width=True):
+                st.session_state["active_page"] = "translate"
+                st.rerun()
+        with b2:
+            if st.button("🎙 Audio→SRT", key="hb_audio", use_container_width=True):
+                st.session_state["active_page"] = "audio_srt"
+                st.rerun()
+        with b3:
+            if st.button("📋 History", key="hb_history", use_container_width=True):
+                st.session_state["active_page"] = "history"
+                st.rerun()
+        with b4:
             if st.button("⚙️ Settings", key="hb_settings", use_container_width=True):
                 st.session_state["active_page"] = "settings"
                 st.rerun()
-        with b2:
+        with b5:
             if st.button("ℹ️ About", key="hb_about", use_container_width=True):
                 st.session_state["active_page"] = "about"
                 st.rerun()
-        with b3:
-            if st.button("🎬 Home", key="hb_home", use_container_width=True):
-                st.session_state["active_page"] = "translate"
-                st.rerun()
         st.markdown('</div>', unsafe_allow_html=True)
 
         # Row 2: clean + sign out
@@ -308,13 +332,32 @@ def _render_header(title: str, sub: str = "") -> None:
         with d1:
             if st.button("🗑 Clean", key="hb_clean", use_container_width=True):
                 try:
+                    # 1. Delete subtitle temp files
                     clean_workspace()
-                    for k in ["uploaded_file_name","subtitle_raw","subtitle_parsed",
-                               "subtitle_format","plain_lines","glossary_raw",
-                               "glossary_edited","translation_result","last_error"]:
+                    # 2. Delete ALL job history + result files (_jobs/ dir)
+                    clear_all_jobs()
+                    # 3. Wipe every workflow-related session key
+                    _clean_keys = [
+                        # Subtitle workflow
+                        "uploaded_file_name", "subtitle_raw", "subtitle_parsed",
+                        "subtitle_format", "plain_lines",
+                        # Glossary — clear completely so no cross-job bleed
+                        "glossary_raw", "glossary_edited", "last_error",
+                        # Translation
+                        "translation_result", "tx_checkpoint",
+                        # Job tracking
+                        "current_job_id",
+                        # Audio SRT
+                        "audio_job_id", "audio_srt_result", "audio_srt_filename",
+                        "audio_srt_to_translate", "audio_srt_orig_name",
+                        # Limit dialog
+                        "limit_hit_info",
+                    ]
+                    for k in _clean_keys:
                         st.session_state[k] = None
                     st.session_state["glossary_approved"] = False
                     st.session_state["translation_done"]  = False
+                    st.session_state["show_limit_dialog"] = False
                     st.session_state["wizard_step"]       = 1
                     st.rerun()
                 except Exception as e:
@@ -384,6 +427,27 @@ def _step1_upload() -> None:
     st.markdown('<div class="card-title">📁 Step 1 — Subtitle ဖိုင် တင်ရန်</div>',
                 unsafe_allow_html=True)
 
+    # ── Auto-populate from Audio→SRT page "Translate this SRT" button ────
+    auto_srt = st.session_state.get("audio_srt_to_translate")
+    auto_name = st.session_state.get("audio_srt_orig_name", "audio.srt")
+    if auto_srt and st.session_state.get("uploaded_file_name") != auto_name:
+        try:
+            from subtitle_parser import parse_subtitle, get_plain_lines
+            subs, fmt = parse_subtitle(auto_srt, auto_name)
+            plain     = get_plain_lines(subs)
+            st.session_state["uploaded_file_name"] = auto_name
+            st.session_state["subtitle_raw"]       = auto_srt
+            st.session_state["subtitle_parsed"]    = subs
+            st.session_state["subtitle_format"]    = fmt
+            st.session_state["plain_lines"]        = plain
+            # Clear audio_srt_to_translate so it doesn't re-trigger
+            st.session_state["audio_srt_to_translate"] = None
+            st.session_state["audio_srt_orig_name"]    = None
+            st.info(f"Audio→SRT ဖိုင် '{auto_name}' ကို auto-load ပြီး", icon="🎙")
+        except Exception as e:
+            st.error(f"Auto-load မအောင်မြင်: {e}", icon="❌")
+            st.session_state["audio_srt_to_translate"] = None
+
     uploaded = st.file_uploader(
         "Subtitle ဖိုင် ရွေးပါ",
         type=["srt", "vtt", "ass", "ssa"],
@@ -401,8 +465,20 @@ def _step1_upload() -> None:
             st.session_state["uploaded_file_name"] = None  # clear while parsing
 
         parse_error = None
-        if st.session_state.get("subtitle_parsed") is None or \
-           st.session_state.get("uploaded_file_name") != uploaded.name:
+        is_new_file = (st.session_state.get("uploaded_file_name") != uploaded.name)
+
+        if st.session_state.get("subtitle_parsed") is None or is_new_file:
+
+            if is_new_file:
+                # New file uploaded — reset ALL glossary & job state
+                # Prevents old glossary bleeding into new translation
+                for _k in ["glossary_raw", "glossary_edited", "translation_result",
+                            "tx_checkpoint", "current_job_id", "limit_hit_info"]:
+                    st.session_state[_k] = None
+                st.session_state["glossary_approved"] = False
+                st.session_state["translation_done"]  = False
+                st.session_state["wizard_step"]       = 1
+
             try:
                 with st.spinner("ဖိုင် ဖတ်နေသည်…"):
                     subs, fmt = parse_subtitle(file_bytes, uploaded.name)
@@ -661,6 +737,21 @@ def _step4_review() -> None:
             st.session_state["glossary_edited"]   = approved
             st.session_state["glossary_approved"] = True
             st.session_state["wizard_step"]       = 5
+
+            # ── Persist glossary to job_store ──────────────────────────
+            # Saved separately from checkpoint so it survives model/provider
+            # changes. Resume always reuses this approved glossary.
+            _jid = st.session_state.get("current_job_id")
+            if not _jid or not load_job(_jid):
+                fname_tmp = st.session_state.get("uploaded_file_name", "file")
+                _jid = create_job(
+                    "translate", fname_tmp,
+                    model=st.session_state.get("selected_model",""),
+                    provider=st.session_state.get("selected_provider",""),
+                )
+                st.session_state["current_job_id"] = _jid
+            save_glossary(_jid, approved)
+
             st.rerun()
 
     with c2:
@@ -943,8 +1034,8 @@ def _step5_translate() -> None:
         return
 
     # ── Translation UI ────────────────────────────────────────────────────
-    from translation import BASE_CHUNK_SIZE as CHUNK_SIZE
     import math
+    CHUNK_SIZE = 150   # must match BASE_CHUNK_SIZE in translation.py
     total_chunks = math.ceil(len(lines) / CHUNK_SIZE)
 
     st.markdown(f"""
@@ -974,119 +1065,81 @@ def _step5_translate() -> None:
         </table>
     </div>
     """, unsafe_allow_html=True)
+    # ── Poll background job if already running ───────────────────────────
+    _jid = st.session_state.get("current_job_id")
+    if _jid:
+        _bgjob = load_job(_jid)
+        if _bgjob and _bgjob["status"] in ("running", "queued"):
+            st.markdown('<div class="card">', unsafe_allow_html=True)
+            st.markdown('<div class="card-title">🔄 Background တွင် ဘာသာပြန်နေသည်</div>', unsafe_allow_html=True)
+            st.progress(_bgjob.get("progress",0.0), text=_bgjob.get("status_msg",""))
+            st.markdown(
+                f'<div class="mono" style="color:#4b5563;margin-top:0.4rem;">' +
+                f'Browser ပိတ်/refresh — ဆက်လုပ်မည် · Job: {_jid}</div>',
+                unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+            time.sleep(3)
+            st.rerun()
+            return
 
-    if st.button("▶ ဘာသာပြန်ခြင်း စတင်မည်", key="s5_start", use_container_width=True):
-        if not key.strip() or not model:
-            st.error("API key / model မရှိပါ — Settings စစ်ဆေးပါ", icon="❌")
-        else:
-            progress_bar = st.progress(0.0, text="ပြင်ဆင်နေသည်…")
-            status_slot  = st.empty()
-            error_slot   = st.empty()
-
-            def progress_cb(fraction: float, msg: str) -> None:
-                try:
-                    progress_bar.progress(min(float(fraction), 1.0), text=msg)
-                    status_slot.markdown(
-                        f'<div class="mono" style="color:#9ca3af;">{msg}</div>',
-                        unsafe_allow_html=True)
-                except Exception:
-                    pass  # never let progress_cb itself crash the run
-
-            debug_log    = []
-            out_bytes    = None
-            paused_error = None
-
-            # ── Check if resuming from checkpoint ──────────────────────
-            cp          = load_checkpoint(st.session_state)
-            is_resume   = bool(cp.get("chunks_done"))
-            done_n, total_n = checkpoint_progress(st.session_state, len(lines))
-            if is_resume and done_n > 0:
-                status_slot.markdown(
-                    f'<div class="mono" style="color:#e8c97e;">' +
-                    f'Checkpoint မှ ဆက်ပြန်နေသည် ({done_n}/{total_n} lines done)…' +
-                    '</div>', unsafe_allow_html=True)
+        if _bgjob and _bgjob["status"] == "completed":
+            result_bytes = load_result(_jid)
+            if result_bytes and not st.session_state.get("translation_done"):
+                st.session_state["translation_result"] = result_bytes
+                st.session_state["translation_done"]   = True
+                st.rerun()
 
-            try:
-                translated_lines = translate_all(
-                    lines, glossary,
-                    provider=prov, model=model, api_key=key,
-                    progress_cb=progress_cb,
-                    debug_log=debug_log,
-                    session_state=st.session_state,
-                    resume=is_resume,
-                )
-            except TranslationPaused as e:
-                paused_error = e
-                translated_lines = None
-                progress_cb(1.0, f"⏸ ရပ်နေသည်: {e}")
-                # Store context for dialog
+        if _bgjob and _bgjob["status"] == "paused":
+            cp = _bgjob.get("checkpoint", {})
+            done_n2 = len(cp.get("lines", {}))
+            st.warning(
+                f"⏸ Limit hit · {done_n2}/{len(lines)} lines saved\n"
+                f"{_bgjob.get('status_msg','')[:200]}",
+                icon="⏸")
+            if st.button("🔔 Key/Provider ပြောင်းမည် (Dialog)", key="s5_open_dialog"):
                 st.session_state["limit_hit_info"] = {
-                    "reason":     str(e),
-                    "key_label":  _active_key_label(),
+                    "reason": _bgjob.get("status_msg",""),
+                    "key_label": _active_key_label(),
                     "key_masked": _mask_key(_active_key()),
-                    "provider":   prov,
-                    "model":      model,
+                    "provider": prov, "model": model,
                 }
                 st.session_state["show_limit_dialog"] = True
-            except Exception as e:
-                st.session_state["last_error"] = traceback.format_exc()
-                progress_cb(1.0, f"⚠ Error: {e}")
-                translated_lines = None
-
-            # ── Verify & build output ─────────────────────────────────
-            if translated_lines:
-                changed = sum(1 for o, t in zip(lines, translated_lines) if o != t)
-                if changed == 0:
-                    # Show debug info
-                    error_slot.warning(
-                        "⚠️ ဘာသာပြန်မထားပါ — AI response parse မရပါ\n"
-                        "gemini-1.5-pro / gemini-2.0-flash ကို ပြောင်းစမ်းပါ",
-                        icon="⚠️")
-                    with st.expander("🐛 AI Raw Response", expanded=True):
-                        for d in debug_log[:3]:
-                            st.markdown(f"**Chunk {d.get('chunk')}** — {d.get('status','')} ")
-                            st.code(d.get('raw_preview', d.get('error','(empty)')), language=None)
-                else:
-                    try:
-                        out_subs  = replace_lines(subs, translated_lines)
-                        out_bytes = write_subtitle(out_subs, fmt)
-                        clear_checkpoint(st.session_state)   # clean up on success
-                    except Exception as e:
-                        st.session_state["last_error"] = traceback.format_exc()
-                        error_slot.error(f"❌ File build error: {e}", icon="❌")
-
-            # ── Paused — dialog triggered on next rerun ───────────────
-            if paused_error:
-                is_res = getattr(paused_error, 'is_resumable', False)
-                if is_res:
-                    done_n2, _ = checkpoint_progress(st.session_state, len(lines))
-                    st.info(
-                        f"⏸ Limit hit — {done_n2}/{len(lines)} lines checkpoint သိမ်းပြီ\n"
-                        "Key/Provider/Model ပြောင်းမည်ဆိုလျှင် dialog ဖွင့်ပါ",
-                        icon="⏸")
-                else:
-                    st.error(f"❌ {paused_error}", icon="❌")
-
-            # ── Parse fail debug ──────────────────────────────────────
-            fails = [d for d in debug_log if d.get("status") in
-                     ("PARSE_FAIL","FALLBACK_ORIGINAL","API_ERROR")]
-            if fails:
-                with st.expander(f"⚠ {len(fails)} chunks မအောင်မြင်ပါ (debug)", expanded=False):
-                    for d in fails:
-                        st.markdown(f"**Chunk {d.get('chunk')}** — `{d.get('status','')}`")
-                        if d.get('raw_preview'):
-                            st.code(d['raw_preview'], language=None)
-                        if d.get('error'):
-                            st.code(d['error'], language=None)
-
-            if out_bytes:
-                st.session_state["translation_result"] = out_bytes
-                st.session_state["translation_done"]   = True
-                status_slot.empty()
+                st.session_state["tx_checkpoint"] = cp
                 st.rerun()
 
-    st.markdown("<br>", unsafe_allow_html=True)
-    st.markdown('<div class="secondary">', unsafe_allow_html=True)
+    if st.button("▶ ဘာသာပြန်ခြင်း စတင်မည် (Background)", key="s5_start",
+                 use_container_width=True):
+        if not key.strip() or not model:
+            st.error("API key / model မရှိပါ — Settings စစ်ဆေးပါ", icon="❌")
+        else:
+            # Create job
+            _jid = st.session_state.get("current_job_id")
+            if not _jid or not load_job(_jid):
+                _jid = create_job("translate", fname, language="my",
+                                  model=model, provider=prov)
+                st.session_state["current_job_id"] = _jid
+
+            # Check for existing checkpoint (resume)
+            cp_data = st.session_state.get("tx_checkpoint", {})
+
+            # Launch background thread
+            run_translation_bg(
+                _jid, lines, glossary,
+                provider=prov, model=model, api_key=key,
+                fmt=fmt, ssafile=subs, filename=fname,
+            )
+            # Stash checkpoint into job so thread can resume
+            if cp_data:
+                update_job(_jid, checkpoint=cp_data)
+
+            st.info(
+                "🔄 Background တွင် စတင်ပြီ\n"
+                "Browser ပိတ်/refresh ဖြစ်ပေမဲ့ ဆက်လုပ်မည်\n"
+                "Progress ကို History page တွင် ကြည့်ရှုနိုင်သည်",
+                icon="🔄")
+            time.sleep(1)
+            st.rerun()
+
     if st.button("← Glossary Review ပြန်သွားမည်", key="s5_back"):
         st.session_state["wizard_step"] = 4
         st.rerun()
@@ -1323,6 +1376,307 @@ def _page_settings() -> None:
 
 
 
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Audio → SRT page
+# ────────────────────��────────────────────────────────────────────────────────
+
+def _page_audio_srt() -> None:
+    _render_header("Audio → SRT", "Audio / Video ဖိုင်မှ Subtitle ထုတ်ရန်")
+
+    st.markdown("""
+    <style>
+    .info-chip {
+        display:inline-block; font-family:'DM Mono',monospace;
+        font-size:0.68rem; padding:0.12rem 0.5rem; border-radius:6px;
+        background:rgba(232,201,126,0.1); color:#e8c97e;
+        margin-right:0.3rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    st.markdown(
+        '<div class="mono" style="color:#374151;margin-bottom:1rem;">'
+        '🧠 Model: <span style="color:#e8c97e;">Whisper large-v3</span>'
+        ' &nbsp;·&nbsp; Browser ပိတ်/refresh ဖြစ်ပေမဲ့ background တွင် ဆက်လုပ်သည်'
+        '</div>',
+        unsafe_allow_html=True)
+
+    # ── Active job polling (running in background) ─────────────────────
+    active_jid = st.session_state.get("audio_job_id")
+    if active_jid:
+        job = load_job(active_jid)
+        if job and job["status"] in ("running", "queued"):
+            st.markdown(f'<div class="card">', unsafe_allow_html=True)
+            st.markdown(
+                f'<div class="card-title">🔄 Transcribing: {job["filename"]}</div>',
+                unsafe_allow_html=True)
+            pct = job.get("progress", 0.0)
+            msg = job.get("status_msg", "")
+            st.progress(pct, text=msg)
+            st.markdown(
+                f'<div class="mono" style="color:#4b5563;margin-top:0.5rem;">'
+                f'Job ID: {active_jid} · Browser ပိတ်ထားနိုင်သည် — background တွင် ဆက်လုပ်မည်</div>',
+                unsafe_allow_html=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+            # Auto-refresh every 3 seconds
+            time.sleep(3)
+            st.rerun()
+            return
+
+        if job and job["status"] == "completed":
+            srt_bytes = load_result(active_jid)
+            if srt_bytes:
+                st.session_state["audio_srt_result"]   = srt_bytes
+                st.session_state["audio_srt_filename"] = job["filename"]
+
+    # ── Show result if available ───────────────────────────────────────
+    srt_result = st.session_state.get("audio_srt_result")
+    srt_fname  = st.session_state.get("audio_srt_filename", "audio")
+
+    if srt_result:
+        out_name = os.path.splitext(srt_fname)[0] + ".srt"
+        st.success(f"✅ Transcription ပြီးသည် — {out_name}", icon="🎉")
+
+        st.download_button(
+            label=f"⬇️ {out_name} Download",
+            data=srt_result,
+            file_name=out_name,
+            mime="text/plain",
+            use_container_width=True,
+            key="audio_dl",
+        )
+
+        with st.expander("📋 SRT Preview (ပထမ 30 ကြောင်း)", expanded=False):
+            preview      = srt_result.decode("utf-8", errors="replace")
+            preview_text = "\n".join(preview.splitlines()[:60])
+            st.code(preview_text, language=None)
+
+        st.markdown("<br>", unsafe_allow_html=True)
+        if st.button("🌐 ဒီ SRT ကို မြန်မာဘာသာပြန်မည်", key="audio_to_translate"):
+            st.session_state["audio_srt_to_translate"] = srt_result
+            st.session_state["audio_srt_orig_name"]    = out_name
+            st.session_state["active_page"]            = "translate"
+            st.session_state["wizard_step"]            = 1
+            st.rerun()
+
+        col_x, _ = st.columns([1, 3])
+        with col_x:
+            st.markdown('<div class="danger">', unsafe_allow_html=True)
+            if st.button("🗑 Clear Result", key="audio_clear"):
+                st.session_state["audio_srt_result"]   = None
+                st.session_state["audio_srt_filename"] = None
+                st.session_state["audio_job_id"]       = None
+                st.rerun()
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        st.markdown('<hr style="border-color:#1e2330;margin:1.5rem 0 1rem;">', unsafe_allow_html=True)
+
+    # ── File upload + start ────────────────────────────────────────────
+    st.markdown("#### 📂 Audio / Video ဖိုင် တင်ရန်")
+    uploaded = st.file_uploader(
+        "audio",
+        type=["mp3","mp4","wav","m4a","flac","ogg","webm","mkv","aac"],
+        label_visibility="collapsed",
+        key="audio_uploader",
+    )
+
+    lang_options = list(SUPPORTED_LANGUAGES.keys())
+    lang_labels  = list(SUPPORTED_LANGUAGES.values())
+    lang_idx = st.selectbox(
+        "ဘာသာစကား",
+        options=range(len(lang_options)),
+        format_func=lambda i: lang_labels[i],
+        key="audio_lang_sel",
+    )
+    selected_lang = lang_options[lang_idx]
+
+    if uploaded is not None:
+        file_bytes = uploaded.read()
+        st.markdown(
+            f'<div class="mono" style="color:#6b7280;margin:0.5rem 0 1rem;">'
+            f'{uploaded.name} · {len(file_bytes)/1024/1024:.1f} MB</div>',
+            unsafe_allow_html=True)
+
+        if st.button("▶ Transcribe မည် (Background)", key="audio_start",
+                     use_container_width=True):
+            job_id = create_job(
+                job_type="audio_srt",
+                filename=uploaded.name,
+                language=selected_lang,
+                model=MODEL,
+            )
+            st.session_state["audio_job_id"]       = job_id
+            st.session_state["audio_srt_result"]   = None
+            st.session_state["audio_srt_filename"] = None
+
+            # Launch background thread — survives browser disconnect
+            run_transcription_bg(job_id, file_bytes, uploaded.name, selected_lang)
+
+            st.info(
+                "🔄 Background တွင် စတင်ပြီ — Browser ပိတ်ထားနိုင်သည်\\n"
+                "Progress ကို History page တွင် ကြည့်ရှုနိုင်သည်",
+                icon="🔄")
+            time.sleep(1)
+            st.rerun()
+
+    st.markdown(
+        '<div class="mono" style="color:#374151;font-size:0.68rem;margin-top:1.5rem;">'
+        '💡 large-v3 model ပထမဆုံးအကြိမ် download ~1.5GB ကြာနိုင်သည်</div>',
+        unsafe_allow_html=True)
+
+
+
+def _page_history() -> None:
+    _render_header("History", "Translation & Transcription Jobs")
+
+    st.markdown("""
+    <style>
+    .job-card {
+        background: var(--card); border: 1px solid var(--border);
+        border-radius: 12px; padding: 1rem 1.2rem; margin-bottom: 0.8rem;
+    }
+    .job-card:hover { border-color: var(--blit); }
+    .job-title { font-weight:600; font-size:0.9rem; color:var(--hi); }
+    .job-meta { font-family:'DM Mono',monospace; font-size:0.68rem;
+                color:var(--lo); margin-top:0.2rem; }
+    .job-status { font-family:'DM Mono',monospace; font-size:0.72rem;
+                  font-weight:600; }
+    </style>
+    """, unsafe_allow_html=True)
+
+    # ── Controls row ───────────────────────────────────────────────────
+    col_filter, col_clear, _ = st.columns([1.5, 1.2, 3])
+    with col_filter:
+        filter_type = st.selectbox(
+            "Filter",
+            ["all", "audio_srt", "translate"],
+            format_func=lambda x: {
+                "all": "All Jobs",
+                "audio_srt": "🎙 Audio→SRT",
+                "translate": "🌐 Translate",
+            }[x],
+            key="hist_filter",
+            label_visibility="collapsed",
+        )
+    with col_clear:
+        st.markdown('<div class="danger">', unsafe_allow_html=True)
+        if st.button("🗑 Clear All", key="hist_clear_all", use_container_width=True):
+            n = clear_all_jobs()
+            st.success(f"{n} jobs deleted")
+            st.rerun()
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # ── Job list ───────────────────────────────────────────────────────
+    jobs = list_jobs(job_type=None if filter_type == "all" else filter_type)
+
+    if not jobs:
+        st.markdown(
+            '<div class="mono" style="color:#374151;padding:2rem 0;text-align:center;">' +
+            'Jobs မရှိသေးပါ</div>',
+            unsafe_allow_html=True)
+        return
+
+    st.markdown(
+        f'<div class="mono" style="color:#4b5563;margin-bottom:1rem;">' +
+        f'{len(jobs)} jobs</div>',
+        unsafe_allow_html=True)
+
+    for job in jobs:
+        job_id  = job["id"]
+        status  = job.get("status","?")
+        jtype   = job.get("type","?")
+        fname   = job.get("filename","?")
+        model   = job.get("model","")
+        lang    = job.get("language","")
+        age     = job_age_str(job)
+        sicon   = status_icon(status)
+        scolor  = status_color(status)
+        pct     = int(job.get("progress",0)*100)
+        msg     = job.get("status_msg","")
+        err     = job.get("error","")
+
+        type_label = "🎙 Audio→SRT" if jtype == "audio_srt" else "🌐 Translate"
+
+        with st.container():
+            st.markdown(f'<div class="job-card">', unsafe_allow_html=True)
+
+            # Title row
+            col_info, col_actions = st.columns([4, 2])
+            with col_info:
+                _gloss_count = len(job.get("extra",{}).get("approved_glossary",{}))
+                _gloss_badge = (
+                    f' · 📖 {_gloss_count} glossary terms'
+                    if _gloss_count > 0 else ""
+                )
+                st.markdown(
+                    f'<div class="job-title">{fname}</div>' +
+                    f'<div class="job-meta">{type_label} · {model} · {lang} · {age}{_gloss_badge}</div>' +
+                    f'<div class="job-status" style="color:{scolor};margin-top:0.3rem;">' +
+                    f'{sicon} {status.upper()}  {pct}%</div>',
+                    unsafe_allow_html=True)
+                if msg:
+                    st.markdown(
+                        f'<div class="mono" style="color:#4b5563;font-size:0.68rem;">{msg}</div>',
+                        unsafe_allow_html=True)
+                if err and status == "failed":
+                    st.markdown(
+                        f'<div class="mono" style="color:#ef4444;font-size:0.68rem;">{err[:120]}</div>',
+                        unsafe_allow_html=True)
+
+            with col_actions:
+                # Download if complete
+                if status == "completed" and job.get("has_result"):
+                    result_bytes = load_result(job_id)
+                    if result_bytes:
+                        out_ext  = ".srt"
+                        out_name = os.path.splitext(fname)[0] + out_ext
+                        st.download_button(
+                            label="⬇️ Download",
+                            data=result_bytes,
+                            file_name=out_name,
+                            mime="text/plain",
+                            key=f"dl_{job_id}",
+                            use_container_width=True,
+                        )
+
+                # Resume if paused (translate jobs)
+                if status == "paused" and jtype == "translate":
+                    if st.button("▶ Resume", key=f"res_{job_id}",
+                                 use_container_width=True):
+                        cp = job.get("checkpoint", {})
+
+                        # ── Restore approved glossary (survives model/provider change)
+                        saved_glossary = load_glossary(job_id)
+                        if saved_glossary:
+                            st.session_state["glossary_edited"]   = saved_glossary
+                            st.session_state["glossary_approved"] = True
+                        else:
+                            # Fallback: try to read from checkpoint
+                            cp_gloss = cp.get("glossary", {})
+                            if cp_gloss:
+                                st.session_state["glossary_edited"]   = cp_gloss
+                                st.session_state["glossary_approved"] = True
+
+                        # ── Restore checkpoint for translate_all resume
+                        st.session_state["tx_checkpoint"]  = cp
+
+                        # ── Set current job and navigate to step 5
+                        st.session_state["current_job_id"] = job_id
+                        st.session_state["active_page"]    = "translate"
+                        st.session_state["wizard_step"]    = 5
+                        st.rerun()
+
+                # Delete button
+                st.markdown('<div class="danger">', unsafe_allow_html=True)
+                if st.button("✕", key=f"del_{job_id}", use_container_width=True):
+                    delete_job(job_id)
+                    st.rerun()
+                st.markdown('</div>', unsafe_allow_html=True)
+
+            st.markdown('</div>', unsafe_allow_html=True)
+
+
 def _page_about() -> None:
     _render_header("About SubSync", "Myanmar Subtitle Translator · v1.0.0")
     st.markdown("""
@@ -1396,6 +1750,10 @@ def main() -> None:
 
     if page == "translate":
         _page_translate()
+    elif page == "audio_srt":
+        _page_audio_srt()
+    elif page == "history":
+        _page_history()
     elif page == "settings":
         _page_settings()
     elif page == "about":

audio_transcriber.py

@@ -0,0 +1,196 @@
+"""
+audio_transcriber.py — Background Audio → SRT Transcription
+
+run_transcription_bg(job_id, audio_bytes, filename, language)
+  → Spawns a daemon thread that runs independently of the browser session.
+  → Progress saved to job_store → UI polls job_store to show status.
+  → Browser close / refresh does NOT stop transcription.
+
+Model: large-v3 only (best accuracy for JA/KO/ZH/TH/HI/EN).
+"""
+
+import os
+import logging
+import tempfile
+import threading
+from typing import Callable
+
+from job_store import update_job, save_result
+
+logger = logging.getLogger(__name__)
+
+# ── Fixed model: large-v3 ─────────────────────────────────────────────────
+MODEL      = "large-v3"
+MODEL_DIR  = os.path.join(tempfile.gettempdir(), "whisper_models")
+
+SUPPORTED_LANGUAGES = {
+    "auto": "Auto-detect",
+    "en":   "English",
+    "ja":   "Japanese (日本語)",
+    "ko":   "Korean (한국어)",
+    "zh":   "Chinese (中文)",
+    "th":   "Thai (ภาษาไทย)",
+    "hi":   "Hindi (हिन्दी)",
+    "fr":   "French",
+    "de":   "German",
+    "es":   "Spanish",
+    "it":   "Italian",
+    "pt":   "Portuguese",
+    "ru":   "Russian",
+    "ar":   "Arabic",
+    "vi":   "Vietnamese",
+    "id":   "Indonesian",
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Time formatting
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _fmt(seconds: float) -> str:
+    ms = int(round((seconds % 1) * 1000))
+    s  = int(seconds)
+    h, m, s = s // 3600, (s % 3600) // 60, s % 60
+    return f"{h:02}:{m:02}:{s:02},{ms:03}"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Segments → SRT string
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _segments_to_srt(segments: list) -> str:
+    lines = []
+    idx   = 1
+    for seg in segments:
+        text = seg.text.strip()
+        if not text:
+            continue
+        lines += [str(idx), f"{_fmt(seg.start)} --> {_fmt(seg.end)}", text, ""]
+        idx += 1
+    return "\n".join(lines)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Core transcription (runs in background thread)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _transcribe_worker(
+    job_id: str,
+    audio_bytes: bytes,
+    filename: str,
+    language: str,
+) -> None:
+    """
+    Background worker — runs in its own thread, independent of browser session.
+    Updates job_store so UI can poll progress even after refresh.
+    Thread is daemon=False so it finishes even if main thread exits
+    (as long as Docker container is alive).
+    """
+    tmp_path = None
+    try:
+        from faster_whisper import WhisperModel
+
+        def cb(frac: float, msg: str) -> None:
+            update_job(job_id, progress=frac, status_msg=msg)
+
+        cb(0.0, "Model load လုပ်နေသည် (large-v3, ပထမဆုံးအကြိမ် ကြာနိုင်သည်)…")
+
+        # Write audio to temp file
+        suffix   = os.path.splitext(filename)[1] or ".mp3"
+        fd, tmp_path = tempfile.mkstemp(suffix=suffix)
+        os.write(fd, audio_bytes)
+        os.close(fd)
+
+        # Load Whisper large-v3
+        model = WhisperModel(
+            MODEL,
+            device="cpu",
+            compute_type="int8",      # fastest CPU quantization
+            download_root=MODEL_DIR,
+        )
+        cb(0.05, f"large-v3 load ပြီး — Transcribing…")
+
+        lang_code = None if language == "auto" else language
+
+        segments_gen, info = model.transcribe(
+            tmp_path,
+            language=lang_code,
+            beam_size=5,
+            temperature=0.0,
+            condition_on_previous_text=False,  # reduce hallucination
+            vad_filter=True,
+            vad_parameters={
+                "min_silence_duration_ms": 500,
+                "threshold": 0.35,
+            },
+        )
+
+        detected  = info.language
+        duration  = max(info.duration or 1.0, 1.0)
+        cb(0.08, f"ဘာသာစကား: {detected} · {duration:.0f}s — Segments ထုတ်နေသည်…")
+
+        segments = []
+        for seg in segments_gen:
+            segments.append(seg)
+            pct  = min(0.08 + (seg.end / duration) * 0.90, 0.98)
+            elapsed = f"{seg.end:.0f}s/{duration:.0f}s"
+            cb(pct, f"Transcribing… {elapsed}  [{len(segments)} segments]")
+
+        if not segments:
+            update_job(job_id, status="failed",
+                       error="Audio မှ speech မတွေ့ပါ",
+                       status_msg="⚠ Speech မတွေ့ပါ")
+            return
+
+        cb(0.99, f"SRT ဖန်တီးနေသည်… ({len(segments)} segments)")
+        srt_text = _segments_to_srt(segments)
+        srt_bytes = srt_text.encode("utf-8")
+
+        save_result(job_id, srt_bytes)
+        # save_result already sets status=completed
+
+    except ImportError:
+        err = ("faster-whisper မထည့်ရသေးပါ — "
+               "requirements.txt မှာ faster-whisper>=1.0.0 ပါပြီး redeploy လုပ်ပါ")
+        update_job(job_id, status="failed", error=err, status_msg="❌ Import Error")
+
+    except Exception as exc:
+        logger.exception("Transcription worker error")
+        update_job(job_id, status="failed",
+                   error=str(exc)[:400],
+                   status_msg=f"❌ Error: {exc}")
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            try: os.unlink(tmp_path)
+            except Exception: pass
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Public API — launch background thread
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run_transcription_bg(
+    job_id: str,
+    audio_bytes: bytes,
+    filename: str,
+    language: str = "auto",
+) -> threading.Thread:
+    """
+    Spawn a background thread to transcribe audio.
+    The thread runs independently of the Streamlit browser session.
+    Browser close / page refresh does NOT stop the transcription.
+
+    Returns the Thread object (caller can ignore it).
+    """
+    update_job(job_id, status="running", progress=0.0,
+               status_msg="Background thread started…")
+
+    t = threading.Thread(
+        target=_transcribe_worker,
+        args=(job_id, audio_bytes, filename, language),
+        daemon=True,   # daemon=True: thread exits with container (correct behavior)
+        name=f"whisper-{job_id}",
+    )
+    t.start()
+    logger.info("Transcription thread started: job=%s file=%s", job_id, filename)
+    return t

job_store.py

@@ -0,0 +1,258 @@
+"""
+job_store.py — Thread-Safe Persistent Job Storage
+
+Files stored in _jobs/ dir → survives browser refresh/close.
+Cleared only on Docker container restart.
+
+Thread safety: atomic write (temp file → rename) prevents corruption
+when background threads update jobs concurrently.
+"""
+
+import json
+import os
+import time
+import uuid
+import tempfile
+import threading
+from typing import Optional
+
+JOBS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_jobs")
+os.makedirs(JOBS_DIR, exist_ok=True)
+
+# Per-job locks so concurrent updates to the same job don't corrupt
+_locks: dict[str, threading.Lock] = {}
+_locks_mutex = threading.Lock()
+
+def _job_lock(job_id: str) -> threading.Lock:
+    with _locks_mutex:
+        if job_id not in _locks:
+            _locks[job_id] = threading.Lock()
+        return _locks[job_id]
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Internal atomic write
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _save_job(job: dict) -> None:
+    """Atomic write: write to temp → rename. Thread-safe."""
+    target = os.path.join(JOBS_DIR, f"{job['id']}.json")
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=JOBS_DIR, suffix=".tmp")
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(job, f, ensure_ascii=False, indent=2)
+        os.replace(tmp_path, target)   # atomic on POSIX
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+        raise
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Job creation
+# ─────────────────────────────────────────────────────────────────────────────
+
+def create_job(
+    job_type: str,
+    filename: str,
+    language: str = "",
+    model: str = "",
+    provider: str = "",
+    extra: dict | None = None,
+) -> str:
+    job_id = str(uuid.uuid4())[:12]
+    now    = time.time()
+    job = {
+        "id":         job_id,
+        "type":       job_type,       # "audio_srt" | "translate"
+        "filename":   filename,
+        "language":   language,
+        "model":      model,
+        "provider":   provider,
+        "status":     "queued",       # queued|running|paused|completed|failed
+        "progress":   0.0,
+        "status_msg": "",
+        "created_at": now,
+        "updated_at": now,
+        "error":      None,
+        "checkpoint": {},
+        "extra":      extra or {},
+        "has_result": False,
+    }
+    _save_job(job)
+    return job_id
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Job updates  (thread-safe)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def update_job(
+    job_id: str,
+    status: str | None = None,
+    progress: float | None = None,
+    status_msg: str | None = None,
+    error: str | None = None,
+    checkpoint: dict | None = None,
+    extra_update: dict | None = None,
+) -> None:
+    with _job_lock(job_id):
+        job = load_job(job_id)
+        if job is None:
+            return
+        if status      is not None: job["status"]     = status
+        if progress    is not None: job["progress"]   = round(float(progress), 4)
+        if status_msg  is not None: job["status_msg"] = str(status_msg)[:300]
+        if error       is not None: job["error"]      = str(error)[:500]
+        if checkpoint  is not None: job["checkpoint"] = checkpoint
+        if extra_update:
+            job.setdefault("extra", {}).update(extra_update)
+        job["updated_at"] = time.time()
+        _save_job(job)
+
+
+def save_result(job_id: str, data: bytes) -> None:
+    result_path = os.path.join(JOBS_DIR, f"{job_id}.result")
+    # Atomic write for result too
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=JOBS_DIR, suffix=".tmp")
+    try:
+        os.write(tmp_fd, data)
+        os.close(tmp_fd)
+        os.replace(tmp_path, result_path)
+    except Exception:
+        try: os.close(tmp_fd)
+        except Exception: pass
+        try: os.unlink(tmp_path)
+        except Exception: pass
+        raise
+
+    with _job_lock(job_id):
+        job = load_job(job_id)
+        if job:
+            job["has_result"] = True
+            job["status"]     = "completed"
+            job["progress"]   = 1.0
+            job["status_msg"] = "ပြီးစီးသည် ✓"
+            job["updated_at"] = time.time()
+            _save_job(job)
+
+
+def load_result(job_id: str) -> bytes | None:
+    path = os.path.join(JOBS_DIR, f"{job_id}.result")
+    if not os.path.exists(path):
+        return None
+    with open(path, "rb") as f:
+        return f.read()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Reading
+# ─────────────────────────────────────────────────────────────────────────────
+
+def load_job(job_id: str) -> dict | None:
+    path = os.path.join(JOBS_DIR, f"{job_id}.json")
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+def list_jobs(job_type: str | None = None) -> list[dict]:
+    jobs = []
+    for fname in os.listdir(JOBS_DIR):
+        if not fname.endswith(".json"):
+            continue
+        job = load_job(fname[:-5])
+        if job is None:
+            continue
+        if job_type and job.get("type") != job_type:
+            continue
+        jobs.append(job)
+    jobs.sort(key=lambda j: j.get("created_at", 0), reverse=True)
+    return jobs
+
+
+def delete_job(job_id: str) -> None:
+    for ext in (".json", ".result"):
+        path = os.path.join(JOBS_DIR, f"{job_id}{ext}")
+        if os.path.exists(path):
+            try: os.remove(path)
+            except Exception: pass
+
+
+def clear_all_jobs() -> int:
+    count = 0
+    for fname in os.listdir(JOBS_DIR):
+        if fname.endswith(".tmp"):
+            continue
+        try:
+            os.remove(os.path.join(JOBS_DIR, fname))
+            count += 1
+        except Exception:
+            pass
+    return count
+
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Glossary persistence
+# Glossary is saved independently of checkpoint so it survives
+# model/provider changes. Resume always reuses the approved glossary.
+# ─────────────────────────────────────────────────────────────────────────────
+
+def save_glossary(job_id: str, glossary: dict) -> None:
+    """
+    Persist the approved glossary for a translation job.
+    Stored inside the job JSON under "approved_glossary".
+    Thread-safe (uses update_job which is already atomic).
+    """
+    update_job(job_id, extra_update={"approved_glossary": glossary})
+
+
+def load_glossary(job_id: str) -> dict:
+    """
+    Load the saved glossary for a job.
+    Returns empty dict if not found.
+    """
+    job = load_job(job_id)
+    if job is None:
+        return {}
+    return job.get("extra", {}).get("approved_glossary", {})
+
+
+def get_latest_translate_job_with_glossary() -> dict | None:
+    """
+    Return the most recent translate job that has a saved glossary.
+    Used to offer glossary reuse when starting a new translation.
+    """
+    jobs = list_jobs(job_type="translate")
+    for job in jobs:
+        g = job.get("extra", {}).get("approved_glossary", {})
+        if g:
+            return job
+    return None
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Display helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def job_age_str(job: dict) -> str:
+    delta = time.time() - job.get("updated_at", job.get("created_at", 0))
+    if delta < 60:     return "just now"
+    if delta < 3600:   return f"{int(delta/60)} min ago"
+    if delta < 86400:  return f"{int(delta/3600)} hr ago"
+    return f"{int(delta/86400)} days ago"
+
+
+def status_icon(status: str) -> str:
+    return {"queued":"⏳","running":"🔄","paused":"⏸","completed":"✅","failed":"❌"}.get(status,"❓")
+
+
+def status_color(status: str) -> str:
+    return {"queued":"#4b5563","running":"#3b82f6","paused":"#f59e0b",
+            "completed":"#22c55e","failed":"#ef4444"}.get(status,"#4b5563")

requirements.txt

@@ -1,6 +1,3 @@
-# SubSync — requirements.txt
-# HF Docker Space: secrets come via env vars, no python-dotenv needed.
-
 streamlit>=1.35.0,<2.0.0
 pysubs2>=1.7.0,<2.0.0
 google-generativeai>=0.7.0,<1.0.0
@@ -9,3 +6,4 @@ requests>=2.31.0,<3.0.0
 httpx>=0.27.0,<1.0.0
 pandas>=2.2.0,<3.0.0
 tenacity>=8.3.0,<9.0.0
+faster-whisper>=1.0.0,<2.0.0

translation.py

@@ -34,7 +34,9 @@ from api_handler import (
 logger = logging.getLogger(__name__)
 
 BASE_CHUNK_SIZE = 150   # default — may shrink on TokenLimitError
-GLOSSARY_SAMPLE = 300
+# Glossary uses full file — Gemini 1M context handles it
+# For very large files (5000+ lines) we spread-sample to stay within limits
+GLOSSARY_MAX_LINES = 3000   # hard cap: beyond this we spread-sample
 MAX_PARSE_RETRY = 2     # parse-only retries per chunk
 
 
@@ -347,21 +349,50 @@ def _translate_chunk_safe(
 # ─────────────────────────────────────────────────────────────────────────────
 
 def extract_glossary(lines: list, *, provider, model, api_key) -> dict:
+    """
+    Extract translation glossary from the FULL subtitle file.
+    Sends all non-empty lines so terms appearing late in the file
+    (episode-specific locations, late-introduced characters, slang) are captured.
+
+    For very large files (>GLOSSARY_MAX_LINES), we spread-sample:
+      - First 1/3 + Middle 1/3 + Last 1/3
+    This preserves coverage across the whole file while staying within token limits.
+    Gemini 1.5/2.0 handles 1M tokens so most files fit entirely.
+    """
     non_empty = [l for l in lines if l.strip()]
-    sample    = non_empty[:GLOSSARY_SAMPLE]
-    numbered  = "\n".join(f"{i+1}. {l}" for i, l in enumerate(sample))
-    prompt    = (
-        f"Extract Myanmar translation glossary from {len(sample)} subtitle lines:\n\n"
-        f"{numbered}"
+    total     = len(non_empty)
+
+    if total <= GLOSSARY_MAX_LINES:
+        # ── Full file ──────────────────────────────────────────────────
+        sample = non_empty
+    else:
+        # ── Spread sample: beginning + middle + end ────────────────────
+        third   = GLOSSARY_MAX_LINES // 3
+        mid_s   = (total // 2) - (third // 2)
+        sample  = (
+            non_empty[:third] +
+            non_empty[mid_s: mid_s + third] +
+            non_empty[-third:]
+        )
+        logger.info(
+            "File has %d lines > %d limit — spread sampling %d lines",
+            total, GLOSSARY_MAX_LINES, len(sample)
+        )
+
+    numbered = "\n".join(f"{i+1}. {l}" for i, l in enumerate(sample))
+    prompt   = (
+        f"Extract Myanmar translation glossary from these {len(sample)} subtitle lines "
+        f"(full file: {total} lines total):\n\n{numbered}"
     )
+
     try:
         raw = call_ai(prompt, provider=provider, model=model, api_key=api_key,
-                      system_prompt=_SYS_GLOSSARY, timeout=90)
+                      system_prompt=_SYS_GLOSSARY, timeout=120)
         r = _parse_dict(raw)
         if r:
             return {str(k): str(v) for k, v in r.items()}
     except Exception as exc:
-        logger.warning("Glossary failed: %s", exc)
+        logger.warning("Glossary extraction failed: %s", exc)
     return {}
 
 
@@ -506,3 +537,84 @@ def translate_all(
         f"Length invariant broken: {len(result)} != {len(lines)}"
 
     return result
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Background translation thread
+# ─────────────────────────────────────────────────────────────────────────────
+
+import threading as _threading
+
+def run_translation_bg(
+    job_id: str,
+    lines: list,
+    glossary: dict,
+    *,
+    provider: str,
+    model: str,
+    api_key: str,
+    fmt: str,
+    ssafile,            # pysubs2.SSAFile
+    filename: str,
+) -> _threading.Thread:
+    """
+    Spawn background thread for translation.
+    Survives browser disconnect — progress saved to job_store.
+    On limit-hit (TranslationPaused): saves checkpoint, sets status=paused.
+    User can resume from History page.
+    """
+    from job_store import update_job, save_result, load_job
+    from subtitle_parser import replace_lines, write_subtitle, output_filename
+
+    def _worker():
+        debug_log  = []
+        # Load existing checkpoint if resuming
+        job        = load_job(job_id)
+        cp_init    = job.get("checkpoint", {}) if job else {}
+        session_st = {"tx_checkpoint": cp_init} if cp_init else {}
+
+        def pcb(frac: float, msg: str) -> None:
+            update_job(job_id, progress=frac, status_msg=msg)
+            # Save checkpoint periodically
+            cp = session_st.get("tx_checkpoint", {})
+            if cp:
+                update_job(job_id, checkpoint=cp)
+
+        update_job(job_id, status="running", progress=0.0)
+
+        try:
+            translated = translate_all(
+                lines, glossary,
+                provider=provider, model=model, api_key=api_key,
+                progress_cb=pcb,
+                debug_log=debug_log,
+                session_state=session_st,
+                resume=bool(cp_init),
+            )
+
+            # Build output file
+            out_subs  = replace_lines(ssafile, translated)
+            out_bytes = write_subtitle(out_subs, fmt)
+            save_result(job_id, out_bytes)   # sets status=completed
+
+        except TranslationPaused as e:
+            cp = session_st.get("tx_checkpoint", {})
+            update_job(job_id,
+                       status="paused",
+                       checkpoint=cp,
+                       status_msg=f"⏸ Limit hit — {str(e)[:200]}",
+                       error=str(e)[:300])
+
+        except Exception as e:
+            update_job(job_id,
+                       status="failed",
+                       error=str(e)[:400],
+                       status_msg=f"❌ {str(e)[:200]}")
+
+    t = _threading.Thread(
+        target=_worker,
+        daemon=True,
+        name=f"translate-{job_id}",
+    )
+    t.start()
+    return t